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) } }