142 lines
3.9 KiB
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)
|
|
}
|
|
}
|