Files
archie/internal/gateway/turn_ledger_test.go
T

405 lines
13 KiB
Go

package gateway
import (
"context"
"errors"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgtest"
)
func TestTurnLedgerClaimLifecycleIsIdempotent(t *testing.T) {
tests := []struct {
name string
open func(t *testing.T) (TurnLedger, func())
}{
{
name: "memory",
open: func(t *testing.T) (TurnLedger, func()) {
store := NewSessionStoreMemory()
return asTurnLedger(t, store), func() { _ = store.Close() }
},
},
{
name: "postgres",
open: func(t *testing.T) (TurnLedger, func()) {
store := newPostgresStore(t)
return asTurnLedger(t, store), func() { _ = store.Close() }
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ledger, cleanup := tt.open(t)
t.Cleanup(cleanup)
ctx := context.Background()
now := time.UnixMilli(1000).UTC()
initial := TurnRecord{
TurnID: CanonicalTurnID("session-1", "source-1"),
SessionID: "session-1",
SourceID: "source-1",
Status: TurnStatusAccepted,
CreatedAt: now,
UpdatedAt: now,
}
claimed, result, err := ledger.ClaimTurn(ctx, initial)
if err != nil {
t.Fatalf("first ClaimTurn() error = %v", err)
}
if result != TurnClaimOwned || claimed.Status != TurnStatusRunning || claimed.Attempt != 1 {
t.Fatalf("first claim = %#v, result %q", claimed, result)
}
inFlight, result, err := ledger.ClaimTurn(ctx, initial)
if err != nil {
t.Fatalf("in-flight ClaimTurn() error = %v", err)
}
if result != TurnClaimInProgress || inFlight.TurnID != initial.TurnID {
t.Fatalf("in-flight claim = %#v, result %q", inFlight, result)
}
claimed.Status = TurnStatusCompleted
claimed.ResponseText = "answer"
claimed.AssistantMessageID = "assistant-1"
claimed.UpdatedAt = now.Add(time.Second)
if err := ledger.SaveTurn(ctx, claimed); err != nil {
t.Fatalf("SaveTurn(completed) error = %v", err)
}
completed, result, err := ledger.ClaimTurn(ctx, initial)
if err != nil {
t.Fatalf("completed ClaimTurn() error = %v", err)
}
if result != TurnClaimCompleted || completed.ResponseText != "answer" {
t.Fatalf("completed claim = %#v, result %q", completed, result)
}
completed.Status = TurnStatusFailed
completed.AssistantMessageID = ""
completed.ResponseText = ""
completed.Error = "provider unavailable"
completed.UpdatedAt = now.Add(2 * time.Second)
if err := ledger.SaveTurn(ctx, completed); err != nil {
t.Fatalf("SaveTurn(failed) error = %v", err)
}
retry, result, err := ledger.ClaimTurn(ctx, initial)
if err != nil {
t.Fatalf("retry ClaimTurn() error = %v", err)
}
if result != TurnClaimOwned || retry.Status != TurnStatusRunning || retry.Attempt != 2 {
t.Fatalf("retry claim = %#v, result %q", retry, result)
}
recoverable, err := ledger.ListRecoverableTurns(ctx)
if err != nil {
t.Fatalf("ListRecoverableTurns() error = %v", err)
}
if len(recoverable) != 1 || recoverable[0].TurnID != initial.TurnID {
t.Fatalf("recoverable turns = %#v, want retried turn", recoverable)
}
})
}
}
func TestTurnLedgerReclaimsAcrossProcessOwnersAndRejectsStaleWrites(t *testing.T) {
tests := []struct {
name string
open func(t *testing.T) (TurnLedger, func())
}{
{
name: "memory",
open: func(t *testing.T) (TurnLedger, func()) {
store := NewSessionStoreMemory()
return asTurnLedger(t, store), func() { _ = store.Close() }
},
},
{
name: "postgres",
open: func(t *testing.T) (TurnLedger, func()) {
store := newPostgresStore(t)
return asTurnLedger(t, store), func() { _ = store.Close() }
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ledger, cleanup := tt.open(t)
t.Cleanup(cleanup)
ctx := context.Background()
initial := TurnRecord{
TurnID: CanonicalTurnID("session-owner", "source-owner"),
SessionID: "session-owner",
SourceID: "source-owner",
OwnerID: "process-a",
Status: TurnStatusAccepted,
}
old, claim, err := ledger.ClaimTurn(ctx, initial)
if err != nil || claim != TurnClaimOwned {
t.Fatalf("first claim = %#v, %q, %v", old, claim, err)
}
newOwner := initial
newOwner.OwnerID = "process-b"
inProgress, claim, err := ledger.ClaimTurn(ctx, newOwner)
if err != nil || claim != TurnClaimInProgress {
t.Fatalf("cross-owner claim = %#v, %q, %v; want in progress", inProgress, claim, err)
}
if err := ledger.RecoverTurns(ctx, "process-b"); err != nil {
t.Fatalf("RecoverTurns() error = %v", err)
}
reclaimed, claim, err := ledger.ClaimTurn(ctx, newOwner)
if err != nil || claim != TurnClaimOwned {
t.Fatalf("reclaim = %#v, %q, %v", reclaimed, claim, err)
}
if reclaimed.Attempt != 2 || reclaimed.OwnerID != "process-b" {
t.Fatalf("reclaimed turn = %#v, want attempt 2 owned by process-b", reclaimed)
}
old.Status = TurnStatusCompleted
old.ResponseText = "stale response"
if err := ledger.SaveTurn(ctx, old); !errors.Is(err, ErrTurnOwnershipLost) {
t.Fatalf("stale SaveTurn() error = %v, want ErrTurnOwnershipLost", err)
}
})
}
}
func TestSessionDeleteRemovesTurns(t *testing.T) {
tests := []struct {
name string
open func(t *testing.T) SessionStore
}{
{
name: "memory",
open: func(*testing.T) SessionStore { return NewSessionStoreMemory() },
},
{name: "postgres", open: newPostgresStore},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
store := tt.open(t)
t.Cleanup(func() { _ = store.Close() })
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("store is %T, want TurnLedger", store)
}
ctx := context.Background()
turn := TurnRecord{
TurnID: CanonicalTurnID("session-delete", "source-delete"), SessionID: "session-delete",
SourceID: "source-delete", OwnerID: "process-a", Status: TurnStatusAccepted,
}
if _, claim, err := ledger.ClaimTurn(ctx, turn); err != nil || claim != TurnClaimOwned {
t.Fatalf("ClaimTurn() = %q, %v", claim, err)
}
if err := store.Delete(ctx, turn.SessionID); err != nil {
t.Fatalf("Delete() error = %v", err)
}
if _, ok, err := ledger.GetTurn(ctx, turn.TurnID); err != nil || ok {
t.Fatalf("GetTurn() after delete = ok %v, err %v; want absent", ok, err)
}
})
}
}
func TestTurnLedgerPersistsToolCallsAcrossClaimAndReopen(t *testing.T) {
url := pgtest.URL(t)
ctx := context.Background()
store := openPostgresStoreAt(t, url)
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("store is %T, want TurnLedger", store)
}
turn := TurnRecord{
TurnID: CanonicalTurnID("session-tools", "source-tools"),
SessionID: "session-tools",
SourceID: "source-tools",
OwnerID: "process-a",
Status: TurnStatusAccepted,
}
claimed, claim, err := ledger.ClaimTurn(ctx, turn)
if err != nil || claim != TurnClaimOwned {
t.Fatalf("ClaimTurn() = %#v, %q, %v", claimed, claim, err)
}
claimed.Status = TurnStatusCompleted
claimed.ResponseText = "answer"
claimed.AssistantMessageID = "assistant-1"
claimed.ToolCalls = []ToolCallEvent{
{ID: "call-1", Name: "shell", Parameters: `{"cmd":"ls"}`, Output: "a.txt"},
{ID: "call-2", Name: "grep", Err: "no matches"},
}
if err := ledger.SaveTurn(ctx, claimed); err != nil {
t.Fatalf("SaveTurn() error = %v", err)
}
completed, claim, err := ledger.ClaimTurn(ctx, turn)
if err != nil || claim != TurnClaimCompleted {
t.Fatalf("re-claim = %#v, %q, %v", completed, claim, err)
}
if len(completed.ToolCalls) != 2 || completed.ToolCalls[0].Name != "shell" || completed.ToolCalls[1].Err != "no matches" {
t.Fatalf("re-claimed tool calls = %#v, want the two saved events in order", completed.ToolCalls)
}
if err := store.Close(); err != nil {
t.Fatalf("Close() error = %v", err)
}
reopened := openPostgresStoreAt(t, url)
defer func() { _ = reopened.Close() }()
reopenedLedger, ok := reopened.(TurnLedger)
if !ok {
t.Fatalf("reopened store is %T, want TurnLedger", reopened)
}
got, ok, err := reopenedLedger.GetTurn(ctx, turn.TurnID)
if err != nil || !ok {
t.Fatalf("GetTurn() after reopen = %#v, %v, %v", got, ok, err)
}
if len(got.ToolCalls) != 2 || got.ToolCalls[0].Name != "shell" || got.ToolCalls[1].Name != "grep" {
t.Fatalf("reopened tool calls = %#v, want the two saved events in order", got.ToolCalls)
}
}
func TestPostgresTurnLedgerSurvivesReopen(t *testing.T) {
url := pgtest.URL(t)
ctx := context.Background()
store := openPostgresStoreAt(t, url)
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("store is %T, want TurnLedger", store)
}
turn := TurnRecord{
TurnID: CanonicalTurnID("session-reopen", "source-reopen"),
SessionID: "session-reopen",
SourceID: "source-reopen",
OwnerID: "process-a",
Status: TurnStatusAccepted,
}
claimed, claim, err := ledger.ClaimTurn(ctx, turn)
if err != nil || claim != TurnClaimOwned {
t.Fatalf("ClaimTurn() = %#v, %q, %v", claimed, claim, err)
}
claimed.Status = TurnStatusCompleted
claimed.ResponseText = "durable response"
if err := ledger.SaveTurn(ctx, claimed); err != nil {
t.Fatalf("SaveTurn() error = %v", err)
}
if err := store.Close(); err != nil {
t.Fatalf("Close() error = %v", err)
}
reopened := openPostgresStoreAt(t, url)
defer func() { _ = reopened.Close() }()
reopenedLedger, ok := reopened.(TurnLedger)
if !ok {
t.Fatalf("reopened store is %T, want TurnLedger", reopened)
}
got, ok, err := reopenedLedger.GetTurn(ctx, turn.TurnID)
if err != nil || !ok {
t.Fatalf("GetTurn() after reopen = %#v, %v, %v", got, ok, err)
}
if got.Status != TurnStatusCompleted || got.ResponseText != "durable response" || got.OwnerID != "process-a" {
t.Fatalf("reopened turn = %#v, want completed durable record", got)
}
}
func TestCanonicalTurnIDIsStableAndSessionScoped(t *testing.T) {
first := CanonicalTurnID("session-1", "source-1")
if first == "" {
t.Fatal("CanonicalTurnID() returned empty ID")
}
if got := CanonicalTurnID("session-1", "source-1"); got != first {
t.Fatalf("same key produced %q, want %q", got, first)
}
if got := CanonicalTurnID("session-2", "source-1"); got == first {
t.Fatal("different sessions shared a turn ID")
}
if got := CanonicalTurnID("session-1", ""); got != "" {
t.Fatalf("empty source ID produced %q, want empty", got)
}
}
func TestCanonicalTurnIDComponentsAreInjectivelyEncoded(t *testing.T) {
t.Parallel()
first := CanonicalTurnID("a\x00b", "c")
second := CanonicalTurnID("a", "b\x00c")
if first == second {
t.Fatalf("ambiguous component pairs shared turn ID %q", first)
}
}
func TestTurnRunnerCanonicalTurnIDPreservesMatchingLegacyRecord(t *testing.T) {
t.Parallel()
store := NewSessionStoreMemory()
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("store is %T, want TurnLedger", store)
}
ctx := t.Context()
const (
sessionID = "a\x00b"
sourceID = "c"
)
legacyID := legacyCanonicalTurnID(sessionID, sourceID)
if _, claim, err := ledger.ClaimTurn(ctx, TurnRecord{
TurnID: legacyID, SessionID: sessionID, SourceID: sourceID,
Status: TurnStatusAccepted, OwnerID: "old-process",
}); err != nil || claim != TurnClaimOwned {
t.Fatalf("seed legacy turn = %q, %v", claim, err)
}
runner := NewTurnRunner(TurnRunnerConfig{Ledger: ledger})
got, err := runner.canonicalTurnID(ctx, sessionID, sourceID)
if err != nil {
t.Fatalf("canonicalTurnID: %v", err)
}
if got != legacyID {
t.Fatalf("canonicalTurnID = %q, want matching legacy ID %q", got, legacyID)
}
}
func TestTurnRunnerCanonicalTurnIDRejectsCollidingLegacyRecord(t *testing.T) {
t.Parallel()
store := NewSessionStoreMemory()
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("store is %T, want TurnLedger", store)
}
ctx := t.Context()
const (
firstSession = "a\x00b"
firstSource = "c"
secondSession = "a"
secondSource = "b\x00c"
)
collidingLegacyID := legacyCanonicalTurnID(firstSession, firstSource)
if _, claim, err := ledger.ClaimTurn(ctx, TurnRecord{
TurnID: collidingLegacyID, SessionID: firstSession, SourceID: firstSource,
Status: TurnStatusAccepted, OwnerID: "first-process",
}); err != nil || claim != TurnClaimOwned {
t.Fatalf("seed colliding turn = %q, %v", claim, err)
}
runner := NewTurnRunner(TurnRunnerConfig{Ledger: ledger})
got, err := runner.canonicalTurnID(ctx, secondSession, secondSource)
if err != nil {
t.Fatalf("canonicalTurnID: %v", err)
}
want := CanonicalTurnID(secondSession, secondSource)
if got != want || got == collidingLegacyID {
t.Fatalf("canonicalTurnID = %q, want isolated ID %q (legacy collision %q)",
got, want, collidingLegacyID)
}
}
func asTurnLedger(t *testing.T, store SessionStore) TurnLedger {
t.Helper()
ledger, ok := store.(TurnLedger)
if !ok {
t.Fatalf("%T does not implement TurnLedger", store)
}
return ledger
}