The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
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)
}
}