Files
pipelines/internal/claude/automation_lifecycle_test.go

144 lines
4.7 KiB
Go

package claude
import (
"bytes"
"context"
"encoding/json"
"net"
"os"
"path/filepath"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/claudehost"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
type automationInput struct{ bytes.Buffer }
func (*automationInput) Close() error { return nil }
func TestAutomationCallbacksAcknowledgeUnknownMetadataAndPreserveUnsupported(t *testing.T) {
c := newChat(context.Background())
defer c.cancel()
s := c.sessionFor("callback-cron", t.TempDir())
p := newProcess(s, "")
s.proc = p
input := &automationInput{}
p.stdin = input
call := func(id string, metadata map[string]any) map[string]any {
input.Reset()
request, _ := json.Marshal(map[string]any{"subtype": "hook_callback", "callback_id": id, "input": metadata})
s.handleControlRequest(p, lineEnvelope{RequestID: "hook", Request: request})
var response struct {
Response map[string]any `json:"response"`
}
if err := json.Unmarshal(input.Bytes(), &response); err != nil {
t.Fatal("callback was not acknowledged:", err)
}
return response.Response
}
metadata := map[string]any{"session_id": s.id, "hook_event_name": "Stop", "session_crons": []map[string]string{{"id": "timer"}}}
if r := call(claudehost.NativeAutomationCallbackID, metadata); r["subtype"] != "success" || s.automations == nil {
t.Fatalf("native observation failed: %+v", r)
}
delete(metadata, "session_crons")
if r := call(claudehost.NativeAutomationCallbackID, metadata); r["subtype"] != "success" || s.automations != nil {
t.Fatalf("absent metadata retained stale count or delayed ACK: %+v", r)
}
if r := call("unrelated-sdk-hook", metadata); r["subtype"] != "error" {
t.Fatalf("unrelated callback lost prior unsupported response: %+v", r)
}
}
func TestNativeAutomationsPreventIdleAndExcessProcessReaping(t *testing.T) {
c := newChat(context.Background())
defer c.cancel()
for i := range maxLiveProcesses + 1 {
s := c.sessionFor(string(rune('a'+i)), t.TempDir())
p := newProcess(s, "")
s.proc, s.automationProcess = p, p
s.automations = &claudehost.AutomationSnapshot{SessionID: s.id, IDs: []string{"timer"}, ObservedAtMS: 123}
s.lastUsed = time.Now().Add(-2 * idleProcessExpiry)
}
c.reapIdleAt(time.Now())
for _, s := range c.sessions {
if s.proc == nil {
t.Fatal("native future work was reaped as idle or excess")
}
before := s.proc
s.releaseIdleProcess()
if s.proc != before {
t.Fatal("idle release bypassed native automation retention")
}
}
}
func TestAutomationReadRejectsDeadAndReplacedDirectProcesses(t *testing.T) {
c := newChat(context.Background())
defer c.cancel()
s := c.sessionFor("direct-cron", t.TempDir())
p := newProcess(s, "")
s.proc, s.automationProcess = p, p
s.automations = &claudehost.AutomationSnapshot{SessionID: s.id, IDs: []string{"timer"}, ObservedAtMS: 123}
info, err := c.Automations(context.Background(), s.id)
if err != nil || info.ActiveCount == nil || *info.ActiveCount != 1 {
t.Fatalf("live native snapshot: %+v, %v", info, err)
}
for _, state := range []string{"exited", "missing", "replacement"} {
s.proc = p
p.exited = state == "exited"
if state == "missing" {
s.proc = nil
} else if state == "replacement" {
s.proc = newProcess(s, "")
}
info, err = c.Automations(context.Background(), s.id)
if err != nil || info.Status != protocol.ChatAutomationUnavailable || info.ActiveCount != nil {
t.Fatalf("%s process reused stale timers: %+v, %v", state, info, err)
}
}
}
func TestAutomationRecordFallbackRejectsExitedHost(t *testing.T) {
dir, err := os.MkdirTemp("/tmp", "pcron")
if err != nil {
t.Fatal(err)
}
defer os.RemoveAll(dir)
id := "exited-cron"
socket := filepath.Join(dir, "fixture.sock")
listener, err := net.Listen("unix", socket)
if err != nil {
t.Fatal(err)
}
defer listener.Close()
record, _ := json.Marshal(claudehost.Record{SessionID: id, Socket: socket})
if err := os.WriteFile(claudehost.PathsFor(dir, id).Record, record, 0o600); err != nil {
t.Fatal(err)
}
done := make(chan struct{})
go func() {
defer close(done)
conn, err := listener.Accept()
if err != nil {
return
}
defer conn.Close()
var request claudehost.Frame
_ = json.NewDecoder(conn).Decode(&request)
_ = json.NewEncoder(conn).Encode(claudehost.Frame{Op: claudehost.OpStatus, Status: &claudehost.Status{
SessionID: id, Exited: true,
Automations: &claudehost.AutomationSnapshot{SessionID: id, IDs: []string{"dead"}, ObservedAtMS: 123},
}})
}()
c := newChat(context.Background())
defer c.cancel()
c.hostDir = dir
info, err := c.Automations(context.Background(), id)
if err != nil || info.Status != protocol.ChatAutomationUnavailable || info.ActiveCount != nil {
t.Fatalf("exited host reused a stale native snapshot: %+v, %v", info, err)
}
<-done
}