tutti/services/tuttid/service/agentstatus/status_cache_test.go

package agentstatus

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/tutti-os/tutti/packages/agent/daemon/providerregistry"
)

func TestProviderStatusCacheReusesProviderAcrossRequestShapes(t *testing.T) {
	var authCalls atomic.Int32
	service := testService(func(string) (string, error) {
		return "/usr/bin/true", nil
	}, map[string]bool{"/home/test/.cursor/cli-config.json": true})
	service.StatusCache = NewProviderStatusCache()
	service.Now = time.Now
	service.RunAuthStatusCommand = func(context.Context, ProviderSpec, string) (AuthInfo, bool) {
		authCalls.Add(1)
		return AuthInfo{Status: AuthAuthenticated}, true
	}

	if _, err := service.List(context.Background(), ListInput{Providers: []string{"cursor", "codex"}}); err != nil {
		t.Fatalf("first List() error = %v", err)
	}
	probesAfterFirst := authCalls.Load()
	if probesAfterFirst != 2 {
		t.Fatalf("first List() auth probes = %d, want 2", probesAfterFirst)
	}
	if _, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}}); err != nil {
		t.Fatalf("second List() error = %v", err)
	}
	if got := authCalls.Load(); got != probesAfterFirst {
		t.Fatalf("auth probes = %d, want cached %d", got, probesAfterFirst)
	}
	if _, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}, ForceRefresh: true}); err != nil {
		t.Fatalf("forced List() error = %v", err)
	}
	if got := authCalls.Load(); got <= probesAfterFirst {
		t.Fatalf("auth probes after force refresh = %d, want > %d", got, probesAfterFirst)
	}
}

func TestProviderStatusCacheRefreshesRemoteAuthEvidenceEveryFifteenMinutes(t *testing.T) {
	cachedAt := time.Unix(100, 0).UTC()
	now := cachedAt.Add(14 * time.Minute)
	service := Service{
		Now:         func() time.Time { return now },
		RunOutcomes: NewRunOutcomeStore(),
	}
	spec := ProviderSpec{RemoteAuthProbe: providerregistry.RemoteAuthProbeDescriptor{
		Kind: providerregistry.RemoteAuthProbeKindHTTPBearer,
	}}
	if !service.cachedProviderStatusStillValid(spec, cachedAt, "") {
		t.Fatal("remote auth cache expired before fifteen minutes")
	}
	now = cachedAt.Add(15 * time.Minute)
	if service.cachedProviderStatusStillValid(spec, cachedAt, "") {
		t.Fatal("remote auth cache remained valid at fifteen minutes")
	}
}

func TestForcedProviderStatusRefreshRechecksAuthButReusesStableCLIVersion(t *testing.T) {
	tempDir := t.TempDir()
	binaryPath := filepath.Join(tempDir, "cursor-agent")
	versionCallsPath := filepath.Join(tempDir, "version-calls")
	script := "#!/bin/sh\n" +
		"if [ \"$1\" = \"--version\" ]; then\n" +
		"  echo call >> " + versionCallsPath + "\n" +
		"  echo 'cursor-agent 1.2.3'\n" +
		"fi\n"
	if err := os.WriteFile(binaryPath, []byte(script), 0o700); err != nil {
		t.Fatalf("write cursor test CLI: %v", err)
	}

	var authCalls atomic.Int32
	service := testService(func(string) (string, error) {
		return binaryPath, nil
	}, map[string]bool{})
	service.StatusCache = NewProviderStatusCache()
	service.CLIVersionCache = NewCLIVersionCache()
	service.RunAuthStatusCommand = func(context.Context, ProviderSpec, string) (AuthInfo, bool) {
		authCalls.Add(1)
		return AuthInfo{Status: AuthAuthenticated}, true
	}

	for range 2 {
		if _, err := service.List(context.Background(), ListInput{
			Providers:    []string{"cursor"},
			ForceRefresh: true,
		}); err != nil {
			t.Fatalf("forced List() error = %v", err)
		}
	}
	if got := authCalls.Load(); got != 2 {
		t.Fatalf("auth checks = %d, want every forced refresh", got)
	}
	versionCalls, err := os.ReadFile(versionCallsPath)
	if err != nil {
		t.Fatalf("read version calls: %v", err)
	}
	if got := len(strings.Fields(string(versionCalls))); got != 1 {
		t.Fatalf("version checks = %d, want stable binary checked once", got)
	}
}

func TestProviderStatusCacheCollapsesConcurrentProviderProbes(t *testing.T) {
	var authCalls atomic.Int32
	service := testService(func(string) (string, error) {
		return "/usr/bin/true", nil
	}, map[string]bool{"/home/test/.cursor/cli-config.json": true})
	service.StatusCache = NewProviderStatusCache()
	service.Now = time.Now
	service.RunAuthStatusCommand = func(context.Context, ProviderSpec, string) (AuthInfo, bool) {
		authCalls.Add(1)
		time.Sleep(30 * time.Millisecond)
		return AuthInfo{Status: AuthAuthenticated}, true
	}

	start := make(chan struct{})
	var wait sync.WaitGroup
	for range 2 {
		wait.Add(1)
		go func() {
			defer wait.Done()
			<-start
			if _, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}}); err != nil {
				t.Errorf("List() error = %v", err)
			}
		}()
	}
	close(start)
	wait.Wait()
	if got := authCalls.Load(); got != 1 {
		t.Fatalf("auth probe calls = %d, want 1", got)
	}
}

