package sqlite //revive:disable:file-length-limit // Task plan HEAD + revision persistence coverage is intentionally scenario-heavy. import ( "context" "errors" "strings" "testing" "time" "github.com/kandev/kandev/internal/task/models" ) func assertTaskPlanEqual(t *testing.T, got, want *models.TaskPlan) { t.Helper() if got == nil { t.Fatal("plan is nil") } if got.ID != want.ID { t.Errorf("ID = %q, want %q", got.ID, want.ID) } if got.TaskID != want.TaskID { t.Errorf("TaskID = %q, want %q", got.TaskID, want.TaskID) } if got.Title != want.Title { t.Errorf("Title = %q, want %q", got.Title, want.Title) } if got.Content != want.Content { t.Errorf("Content = %q, want %q", got.Content, want.Content) } if got.CreatedBy != want.CreatedBy { t.Errorf("CreatedBy = %q, want %q", got.CreatedBy, want.CreatedBy) } assertTimeEqual(t, "CreatedAt", got.CreatedAt, want.CreatedAt) assertTimeEqual(t, "UpdatedAt", got.UpdatedAt, want.UpdatedAt) assertOptionalString(t, "ImplementationStartedSessionID", got.ImplementationStartedSessionID, want.ImplementationStartedSessionID) assertOptionalString(t, "ImplementationStartedBy", got.ImplementationStartedBy, want.ImplementationStartedBy) switch { case want.ImplementationStartedAt == nil && got.ImplementationStartedAt != nil: t.Errorf("ImplementationStartedAt = %v, want nil", *got.ImplementationStartedAt) case want.ImplementationStartedAt != nil && got.ImplementationStartedAt == nil: t.Errorf("ImplementationStartedAt = nil, want %v", *want.ImplementationStartedAt) case want.ImplementationStartedAt != nil && !got.ImplementationStartedAt.Truncate(time.Microsecond).Equal(want.ImplementationStartedAt.Truncate(time.Microsecond)): t.Errorf("ImplementationStartedAt = %v, want %v", *got.ImplementationStartedAt, *want.ImplementationStartedAt) } } func assertOptionalString(t *testing.T, label string, got, want *string) { t.Helper() switch { case want == nil && got != nil: t.Errorf("%s = %q, want nil", label, *got) case want != nil && got == nil: t.Errorf("%s = nil, want %q", label, *want) case want != nil && *got != *want: t.Errorf("%s = %q, want %q", label, *got, *want) } } func assertPlanRevisionEqual(t *testing.T, got, want *models.TaskPlanRevision) { t.Helper() if got == nil { t.Fatal("revision is nil") } if got.ID != want.ID { t.Errorf("ID = %q, want %q", got.ID, want.ID) } if got.TaskID != want.TaskID { t.Errorf("TaskID = %q, want %q", got.TaskID, want.TaskID) } if got.RevisionNumber != want.RevisionNumber { t.Errorf("RevisionNumber = %d, want %d", got.RevisionNumber, want.RevisionNumber) } if got.Title != want.Title { t.Errorf("Title = %q, want %q", got.Title, want.Title) } if got.Content != want.Content { t.Errorf("Content = %q, want %q", got.Content, want.Content) } if got.AuthorKind != want.AuthorKind { t.Errorf("AuthorKind = %q, want %q", got.AuthorKind, want.AuthorKind) } if got.AuthorName != want.AuthorName { t.Errorf("AuthorName = %q, want %q", got.AuthorName, want.AuthorName) } if got.WorkflowStepID != want.WorkflowStepID { t.Errorf("WorkflowStepID = %q, want %q", got.WorkflowStepID, want.WorkflowStepID) } if got.WorkflowStepName != want.WorkflowStepName { t.Errorf("WorkflowStepName = %q, want %q", got.WorkflowStepName, want.WorkflowStepName) } if got.WorkflowStepColor != want.WorkflowStepColor { t.Errorf("WorkflowStepColor = %q, want %q", got.WorkflowStepColor, want.WorkflowStepColor) } assertOptionalString(t, "RevertOfRevisionID", got.RevertOfRevisionID, want.RevertOfRevisionID) assertTimeEqual(t, "CreatedAt", got.CreatedAt, want.CreatedAt) assertTimeEqual(t, "UpdatedAt", got.UpdatedAt, want.UpdatedAt) } func TestCreateTaskPlanRoundTripsEveryField(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-full") before := time.Now().UTC().Add(-time.Second) want := &models.TaskPlan{ ID: "plan-full", TaskID: "task-plan-full", Title: "Implementation plan", Content: "## Steps\n1. do it", CreatedBy: "user", } if err := repo.CreateTaskPlan(ctx, want); err != nil { t.Fatalf("CreateTaskPlan: %v", err) } if want.CreatedAt.Before(before) || !want.CreatedAt.Equal(want.UpdatedAt) { t.Fatalf("CreateTaskPlan stamped CreatedAt=%v UpdatedAt=%v, want equal times after %v", want.CreatedAt, want.UpdatedAt, before) } got, err := repo.GetTaskPlan(ctx, "task-plan-full") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } assertTaskPlanEqual(t, got, want) } func TestCreateTaskPlanAppliesDefaultsForEmptyFields(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-defaults") plan := &models.TaskPlan{TaskID: "task-plan-defaults", Content: "body"} if err := repo.CreateTaskPlan(ctx, plan); err != nil { t.Fatalf("CreateTaskPlan: %v", err) } if plan.ID == "" { t.Fatal("ID left empty; a UUID should have been generated") } if plan.Title != "Plan" { t.Errorf("Title = %q, want the %q default", plan.Title, "Plan") } if plan.CreatedBy != authorKindAgent { t.Errorf("CreatedBy = %q, want the %q default", plan.CreatedBy, authorKindAgent) } got, err := repo.GetTaskPlan(ctx, "task-plan-defaults") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } if got.Title != "Plan" || got.CreatedBy != authorKindAgent { t.Errorf("persisted defaults = %q/%q, want Plan/%s", got.Title, got.CreatedBy, authorKindAgent) } if got.ImplementationStartedAt != nil || got.ImplementationStartedSessionID != nil || got.ImplementationStartedBy != nil { t.Errorf("implementation markers = %+v, want all nil on a fresh plan", got) } } func TestCreateTaskPlanRejectsSecondPlanForSameTask(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-unique") if err := repo.CreateTaskPlan(ctx, &models.TaskPlan{ ID: "plan-unique-1", TaskID: "task-plan-unique", Title: "One", Content: "one", }); err != nil { t.Fatalf("CreateTaskPlan(first): %v", err) } if err := repo.CreateTaskPlan(ctx, &models.TaskPlan{ ID: "plan-unique-2", TaskID: "task-plan-unique", Title: "Two", Content: "two", }); err == nil { t.Fatal("CreateTaskPlan accepted a second plan for the same task; task_id is UNIQUE") } got, err := repo.GetTaskPlan(ctx, "task-plan-unique") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } if got.Title != "One" { t.Errorf("Title = %q, want the original %q", got.Title, "One") } } func TestGetTaskPlanReturnsNilNilWhenMissing(t *testing.T) { repo := newRepoForEntityTests(t) got, err := repo.GetTaskPlan(context.Background(), "task-plan-missing") if err != nil { t.Fatalf("GetTaskPlan returned error %v, want the nil,nil not-found contract", err) } if got != nil { t.Errorf("GetTaskPlan = %+v, want nil", got) } } func TestUpdateTaskPlanWritesMutableFieldsAndReportsMissing(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-update") plan := &models.TaskPlan{ ID: "plan-update", TaskID: "task-plan-update", Title: "Before", Content: "old", CreatedBy: "agent", } if err := repo.CreateTaskPlan(ctx, plan); err != nil { t.Fatalf("CreateTaskPlan: %v", err) } createdAt := plan.CreatedAt plan.Title = "After" plan.Content = "new" plan.CreatedBy = "user" if err := repo.UpdateTaskPlan(ctx, plan); err != nil { t.Fatalf("UpdateTaskPlan: %v", err) } got, err := repo.GetTaskPlan(ctx, "task-plan-update") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } assertTaskPlanEqual(t, got, plan) if !got.CreatedAt.Equal(createdAt) { t.Errorf("CreatedAt = %v, want it preserved at %v", got.CreatedAt, createdAt) } err = repo.UpdateTaskPlan(ctx, &models.TaskPlan{TaskID: "task-plan-nowhere", Title: "x"}) if err == nil { t.Fatal("UpdateTaskPlan on a missing row returned nil") } if !strings.Contains(err.Error(), "task plan not found") { t.Errorf("UpdateTaskPlan error = %q, want a task-plan-not-found message", err) } } func TestDeleteTaskPlanRemovesRowAndReportsMissing(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-delete") seedTaskForDocs(t, repo, "task-plan-keep") for _, taskID := range []string{"task-plan-delete", "task-plan-keep"} { if err := repo.CreateTaskPlan(ctx, &models.TaskPlan{ ID: "plan-" + taskID, TaskID: taskID, Title: "Plan", Content: taskID, }); err != nil { t.Fatalf("CreateTaskPlan(%s): %v", taskID, err) } } if err := repo.DeleteTaskPlan(ctx, "task-plan-delete"); err != nil { t.Fatalf("DeleteTaskPlan: %v", err) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plans WHERE task_id = ?`, "task-plan-delete"); got != 0 { t.Errorf("rows after delete = %d, want 0", got) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plans WHERE task_id = ?`, "task-plan-keep"); got != 1 { t.Errorf("other task's plan rows = %d, want 1 (delete must be task-scoped)", got) } err := repo.DeleteTaskPlan(ctx, "task-plan-delete") if err == nil { t.Fatal("second DeleteTaskPlan returned nil; a missing row must be reported") } if !strings.Contains(err.Error(), "task plan not found") { t.Errorf("DeleteTaskPlan error = %q, want a task-plan-not-found message", err) } } func TestMarkTaskPlanImplementationStartedIsIdempotent(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-mark") plan := &models.TaskPlan{ID: "plan-mark", TaskID: "task-plan-mark", Title: "Plan", Content: "body"} if err := repo.CreateTaskPlan(ctx, plan); err != nil { t.Fatalf("CreateTaskPlan: %v", err) } createdUpdatedAt := plan.UpdatedAt marked, err := repo.MarkTaskPlanImplementationStarted(ctx, "task-plan-mark", "session-first", "jcfs") if err != nil { t.Fatalf("MarkTaskPlanImplementationStarted: %v", err) } if marked.ImplementationStartedAt == nil { t.Fatal("ImplementationStartedAt = nil, want the first-start marker set") } assertOptionalString(t, "ImplementationStartedSessionID", marked.ImplementationStartedSessionID, strptr("session-first")) assertOptionalString(t, "ImplementationStartedBy", marked.ImplementationStartedBy, strptr("jcfs")) if !marked.UpdatedAt.After(createdUpdatedAt) { t.Errorf("UpdatedAt = %v, want it bumped past %v on the first mark", marked.UpdatedAt, createdUpdatedAt) } firstStartedAt := *marked.ImplementationStartedAt firstUpdatedAt := marked.UpdatedAt second, err := repo.MarkTaskPlanImplementationStarted(ctx, "task-plan-mark", "session-second", "someone-else") if err != nil { t.Fatalf("second MarkTaskPlanImplementationStarted: %v", err) } if !second.ImplementationStartedAt.Equal(firstStartedAt) { t.Errorf("ImplementationStartedAt = %v, want the first value %v preserved", *second.ImplementationStartedAt, firstStartedAt) } assertOptionalString(t, "ImplementationStartedSessionID", second.ImplementationStartedSessionID, strptr("session-first")) assertOptionalString(t, "ImplementationStartedBy", second.ImplementationStartedBy, strptr("jcfs")) if !second.UpdatedAt.Equal(firstUpdatedAt) { t.Errorf("UpdatedAt = %v, want it unchanged at %v on a repeat mark", second.UpdatedAt, firstUpdatedAt) } } func TestMarkTaskPlanImplementationStartedReturnsSentinelWhenPlanMissing(t *testing.T) { repo := newRepoForEntityTests(t) got, err := repo.MarkTaskPlanImplementationStarted(context.Background(), "task-plan-absent", "session", "actor") if got != nil { t.Errorf("plan = %+v, want nil", got) } if !errors.Is(err, ErrTaskPlanNotFound) { t.Fatalf("error = %v, want ErrTaskPlanNotFound", err) } if !strings.Contains(err.Error(), "task-plan-absent") { t.Errorf("error = %q, want the task id included for diagnostics", err) } } func TestInsertTaskPlanRevisionRoundTripsEveryField(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-planrev-full") revertOf := "rev-earlier" want := &models.TaskPlanRevision{ ID: "planrev-full", TaskID: "task-planrev-full", RevisionNumber: 4, Title: "Plan v4", Content: "four", AuthorKind: "user", AuthorName: "jcfs", RevertOfRevisionID: &revertOf, WorkflowStepID: "step-build", WorkflowStepName: "Build", WorkflowStepColor: "bg-blue-500", CreatedAt: time.Date(2026, 6, 6, 6, 6, 6, 789000000, time.UTC), } if err := repo.InsertTaskPlanRevision(ctx, want); err != nil { t.Fatalf("InsertTaskPlanRevision: %v", err) } got, err := repo.GetTaskPlanRevision(ctx, "planrev-full") if err != nil { t.Fatalf("GetTaskPlanRevision: %v", err) } assertPlanRevisionEqual(t, got, want) latest, err := repo.GetLatestTaskPlanRevision(ctx, "task-planrev-full") if err != nil { t.Fatalf("GetLatestTaskPlanRevision: %v", err) } assertPlanRevisionEqual(t, latest, want) listed, err := repo.ListTaskPlanRevisions(ctx, "task-planrev-full", 0) if err != nil { t.Fatalf("ListTaskPlanRevisions: %v", err) } if len(listed) != 1 { t.Fatalf("ListTaskPlanRevisions returned %d rows, want 1", len(listed)) } assertPlanRevisionEqual(t, listed[0], want) } func TestInsertTaskPlanRevisionDefaultsIDAndCreatedAt(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-planrev-defaults") before := time.Now().UTC().Add(-time.Second) rev := &models.TaskPlanRevision{ TaskID: "task-planrev-defaults", RevisionNumber: 1, Title: "Plan", Content: "v1", AuthorKind: "agent", } if err := repo.InsertTaskPlanRevision(ctx, rev); err != nil { t.Fatalf("InsertTaskPlanRevision: %v", err) } if rev.ID == "" { t.Fatal("ID left empty; a UUID should have been generated") } if rev.CreatedAt.Before(before) { t.Errorf("CreatedAt = %v, want a freshly stamped time after %v", rev.CreatedAt, before) } got, err := repo.GetTaskPlanRevision(ctx, rev.ID) if err != nil { t.Fatalf("GetTaskPlanRevision: %v", err) } if got.RevertOfRevisionID != nil { t.Errorf("RevertOfRevisionID = %q, want nil for a NULL column", *got.RevertOfRevisionID) } } func TestInsertTaskPlanRevisionRejectsDuplicateRevisionNumber(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-planrev-dupe") if err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{ ID: "planrev-dupe-1", TaskID: "task-planrev-dupe", RevisionNumber: 1, Title: "Plan", Content: "one", AuthorKind: "agent", }); err != nil { t.Fatalf("InsertTaskPlanRevision(first): %v", err) } err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{ ID: "planrev-dupe-2", TaskID: "task-planrev-dupe", RevisionNumber: 1, Title: "Plan", Content: "two", AuthorKind: "agent", }) if err == nil { t.Fatal("InsertTaskPlanRevision accepted a duplicate (task_id, revision_number)") } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plan_revisions WHERE task_id = ?`, "task-planrev-dupe"); got != 1 { t.Errorf("rows = %d, want 1 (the duplicate must not land)", got) } } func TestUpdateTaskPlanRevisionMergesTitleAndContentOnly(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-planrev-update") rev := &models.TaskPlanRevision{ ID: "planrev-update", TaskID: "task-planrev-update", RevisionNumber: 2, Title: "Before", Content: "old", AuthorKind: "agent", AuthorName: "claude", CreatedAt: time.Date(2026, 1, 1, 1, 1, 1, 0, time.UTC), } if err := repo.InsertTaskPlanRevision(ctx, rev); err != nil { t.Fatalf("InsertTaskPlanRevision: %v", err) } rev.Title = "After" rev.Content = "new" rev.AuthorKind = "user" rev.AuthorName = "ignored" if err := repo.UpdateTaskPlanRevision(ctx, rev); err != nil { t.Fatalf("UpdateTaskPlanRevision: %v", err) } got, err := repo.GetTaskPlanRevision(ctx, "planrev-update") if err != nil { t.Fatalf("GetTaskPlanRevision: %v", err) } if got.Title != "After" || got.Content != "new" { t.Errorf("merged revision = %q/%q, want After/new", got.Title, got.Content) } if got.AuthorKind != "agent" || got.AuthorName != "claude" { t.Errorf("author = %q/%q, want the stored agent/claude — the UPDATE must not touch author columns", got.AuthorKind, got.AuthorName) } if got.RevisionNumber != 2 { t.Errorf("RevisionNumber = %d, want 2 preserved", got.RevisionNumber) } if !got.CreatedAt.Equal(time.Date(2026, 1, 1, 1, 1, 1, 0, time.UTC)) { t.Errorf("CreatedAt = %v, want it preserved", got.CreatedAt) } if !got.UpdatedAt.Equal(rev.UpdatedAt) { t.Errorf("UpdatedAt = %v, want the refreshed %v", got.UpdatedAt, rev.UpdatedAt) } err = repo.UpdateTaskPlanRevision(ctx, &models.TaskPlanRevision{ID: "planrev-nowhere", Title: "x"}) if err == nil { t.Fatal("UpdateTaskPlanRevision on a missing row returned nil") } if !strings.Contains(err.Error(), "task plan revision not found") { t.Errorf("error = %q, want a task-plan-revision-not-found message", err) } } func TestGetTaskPlanRevisionReturnsNilNilWhenMissing(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() got, err := repo.GetTaskPlanRevision(ctx, "planrev-missing") if err != nil { t.Fatalf("GetTaskPlanRevision returned error %v, want nil,nil", err) } if got != nil { t.Errorf("GetTaskPlanRevision = %+v, want nil", got) } latest, err := repo.GetLatestTaskPlanRevision(ctx, "task-planrev-missing") if err != nil { t.Fatalf("GetLatestTaskPlanRevision returned error %v, want nil,nil", err) } if latest != nil { t.Errorf("GetLatestTaskPlanRevision = %+v, want nil", latest) } } func TestListTaskPlanRevisionsOrdersDescendingAndHonoursLimit(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-planrev-list") seedTaskForDocs(t, repo, "task-planrev-noise") for number := 1; number <= 3; number++ { if err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{ ID: "planrev-list-" + string(rune('0'+number)), TaskID: "task-planrev-list", RevisionNumber: number, Title: "Plan", Content: "v", AuthorKind: "agent", }); err != nil { t.Fatalf("InsertTaskPlanRevision(%d): %v", number, err) } } if err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{ ID: "planrev-noise", TaskID: "task-planrev-noise", RevisionNumber: 99, Title: "Plan", Content: "noise", AuthorKind: "agent", }); err != nil { t.Fatalf("InsertTaskPlanRevision(noise): %v", err) } all, err := repo.ListTaskPlanRevisions(ctx, "task-planrev-list", 0) if err != nil { t.Fatalf("ListTaskPlanRevisions(limit=0): %v", err) } if len(all) != 3 { t.Fatalf("limit=0 returned %d rows, want 3", len(all)) } for i, wantNumber := range []int{3, 2, 1} { if all[i].RevisionNumber != wantNumber { t.Fatalf("revision numbers = %d at index %d, want %d (newest first)", all[i].RevisionNumber, i, wantNumber) } } limited, err := repo.ListTaskPlanRevisions(ctx, "task-planrev-list", 1) if err != nil { t.Fatalf("ListTaskPlanRevisions(limit=1): %v", err) } if len(limited) != 1 || limited[0].RevisionNumber != 3 { t.Errorf("limit=1 returned %+v, want only revision 3", limited) } empty, err := repo.ListTaskPlanRevisions(ctx, "task-planrev-nothing", 0) if err != nil { t.Fatalf("ListTaskPlanRevisions(unknown task): %v", err) } if len(empty) != 0 { t.Errorf("unknown task returned %+v, want empty", empty) } } func TestNextTaskPlanRevisionNumber(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-planrev-next") next, err := repo.NextTaskPlanRevisionNumber(ctx, "task-planrev-next") if err != nil { t.Fatalf("NextTaskPlanRevisionNumber: %v", err) } if next != 1 { t.Errorf("NextTaskPlanRevisionNumber with no history = %d, want 1", next) } if err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{ ID: "planrev-next-7", TaskID: "task-planrev-next", RevisionNumber: 7, Title: "Plan", Content: "v7", AuthorKind: "agent", }); err != nil { t.Fatalf("InsertTaskPlanRevision: %v", err) } next, err = repo.NextTaskPlanRevisionNumber(ctx, "task-planrev-next") if err != nil { t.Fatalf("NextTaskPlanRevisionNumber: %v", err) } if next != 8 { t.Errorf("NextTaskPlanRevisionNumber = %d, want 8 (MAX(7)+1)", next) } } func TestWritePlanRevisionCreatesHeadAndFirstRevision(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan") head := &models.TaskPlan{TaskID: "task-writeplan", Content: "first"} rev := &models.TaskPlanRevision{ TaskID: "task-writeplan", Title: "Plan", Content: "first", AuthorKind: "agent", AuthorName: "claude", } if err := repo.WritePlanRevision(ctx, head, rev, nil, false, false); err != nil { t.Fatalf("WritePlanRevision: %v", err) } if head.ID == "" { t.Fatal("head ID left empty; a UUID should have been generated") } if head.Title != "Plan" || head.CreatedBy != authorKindAgent { t.Errorf("head defaults = %q/%q, want Plan/%s", head.Title, head.CreatedBy, authorKindAgent) } if rev.RevisionNumber != 1 { t.Errorf("RevisionNumber = %d, want 1", rev.RevisionNumber) } gotHead, err := repo.GetTaskPlan(ctx, "task-writeplan") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } assertTaskPlanEqual(t, gotHead, head) gotRev, err := repo.GetLatestTaskPlanRevision(ctx, "task-writeplan") if err != nil { t.Fatalf("GetLatestTaskPlanRevision: %v", err) } assertPlanRevisionEqual(t, gotRev, rev) } func seedPlanWorkflowStep(t *testing.T, repo *Repository, taskID, workflowID, stepID, name, color string) { t.Helper() ctx := context.Background() if err := repo.CreateWorkflow(ctx, &models.Workflow{ID: workflowID, Name: workflowID}); err != nil { t.Fatalf("CreateWorkflow(%s): %v", workflowID, err) } now := time.Now().UTC() if _, err := repo.db.Exec(repo.db.Rebind(` INSERT INTO workflow_steps (id, workflow_id, name, position, color, created_at, updated_at) VALUES (?, ?, ?, 0, ?, ?, ?) `), stepID, workflowID, name, color, now, now); err != nil { t.Fatalf("insert workflow step %s: %v", stepID, err) } if _, err := repo.db.Exec(repo.db.Rebind(` UPDATE tasks SET workflow_id = ?, workflow_step_id = ? WHERE id = ? `), workflowID, stepID, taskID); err != nil { t.Fatalf("set task workflow step %s: %v", stepID, err) } } func TestWritePlanRevisionStampsCurrentWorkflowStep(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-step") seedPlanWorkflowStep(t, repo, "task-writeplan-step", "workflow-writeplan-step", "step-build", "Build", "bg-blue-500") head := &models.TaskPlan{TaskID: "task-writeplan-step", Content: "first"} rev := &models.TaskPlanRevision{ TaskID: "task-writeplan-step", Title: "Plan", Content: "first", AuthorKind: "agent", } if err := repo.WritePlanRevision(ctx, head, rev, nil, false, false); err != nil { t.Fatalf("WritePlanRevision: %v", err) } if rev.WorkflowStepID != "step-build" || rev.WorkflowStepName != "Build" || rev.WorkflowStepColor != "bg-blue-500" { t.Fatalf("workflow step stamp = %q/%q/%q, want step-build/Build/bg-blue-500", rev.WorkflowStepID, rev.WorkflowStepName, rev.WorkflowStepColor) } } func TestPlanRevisionWorkflowColumnsReplayMigration(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-replay") for _, column := range []string{"workflow_step_id", "workflow_step_name", "workflow_step_color"} { if _, err := repo.db.Exec("ALTER TABLE task_plan_revisions DROP COLUMN " + column); err != nil { t.Fatalf("drop legacy column %s: %v", column, err) } } now := time.Now().UTC() if _, err := repo.db.Exec(repo.db.Rebind(` INSERT INTO task_plan_revisions (id, task_id, revision_number, title, content, author_kind, author_name, revert_of_revision_id, created_at, updated_at) VALUES (?, ?, 1, ?, ?, ?, ?, NULL, ?, ?) `), "legacy-plan-revision", "task-plan-replay", "Plan", "legacy", "agent", "Agent", now, now); err != nil { t.Fatalf("insert legacy plan revision: %v", err) } if err := repo.runMigrations(); err != nil { t.Fatalf("run legacy plan migrations: %v", err) } if err := repo.runMigrations(); err != nil { t.Fatalf("replay legacy plan migrations: %v", err) } var stepID, stepName, stepColor string if err := repo.db.QueryRow(repo.db.Rebind(` SELECT workflow_step_id, workflow_step_name, workflow_step_color FROM task_plan_revisions WHERE id = ? `), "legacy-plan-revision").Scan(&stepID, &stepName, &stepColor); err != nil { t.Fatalf("read migrated legacy revision: %v", err) } if stepID != "" || stepName != "" || stepColor != "" { t.Fatalf("legacy workflow fields = %q/%q/%q, want empty defaults", stepID, stepName, stepColor) } seedPlanWorkflowStep(t, repo, "task-plan-replay", "workflow-plan-replay", "step-review", "Review", "bg-purple-500") head := &models.TaskPlan{TaskID: "task-plan-replay", Content: "new"} rev := &models.TaskPlanRevision{ TaskID: "task-plan-replay", Title: "Plan", Content: "new", AuthorKind: "user", AuthorName: "You", } if err := repo.WritePlanRevision(ctx, head, rev, nil, false, false); err != nil { t.Fatalf("write stamped revision after migration: %v", err) } if rev.WorkflowStepID != "step-review" || rev.WorkflowStepName != "Review" || rev.WorkflowStepColor != "bg-purple-500" { t.Fatalf("post-migration workflow stamp = %q/%q/%q, want step-review/Review/bg-purple-500", rev.WorkflowStepID, rev.WorkflowStepName, rev.WorkflowStepColor) } } func TestWritePlanRevisionMissingTask(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() taskID := "task-writeplan-missing" err := repo.WritePlanRevision(ctx, &models.TaskPlan{ID: "plan-missing", TaskID: taskID, Title: "Plan", Content: "body"}, &models.TaskPlanRevision{TaskID: taskID, Title: "Plan", Content: "body", AuthorKind: "agent"}, nil, false, false) if !errors.Is(err, ErrTaskNotFound) { t.Fatalf("WritePlanRevision error = %v, want ErrTaskNotFound", err) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plans WHERE task_id = ?`, taskID); got != 0 { t.Fatalf("plan HEAD rows = %d, want 0 after rollback", got) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plan_revisions WHERE task_id = ?`, taskID); got != 0 { t.Fatalf("plan revision rows = %d, want 0 after rollback", got) } } func TestWritePlanRevisionUpsertsHeadAndAppendsRevisions(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-append") head := &models.TaskPlan{ ID: "plan-append", TaskID: "task-writeplan-append", Title: "v1", Content: "one", CreatedBy: "agent", } if err := repo.WritePlanRevision(ctx, head, &models.TaskPlanRevision{ TaskID: "task-writeplan-append", Title: "v1", Content: "one", AuthorKind: "agent", }, nil, false, false); err != nil { t.Fatalf("WritePlanRevision(first): %v", err) } createdAt := head.CreatedAt head.Title = "v2" head.Content = "two" head.CreatedBy = "user" second := &models.TaskPlanRevision{ TaskID: "task-writeplan-append", Title: "v2", Content: "two", AuthorKind: "user", AuthorName: "jcfs", } if err := repo.WritePlanRevision(ctx, head, second, nil, false, false); err != nil { t.Fatalf("WritePlanRevision(second): %v", err) } if second.RevisionNumber != 2 { t.Errorf("second RevisionNumber = %d, want 2", second.RevisionNumber) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plans WHERE task_id = ?`, "task-writeplan-append"); got != 1 { t.Errorf("HEAD rows = %d, want 1 (the upsert must not insert a second row)", got) } gotHead, err := repo.GetTaskPlan(ctx, "task-writeplan-append") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } if gotHead.ID != "plan-append" { t.Errorf("HEAD id = %q, want plan-append", gotHead.ID) } if gotHead.Title != "v2" || gotHead.Content != "two" || gotHead.CreatedBy != "user" { t.Errorf("HEAD = %+v, want the v2 values", gotHead) } if !gotHead.CreatedAt.Equal(createdAt) { t.Errorf("HEAD CreatedAt = %v, want it preserved at %v", gotHead.CreatedAt, createdAt) } history, err := repo.ListTaskPlanRevisions(ctx, "task-writeplan-append", 0) if err != nil { t.Fatalf("ListTaskPlanRevisions: %v", err) } if len(history) != 2 { t.Fatalf("history has %d revisions, want 2", len(history)) } if history[0].RevisionNumber != 2 || history[0].Content != "two" || history[0].AuthorName != "jcfs" { t.Errorf("newest revision = %+v, want revision 2 by jcfs", history[0]) } if history[1].RevisionNumber != 1 || history[1].Content != "one" { t.Errorf("oldest revision = %+v, want revision 1 with the original content", history[1]) } } func TestWritePlanRevisionPreservesImplementationMarkerAcrossUpsert(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-marker") head := &models.TaskPlan{ID: "plan-marker", TaskID: "task-writeplan-marker", Title: "v1", Content: "one"} if err := repo.WritePlanRevision(ctx, head, &models.TaskPlanRevision{ TaskID: "task-writeplan-marker", Title: "v1", Content: "one", AuthorKind: "agent", }, nil, false, false); err != nil { t.Fatalf("WritePlanRevision(first): %v", err) } if _, err := repo.MarkTaskPlanImplementationStarted(ctx, "task-writeplan-marker", "session-x", "jcfs"); err != nil { t.Fatalf("MarkTaskPlanImplementationStarted: %v", err) } head.Title = "v2" head.Content = "two" if err := repo.WritePlanRevision(ctx, head, &models.TaskPlanRevision{ TaskID: "task-writeplan-marker", Title: "v2", Content: "two", AuthorKind: "agent", }, nil, false, false); err != nil { t.Fatalf("WritePlanRevision(second): %v", err) } got, err := repo.GetTaskPlan(ctx, "task-writeplan-marker") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } if got.ImplementationStartedAt == nil { t.Fatal("ImplementationStartedAt = nil; the ON CONFLICT clause must not clear the marker") } assertOptionalString(t, "ImplementationStartedSessionID", got.ImplementationStartedSessionID, strptr("session-x")) assertOptionalString(t, "ImplementationStartedBy", got.ImplementationStartedBy, strptr("jcfs")) } func TestWritePlanRevisionCoalescesIntoExistingRevision(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-merge") seedPlanWorkflowStep(t, repo, "task-writeplan-merge", "workflow-writeplan-merge", "step-build", "Build", "bg-blue-500") head := &models.TaskPlan{ID: "plan-merge", TaskID: "task-writeplan-merge", Title: "v1", Content: "one"} first := &models.TaskPlanRevision{ ID: "planrev-merge", TaskID: "task-writeplan-merge", Title: "v1", Content: "one", AuthorKind: "agent", AuthorName: "claude", WorkflowStepID: "step-build", WorkflowStepName: "Build", CreatedAt: time.Date(2026, 2, 2, 2, 2, 2, 0, time.UTC), } if err := repo.WritePlanRevision(ctx, head, first, nil, false, false); err != nil { t.Fatalf("WritePlanRevision(first): %v", err) } head.Title = "v1 edited" head.Content = "one edited" merged := &models.TaskPlanRevision{ TaskID: "task-writeplan-merge", Title: "v1 edited", Content: "one edited", AuthorKind: "ignored", AuthorName: "ignored", // Different step than `first` — proves the merge UPDATE (title/content/ // updated_at only) doesn't re-stamp the persisted step columns. WorkflowStepID: "step-review", WorkflowStepName: "Review", } coalesceID := "planrev-merge" if err := repo.WritePlanRevision(ctx, head, merged, &coalesceID, false, false); err != nil { t.Fatalf("WritePlanRevision(merge): %v", err) } if merged.ID != "planrev-merge" { t.Errorf("merged ID = %q, want planrev-merge", merged.ID) } history, err := repo.ListTaskPlanRevisions(ctx, "task-writeplan-merge", 0) if err != nil { t.Fatalf("ListTaskPlanRevisions: %v", err) } if len(history) != 1 { t.Fatalf("history has %d revisions, want 1 (coalesce must merge, not append)", len(history)) } got := history[0] if got.Title != "v1 edited" || got.Content != "one edited" { t.Errorf("merged revision = %+v, want the edited title/content", got) } if got.RevisionNumber != 1 { t.Errorf("RevisionNumber = %d, want 1 preserved", got.RevisionNumber) } if got.AuthorKind != "agent" || got.AuthorName != "claude" { t.Errorf("author = %q/%q, want the original agent/claude preserved", got.AuthorKind, got.AuthorName) } if got.WorkflowStepID != "step-build" || got.WorkflowStepName != "Build" { t.Errorf("workflow step = %q/%q, want the original step-build/Build preserved (merge must not re-stamp)", got.WorkflowStepID, got.WorkflowStepName) } if !got.CreatedAt.Equal(first.CreatedAt) { t.Errorf("CreatedAt = %v, want %v preserved", got.CreatedAt, first.CreatedAt) } if !got.UpdatedAt.After(got.CreatedAt) { t.Errorf("UpdatedAt = %v, want it bumped past CreatedAt %v", got.UpdatedAt, got.CreatedAt) } } func TestWritePlanRevisionRollsBackWhenCoalesceTargetMissing(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-rollback") missingID := "planrev-does-not-exist" err := repo.WritePlanRevision(ctx, &models.TaskPlan{ID: "plan-rollback", TaskID: "task-writeplan-rollback", Title: "nope", Content: "nope"}, &models.TaskPlanRevision{TaskID: "task-writeplan-rollback", Title: "x", Content: "y"}, &missingID, false, false) if err == nil { t.Fatal("WritePlanRevision with an unknown coalesce id returned nil") } if !strings.Contains(err.Error(), "task plan revision not found") { t.Errorf("error = %q, want a task-plan-revision-not-found message", err) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plans WHERE task_id = ?`, "task-writeplan-rollback"); got != 0 { t.Errorf("HEAD rows after a failed merge = %d, want 0 (transaction must roll back)", got) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plan_revisions WHERE task_id = ?`, "task-writeplan-rollback"); got != 0 { t.Errorf("revision rows after a failed merge = %d, want 0", got) } } func TestTaskPlanAndRevisionsCascadeOnTaskDelete(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-cascade") if err := repo.WritePlanRevision(ctx, &models.TaskPlan{ID: "plan-cascade", TaskID: "task-plan-cascade", Title: "Plan", Content: "body"}, &models.TaskPlanRevision{TaskID: "task-plan-cascade", Title: "Plan", Content: "body", AuthorKind: "agent"}, nil, false, false); err != nil { t.Fatalf("WritePlanRevision: %v", err) } if err := repo.DeleteTask(ctx, "task-plan-cascade"); err != nil { t.Fatalf("DeleteTask: %v", err) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plans WHERE task_id = ?`, "task-plan-cascade"); got != 0 { t.Errorf("plan rows after task delete = %d, want 0 (FK cascade)", got) } if got := countRows(t, repo, `SELECT COUNT(1) FROM task_plan_revisions WHERE task_id = ?`, "task-plan-cascade"); got != 0 { t.Errorf("plan revision rows after task delete = %d, want 0 (FK cascade)", got) } } func TestTaskPlanMethodsPropagateBackendErrors(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-plan-broken") if err := repo.CreateTaskPlan(ctx, &models.TaskPlan{ ID: "plan-broken", TaskID: "task-plan-broken", Title: "Plan", Content: "body", }); err != nil { t.Fatalf("CreateTaskPlan: %v", err) } closeRepoDB(t, repo) if err := repo.CreateTaskPlan(ctx, &models.TaskPlan{ID: "plan-after-close", TaskID: "task-plan-broken"}); err == nil { t.Error("CreateTaskPlan on a closed database returned nil") } if _, err := repo.GetTaskPlan(ctx, "task-plan-broken"); err == nil { t.Error("GetTaskPlan on a closed database returned nil") } if err := repo.UpdateTaskPlan(ctx, &models.TaskPlan{TaskID: "task-plan-broken"}); err == nil { t.Error("UpdateTaskPlan on a closed database returned nil") } if _, err := repo.MarkTaskPlanImplementationStarted(ctx, "task-plan-broken", "s", "a"); err == nil { t.Error("MarkTaskPlanImplementationStarted on a closed database returned nil") } if err := repo.DeleteTaskPlan(ctx, "task-plan-broken"); err == nil { t.Error("DeleteTaskPlan on a closed database returned nil") } if err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{ TaskID: "task-plan-broken", RevisionNumber: 1, }); err == nil { t.Error("InsertTaskPlanRevision on a closed database returned nil") } if err := repo.UpdateTaskPlanRevision(ctx, &models.TaskPlanRevision{ID: "planrev-broken"}); err == nil { t.Error("UpdateTaskPlanRevision on a closed database returned nil") } if _, err := repo.GetTaskPlanRevision(ctx, "planrev-broken"); err == nil { t.Error("GetTaskPlanRevision on a closed database returned nil") } if _, err := repo.ListTaskPlanRevisions(ctx, "task-plan-broken", 0); err == nil { t.Error("ListTaskPlanRevisions on a closed database returned nil") } if _, err := repo.NextTaskPlanRevisionNumber(ctx, "task-plan-broken"); err == nil { t.Error("NextTaskPlanRevisionNumber on a closed database returned nil") } if err := repo.WritePlanRevision(ctx, &models.TaskPlan{TaskID: "task-plan-broken"}, &models.TaskPlanRevision{TaskID: "task-plan-broken"}, nil, false, false); err == nil { t.Error("WritePlanRevision on a closed database returned nil") } } func TestWritePlanRevisionPreserveFlagsGateOnlyTheUpdateBranch(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-preserve") head := &models.TaskPlan{ ID: "plan-preserve", TaskID: "task-writeplan-preserve", Title: "v1", Content: "one", CreatedBy: "agent", } if err := repo.WritePlanRevision(ctx, head, &models.TaskPlanRevision{ TaskID: "task-writeplan-preserve", Title: "v1", Content: "one", AuthorKind: "agent", }, nil, false, false); err != nil { t.Fatalf("WritePlanRevision(first): %v", err) } // An existing row with preserveTitle/preserveCreatedBy set keeps its stored title and // created_by even though head carries different values; content still updates. head.Title = "v2" head.Content = "two" head.CreatedBy = "user" if err := repo.WritePlanRevision(ctx, head, &models.TaskPlanRevision{ TaskID: "task-writeplan-preserve", Title: "v2", Content: "two", AuthorKind: "agent", }, nil, true, true); err != nil { t.Fatalf("WritePlanRevision(preserve): %v", err) } gotHead, err := repo.GetTaskPlan(ctx, "task-writeplan-preserve") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } if gotHead.Title != "v1" { t.Errorf("HEAD title = %q, want v1 preserved", gotHead.Title) } if gotHead.CreatedBy != "agent" { t.Errorf("HEAD created_by = %q, want agent preserved", gotHead.CreatedBy) } if gotHead.Content != "two" { t.Errorf("HEAD content = %q, want two (content is never preserved)", gotHead.Content) } if head.Title != "v1" || head.CreatedBy != "agent" { t.Errorf("returned HEAD metadata = %q/%q, want authoritative preserved values v1/agent", head.Title, head.CreatedBy) } revisions, err := repo.ListTaskPlanRevisions(ctx, "task-writeplan-preserve", 0) if err != nil { t.Fatalf("ListTaskPlanRevisions: %v", err) } latest, err := repo.GetTaskPlanRevision(ctx, revisions[0].ID) if err != nil { t.Fatalf("GetTaskPlanRevision: %v", err) } if latest.Title != "v1" { t.Errorf("revision title = %q, want authoritative preserved title v1", latest.Title) } } func TestWritePlanRevisionPreserveFlagsIgnoredOnFreshInsert(t *testing.T) { repo := newRepoForEntityTests(t) ctx := context.Background() seedTaskForDocs(t, repo, "task-writeplan-preserve-insert") head := &models.TaskPlan{ TaskID: "task-writeplan-preserve-insert", Title: "fresh", Content: "body", CreatedBy: "agent", } if err := repo.WritePlanRevision(ctx, head, &models.TaskPlanRevision{ TaskID: "task-writeplan-preserve-insert", Title: "fresh", Content: "body", AuthorKind: "agent", }, nil, true, true); err != nil { t.Fatalf("WritePlanRevision: %v", err) } gotHead, err := repo.GetTaskPlan(ctx, "task-writeplan-preserve-insert") if err != nil { t.Fatalf("GetTaskPlan: %v", err) } if gotHead.Title != "fresh" || gotHead.CreatedBy != "agent" { t.Errorf("HEAD = %+v, want head's own values used on a fresh insert regardless of preserve flags", gotHead) } }