Files
pipelines/internal/claude/hosted_completeness_test.go

142 lines
3.9 KiB
Go

package claude
import (
"context"
"encoding/json"
"net"
"os"
"path/filepath"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/claudehost"
)
func taskReadbackFixture(t *testing.T, serve func(net.Listener, <-chan struct{})) (*Chat, *process) {
t.Helper()
base, err := os.MkdirTemp("/tmp", "pcr")
if err != nil {
t.Fatal(err)
}
socket := filepath.Join(base, "host.sock")
listener, err := net.Listen("unix", socket)
if err != nil {
os.RemoveAll(base)
t.Fatal(err)
}
stop := make(chan struct{})
done := make(chan struct{})
go func() { defer close(done); serve(listener, stop) }()
chat := newChat(context.Background())
p, conn, plan := chat.connectHost(claudehost.Record{SessionID: "completeness-session", Socket: socket})
if p == nil {
close(stop)
listener.Close()
os.RemoveAll(base)
chat.Close()
t.Fatal("readback fixture did not attach")
}
s := p.session
s.mu.Lock()
s.proc = p
s.mu.Unlock()
go p.readHost(conn, plan)
t.Cleanup(func() {
p.detach()
close(stop)
listener.Close()
<-done
chat.Close()
os.RemoveAll(base)
})
return chat, p
}
func serveTaskReadback(conn net.Conn, base, end int64, tasks *[]claudehost.Task) error {
var attach claudehost.Frame
if err := json.NewDecoder(conn).Decode(&attach); err != nil {
return err
}
out := json.NewEncoder(conn)
if err := out.Encode(claudehost.Frame{Op: claudehost.OpStatus, Status: &claudehost.Status{SessionID: "completeness-session", Base: base, Acked: base, End: end, Init: json.RawMessage(`{"models":[{"value":"fixture"}]}`), Tasks: tasks}}); err != nil {
return err
}
return out.Encode(claudehost.Frame{Op: claudehost.OpOut, Offset: base, End: end, Data: json.RawMessage(`{"type":"system","subtype":"status"}`)})
}
func TestLegacyTaskReadbackDistinguishesTrimmedUnknownFromCompleteIdle(t *testing.T) {
empty := []claudehost.Task{}
for _, tc := range []struct {
name string
base int64
tasks *[]claudehost.Task
unknown bool
}{
{name: "trimmed legacy is unknown", base: 200, unknown: true},
{name: "full legacy replay is complete", base: 0},
{name: "new authoritative snapshot survives trim", base: 200, tasks: &empty},
} {
t.Run(tc.name, func(t *testing.T) {
chat, _ := taskReadbackFixture(t, func(listener net.Listener, stop <-chan struct{}) {
conn, err := listener.Accept()
if err != nil {
return
}
defer conn.Close()
if serveTaskReadback(conn, tc.base, tc.base+100, tc.tasks) != nil {
return
}
<-stop
})
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
shells, err := chat.Shells(ctx, "completeness-session")
if (err != nil) != tc.unknown || len(shells) != 0 {
t.Fatalf("incorrect authoritative-empty decision: tasks=%+v err=%v", shells, err)
}
})
}
}
func TestLegacyReconnectGapInvalidatesPreviouslyCompleteTaskReadback(t *testing.T) {
drop := make(chan struct{})
chat, p := taskReadbackFixture(t, func(listener net.Listener, stop <-chan struct{}) {
first, err := listener.Accept()
if err != nil {
return
}
if serveTaskReadback(first, 0, 100, nil) != nil {
first.Close()
return
}
select {
case <-drop:
case <-stop:
first.Close()
return
}
first.Close()
second, err := listener.Accept()
if err != nil {
return
}
defer second.Close()
if serveTaskReadback(second, 300, 400, nil) != nil {
return
}
<-stop
})
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
if shells, err := chat.Shells(ctx, "completeness-session"); err != nil || len(shells) != 0 {
t.Fatalf("initial full replay should be known idle: %+v %v", shells, err)
}
close(drop)
eventually(t, "legacy reconnect gap to make task readback incomplete", func() bool {
return p.link.tasksIncomplete.Load()
})
if shells, err := chat.Shells(ctx, "completeness-session"); err == nil || len(shells) != 0 {
t.Fatalf("missing events became an authoritative empty task set: %+v %v", shells, err)
}
}