Initial commit

Assisted-by: GLM 5.3

internal/updater/updater_test.go

@@ -0,0 +1,217 @@
+// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
+// SPDX-License-Identifier: PolyForm-Noncommercial-1.0.0
+
+package updater
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestCompareVersions(t *testing.T) {
+	cases := []struct {
+		a, b string
+		want int
+	}{
+		{"0.6.0", "0.6.0", 0},
+		{"0.7.0", "0.6.0", 1},
+		{"0.6.0", "0.7.0", -1},
+		{"1.0.0", "0.9.9", 1},
+		{"0.6.1", "0.6", 1},
+		{"0.6", "0.6.0", 0},
+		{"0.10.0", "0.9.0", 1},
+		{"1.2.3-rc1", "1.2.3", 0}, // suffix ignored per part
+	}
+	for _, tc := range cases {
+		if got := CompareVersions(tc.a, tc.b); got != tc.want {
+			t.Fatalf("CompareVersions(%q, %q) = %d, want %d", tc.a, tc.b, got, tc.want)
+		}
+	}
+}
+
+func TestCheckLatestParsesTag(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		_ = json.NewEncoder(w).Encode(map[string]any{"tag_name": "v1.2.3"})
+	}))
+	defer srv.Close()
+	old := ReleaseBase
+	ReleaseBase = srv.URL
+	defer func() { ReleaseBase = old }()
+
+	latest, err := CheckLatest()
+	if err != nil || latest != "1.2.3" {
+		t.Fatalf("CheckLatest = %q, %v", latest, err)
+	}
+	if got := UpdateAvailable("1.2.2"); got != "1.2.3" {
+		t.Fatalf("UpdateAvailable = %q", got)
+	}
+	if got := UpdateAvailable("1.2.3"); got != "" {
+		t.Fatalf("UpdateAvailable(current) = %q", got)
+	}
+	if got := UpdateAvailable("2.0.0"); got != "" {
+		t.Fatalf("UpdateAvailable(newer local) = %q", got)
+	}
+}
+
+func TestCheckLatestErrors(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusInternalServerError)
+	}))
+	defer srv.Close()
+	old := ReleaseBase
+	ReleaseBase = srv.URL
+	defer func() { ReleaseBase = old }()
+	if _, err := CheckLatest(); err == nil {
+		t.Fatal("want error on HTTP 500")
+	}
+}
+
+func TestSelfUpdateURLsIncludeRepoPath(t *testing.T) {
+	var paths []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		paths = append(paths, r.URL.Path)
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/releases/latest"):
+			_ = json.NewEncoder(w).Encode(map[string]any{"tag_name": "v9.9.9"})
+		case strings.HasSuffix(r.URL.Path, "checksums.txt"):
+			_, _ = w.Write([]byte("0000000000000000000000000000000000000000000000000000000000000000  volumen-9.9.9-" + goos() + "-" + goarch() + "\n"))
+		default:
+			_, _ = w.Write([]byte("binary"))
+		}
+	}))
+	defer srv.Close()
+
+	old := ReleaseBase
+	ReleaseBase = srv.URL
+	defer func() { ReleaseBase = old }()
+
+	// SelfUpdate downloads and then fails on the checksum; the point of
+	// this test is the request paths, not the outcome.
+	_, _ = SelfUpdate("0.0.1")
+
+	want := RepoSlug + "/releases/download/v9.9.9/"
+	downloads := 0
+	for _, path := range paths {
+		if !strings.Contains(path, "/releases/download/") {
+			continue // the /api/... release check uses its own path shape
+		}
+		downloads++
+		if !strings.Contains(path, want) {
+			t.Fatalf("download path %q does not contain %q", path, want)
+		}
+	}
+	if downloads < 2 {
+		t.Fatalf("expected checksums and binary downloads, saw %d download requests", downloads)
+	}
+}
+
+// The self-update tail replaces the running binary, so it is exercised
+// through the two seams rather than by actually exec-ing anything.
+func TestSelfUpdateStagesAndExecs(t *testing.T) {
+	binary := []byte("#!/bin/sh\necho replaced\n")
+	sum := sha256.Sum256(binary)
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/releases/latest"):
+			_ = json.NewEncoder(w).Encode(map[string]any{"tag_name": "v9.9.9"})
+		case strings.HasSuffix(r.URL.Path, "checksums.txt"):
+			fmt.Fprintf(w, "%s  volumen-9.9.9-%s-%s\n", hex.EncodeToString(sum[:]), goos(), goarch())
+		default:
+			_, _ = w.Write(binary)
+		}
+	}))
+	defer srv.Close()
+
+	oldBase := ReleaseBase
+	ReleaseBase = srv.URL
+	defer func() { ReleaseBase = oldBase }()
+
+	dir := t.TempDir()
+	exe := filepath.Join(dir, "volumen")
+	if err := os.WriteFile(exe, []byte("old binary"), 0o755); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	oldExecutable, oldExec := executable, syscallExec
+	executable = func() (string, error) { return exe, nil }
+	var gotPath string
+	var gotArgv []string
+	syscallExec = func(path string, argv []string) error {
+		gotPath, gotArgv = path, argv
+		return errors.New("stop here")
+	}
+	t.Cleanup(func() { executable, syscallExec = oldExecutable, oldExec })
+
+	_, err := SelfUpdate("0.0.1")
+	if err == nil || !strings.Contains(err.Error(), "stop here") {
+		t.Fatalf("SelfUpdate = %v, want the seam's error", err)
+	}
+	if gotPath != exe {
+		t.Fatalf("exec path = %q, want %q", gotPath, exe)
+	}
+	if len(gotArgv) == 0 || gotArgv[0] != exe {
+		t.Fatalf("argv = %v", gotArgv)
+	}
+	staged, err := os.ReadFile(exe)
+	if err != nil {
+		t.Fatalf("read the replaced binary: %v", err)
+	}
+	if string(staged) != string(binary) {
+		t.Fatalf("the binary was not replaced: %q", staged)
+	}
+	info, err := os.Stat(exe)
+	if err != nil {
+		t.Fatalf("stat: %v", err)
+	}
+	if info.Mode().Perm() != 0o755 {
+		t.Fatalf("mode = %v, want 0755", info.Mode().Perm())
+	}
+}
+
+func TestSelfUpdateRejectsAChecksumMismatch(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/releases/latest"):
+			_ = json.NewEncoder(w).Encode(map[string]any{"tag_name": "v9.9.9"})
+		case strings.HasSuffix(r.URL.Path, "checksums.txt"):
+			fmt.Fprintf(w, "%s  volumen-9.9.9-%s-%s\n", strings.Repeat("0", 64), goos(), goarch())
+		default:
+			_, _ = w.Write([]byte("binary"))
+		}
+	}))
+	defer srv.Close()
+	old := ReleaseBase
+	ReleaseBase = srv.URL
+	defer func() { ReleaseBase = old }()
+
+	exe := filepath.Join(t.TempDir(), "volumen")
+	if err := os.WriteFile(exe, []byte("old"), 0o755); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	oldExecutable := executable
+	executable = func() (string, error) { return exe, nil }
+	t.Cleanup(func() { executable = oldExecutable })
+
+	if _, err := SelfUpdate("0.0.1"); err == nil || !strings.Contains(err.Error(), "checksum") {
+		t.Fatalf("SelfUpdate = %v, want a checksum failure", err)
+	}
+}
+
+func TestCompareVersionsClampsLongComponents(t *testing.T) {
+	// A component wider than an int must compare, not overflow.
+	huge := strings.Repeat("9", 30)
+	if CompareVersions(huge, "1.0.0") <= 0 {
+		t.Fatal("a very large component did not compare as newer")
+	}
+	if CompareVersions("1.0.0", huge) >= 0 {
+		t.Fatal("a very large component did not compare as newer")
+	}
+}