func TestProviderStatusCacheUsesProbeCompletionTime(t *testing.T) {
	times := []time.Time{
		time.Unix(100, 0).UTC(),
		time.Unix(101, 0).UTC(),
		time.Unix(102, 0).UTC(),
		time.Unix(103, 0).UTC(),
		time.Unix(104, 0).UTC(),
	}
	var index atomic.Int32
	service := testService(func(string) (string, error) {
		return "", errors.New("not found")
	}, map[string]bool{})
	service.StatusCache = NewProviderStatusCache()
	service.Now = func() time.Time {
		i := int(index.Add(1) - 1)
		if i >= len(times) {
			return times[len(times)-1]
		}
		return times[i]
	}

	snapshot, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}})
	if err != nil {
		t.Fatalf("List() error = %v", err)
	}
	checkedAt := onlyStatus(t, snapshot).Availability.CheckedAt
	if checkedAt == nil || !checkedAt.After(times[0]) {
		t.Fatalf("checkedAt = %v, want after probe start %v", checkedAt, times[0])
	}
}

func TestProviderStatusCacheInvalidatesWhenCredentialsChange(t *testing.T) {
	var authCalls atomic.Int32
	credentialModifiedAt := time.Unix(100, 0).UTC()
	service := testService(func(string) (string, error) {
		return "/usr/bin/true", nil
	}, map[string]bool{"/home/test/.cursor/cli-config.json": true})
	service.StatusCache = NewProviderStatusCache()
	service.Now = time.Now
	service.FileModTime = func(path string) (time.Time, bool) {
		if path == "/home/test/.cursor/cli-config.json" {
			return credentialModifiedAt, true
		}
		return time.Time{}, false
	}
	service.RunAuthStatusCommand = func(context.Context, ProviderSpec, string) (AuthInfo, bool) {
		authCalls.Add(1)
		return AuthInfo{Status: AuthAuthenticated}, true
	}

	for range 2 {
		if _, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}}); err != nil {
			t.Fatalf("List() error = %v", err)
		}
	}
	if got := authCalls.Load(); got != 1 {
		t.Fatalf("auth probes before credential change = %d, want 1", got)
	}
	credentialModifiedAt = credentialModifiedAt.Add(time.Second)
	if _, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}}); err != nil {
		t.Fatalf("List() after credential change error = %v", err)
	}
	if got := authCalls.Load(); got != 2 {
		t.Fatalf("auth probes after credential change = %d, want 2", got)
	}
}

func TestProviderStatusCacheInvalidatesForNewRuntimeAuthEvidence(t *testing.T) {
	var authCalls atomic.Int32
	service := testService(func(string) (string, error) {
		return "/usr/bin/true", nil
	}, map[string]bool{"/home/test/.cursor/cli-config.json": true})
	service.StatusCache = NewProviderStatusCache()
	service.RunOutcomes = NewRunOutcomeStore()
	service.Now = time.Now
	service.FileModTime = func(string) (time.Time, bool) {
		return time.Unix(100, 0), true
	}
	service.RunAuthStatusCommand = func(context.Context, ProviderSpec, string) (AuthInfo, bool) {
		authCalls.Add(1)
		return AuthInfo{Status: AuthAuthenticated, AuthMethod: "oauth"}, true
	}

	configured, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}})
	if err != nil {
		t.Fatalf("initial List() error = %v", err)
	}
	if got := onlyStatus(t, configured).Auth.Status; got != AuthConfigured {
		t.Fatalf("initial auth = %q, want configured", got)
	}
	service.RunOutcomes.RecordSuccess("cursor")

	authenticated, err := service.List(context.Background(), ListInput{Providers: []string{"cursor"}})
	if err != nil {
		t.Fatalf("List() after runtime success error = %v", err)
	}
	if got := onlyStatus(t, authenticated).Auth.Status; got != AuthAuthenticated {
		t.Fatalf("auth after runtime success = %q, want authenticated", got)
	}
	if got := authCalls.Load(); got != 2 {
		t.Fatalf("auth probes after runtime evidence = %d, want cache invalidated", got)
	}
}

func TestProviderStatusCacheDoesNotCacheFailedCodexRepairEvidence(t *testing.T) {
	home := t.TempDir()
	writeCodexBunInstall(t, home, codexBunReadyLauncher)
	service := probeTestService(home)
	service.StatusCache = NewProviderStatusCache()
	var probes atomic.Int32
	service.CodexProtocolProbe = func(context.Context, []string, []string) CodexProbeEvidence {
		probes.Add(1)
		return CodexProbeEvidence{CommandStarted: true, Category: "handshake_timeout"}
	}
	service.RunAuthStatusCommand = func(context.Context, ProviderSpec, string) (AuthInfo, bool) {
		return AuthInfo{Status: AuthAuthenticated}, true
	}

	for range 2 {
		if _, err := service.List(context.Background(), ListInput{Providers: []string{"codex"}}); err != nil {
			t.Fatalf("List() error = %v", err)
		}
	}
	if got := probes.Load(); got != 2 {
		t.Fatalf("failed Codex probes = %d, want fresh probe for each List", got)
	}
}