Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

7.2 KB
Raw Blame
package cmd

import (
	"bytes"
	"context"
	"errors"
	"strings"
	"testing"
	"time"

	"github.com/spf13/cobra"

	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/testenv"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/updatecheck"
	"github.com/asymptote-labs/agent-beacon/cli/beacon/internal/version"
)

type stubVersionChecker struct {
	result updatecheck.Result
	err    error
}

func (c stubVersionChecker) Check(context.Context) (updatecheck.Result, error) {
	if c.err != nil {
		return updatecheck.Result{}, c.err
	}
	return c.result, nil
}

func TestRunVersionWithoutCheckPrintsVersionOnly(t *testing.T) {
	restoreVersion := setVersionForTest(t, "v0.0.10")
	defer restoreVersion()
	restoreFlag := setVersionCheckForTest(t, false)
	defer restoreFlag()
	restoreChecker := setVersionCheckerForTest(t, stubVersionChecker{err: errors.New("should not run")})
	defer restoreChecker()

	cmd := &cobra.Command{}
	var out bytes.Buffer
	cmd.SetOut(&out)
	if err := runVersion(cmd, nil); err != nil {
		t.Fatalf("runVersion returned error: %v", err)
	}
	got := out.String()
	if !strings.Contains(got, "beacon version v0.0.10") {
		t.Fatalf("output = %q, want version", got)
	}
	if strings.Contains(got, "unable to check") {
		t.Fatalf("output = %q, update check unexpectedly ran", got)
	}
}

func TestRunVersionWithCheckPrintsVersionAndUpdateResult(t *testing.T) {
	restoreVersion := setVersionForTest(t, "v0.0.10")
	defer restoreVersion()
	restoreFlag := setVersionCheckForTest(t, true)
	defer restoreFlag()
	restoreChecker := setVersionCheckerForTest(t, stubVersionChecker{
		result: updatecheck.Result{CurrentVersion: "v0.0.10", LatestVersion: "v0.0.10"},
	})
	defer restoreChecker()

	cmd := &cobra.Command{}
	var out bytes.Buffer
	cmd.SetOut(&out)
	if err := runVersion(cmd, nil); err != nil {
		t.Fatalf("runVersion returned error: %v", err)
	}
	got := out.String()
	for _, want := range []string{
		"beacon version v0.0.10",
		"Beacon v0.0.10 is up to date.",
	} {
		if !strings.Contains(got, want) {
			t.Fatalf("output = %q, want %q", got, want)
		}
	}
}

func TestRunVersionCheckReportsAvailableUpdate(t *testing.T) {
	got := runVersionCheckWithStub(t, "v0.0.10", stubVersionChecker{
		result: updatecheck.Result{
			CurrentVersion:  "v0.0.10",
			LatestVersion:   "v0.0.12",
			ReleaseURL:      "https://example.test/releases/v0.0.12",
			UpdateAvailable: true,
		},
	})
	for _, want := range []string{
		"Beacon v0.0.12 is available. Current version: v0.0.10",
		"If installed with Homebrew: brew update && brew upgrade beacon",
		"Download: https://example.test/releases/v0.0.12",
	} {
		if !strings.Contains(got, want) {
			t.Fatalf("output = %q, want %q", got, want)
		}
	}
}

func TestRunVersionCheckReportsDevBuild(t *testing.T) {
	got := runVersionCheckWithStub(t, "dev", stubVersionChecker{
		result: updatecheck.Result{CurrentVersion: "dev", CurrentIsDev: true},
	})
	if !strings.Contains(got, "Beacon dev build: update checks require a released version.") {
		t.Fatalf("output = %q, want dev-build message", got)
	}
}

func TestRunVersionCheckReportsUnsupportedCurrentVersion(t *testing.T) {
	got := runVersionCheckWithStub(t, "v0.0.12+local", stubVersionChecker{
		result: updatecheck.Result{CurrentVersion: "v0.0.12+local", UnsupportedCurrentVersion: true},
	})
	if !strings.Contains(got, `Beacon version "v0.0.12+local" cannot be compared to released versions.`) {
		t.Fatalf("output = %q, want unsupported-version message", got)
	}
}

