package updates
import (
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/persistence"
"github.com/kandev/kandev/internal/system/jobs"
)
func TestService_ApplyQueuesSelfUpdateJobAndWritesIntent(t *testing.T) {
homeDir := t.TempDir()
metadataPath, _ := writeServiceInstallForTest(t, homeDir, serviceInstallMetadata{
Manager: "systemd",
Mode: "user",
Kind: "npm",
HomeDir: homeDir,
LogDir: filepath.Join(homeDir, "logs"),
ServicePath: filepath.Join(homeDir, "kandev.service"),
NodePath: "/usr/bin/node",
CLIEntry: "/usr/lib/node_modules/kandev/bin/cli.js",
Port: 38429,
})
t.Setenv(envRunningAsService, "true")
t.Setenv(envServiceMode, "user")
t.Setenv(envServiceManager, "systemd")
t.Setenv(envInstallKind, "npm")
t.Setenv(envServiceMetadata, metadataPath)
pool := newTestPool(t)
if err := persistence.WriteLatestVersion(pool.Writer(), "v1.0.1", "https://example/v1.0.1", time.Now().UTC()); err != nil {
t.Fatalf("write latest: %v", err)
}
tracker := jobs.NewTracker(nil, logger.Default())
var gotReq applyRequest
svc := NewService(
pool,
"v1.0.0",
nil,
logger.Default(),
WithHomeDir(homeDir),
WithJobs(tracker),
WithApplyRunner(func(_ context.Context, req applyRequest) (map[string]interface{}, error) {
gotReq = req
return map[string]interface{}{"status": "started"}, nil
}),
)
jobID, err := svc.Apply(context.Background(), "UPDATE")
if err != nil {
t.Fatalf("Apply: %v", err)
}
waitForJobState(t, tracker, jobID, jobs.StateSucceeded)
if gotReq.IntentPath == "" {
t.Fatalf("runner did not receive intent path")
}
data, err := os.ReadFile(gotReq.IntentPath)
if err != nil {
t.Fatalf("read intent: %v", err)
}
var intent updateIntent
if err := json.Unmarshal(data, &intent); err != nil {
t.Fatalf("unmarshal intent: %v", err)
}
if intent.TargetVersion != "1.0.1" {
t.Fatalf("TargetVersion=%q want 1.0.1", intent.TargetVersion)
}
if intent.Install.Port != 38429 {
t.Fatalf("Port=%d want 38429", intent.Install.Port)
}
}
func TestService_ApplyRejectsUnsupportedInstall(t *testing.T) {
pool := newTestPool(t)
if err := persistence.WriteLatestVersion(pool.Writer(), "v1.0.1", "https://example/v1.0.1", time.Now().UTC()); err != nil {
t.Fatalf("write latest: %v", err)
}
svc := NewService(pool, "v1.0.0", nil, logger.Default(), WithJobs(jobs.NewTracker(nil, logger.Default())))
_, err := svc.Apply(context.Background(), "UPDATE")
if !errors.Is(err, ErrApplyUnsupported) {
t.Fatalf("err=%v want ErrApplyUnsupported", err)
}
}
func TestService_ApplyRejectsConcurrentSelfUpdate(t *testing.T) {
homeDir := t.TempDir()
metadataPath, _ := writeServiceInstallForTest(t, homeDir, serviceInstallMetadata{
Manager: "systemd",
Mode: "user",
Kind: "npm",
HomeDir: homeDir,
LogDir: filepath.Join(homeDir, "logs"),
ServicePath: filepath.Join(homeDir, "kandev.service"),
NodePath: "/usr/bin/node",
CLIEntry: "/usr/lib/node_modules/kandev/bin/cli.js",
})
t.Setenv(envRunningAsService, "true")
t.Setenv(envServiceMode, "user")
t.Setenv(envServiceManager, "systemd")
t.Setenv(envInstallKind, "npm")
t.Setenv(envServiceMetadata, metadataPath)
pool := newTestPool(t)
if err := persistence.WriteLatestVersion(pool.Writer(), "v1.0.1", "https://example/v1.0.1", time.Now().UTC()); err != nil {
t.Fatalf("write latest: %v", err)
}
// Block the first helper so its job stays running while the second apply is
// attempted, making the in-flight guard deterministic.
release := make(chan struct{})
svc := NewService(pool, "v1.0.0", nil, logger.Default(),
WithHomeDir(homeDir),
WithJobs(jobs.NewTracker(nil, logger.Default())),
WithApplyRunner(func(_ context.Context, _ applyRequest) (map[string]interface{}, error) {
<-release
return map[string]interface{}{"status": "started"}, nil
}),
)
if _, err := svc.Apply(context.Background(), "UPDATE"); err != nil {
t.Fatalf("first Apply: %v", err)
}
if _, err := svc.Apply(context.Background(), "UPDATE"); !errors.Is(err, ErrApplyInProgress) {
t.Fatalf("second Apply err=%v want ErrApplyInProgress", err)
}
close(release)
}
func TestService_ApplyGuardExpiresAfterTTL(t *testing.T) {
homeDir := t.TempDir()
metadataPath, _ := writeServiceInstallForTest(t, homeDir, serviceInstallMetadata{
Manager: "systemd",
Mode: "user",
Kind: "npm",
HomeDir: homeDir,
LogDir: filepath.Join(homeDir, "logs"),
ServicePath: filepath.Join(homeDir, "kandev.service"),
NodePath: "/usr/bin/node",
CLIEntry: "/usr/lib/node_modules/kandev/bin/cli.js",
})
t.Setenv(envRunningAsService, "true")
t.Setenv(envServiceMode, "user")
t.Setenv(envServiceManager, "systemd")
t.Setenv(envInstallKind, "npm")
t.Setenv(envServiceMetadata, metadataPath)
pool := newTestPool(t)
if err := persistence.WriteLatestVersion(pool.Writer(), "v1.0.1", "https://example/v1.0.1", time.Now().UTC()); err != nil {
t.Fatalf("write latest: %v", err)
}
svc := NewService(pool, "v1.0.0", nil, logger.Default(),
WithHomeDir(homeDir),
WithJobs(jobs.NewTracker(nil, logger.Default())),
WithApplyRunner(func(_ context.Context, _ applyRequest) (map[string]interface{}, error) {
// Launch "succeeds" (helper started) but never restarts the backend,
// so the guard is not released by an error path.
return map[string]interface{}{"status": "started"}, nil
}),
)
clock := time.Now()
svc.now = func() time.Time { return clock }
if _, err := svc.Apply(context.Background(), "UPDATE"); err != nil {
t.Fatalf("first Apply: %v", err)
}
// Within the TTL a second apply is still refused.
if _, err := svc.Apply(context.Background(), "UPDATE"); !errors.Is(err, ErrApplyInProgress) {
t.Fatalf("within TTL err=%v want ErrApplyInProgress", err)
}
// Past the TTL the guard expires (helper assumed dead) and a retry succeeds.
clock = clock.Add(applyGuardTTL + time.Second)
if _, err := svc.Apply(context.Background(), "UPDATE"); err != nil {
t.Fatalf("after TTL Apply: %v", err)
}
}
func TestService_ApplyRejectsWrongConfirm(t *testing.T) {
svc := NewService(newTestPool(t), "v1.0.0", nil, logger.Default())
_, err := svc.Apply(context.Background(), "NOPE")
if !errors.Is(err, ErrApplyConfirm) {
t.Fatalf("err=%v want ErrApplyConfirm", err)
}
}
func TestSystemdSelfUpdateArgsPropagateUpdateEnvironment(t *testing.T) {
t.Setenv("PATH", "/opt/homebrew/bin:/usr/bin")
t.Setenv("npm_config_prefix", "/tmp/npm-global")
t.Setenv("NPM_CONFIG_PREFIX", "/tmp/npm-global")
req := applyRequest{
IntentPath: "/tmp/intent.json",
Intent: updateIntent{Install: serviceInstallMetadata{
NodePath: "/opt/homebrew/bin/node",
CLIEntry: "/tmp/npm-global/lib/node_modules/kandev/bin/cli.js",
}},
}
got := systemdSelfUpdateArgs(req, "kandev-self-update-test")
want := []string{
"--user",
"--unit", "kandev-self-update-test",
"--collect",
"--setenv=PATH=/opt/homebrew/bin:/usr/bin",
"--setenv=npm_config_prefix=/tmp/npm-global",
"--setenv=NPM_CONFIG_PREFIX=/tmp/npm-global",
"/opt/homebrew/bin/node",
"/tmp/npm-global/lib/node_modules/kandev/bin/cli.js",
"service",
"self-update",
"--intent",
"/tmp/intent.json",
}
if !stringSlicesEqual(got, want) {
t.Fatalf("args=%#v want %#v", got, want)
}
}
func TestRenderLaunchdHelperPlistRunsOnceWithUpdateEnvironment(t *testing.T) {
t.Setenv("PATH", "/opt/homebrew/bin:/usr/bin")
t.Setenv("npm_config_prefix", "/tmp/npm-global")
t.Setenv("NPM_CONFIG_PREFIX", "/tmp/npm-global")
req := applyRequest{
IntentPath: "/tmp/intent.json",
Intent: updateIntent{Install: serviceInstallMetadata{
NodePath: "/opt/homebrew/bin/node",
CLIEntry: "/tmp/npm-global/lib/node_modules/kandev/bin/cli.js",
LogDir: "/tmp/kandev/logs",
}},
}
plist := renderLaunchdHelperPlist("com.kdlbs.kandev.self-update.test", req)
// The whole point of this change: the helper must run exactly once. A
// KeepAlive=true (the implicit behaviour of `launchctl submit`) would make
// launchd re-run the one-shot updater forever.
if !strings.Contains(plist, "KeepAlive\n ") {
t.Fatalf("plist must set KeepAlive=false to run once:\n%s", plist)
}
for _, want := range []string{
"com.kdlbs.kandev.self-update.test",
"RunAtLoad\n ",
"/opt/homebrew/bin/node",
"/tmp/npm-global/lib/node_modules/kandev/bin/cli.js",
"self-update",
"/tmp/intent.json",
"PATH\n /opt/homebrew/bin:/usr/bin",
"NPM_CONFIG_PREFIX\n /tmp/npm-global",
"/tmp/kandev/logs/self-update-launchd.log",
} {
if !strings.Contains(plist, want) {
t.Fatalf("plist missing %q:\n%s", want, plist)
}
}
// Must not regress to the looping `launchctl submit` mechanism.
if strings.Contains(plist, "submit") {
t.Fatalf("plist should not reference submit:\n%s", plist)
}
}
func TestLaunchdSelfUpdateDomain(t *testing.T) {
user := applyRequest{Intent: updateIntent{Install: serviceInstallMetadata{Mode: installModeUser}}}
if got := launchdSelfUpdateDomain(user, 501); got != "gui/501" {
t.Fatalf("user domain=%q want gui/501", got)
}
system := applyRequest{Intent: updateIntent{Install: serviceInstallMetadata{Mode: installModeSystem}}}
if got := launchdSelfUpdateDomain(system, 501); got != "system" {
t.Fatalf("system domain=%q want system", got)
}
}
func stringSlicesEqual(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
func waitForJobState(t *testing.T, tracker *jobs.Tracker, id string, want jobs.State) *jobs.Job {
t.Helper()
deadline := time.Now().Add(2 * time.Second)
for time.Now().Before(deadline) {
job := tracker.Get(id)
if job != nil && job.State == want {
return job
}
time.Sleep(10 * time.Millisecond)
}
t.Fatalf("job %s did not reach %s", id, want)
return nil
}