396 lines
12 KiB
Go
396 lines
12 KiB
Go
package store
|
||
|
||
import (
|
||
"context"
|
||
"reflect"
|
||
"testing"
|
||
"time"
|
||
|
||
"github.com/samcharles93/archie-core/internal/domain/workflow"
|
||
"github.com/samcharles93/archie-core/internal/events"
|
||
)
|
||
|
||
func TestTaskByIssue(t *testing.T) {
|
||
s := openTest(t)
|
||
ctx := context.Background()
|
||
|
||
if got, err := s.TaskByIssue(ctx, "acme", "widget", 1); err != nil || got != nil {
|
||
t.Fatalf("TaskByIssue on empty store = (%+v, %v)", got, err)
|
||
}
|
||
|
||
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "title", "body", "bug", ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
got, err := s.TaskByIssue(ctx, "acme", "widget", 1)
|
||
if err != nil || got == nil {
|
||
t.Fatalf("TaskByIssue = (%+v, %v)", got, err)
|
||
}
|
||
if got.Title != "title" || got.IssueNumber != 1 {
|
||
t.Fatalf("TaskByIssue = %+v", got)
|
||
}
|
||
|
||
if got, err := s.TaskByIssue(ctx, "acme", "widget", 2); err != nil || got != nil {
|
||
t.Fatalf("TaskByIssue for missing issue = (%+v, %v)", got, err)
|
||
}
|
||
}
|
||
|
||
func TestOpenTaskByPR(t *testing.T) {
|
||
s := openTest(t)
|
||
ctx := t.Context()
|
||
|
||
for i, status := range []string{workflow.StatusPROpen, workflow.StatusMerged, workflow.StatusRejected} {
|
||
issueNumber := i + 1
|
||
prNumber := 101 + i
|
||
if _, err := s.EnqueueIssue(ctx, "acme", "widget", issueNumber, "title", "body", "", ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
task, err := s.TaskByIssue(ctx, "acme", "widget", issueNumber)
|
||
if err != nil || task == nil {
|
||
t.Fatalf("TaskByIssue(%d) = (%+v, %v)", issueNumber, task, err)
|
||
}
|
||
task.PRNumber = prNumber
|
||
if err := s.Update(ctx, task); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := s.Transition(ctx, task.ID, workflow.StatusQueued, status, ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
|
||
got, err := s.OpenTaskByPR(ctx, "acme", "widget", 101)
|
||
if err != nil || got == nil || got.IssueNumber != 1 {
|
||
t.Fatalf("OpenTaskByPR(open) = (%+v, %v)", got, err)
|
||
}
|
||
for _, prNumber := range []int{102, 103, 999} {
|
||
got, err := s.OpenTaskByPR(ctx, "acme", "widget", prNumber)
|
||
if err != nil || got != nil {
|
||
t.Errorf("OpenTaskByPR(%d) = (%+v, %v), want (nil, nil)", prNumber, got, err)
|
||
}
|
||
}
|
||
if got, err := s.OpenTaskByPR(ctx, "other", "widget", 101); err != nil || got != nil {
|
||
t.Errorf("OpenTaskByPR(other owner) = (%+v, %v), want (nil, nil)", got, err)
|
||
}
|
||
|
||
var indexedColumns string
|
||
if err := s.db.QueryRowContext(ctx, `
|
||
SELECT group_concat(name, ',')
|
||
FROM pragma_index_info('idx_tasks_pr')`).Scan(&indexedColumns); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if indexedColumns != "owner,repo,pr_number" {
|
||
t.Fatalf("idx_tasks_pr columns = %q, want owner,repo,pr_number", indexedColumns)
|
||
}
|
||
}
|
||
|
||
func TestRequeueFromWaitingHuman(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)
|
||
}
|
||
|
||
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusWaitingHuman, "needs input"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
waiting, err := s.TaskByID(ctx, task.ID)
|
||
if err != nil || waiting == nil || waiting.Status != workflow.StatusWaitingHuman {
|
||
t.Fatalf("after transition = (%+v, %v), want waiting_human", waiting, err)
|
||
}
|
||
|
||
// Requeue with a workflow forces it (waiting_human -> approved -> implement).
|
||
if err := s.Requeue(ctx, task.ID, workflow.StatusWaitingHuman, "implement"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
requeued, err := s.TaskByIssue(ctx, "acme", "widget", 1)
|
||
if err != nil || requeued == nil || requeued.Status != workflow.StatusQueued || requeued.Workflow != "implement" {
|
||
t.Fatalf("after forced requeue = %+v, %v", requeued, err)
|
||
}
|
||
|
||
// Requeue with an empty workflow keeps the task's current workflow
|
||
// (retrying a parked task).
|
||
task2, err := s.ClaimNext(ctx)
|
||
if err != nil || task2 == nil {
|
||
t.Fatalf("second claim = (%v, %v)", task2, err)
|
||
}
|
||
task2.Workflow = "feasibility"
|
||
if err := s.Update(ctx, task2); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := s.Transition(ctx, task2.ID, workflow.StatusRunning, workflow.StatusParked, "parked"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := s.Requeue(ctx, task2.ID, workflow.StatusParked, ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
retried, err := s.TaskByIssue(ctx, "acme", "widget", 1)
|
||
if err != nil || retried == nil || retried.Status != workflow.StatusQueued || retried.Workflow != "feasibility" {
|
||
t.Fatalf("after empty-workflow requeue = %+v, %v", retried, err)
|
||
}
|
||
if retried.ParkReason != "" {
|
||
t.Fatalf("Requeue must clear park_reason, got %q", retried.ParkReason)
|
||
}
|
||
|
||
// Verify retry_count is NOT reset by Requeue (it persists). Bumped
|
||
// directly rather than through RetryTask, which also transitions
|
||
// status -- this fixture only needs the counter moved.
|
||
if _, err := s.db.ExecContext(ctx, `UPDATE tasks SET retry_count = retry_count + 1 WHERE id = ?`, task2.ID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := s.db.ExecContext(ctx, `UPDATE tasks SET retry_count = retry_count + 1 WHERE id = ?`, task2.ID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
// Park again and requeue.
|
||
if err := s.Transition(ctx, task2.ID, workflow.StatusQueued, workflow.StatusParked, "parked again"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := s.Requeue(ctx, task2.ID, workflow.StatusParked, ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
afterRequeue, err := s.TaskByIssue(ctx, "acme", "widget", 1)
|
||
if err != nil || afterRequeue == nil {
|
||
t.Fatalf("TaskByIssue after second requeue = (%+v, %v)", afterRequeue, err)
|
||
}
|
||
if afterRequeue.RetryCount != 2 {
|
||
t.Fatalf("Requeue must not reset retry_count, got %d, want 2", afterRequeue.RetryCount)
|
||
}
|
||
}
|
||
|
||
func TestTasksListingAndStatusCounts(t *testing.T) {
|
||
s := openTest(t)
|
||
ctx := context.Background()
|
||
|
||
for i, status := range []string{workflow.StatusQueued, workflow.StatusRunning, workflow.StatusPROpen} {
|
||
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)
|
||
}
|
||
}
|
||
}
|
||
|
||
tasks, err := s.Tasks(ctx, 10)
|
||
if err != nil || len(tasks) != 3 {
|
||
t.Fatalf("Tasks = (%d, %v)", len(tasks), err)
|
||
}
|
||
|
||
limited, err := s.Tasks(ctx, 2)
|
||
if err != nil || len(limited) != 2 {
|
||
t.Fatalf("Tasks with limit = (%d, %v)", len(limited), err)
|
||
}
|
||
|
||
counts, err := s.StatusCounts(ctx)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
want := map[string]int{workflow.StatusQueued: 1, workflow.StatusRunning: 1, workflow.StatusPROpen: 1}
|
||
for status, n := range want {
|
||
if counts[status] != n {
|
||
t.Fatalf("StatusCounts[%s] = %d, want %d (all: %+v)", status, counts[status], n, counts)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestWorkflowStats(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.Workflow = "implement"
|
||
task.TokensUsed = 1000
|
||
task.Iterations = 4
|
||
if err := s.Update(ctx, task); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if err := s.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusMerged, "merged"); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
stats, err := s.WorkflowStats(ctx)
|
||
if err != nil || len(stats) != 1 {
|
||
t.Fatalf("WorkflowStats = (%+v, %v)", stats, err)
|
||
}
|
||
got := stats[0]
|
||
if got.Workflow != "implement" || got.Runs != 1 || got.Merged != 1 || got.AvgTokens != 1000 || got.TotalToken != 1000 {
|
||
t.Fatalf("WorkflowStats[0] = %+v", got)
|
||
}
|
||
}
|
||
|
||
func TestTokensByDayFallsBackToTaskTotals(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.TokensUsed = 904901
|
||
if err := s.Update(ctx, task); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := s.db.ExecContext(ctx, `UPDATE tasks SET updated_at=? WHERE id=?`, "2026-08-14 12:00:00", task.ID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
got, err := s.TokensByDay(ctx, 14)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
want := []DayTokens{{Day: "2026-08-14", Tokens: 904901}}
|
||
if !reflect.DeepEqual(got, want) {
|
||
t.Fatalf("TokensByDay = %#v, want %#v", got, want)
|
||
}
|
||
}
|
||
|
||
func TestTokensByDayUsesEventsAndIgnoresMalformedTokenFields(t *testing.T) {
|
||
s := openTest(t)
|
||
ctx := context.Background()
|
||
|
||
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 1, "event task", "b", "", ""); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
eventTask, err := s.ClaimNext(ctx)
|
||
if err != nil || eventTask == nil {
|
||
t.Fatalf("claim event task = (%v, %v)", eventTask, err)
|
||
}
|
||
eventTask.TokensUsed = 999
|
||
if err := s.Update(ctx, eventTask); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if _, err := s.db.ExecContext(ctx, `UPDATE tasks SET updated_at=? WHERE id=?`, "2026-08-14 12:00:00", eventTask.ID); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
for _, ev := range []events.Event{
|
||
{Kind: events.KindAgentFinish, TaskID: eventTask.ID, At: time.Date(2026, 8, 13, 12, 0, 0, 0, time.UTC), Data: map[string]any{"tokens": 30}},
|
||
{Kind: events.KindAgentFinish, TaskID: eventTask.ID, At: time.Date(2026, 8, 14, 12, 0, 0, 0, time.UTC), Data: map[string]any{"tokens": 70}},
|
||
{Kind: events.KindAgentFinish, TaskID: eventTask.ID, At: time.Date(2026, 8, 14, 13, 0, 0, 0, time.UTC), Data: map[string]any{"tokens": "bad"}},
|
||
} {
|
||
if _, err := s.InsertEvent(ctx, ev); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
|
||
got, err := s.TokensByDay(ctx, 14)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
want := []DayTokens{{Day: "2026-08-14", Tokens: 70}, {Day: "2026-08-13", Tokens: 30}}
|
||
if !reflect.DeepEqual(got, want) {
|
||
t.Fatalf("TokensByDay = %#v, want %#v", got, want)
|
||
}
|
||
}
|
||
|
||
func TestTokensByDayReturnsEmptySlice(t *testing.T) {
|
||
s := openTest(t)
|
||
got, err := s.TokensByDay(t.Context(), 14)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
if got == nil || len(got) != 0 {
|
||
t.Fatalf("TokensByDay = %#v, want non-nil empty slice", got)
|
||
}
|
||
}
|
||
|
||
func TestStageStats(t *testing.T) {
|
||
s := openTest(t)
|
||
ctx := context.Background()
|
||
|
||
// Insert 6 stage_finish events across 2 workflows × 3 stage groups.
|
||
// plan/draft: 3 runs, avg 400 ms, 1 error
|
||
// plan/review: 1 run, avg 300 ms, 0 errors
|
||
// implement/build: 2 runs, avg 1500 ms, 1 error
|
||
|
||
type stageEvent struct {
|
||
workflow string
|
||
stage string
|
||
durationMs int
|
||
errorMsg string // empty means no error key
|
||
}
|
||
|
||
inputs := []stageEvent{
|
||
{workflow: "plan", stage: "draft", durationMs: 200},
|
||
{workflow: "plan", stage: "draft", durationMs: 400},
|
||
{workflow: "plan", stage: "draft", durationMs: 600, errorMsg: "something broke"},
|
||
|
||
{workflow: "plan", stage: "review", durationMs: 300},
|
||
|
||
{workflow: "implement", stage: "build", durationMs: 1000},
|
||
{workflow: "implement", stage: "build", durationMs: 2000, errorMsg: "build failed"},
|
||
}
|
||
|
||
for _, in := range inputs {
|
||
data := map[string]any{"duration_ms": in.durationMs}
|
||
if in.errorMsg != "" {
|
||
data["error"] = in.errorMsg
|
||
}
|
||
if _, err := s.InsertEvent(ctx, events.Event{
|
||
Kind: "stage_finish",
|
||
Workflow: in.workflow,
|
||
Stage: in.stage,
|
||
Data: data,
|
||
}); err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
}
|
||
|
||
stats, err := s.StageStats(ctx)
|
||
if err != nil {
|
||
t.Fatal(err)
|
||
}
|
||
|
||
if len(stats) != 3 {
|
||
t.Fatalf("StageStats: got %d groups, want 3: %+v", len(stats), stats)
|
||
}
|
||
|
||
// Verify ordering: workflow then stage.
|
||
want := []struct {
|
||
workflow string
|
||
stage string
|
||
runs int
|
||
avgMs int
|
||
errors int
|
||
}{
|
||
{workflow: "implement", stage: "build", runs: 2, avgMs: 1500, errors: 1},
|
||
{workflow: "plan", stage: "draft", runs: 3, avgMs: 400, errors: 1},
|
||
{workflow: "plan", stage: "review", runs: 1, avgMs: 300, errors: 0},
|
||
}
|
||
|
||
for i, w := range want {
|
||
got := stats[i]
|
||
if got.Workflow != w.workflow {
|
||
t.Fatalf("stats[%d].Workflow = %q, want %q", i, got.Workflow, w.workflow)
|
||
}
|
||
if got.Stage != w.stage {
|
||
t.Fatalf("stats[%d].Stage = %q, want %q", i, got.Stage, w.stage)
|
||
}
|
||
if got.Runs != w.runs {
|
||
t.Fatalf("stats[%d].Runs = %d, want %d", i, got.Runs, w.runs)
|
||
}
|
||
if got.AvgMs != w.avgMs {
|
||
t.Fatalf("stats[%d].AvgMs = %d, want %d", i, got.AvgMs, w.avgMs)
|
||
}
|
||
if got.Errors != w.errors {
|
||
t.Fatalf("stats[%d].Errors = %d, want %d", i, got.Errors, w.errors)
|
||
}
|
||
}
|
||
}
|