func TestRunVersionCheckReturnsFriendlyError(t *testing.T) {
	restoreVersion := setVersionForTest(t, "v0.0.10")
	defer restoreVersion()
	restoreChecker := setVersionCheckerForTest(t, stubVersionChecker{err: errors.New("rate limited")})
	defer restoreChecker()

	cmd := &cobra.Command{}
	var out bytes.Buffer
	cmd.SetOut(&out)
	err := runVersionCheck(cmd, nil)
	if err == nil {
		t.Fatal("runVersionCheck error = nil, want error")
	}
	if !strings.Contains(err.Error(), "unable to check for Beacon updates") {
		t.Fatalf("error = %v, want friendly update error", err)
	}
}

func runVersionCheckWithStub(t *testing.T, current string, checker stubVersionChecker) string {
	t.Helper()
	restoreVersion := setVersionForTest(t, current)
	defer restoreVersion()
	restoreChecker := setVersionCheckerForTest(t, checker)
	defer restoreChecker()

	cmd := &cobra.Command{}
	var out bytes.Buffer
	cmd.SetOut(&out)
	if err := runVersionCheck(cmd, nil); err != nil {
		t.Fatalf("runVersionCheck returned error: %v", err)
	}
	return out.String()
}

func setVersionForTest(t *testing.T, v string) func() {
	t.Helper()
	old := version.Version
	version.Version = v
	return func() { version.Version = old }
}

func setVersionCheckerForTest(t *testing.T, checker versionChecker) func() {
	t.Helper()
	// A check records its answer in the update cache under the home directory.
	testenv.SetHome(t, t.TempDir())
	old := newVersionChecker
	newVersionChecker = func(currentVersion string) versionChecker {
		return checker
	}
	return func() { newVersionChecker = old }
}

func setVersionCheckForTest(t *testing.T, enabled bool) func() {
	t.Helper()
	old := versionCheck
	versionCheck = enabled
	return func() { versionCheck = old }
}

func TestVersionCheckRecordsTheAnswerForTheStartupNotice(t *testing.T) {
	restoreVersion := setVersionForTest(t, "v0.0.10")
	defer restoreVersion()
	restoreChecker := setVersionCheckerForTest(t, stubVersionChecker{result: updatecheck.Result{
		CurrentVersion:  "v0.0.10",
		LatestVersion:   "v0.0.12",
		ReleaseURL:      "https://example.test/v0.0.12",
		UpdateAvailable: true,
	}})
	defer restoreChecker()

	cmd := &cobra.Command{}
	cmd.SetOut(&bytes.Buffer{})
	if err := runVersionCheck(cmd, nil); err != nil {
		t.Fatalf("runVersionCheck returned error: %v", err)
	}
	cache := updatecheck.LoadCache(updateCachePath())
	if cache.LatestVersion != "v0.0.12" || cache.ReleaseURL != "https://example.test/v0.0.12" || cache.LastCheckedAt.IsZero() {
		t.Fatalf("cache = %#v, want the checked release", cache)
	}
}

func TestVersionRefreshSkipsAFreshCache(t *testing.T) {
	restoreVersion := setVersionForTest(t, "v0.0.10")
	defer restoreVersion()
	calls := 0
	restoreChecker := setVersionCheckerForTest(t, stubVersionChecker{err: errors.New("should not run")})
	defer restoreChecker()
	newVersionChecker = func(string) versionChecker {
		calls++
		return stubVersionChecker{result: updatecheck.Result{LatestVersion: "v0.0.12"}}
	}
	t.Setenv(updatecheck.DisableEnv, "")
	t.Setenv("CI", "")

	if err := updatecheck.SaveCache(updateCachePath(), updatecheck.Cache{LatestVersion: "v0.0.11", LastCheckedAt: time.Now()}); err != nil {
		t.Fatal(err)
	}
	cmd := &cobra.Command{}
	if err := versionRefreshCmd.RunE(cmd, nil); err != nil {
		t.Fatal(err)
	}
	if calls != 0 {
		t.Fatalf("refresh of a fresh cache looked up the release %d times", calls)
	}

	if err := updatecheck.SaveCache(updateCachePath(), updatecheck.Cache{LatestVersion: "v0.0.11", LastCheckedAt: time.Now().Add(-25 * time.Hour)}); err != nil {
		t.Fatal(err)
	}
	if err := versionRefreshCmd.RunE(cmd, nil); err != nil {
		t.Fatal(err)
	}
	if calls != 1 {
		t.Fatalf("refresh of a stale cache looked up the release %d times, want 1", calls)
	}
	if got := updatecheck.LoadCache(updateCachePath()).LatestVersion; got != "v0.0.12" {
		t.Fatalf("cached latest = %q, want v0.0.12", got)
	}
}