Files

167 lines
5.6 KiB
Go

package pipeline
import (
"context"
"fmt"
"path/filepath"
"reflect"
"testing"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
func attentionAckFixture(t *testing.T) (*Store, string, []int64) {
t.Helper()
ctx := context.Background()
path := filepath.Join(t.TempDir(), "acks.db")
s, err := Open(path)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { s.Close() })
if _, err := s.Submit(ctx, "acks", Template([]string{"one"}, true)); err != nil {
t.Fatal(err)
}
items, err := s.List(ctx)
if err != nil {
t.Fatal(err)
}
definition, err := s.Get(ctx, items[0].ID, 1)
if err != nil {
t.Fatal(err)
}
var runs []int64
for i := range 2 {
id, _, err := s.CreateRun(ctx, definition, fmt.Sprintf("ack-%d", i), "/work/acks", false, nil, map[string]any{"prompt": "task"})
if err != nil {
t.Fatal(err)
}
runs = append(runs, id)
}
if err := s.RecordOperatorSession(ctx, "ses_seen", "/work/acks", "Seen", "operator"); err != nil {
t.Fatal(err)
}
return s, path, runs
}
func TestAttentionAcksPersistAdvanceAndSkipUnknown(t *testing.T) {
ctx := context.Background()
s, path, runs := attentionAckFixture(t)
empty, err := s.AttentionAcks(ctx)
if err != nil || len(empty.Dismissed) != 0 || len(empty.ChatSeen) != 0 {
t.Fatalf("fresh acks = %+v, %v", empty, err)
}
session, _, err := s.OperatorSession(ctx, "ses_seen")
if err != nil {
t.Fatal(err)
}
failed := fmt.Sprintf("%d:Failed", runs[0])
decision := fmt.Sprintf("%d:Decision", runs[1])
now := time.Now()
delta, all, err := s.AckAttention(ctx, &protocol.AttentionAcks{
Dismissed: []string{failed, failed, decision, "999999:Failed"},
ChatSeen: map[string]int64{"ses_seen": session.UpdatedAt + 5, "ses_gone": 10},
}, now)
if err != nil {
t.Fatal(err)
}
wantKeys := []string{decision, failed}
if decision > failed {
wantKeys = []string{failed, decision}
}
if !reflect.DeepEqual(delta.Dismissed, wantKeys) || !reflect.DeepEqual(all.Dismissed, wantKeys) {
t.Fatalf("dismissed delta=%v all=%v, want %v (unknown run skipped)", delta.Dismissed, all.Dismissed, wantKeys)
}
if len(delta.ChatSeen) != 1 || delta.ChatSeen["ses_seen"] != session.UpdatedAt+5 || len(all.ChatSeen) != 1 {
t.Fatalf("chat seen delta=%v all=%v", delta.ChatSeen, all.ChatSeen)
}
// A repeated dismissal and an older watermark change nothing: the stored
// value never moves backwards and the delta is empty.
delta, all, err = s.AckAttention(ctx, &protocol.AttentionAcks{Dismissed: []string{failed}, ChatSeen: map[string]int64{"ses_seen": 1}}, now)
if err != nil || !delta.Empty() || all.ChatSeen["ses_seen"] != session.UpdatedAt+5 {
t.Fatalf("repeat delta=%+v all=%+v err=%v", delta, all, err)
}
// A stale client value is lifted to the session's registry recency.
recency := session.UpdatedAt + 60_000
if _, err := s.db.ExecContext(ctx, `UPDATE operator_sessions SET last_used_at=? WHERE session_id='ses_seen'`, recency); err != nil {
t.Fatal(err)
}
delta, _, err = s.AckAttention(ctx, &protocol.AttentionAcks{ChatSeen: map[string]int64{"ses_seen": 1}}, now)
if err != nil || delta.ChatSeen["ses_seen"] != recency {
t.Fatalf("lifted delta=%+v err=%v (recency %d)", delta, err, recency)
}
if err := s.Close(); err != nil {
t.Fatal(err)
}
reopened, err := Open(path)
if err != nil {
t.Fatal(err)
}
defer reopened.Close()
again, err := reopened.AttentionAcks(ctx)
if err != nil || !reflect.DeepEqual(again.Dismissed, wantKeys) || again.ChatSeen["ses_seen"] == 0 {
t.Fatalf("after reopen = %+v, %v", again, err)
}
}
func TestAttentionAcksPruneDeletedAndExpired(t *testing.T) {
ctx := context.Background()
s, _, runs := attentionAckFixture(t)
now := time.Now()
old := now.Add(-AttentionAckRetention - time.Hour)
if _, _, err := s.AckAttention(ctx, &protocol.AttentionAcks{Dismissed: []string{fmt.Sprintf("%d:Failed", runs[0])}}, old); err != nil {
t.Fatal(err)
}
if _, _, err := s.AckAttention(ctx, &protocol.AttentionAcks{
Dismissed: []string{fmt.Sprintf("%d:Failed", runs[1])},
ChatSeen: map[string]int64{"ses_seen": 5},
}, now); err != nil {
t.Fatal(err)
}
all, _ := s.AttentionAcks(ctx)
if len(all.Dismissed) != 1 || all.Dismissed[0] != fmt.Sprintf("%d:Failed", runs[1]) {
t.Fatalf("expired dismissal not pruned: %+v", all)
}
if _, err := s.db.ExecContext(ctx, `DELETE FROM pipeline_runs WHERE id=?`, runs[1]); err != nil {
t.Fatal(err)
}
if _, err := s.db.ExecContext(ctx, `DELETE FROM operator_sessions WHERE session_id='ses_seen'`); err != nil {
t.Fatal(err)
}
if err := s.PruneAttentionAcks(ctx, now); err != nil {
t.Fatal(err)
}
all, err := s.AttentionAcks(ctx)
if err != nil || len(all.Dismissed) != 0 || len(all.ChatSeen) != 0 {
t.Fatalf("acks for deleted run/session not pruned: %+v, %v", all, err)
}
}
func TestAttentionAcksRejectMalformed(t *testing.T) {
ctx := context.Background()
s, _, runs := attentionAckFixture(t)
tooMany := make([]string, protocol.MaxAttentionAckItems+1)
for i := range tooMany {
tooMany[i] = fmt.Sprintf("%d:Failed", i+1)
}
for name, ack := range map[string]*protocol.AttentionAcks{
"nil": nil,
"empty": {},
"kind": {Dismissed: []string{fmt.Sprintf("%d:Running", runs[0])}},
"zero run": {Dismissed: []string{"0:Failed"}},
"bare": {Dismissed: []string{"Failed"}},
"session id": {ChatSeen: map[string]int64{"../etc": 4}},
"non-positive": {ChatSeen: map[string]int64{"ses_seen": 0}},
"too many": {Dismissed: tooMany},
} {
if _, _, err := s.AckAttention(ctx, ack, time.Now()); err == nil {
t.Errorf("%s: malformed ack accepted", name)
}
}
all, _ := s.AttentionAcks(ctx)
if !all.Empty() {
t.Fatalf("a refused ack wrote something: %+v", all)
}
}