Files
archie/internal/store/store_test.go
T
sam b0050ff20a refactor(state): delete the dead IncrementRetryCount RPC (breaking change, accepted)
IncrementRetryCount had zero production callers -- only tests and the
staterpc plumbing referenced it. taskactions.Service.applyRetry already
uses the atomic RetryTask exclusively, which increments retry_count and
requeues in one transaction.

Unlike ListCaptures/ListUndispatchedCaptures (kept as declared-unconsumed
compatibility surfaces because a rolling deploy could have an old
client/server pairing mid-flight), this repo has one production consumer
(see AGENTS.md's solo-project note), so the breaking removal is accepted
outright rather than deprecated-and-kept. Deleted the Go method, the
storecontract interface entry, the staterpc server/client methods, and the
RPC/messages from state.proto, regenerating the .pb.go/_grpc.pb.go pair.

Test fixtures that used IncrementRetryCount as a setup helper now drive
retry_count through the real path instead: queries_test.go bumps it via
direct SQL (same package, no contract to route through), and
api_tasks_actions_test.go now loops RetryTask+Transition, which exercises
production code instead of a deleted one.
2026-09-15 11:24:57 +10:00

872 lines
27 KiB
Go

package store
import (
"context"
"database/sql"
"errors"
"path/filepath"
"strings"
"sync"
"testing"
"unicode/utf8"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/events"
)
func TestOpenLimitsSQLiteToOneConnection(t *testing.T) {
s := openTest(t)
if got := s.db.Stats().MaxOpenConnections; got != 1 {
t.Fatalf("MaxOpenConnections = %d, want 1", got)
}
}
func TestOpenAppliesPragmasWithTrailingQueryDelimiter(t *testing.T) {
s, err := Open(t.Context(), filepath.Join(t.TempDir(), "tasks.db")+"?")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = s.Close() })
var mode string
if err := s.db.QueryRowContext(t.Context(), `PRAGMA journal_mode`).Scan(&mode); err != nil {
t.Fatal(err)
}
if mode != "wal" {
t.Fatalf("journal_mode = %q, want wal", mode)
}
}
func TestOpenHonorsCancelledContext(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
cancel()
s, err := Open(ctx, filepath.Join(t.TempDir(), "tasks.db"))
if s != nil || !errors.Is(err, context.Canceled) {
t.Fatalf("Open = (%+v, %v), want (nil, context.Canceled)", s, err)
}
}
func TestOpenMigratesUnversionedTaskSchemas(t *testing.T) {
tests := []struct {
name string
columns string
}{
{name: "legacy", columns: "id INTEGER PRIMARY KEY"},
{name: "partially migrated", columns: "id INTEGER PRIMARY KEY, watch_comment_id INTEGER NOT NULL DEFAULT 0, source TEXT NOT NULL DEFAULT 'forge'"},
{name: "fully migrated", columns: "id INTEGER PRIMARY KEY, watch_comment_id INTEGER NOT NULL DEFAULT 0, retry_count INTEGER NOT NULL DEFAULT 0, source TEXT NOT NULL DEFAULT 'forge', identity TEXT NOT NULL DEFAULT ''"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "tasks.db")
db, err := sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
if _, err := db.ExecContext(t.Context(), `CREATE TABLE tasks (`+tt.columns+`)`); err != nil {
t.Fatal(err)
}
if err := db.Close(); err != nil {
t.Fatal(err)
}
s, err := Open(t.Context(), path)
if err != nil {
t.Fatal(err)
}
defer func() { _ = s.Close() }()
var version int
if err := s.db.QueryRowContext(t.Context(), `PRAGMA user_version`).Scan(&version); err != nil {
t.Fatal(err)
}
if version != taskSchemaVersion {
t.Fatalf("user_version = %d, want %d", version, taskSchemaVersion)
}
rows, err := s.db.QueryContext(t.Context(), `PRAGMA table_info(tasks)`)
if err != nil {
t.Fatal(err)
}
defer func() {
if err := rows.Close(); err != nil {
t.Errorf("close table_info rows: %v", err)
}
}()
got := map[string]bool{}
for rows.Next() {
var cid, notNull, primaryKey int
var name, columnType string
var defaultValue any
if err := rows.Scan(&cid, &name, &columnType, &notNull, &defaultValue, &primaryKey); err != nil {
t.Fatal(err)
}
got[name] = true
}
if err := rows.Err(); err != nil {
t.Fatal(err)
}
for _, name := range []string{"watch_comment_id", "retry_count", "source", "identity"} {
if !got[name] {
t.Errorf("column %q was not migrated", name)
}
}
})
}
}
func TestOpenRejectsNewerSchemaVersion(t *testing.T) {
path := filepath.Join(t.TempDir(), "tasks.db")
db, err := sql.Open("sqlite", path)
if err != nil {
t.Fatal(err)
}
if _, err := db.ExecContext(t.Context(), `PRAGMA user_version = 4`); err != nil {
t.Fatal(err)
}
if err := db.Close(); err != nil {
t.Fatal(err)
}
s, err := Open(t.Context(), path)
if s != nil || err == nil || !strings.Contains(err.Error(), "newer than supported") {
t.Fatalf("Open = (%+v, %v), want newer-schema error", s, err)
}
}
func TestPersistenceAcrossRestart(t *testing.T) {
path := filepath.Join(t.TempDir(), "tasks.db")
ctx := t.Context()
s, err := Open(ctx, path)
if err != nil {
t.Fatal(err)
}
if _, err := s.EnqueueIssue(ctx, "acme", "todo", 1, "survive restart", "", "", ""); err != nil {
t.Fatal(err)
}
if err := s.Close(); err != nil {
t.Fatal(err)
}
s, err = Open(ctx, path)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = s.Close() })
task, err := s.TaskByIssue(ctx, "acme", "todo", 1)
if err != nil || task == nil {
t.Fatalf("TaskByIssue after reopen = (%+v, %v)", task, err)
}
if task.Title != "survive restart" {
t.Fatalf("Title = %q, want survive restart", task.Title)
}
}
func TestConcurrentEnqueueAndClaim(t *testing.T) {
s := openTest(t)
ctx := t.Context()
const count = 20
var wg sync.WaitGroup
for number := range count {
wg.Go(func() {
if _, err := s.EnqueueIssue(ctx, "acme", "repo", number, "title", "", "", ""); err != nil {
t.Errorf("EnqueueIssue(%d): %v", number, err)
}
})
}
wg.Wait()
claimed := make(map[int64]struct{}, count)
var mu sync.Mutex
for range count {
wg.Go(func() {
task, err := s.ClaimNext(ctx)
if err != nil {
t.Errorf("ClaimNext: %v", err)
return
}
if task == nil {
t.Error("ClaimNext returned nil task")
return
}
mu.Lock()
claimed[task.ID] = struct{}{}
mu.Unlock()
})
}
wg.Wait()
if len(claimed) != count {
t.Fatalf("claimed %d unique tasks, want %d", len(claimed), count)
}
}
func TestChatIssueNumbersAreDurableAcrossStoreInstances(t *testing.T) {
path := filepath.Join(t.TempDir(), "tasks.db")
stores := make([]*Store, 2)
for i := range stores {
var err error
stores[i], err = Open(t.Context(), path)
if err != nil {
t.Fatal(err)
}
defer func(s *Store) { _ = s.Close() }(stores[i])
}
const count = 20
numbers := make(map[int]struct{}, count)
var mu sync.Mutex
var wg sync.WaitGroup
for i := range count {
wg.Go(func() {
task, err := stores[i%len(stores)].EnqueueChatTask(
t.Context(), "acme", "widget", "chat task", "", "", "archie",
)
if err != nil {
t.Errorf("EnqueueChatTask: %v", err)
return
}
mu.Lock()
numbers[task.IssueNumber] = struct{}{}
mu.Unlock()
})
}
wg.Wait()
if len(numbers) != count {
t.Fatalf("allocated %d unique issue numbers, want %d", len(numbers), count)
}
for number := range numbers {
if number < 1_000_000_000_000_000 || number > 1<<53-1 {
t.Errorf("synthetic issue number %d is outside the reserved JSON-safe range", number)
}
}
}
func TestTasksIncludesIdentity(t *testing.T) {
s := openTest(t)
want, err := s.EnqueueChatTask(t.Context(), "acme", "widget", "chat task", "", "", "reviewer")
if err != nil {
t.Fatal(err)
}
got, err := s.Tasks(t.Context(), 1)
if err != nil {
t.Fatal(err)
}
if len(got) != 1 || got[0].ID != want.ID || got[0].Identity != "reviewer" {
t.Fatalf("Tasks = %+v, want task %d with identity reviewer", got, want.ID)
}
}
func TestStoreOperationsHonorContextCancellation(t *testing.T) {
s := openTest(t)
ctx, cancel := context.WithCancel(context.Background())
cancel()
if task, err := s.ClaimNext(ctx); task != nil || !errors.Is(err, context.Canceled) {
t.Fatalf("ClaimNext = (%+v, %v), want (nil, context.Canceled)", task, err)
}
if task, err := s.TaskByIssue(ctx, "acme", "repo", 1); task != nil || !errors.Is(err, context.Canceled) {
t.Fatalf("TaskByIssue = (%+v, %v), want (nil, context.Canceled)", task, err)
}
}
func TestOversizedEventPayload(t *testing.T) {
s := openTest(t)
detail := strings.Repeat("x", 5000)
id, err := s.InsertEvent(t.Context(), events.Event{Kind: events.KindLog, Detail: detail})
if err != nil {
t.Fatal(err)
}
got, err := s.EventsSince(t.Context(), id-1, 1)
if err != nil {
t.Fatal(err)
}
if len(got) != 1 || got[0].Detail != detail[:4000] {
t.Fatalf("stored detail length = %d, want 4000", len(got[0].Detail))
}
}
func TestInsertEventWithUnmarshalableData(t *testing.T) {
s := openTest(t)
id, err := s.InsertEvent(t.Context(), events.Event{
Kind: events.KindLog,
Data: map[string]any{"channel": make(chan int)},
})
if err != nil {
t.Fatal(err)
}
got, err := s.EventsSince(t.Context(), id-1, 1)
if err != nil {
t.Fatal(err)
}
if len(got) != 1 {
t.Fatalf("events = %d, want 1", len(got))
}
if message, ok := got[0].Data["marshal_error"].(string); !ok || message == "" {
t.Fatalf("marshal_error = %#v, want non-empty string", got[0].Data["marshal_error"])
}
}
func openTest(t *testing.T) *Store {
t.Helper()
s, err := Open(t.Context(), filepath.Join(t.TempDir(), "test.db"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if err := s.Close(); err != nil {
t.Errorf("close store: %v", err)
}
})
return s
}
// TestTasksBindingColumnsRoundTrip confirms the binding_id and
// binding_version columns added in store schema 2 survive an INSERT and a
// full SELECT round-trip through the Task read paths (scanTask,
// TaskByIssue, TaskByID, Tasks).
func TestTasksBindingColumnsRoundTrip(t *testing.T) {
s := openTest(t)
ctx := t.Context()
task, err := s.EnqueueChatTask(ctx, "acme", "widget", "binding task", "body", "implement", "")
if err != nil {
t.Fatalf("EnqueueChatTask: %v", err)
}
if _, err := s.db.ExecContext(ctx,
`UPDATE tasks SET binding_id=?, binding_version=? WHERE id=?`,
int64(42), 3, task.ID); err != nil {
t.Fatalf("UPDATE binding provenance: %v", err)
}
for name, read := range map[string]func() (*workflow.Task, error){
"scanTask-via-TaskByIssue": func() (*workflow.Task, error) { return s.TaskByIssue(ctx, "acme", "widget", task.IssueNumber) },
"TaskByID": func() (*workflow.Task, error) { return s.TaskByID(ctx, task.ID) },
} {
got, err := read()
if err != nil {
t.Fatalf("%s: %v", name, err)
}
if got == nil {
t.Fatalf("%s: nil task", name)
}
if got.BindingID != 42 || got.BindingVersion != 3 {
t.Fatalf("%s: BindingID=%d BindingVersion=%d, want 42/3",
name, got.BindingID, got.BindingVersion)
}
}
listed, err := s.Tasks(ctx, 10)
if err != nil {
t.Fatalf("Tasks: %v", err)
}
if len(listed) == 0 || listed[0].BindingID != 42 || listed[0].BindingVersion != 3 {
t.Fatalf("Tasks() round-trip: %+v", listed)
}
}
func TestClip(t *testing.T) {
tests := []struct {
name string
input string
n int
want string
}{
{"ascii truncate", "hello", 3, "hel"},
{"ascii below n", "hello", 10, "hello"},
{"empty zero", "", 0, ""},
{"empty positive", "", 5, ""},
{"2-byte fits exactly", "café", 5, "café"},
{"2-byte cut off", "café", 4, "caf"},
{"clean ASCII boundary", "café", 3, "caf"},
{"4-byte emoji fits", "🍕pizza", 4, "🍕"},
{"4-byte emoji cut off", "🍕pizza", 3, ""},
{"2-byte ñ fits", "niño", 5, "niño"},
{"2-byte ñ cut off", "niño", 4, "niñ"},
{"3-byte CJK fits", "日本語", 6, "日本"},
{"3-byte CJK cut off", "日本語", 5, "日"},
{"mixed multi-byte", "a🍕b", 5, "a🍕"},
{"mixed multi-byte cut off", "a🍕b", 4, "a"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := clip(tt.input, tt.n)
if got != tt.want {
t.Errorf("clip(%q, %d) = %q, want %q", tt.input, tt.n, got, tt.want)
}
// Verify output is valid UTF-8.
if !utf8.ValidString(got) {
t.Errorf("clip(%q, %d) produced invalid UTF-8: %q", tt.input, tt.n, got)
}
})
}
}
func TestClearTerminalTasks(t *testing.T) {
s := openTest(t)
ctx := context.Background()
statuses := []string{workflow.StatusMerged, workflow.StatusParked, workflow.StatusRejected, workflow.StatusClosedWontDo, workflow.StatusQueued}
for i, status := range statuses {
if _, err := s.EnqueueIssue(ctx, "acme", "widget", i+1, "t", "b", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.TaskByIssue(ctx, "acme", "widget", i+1)
if err != nil || task == nil {
t.Fatalf("TaskByIssue(%d) = (%+v, %v)", i+1, task, err)
}
if status != workflow.StatusQueued {
if err := s.Transition(ctx, task.ID, workflow.StatusQueued, status, ""); err != nil {
t.Fatal(err)
}
}
}
n, err := s.ClearTerminalTasks(ctx)
if err != nil || n != 3 {
t.Fatalf("ClearTerminalTasks = (%d, %v), want (3, nil)", n, err)
}
counts, err := s.StatusCounts(ctx)
if err != nil {
t.Fatal(err)
}
if counts[workflow.StatusQueued] != 1 {
t.Fatalf("expected 1 queued, got %d", counts[workflow.StatusQueued])
}
if counts[workflow.StatusParked] != 1 {
t.Fatalf("recoverable parked task was cleared: count = %d", counts[workflow.StatusParked])
}
for _, status := range []string{workflow.StatusMerged, workflow.StatusRejected, workflow.StatusClosedWontDo} {
if counts[status] != 0 {
t.Fatalf("expected 0 for %s, got %d", status, counts[status])
}
}
// Idempotent: second call removes nothing.
n, err = s.ClearTerminalTasks(ctx)
if err != nil || n != 0 {
t.Fatalf("second ClearTerminalTasks = (%d, %v), want (0, nil)", n, err)
}
}
func TestArchiveTaskIsGuardedAndScoped(t *testing.T) {
s := openTest(t)
ctx := context.Background()
for number := 1; number <= 2; number++ {
if _, err := s.EnqueueIssue(ctx, "acme", "widget", number, "t", "b", "", ""); err != nil {
t.Fatal(err)
}
}
task, err := s.TaskByIssue(ctx, "acme", "widget", 1)
if err != nil || task == nil {
t.Fatalf("TaskByIssue = (%+v, %v)", task, err)
}
if err := s.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
t.Fatal(err)
}
audit := events.Event{Kind: events.KindTaskArchiveRequested, TaskID: task.ID}
if _, err := s.ArchiveTask(ctx, task.ID, workflow.StatusQueued, audit); !errors.Is(err, ErrStaleTransition) {
t.Fatalf("ArchiveTask stale guard = %v, want ErrStaleTransition", err)
}
if got, err := s.TaskByID(ctx, task.ID); err != nil || got == nil {
t.Fatalf("stale archive removed task: (%+v, %v)", got, err)
}
eventID, err := s.ArchiveTask(ctx, task.ID, workflow.StatusMerged, audit)
if err != nil {
t.Fatalf("ArchiveTask = %v", err)
}
if eventID == 0 {
t.Fatal("ArchiveTask returned no durable event ID")
}
if got, err := s.TaskByID(ctx, task.ID); err != nil || got != nil {
t.Fatalf("archived task = (%+v, %v), want nil", got, err)
}
if other, err := s.TaskByIssue(ctx, "acme", "widget", 2); err != nil || other == nil {
t.Fatalf("archive removed another task: (%+v, %v)", other, err)
}
}
func TestArchiveAuditFailurePreservesTask(t *testing.T) {
s := openTest(t)
ctx := t.Context()
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "t", "", "", ""); err != nil {
t.Fatal(err)
}
task, _ := s.TaskByIssue(ctx, "acme", "widget", 1)
if err := s.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusMerged, "done"); err != nil {
t.Fatal(err)
}
if _, err := s.db.ExecContext(ctx, `
CREATE TRIGGER fail_archive_audit BEFORE INSERT ON events
WHEN NEW.kind = 'task_archive_requested'
BEGIN SELECT RAISE(FAIL, 'audit failed'); END`); err != nil {
t.Fatal(err)
}
if _, err := s.ArchiveTask(ctx, task.ID, workflow.StatusMerged, events.Event{
Kind: events.KindTaskArchiveRequested, TaskID: task.ID,
}); err == nil {
t.Fatal("ArchiveTask succeeded despite forced audit failure")
}
if got, err := s.TaskByID(ctx, task.ID); err != nil || got == nil {
t.Fatalf("audit failure deleted task: (%+v, %v)", got, err)
}
}
func TestEnqueueIsIdempotent(t *testing.T) {
s := openTest(t)
ctx := context.Background()
ins, err := s.EnqueueIssue(ctx, "acme", "todo", 1, "add tests", "body", "widget", "")
if err != nil || !ins {
t.Fatalf("first enqueue = (%v, %v)", ins, err)
}
ins, err = s.EnqueueIssue(ctx, "acme", "todo", 1, "add tests", "body", "widget", "")
if err != nil || ins {
t.Fatalf("duplicate enqueue must be a no-op, got (%v, %v)", ins, err)
}
}
func TestEventLogRoundTrip(t *testing.T) {
s := openTest(t)
ctx := context.Background()
id1, err := s.InsertEvent(ctx, events.Event{Kind: "stage_start", TaskID: 1, Stage: "plan"})
if err != nil || id1 == 0 {
t.Fatalf("insert = (%d, %v)", id1, err)
}
id2, err := s.InsertEvent(ctx, events.Event{
Kind: "stage_finish", TaskID: 1, Workflow: "implement", Stage: "plan",
Data: map[string]any{"duration_ms": 1200},
})
if err != nil || id2 <= id1 {
t.Fatalf("second insert = (%d, %v)", id2, err)
}
evs, err := s.EventsSince(ctx, id1, 10)
if err != nil || len(evs) != 1 || evs[0].Kind != "stage_finish" {
t.Fatalf("EventsSince = (%+v, %v)", evs, err)
}
if evs[0].Data["duration_ms"] != float64(1200) {
t.Fatalf("data round-trip = %v", evs[0].Data)
}
timeline, err := s.TaskEvents(ctx, 1)
if err != nil || len(timeline) != 2 {
t.Fatalf("TaskEvents = (%d, %v)", len(timeline), err)
}
stats, err := s.StageStats(ctx)
if err != nil || len(stats) != 1 || stats[0].AvgMs != 1200 || stats[0].Stage != "plan" {
t.Fatalf("StageStats = (%+v, %v)", stats, err)
}
}
// TestTransitionRejectsStaleFrom proves that Transition rejects a call
// whose `from` parameter does not match the task's current status.
// Today Transition ignores the `from` guard, so the call succeeds when
// it should fail — this test captures that bug.
func TestTransitionRejectsStaleFrom(t *testing.T) {
s := openTest(t)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "t", "b", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%v, %v)", task, err)
}
// Task is now workflow.StatusRunning. Transition with from=workflow.StatusQueued
// must fail because the task is not queued.
err = s.Transition(ctx, task.ID, workflow.StatusQueued, workflow.StatusPROpen, "stale from")
if err == nil {
t.Fatal("Transition with stale 'from' (workflow.StatusQueued) on a running task must return an error, but got nil")
}
// Verify the task was NOT changed.
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusRunning {
t.Fatalf("task status changed to %q despite stale from guard; want %q", got.Status, workflow.StatusRunning)
}
}
// TestTransitionPreventsDoubleTransition proves that two callers racing
// to transition the same task from the same `from` status cannot both
// succeed — the second must get an error because the first already
// changed the status.
func TestTransitionPreventsDoubleTransition(t *testing.T) {
s := openTest(t)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "t", "b", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%v, %v)", task, err)
}
// First transition: running → pr_open should succeed.
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusPROpen, "first"); err != nil {
t.Fatalf("first transition = %v", err)
}
// Second transition: the task is now workflow.StatusPROpen, so
// from=workflow.StatusRunning must fail.
err = s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusMerged, "second")
if err == nil {
t.Fatal("second Transition with stale 'from' (workflow.StatusRunning) on a pr_open task must return an error, but got nil")
}
// Verify the task kept the first transition's status.
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusPROpen {
t.Fatalf("task status = %q, want %q (second transition must not overwrite)", got.Status, workflow.StatusPROpen)
}
}
func TestTransitionToParkedPersistsReasonOnTask(t *testing.T) {
s := openTest(t)
ctx := t.Context()
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "task", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
}
const reason = "managed worker unavailable"
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusParked, reason); err != nil {
t.Fatal(err)
}
got, err := s.TaskByID(ctx, task.ID)
if err != nil {
t.Fatal(err)
}
if got.ParkReason != reason {
t.Errorf("ParkReason = %q, want %q", got.ParkReason, reason)
}
}
// TestRequeueRejectsStaleFrom proves that Requeue rejects a call whose
// fromStatus does not match the task's current status.
func TestRequeueRejectsStaleFrom(t *testing.T) {
s := openTest(t)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "t", "b", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%v, %v)", task, err)
}
// Task is workflow.StatusRunning. Requeue with fromStatus=workflow.StatusParked must
// fail because the task is not parked.
err = s.Requeue(ctx, task.ID, workflow.StatusParked, "implement")
if err == nil {
t.Fatal("Requeue with stale fromStatus (workflow.StatusParked) on a running task must return an error, but got nil")
}
// Verify the task was NOT changed.
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusRunning {
t.Fatalf("task status changed to %q despite stale fromStatus guard; want %q", got.Status, workflow.StatusRunning)
}
}
func TestRetryTaskAtomicallyRequeuesAndIncrements(t *testing.T) {
s := openTest(t)
ctx := t.Context()
if _, err := s.EnqueueIssue(ctx, "acme", "todo", 1, "t", "", "", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("ClaimNext = (%+v, %v)", task, err)
}
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusParked, "failed"); err != nil {
t.Fatal(err)
}
if err := s.RetryTask(ctx, task.ID, workflow.StatusParked, ""); err != nil {
t.Fatal(err)
}
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusQueued || got.RetryCount != 1 {
t.Fatalf("task = status %q retry_count %d, want queued/1", got.Status, got.RetryCount)
}
if err := s.RetryTask(ctx, task.ID, workflow.StatusParked, ""); !errors.Is(err, ErrStaleTransition) {
t.Fatalf("stale RetryTask error = %v, want ErrStaleTransition", err)
}
}
func TestRetryTaskWriteFailureLeavesParkedCountUnchanged(t *testing.T) {
s := openTest(t)
ctx := t.Context()
if _, err := s.EnqueueIssue(ctx, "acme", "todo", 1, "t", "", "", ""); err != nil {
t.Fatal(err)
}
task, _ := s.ClaimNext(ctx)
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusParked, "failed"); err != nil {
t.Fatal(err)
}
if _, err := s.db.ExecContext(ctx, `
CREATE TRIGGER fail_retry BEFORE UPDATE OF retry_count ON tasks
BEGIN SELECT RAISE(FAIL, 'retry failed'); END`); err != nil {
t.Fatal(err)
}
if err := s.RetryTask(ctx, task.ID, workflow.StatusParked, ""); err == nil {
t.Fatal("RetryTask succeeded despite forced write failure")
}
got, err := s.TaskByID(ctx, task.ID)
if err != nil || got == nil {
t.Fatalf("TaskByID = (%+v, %v)", got, err)
}
if got.Status != workflow.StatusParked || got.RetryCount != 0 {
t.Fatalf("partial retry write: status %q retry_count %d", got.Status, got.RetryCount)
}
}
func TestRetryCountColumn(t *testing.T) {
s := openTest(t)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "todo", 1, "t", "", "", ""); err != nil {
t.Fatal(err)
}
// Verify column exists and defaults to 0 via direct query.
var count int
if err := s.db.QueryRowContext(ctx,
`SELECT retry_count FROM tasks WHERE owner='acme' AND repo='todo' AND issue_number=1`).Scan(&count); err != nil {
t.Fatalf("retry_count scan failed: %v", err)
}
if count != 0 {
t.Fatalf("default retry_count = %d, want 0", count)
}
}
func TestClaimTransitionAndRecovery(t *testing.T) {
s := openTest(t)
ctx := context.Background()
if _, err := s.EnqueueIssue(ctx, "acme", "todo", 7, "t", "", "archie,bug", ""); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%v, %v)", task, err)
}
if task.Status != workflow.StatusRunning || task.Attempt != 1 || task.Labels != "archie,bug" {
t.Fatalf("claimed task = %+v", task)
}
if next, _ := s.ClaimNext(ctx); next != nil {
t.Fatal("second claim must return nil while task is running")
}
// Crash recovery: running goes back to queued, attempt increments on
// the next claim.
if n, err := s.RecoverStale(ctx); err != nil || n != 1 {
t.Fatalf("recover = (%d, %v)", n, err)
}
task, err = s.ClaimNext(ctx)
if err != nil || task == nil || task.Attempt != 2 {
t.Fatalf("re-claim after recovery = (%+v, %v)", task, err)
}
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusPROpen, "PR #3"); err != nil {
t.Fatal(err)
}
task.PRNumber = 3
if err := s.Update(ctx, task); err != nil {
t.Fatal(err)
}
open, err := s.OpenPRs(ctx)
if err != nil || len(open) != 1 || open[0].PRNumber != 3 {
t.Fatalf("open PRs = (%+v, %v)", open, err)
}
}
func TestRecoverStalePreservesChatTaskRouting(t *testing.T) {
s := openTest(t)
ctx := context.Background()
created, err := s.EnqueueChatTask(ctx, "acme", "todo", "chat task", "", "tdd", "reviewer")
if err != nil {
t.Fatal(err)
}
claimed, err := s.ClaimNext(ctx)
if err != nil || claimed == nil || claimed.ID != created.ID {
t.Fatalf("ClaimNext() = (%+v, %v), want task %d", claimed, err, created.ID)
}
if n, err := s.RecoverStale(ctx); err != nil || n != 1 {
t.Fatalf("RecoverStale() = (%d, %v), want (1, nil)", n, err)
}
recovered, err := s.TaskByID(ctx, created.ID)
if err != nil {
t.Fatal(err)
}
if recovered == nil {
t.Fatal("TaskByID() returned nil after recovery")
}
if recovered.Status != workflow.StatusQueued || recovered.Source != workflow.SourceChat ||
recovered.Identity != "reviewer" || recovered.Workflow != "tdd" {
t.Errorf("recovered task = %+v, want queued chat task routed to reviewer/tdd", recovered)
}
}
func TestLifecycleQueriesPreserveChatTaskRouting(t *testing.T) {
s := openTest(t)
ctx := context.Background()
waiting, err := s.EnqueueChatTask(ctx, "acme", "todo", "needs approval", "", "feasibility", "reviewer")
if err != nil {
t.Fatal(err)
}
if err := s.Transition(ctx, waiting.ID, workflow.StatusQueued, workflow.StatusWaitingHuman, "await approval"); err != nil {
t.Fatal(err)
}
// Routing metadata must survive a status transition: a chat task that
// stops for approval still has to come back to the identity that owns it.
waitingTask, err := s.TaskByID(ctx, waiting.ID)
if err != nil || waitingTask == nil {
t.Fatalf("TaskByID = (%+v, %v)", waitingTask, err)
}
if waitingTask.Status != workflow.StatusWaitingHuman || waitingTask.Source != workflow.SourceChat ||
waitingTask.Identity != "reviewer" {
t.Fatalf("waiting task = %+v, want waiting_human chat/reviewer routing", waitingTask)
}
pr, err := s.EnqueueChatTask(ctx, "acme", "todo", "open PR", "", "implement", "builder")
if err != nil {
t.Fatal(err)
}
pr.PRNumber = 7
if err := s.Update(ctx, pr); err != nil {
t.Fatal(err)
}
if err := s.Transition(ctx, pr.ID, workflow.StatusQueued, workflow.StatusPROpen, "PR #7"); err != nil {
t.Fatal(err)
}
openPRs, err := s.OpenPRs(ctx)
if err != nil {
t.Fatal(err)
}
if len(openPRs) != 1 || openPRs[0].Source != workflow.SourceChat ||
openPRs[0].Identity != "builder" {
t.Fatalf("OpenPRs() = %+v, want chat/builder routing", openPRs)
}
}