Files
kandev/apps/backend/internal/task/service/service_resources_test.go
T
Carlos Florêncio 657b92eb69 fix: restore workspace deletion from settings (#1547)
* fix: restore workspace deletion from settings

* fix: validate workspace delete in service

* fix: clarify workspace delete errors

* fix: address workspace delete review feedback

* fix: guard confirmed workspace delete before cascade

* fix: simplify workspace delete cascade guard

* fix: make confirmed workspace delete atomic

* fix: preserve confirmed workspace delete side effects

* fix: snapshot confirmed workspace cascade rows

* fix: clarify confirmed workspace delete cleanup

* fix: preserve office workspace deletion cleanup

* fix: preserve workspace delete error mapping

* fix: streamline workspace delete cascade

* fix: harden workspace delete cleanup

* fix: keep workspace delete failure logs

* fix: fail workspace delete on missing session inventory

---------

Co-authored-by: root <root@kandev.ts.net>
2026-06-30 08:24:43 +01:00

841 lines
29 KiB
Go

package service
import (
"context"
"errors"
"fmt"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/worktree"
)
// errWorkspaceRepo is a WorkspaceRepository that always returns an error from
// ListWorkspaces. Used to exercise the DB-error path of GetOfficeWorkflowIDs.
type errWorkspaceRepo struct {
// embed the real repo for all methods except ListWorkspaces.
WorkspaceRepositoryStub
}
type blockingWorktreeCleanup struct {
release chan struct{}
active atomic.Int32
maxActive atomic.Int32
}
func (c *blockingWorktreeCleanup) OnTaskDeleted(context.Context, string) error {
return nil
}
func (c *blockingWorktreeCleanup) GetAllByTaskID(context.Context, string) ([]*worktree.Worktree, error) {
return nil, nil
}
func (c *blockingWorktreeCleanup) CleanupWorktrees(ctx context.Context, _ []*worktree.Worktree) error {
active := c.active.Add(1)
updateMaxActive(&c.maxActive, active)
defer c.active.Add(-1)
select {
case <-ctx.Done():
return ctx.Err()
case <-c.release:
return nil
}
}
func updateMaxActive(maxActive *atomic.Int32, value int32) {
for {
current := maxActive.Load()
if value <= current || maxActive.CompareAndSwap(current, value) {
return
}
}
}
func waitForActiveCleanups(t *testing.T, cleanup *blockingWorktreeCleanup, want int32) {
t.Helper()
deadline := time.After(500 * time.Millisecond)
ticker := time.NewTicker(5 * time.Millisecond)
defer ticker.Stop()
for {
if cleanup.active.Load() >= want {
return
}
select {
case <-deadline:
t.Fatalf("active cleanups = %d, want at least %d", cleanup.active.Load(), want)
case <-ticker.C:
}
}
}
// WorkspaceRepositoryStub satisfies the full WorkspaceRepository interface
// with no-op / panic stubs. Only methods under test need real implementations.
type WorkspaceRepositoryStub struct{}
func (WorkspaceRepositoryStub) CreateWorkspace(_ context.Context, _ *models.Workspace) error {
panic("not implemented")
}
func (WorkspaceRepositoryStub) GetWorkspace(_ context.Context, _ string) (*models.Workspace, error) {
panic("not implemented")
}
func (WorkspaceRepositoryStub) UpdateWorkspace(_ context.Context, _ *models.Workspace) error {
panic("not implemented")
}
func (WorkspaceRepositoryStub) DeleteWorkspace(_ context.Context, _ string) error {
panic("not implemented")
}
func (WorkspaceRepositoryStub) DeleteWorkspaceCascade(_ context.Context, _ string) ([]*models.Task, []*models.Workflow, error) {
panic("not implemented")
}
func (WorkspaceRepositoryStub) DeleteWorkspaceCascadeWithName(_ context.Context, _, _ string) ([]*models.Task, []*models.Workflow, error) {
panic("not implemented")
}
func (WorkspaceRepositoryStub) ListWorkspaces(_ context.Context) ([]*models.Workspace, error) {
panic("not implemented")
}
type renameBeforeConfirmedDeleteRepo struct {
repository.WorkspaceRepository
}
func (r renameBeforeConfirmedDeleteRepo) DeleteWorkspaceCascadeWithName(
ctx context.Context,
id, name string,
) ([]*models.Task, []*models.Workflow, error) {
workspace, err := r.GetWorkspace(ctx, id)
if err != nil {
return nil, nil, err
}
workspace.Name = "Renamed"
if err := r.UpdateWorkspace(ctx, workspace); err != nil {
return nil, nil, err
}
return r.WorkspaceRepository.DeleteWorkspaceCascadeWithName(ctx, id, name)
}
type createDuringConfirmedDeleteRepo struct {
repository.WorkspaceRepository
tasks repository.TaskRepository
workflows repository.WorkflowRepository
}
func (r createDuringConfirmedDeleteRepo) DeleteWorkspaceCascadeWithName(
ctx context.Context,
id, name string,
) ([]*models.Task, []*models.Workflow, error) {
if err := r.workflows.CreateWorkflow(ctx, &models.Workflow{
ID: "wf-raced",
WorkspaceID: id,
Name: "Raced",
}); err != nil {
return nil, nil, err
}
if err := r.tasks.CreateTask(ctx, &models.Task{
ID: "task-raced",
WorkspaceID: id,
WorkflowID: "wf-raced",
WorkflowStepID: "step-raced",
Title: "Raced task",
}); err != nil {
return nil, nil, err
}
return r.WorkspaceRepository.DeleteWorkspaceCascadeWithName(ctx, id, name)
}
type failingListTaskSessionsRepo struct {
repository.SessionRepository
err error
}
func (r failingListTaskSessionsRepo) ListTaskSessions(context.Context, string) ([]*models.TaskSession, error) {
return nil, r.err
}
func (e errWorkspaceRepo) ListWorkspaces(_ context.Context) ([]*models.Workspace, error) {
return nil, errors.New("db unavailable")
}
func TestService_GetOfficeWorkflowIDs_Empty(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
// No workspaces → empty result.
ids := svc.GetOfficeWorkflowIDs(ctx)
if len(ids) != 0 {
t.Errorf("expected empty map, got %v", ids)
}
// Workspace with no office_workflow_id → still excluded.
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-no-office", Name: "No Office"})
ids = svc.GetOfficeWorkflowIDs(ctx)
if len(ids) != 0 {
t.Errorf("expected empty map for workspace without office_workflow_id, got %v", ids)
}
}
func TestService_GetOfficeWorkflowIDs_SingleWorkflow(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{
ID: "ws-1",
Name: "WS 1",
OfficeWorkflowID: "wf-office-1",
})
ids := svc.GetOfficeWorkflowIDs(ctx)
if _, ok := ids["wf-office-1"]; !ok {
t.Errorf("expected wf-office-1 in result, got %v", ids)
}
if len(ids) != 1 {
t.Errorf("expected exactly 1 id, got %d", len(ids))
}
}
func TestService_GetOfficeWorkflowIDs_MultipleWorkflows(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
workspaces := []struct {
id string
wfID string
}{
{"ws-a", "wf-office-a"},
{"ws-b", "wf-office-b"},
{"ws-c", ""},
}
for _, ws := range workspaces {
_ = repo.CreateWorkspace(ctx, &models.Workspace{
ID: ws.id,
Name: ws.id,
OfficeWorkflowID: ws.wfID,
})
}
ids := svc.GetOfficeWorkflowIDs(ctx)
if _, ok := ids["wf-office-a"]; !ok {
t.Errorf("expected wf-office-a")
}
if _, ok := ids["wf-office-b"]; !ok {
t.Errorf("expected wf-office-b")
}
if len(ids) != 2 {
t.Errorf("expected 2 ids (ws-c has no office wf), got %d: %v", len(ids), ids)
}
}
func TestService_GetOfficeWorkflowIDs_DBError(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
// Seed a workspace first so we know the real repo would return something.
_ = repo.CreateWorkspace(ctx, &models.Workspace{
ID: "ws-ok",
Name: "OK",
OfficeWorkflowID: "wf-ok",
})
// Replace the workspace repo with one that always errors.
svc.workspaces = errWorkspaceRepo{}
ids := svc.GetOfficeWorkflowIDs(ctx)
if ids != nil {
t.Errorf("expected nil on DB error, got %v", ids)
}
}
func TestService_DeleteWorkspaceDeletesWorkspaceOwnedTasksAndWorkflows(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-keep", Name: "Keep Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-keep", WorkspaceID: "ws-keep", Name: "Keep"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
if err := svc.DeleteWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("DeleteWorkspace: %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err == nil {
t.Fatalf("workspace should be deleted")
}
if _, err := repo.GetTask(ctx, "task-delete"); err == nil {
t.Fatalf("workspace task should be deleted")
}
workflows, err := repo.ListWorkflows(ctx, "ws-delete", true)
if err != nil {
t.Fatalf("ListWorkflows: %v", err)
}
if len(workflows) != 0 {
t.Fatalf("workspace workflows should be deleted, got %d", len(workflows))
}
if _, err := repo.GetWorkflow(ctx, "wf-keep"); err != nil {
t.Fatalf("unrelated workflow should remain: %v", err)
}
}
func TestService_DeleteWorkspacePublishesChildEventsAndCleansResources(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
svc.setCleanupDoneForTestHook(make(chan struct{}, 1))
cleanup := &recordingWorktreeCleanup{
worktrees: []*worktree.Worktree{{ID: "wt-delete", TaskID: "task-delete"}},
}
svc.SetWorktreeCleanup(cleanup)
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
eventBus.ClearEvents()
if err := svc.DeleteWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("DeleteWorkspace: %v", err)
}
waitForCleanupDone(t, svc)
eventCounts := make(map[string]int)
for _, event := range eventBus.GetPublishedEvents() {
eventCounts[event.Type]++
}
if eventCounts[events.TaskDeleted] != 1 {
t.Fatalf("task deleted events = %d, want 1", eventCounts[events.TaskDeleted])
}
if eventCounts[events.WorkflowDeleted] != 1 {
t.Fatalf("workflow deleted events = %d, want 1", eventCounts[events.WorkflowDeleted])
}
if eventCounts[events.WorkspaceDeleted] != 1 {
t.Fatalf("workspace deleted events = %d, want 1", eventCounts[events.WorkspaceDeleted])
}
cleanedIDs := cleanup.cleanedIDs()
if len(cleanedIDs) != 1 || cleanedIDs[0] != "wt-delete" {
t.Fatalf("cleaned worktrees = %#v, want wt-delete", cleanedIDs)
}
}
func TestService_DeleteWorkspaceStopsBeforeCascadeWhenSessionInventoryFails(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
listErr := errors.New("session inventory unavailable")
svc.sessions = failingListTaskSessionsRepo{SessionRepository: repo, err: listErr}
err := svc.DeleteWorkspace(ctx, "ws-delete")
if !errors.Is(err, listErr) {
t.Fatalf("expected session inventory error, got %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
func TestService_RunWorkspaceDeleteTaskCleanupsCapsConcurrency(t *testing.T) {
svc, _, _ := createTestService(t)
taskCount := workspaceDeleteCleanupConcurrency + 3
svc.setCleanupDoneForTestHook(make(chan struct{}, taskCount))
cleanup := &blockingWorktreeCleanup{release: make(chan struct{})}
svc.SetWorktreeCleanup(cleanup)
cleanups := make([]workspaceDeleteTaskCleanup, 0, taskCount)
deletedTasks := make([]*models.Task, 0, taskCount)
for i := 0; i < taskCount; i++ {
taskID := fmt.Sprintf("task-%02d", i)
task := &models.Task{ID: taskID}
cleanups = append(cleanups, workspaceDeleteTaskCleanup{
task: task,
worktrees: []*worktree.Worktree{{ID: "wt-" + taskID, TaskID: taskID}},
})
deletedTasks = append(deletedTasks, task)
}
svc.runWorkspaceDeleteTaskCleanups(cleanups, deletedTasks)
waitForActiveCleanups(t, cleanup, workspaceDeleteCleanupConcurrency)
close(cleanup.release)
for i := 0; i < taskCount; i++ {
waitForCleanupDone(t, svc)
}
if got := cleanup.maxActive.Load(); got > workspaceDeleteCleanupConcurrency {
t.Fatalf("max active cleanups = %d, want <= %d", got, workspaceDeleteCleanupConcurrency)
}
}
func TestService_DeleteWorkspaceWithConfirmNameDeletesWhenNameMatches(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
if err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me"); err != nil {
t.Fatalf("DeleteWorkspaceWithConfirmName: %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err == nil {
t.Fatalf("workspace should be deleted")
}
if _, err := repo.GetTask(ctx, "task-delete"); err == nil {
t.Fatalf("workspace task should be deleted")
}
workflows, err := repo.ListWorkflows(ctx, "ws-delete", true)
if err != nil {
t.Fatalf("ListWorkflows: %v", err)
}
if len(workflows) != 0 {
t.Fatalf("workspace workflows should be deleted, got %d", len(workflows))
}
}
func TestService_DeleteWorkspaceWithConfirmNamePublishesChildEventsAndCleansResources(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
svc.setCleanupDoneForTestHook(make(chan struct{}, 1))
cleanup := &recordingWorktreeCleanup{
worktrees: []*worktree.Worktree{{ID: "wt-delete", TaskID: "task-delete"}},
}
svc.SetWorktreeCleanup(cleanup)
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
eventBus.ClearEvents()
if err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me"); err != nil {
t.Fatalf("DeleteWorkspaceWithConfirmName: %v", err)
}
waitForCleanupDone(t, svc)
eventCounts := make(map[string]int)
for _, event := range eventBus.GetPublishedEvents() {
eventCounts[event.Type]++
}
if eventCounts[events.TaskDeleted] != 1 {
t.Fatalf("task deleted events = %d, want 1", eventCounts[events.TaskDeleted])
}
if eventCounts[events.WorkflowDeleted] != 1 {
t.Fatalf("workflow deleted events = %d, want 1", eventCounts[events.WorkflowDeleted])
}
if eventCounts[events.WorkspaceDeleted] != 1 {
t.Fatalf("workspace deleted events = %d, want 1", eventCounts[events.WorkspaceDeleted])
}
cleanedIDs := cleanup.cleanedIDs()
if len(cleanedIDs) != 1 || cleanedIDs[0] != "wt-delete" {
t.Fatalf("cleaned worktrees = %#v, want wt-delete", cleanedIDs)
}
}
func TestService_DeleteWorkspaceWithConfirmNamePublishesEventsForAllCascadeDeletedChildren(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
svc.setCleanupDoneForTestHook(make(chan struct{}, 2))
cleanup := &recordingWorktreeCleanup{
worktreesByTaskID: map[string][]*worktree.Worktree{
"task-delete": {{ID: "wt-delete", TaskID: "task-delete"}},
"task-raced": {{ID: "wt-raced", TaskID: "task-raced"}},
},
}
svc.SetWorktreeCleanup(cleanup)
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
svc.workspaces = createDuringConfirmedDeleteRepo{
WorkspaceRepository: repo,
tasks: repo,
workflows: repo,
}
eventBus.ClearEvents()
if err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me"); err != nil {
t.Fatalf("DeleteWorkspaceWithConfirmName: %v", err)
}
waitForCleanupDone(t, svc)
waitForCleanupDone(t, svc)
// This covers event publication from the repository cascade return value.
// Runtime cleanup is prepared before the cascade and topped up from the
// cascade return value for children that appear after that first snapshot.
eventCounts := make(map[string]int)
for _, event := range eventBus.GetPublishedEvents() {
eventCounts[event.Type]++
}
if eventCounts[events.TaskDeleted] != 2 {
t.Fatalf("task deleted events = %d, want 2", eventCounts[events.TaskDeleted])
}
if eventCounts[events.WorkflowDeleted] != 2 {
t.Fatalf("workflow deleted events = %d, want 2", eventCounts[events.WorkflowDeleted])
}
if _, err := repo.GetTask(ctx, "task-raced"); err == nil {
t.Fatalf("late-created task should be deleted")
}
if _, err := repo.GetWorkflow(ctx, "wf-raced"); err == nil {
t.Fatalf("late-created workflow should be deleted")
}
cleaned := make(map[string]bool)
for _, id := range cleanup.cleanedIDs() {
cleaned[id] = true
}
if len(cleaned) != 2 || !cleaned["wt-delete"] || !cleaned["wt-raced"] {
t.Fatalf("cleaned worktrees = %#v, want wt-delete and wt-raced", cleaned)
}
}
func TestService_DeleteWorkspaceWithConfirmNameRejectsMismatchedName(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Wrong")
if !errors.Is(err, ErrWorkspaceConfirmNameMismatch) {
t.Fatalf("expected ErrWorkspaceConfirmNameMismatch, got %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
func TestService_DeleteWorkspaceWithConfirmNameReturnsMissingWorkspaceError(t *testing.T) {
svc, _, _ := createTestService(t)
ctx := context.Background()
err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-missing", "Missing")
if err == nil {
t.Fatalf("expected missing workspace error")
}
if errors.Is(err, ErrWorkspaceConfirmNameMismatch) {
t.Fatalf("expected missing workspace error, got confirm-name mismatch")
}
if !errors.Is(err, repository.ErrWorkspaceNotFound) {
t.Fatalf("expected ErrWorkspaceNotFound, got %v", err)
}
if !strings.Contains(err.Error(), "workspace not found") {
t.Fatalf("expected workspace not found error, got %v", err)
}
}
func TestService_DeleteWorkspaceWithConfirmNameRejectsFinalNameMismatch(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
svc.workspaces = renameBeforeConfirmedDeleteRepo{WorkspaceRepository: repo}
err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me")
if !errors.Is(err, ErrWorkspaceConfirmNameMismatch) {
t.Fatalf("expected ErrWorkspaceConfirmNameMismatch, got %v", err)
}
workspace, err := repo.GetWorkspace(ctx, "ws-delete")
if err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if workspace.Name != "Renamed" {
t.Fatalf("workspace should keep concurrent rename, got %q", workspace.Name)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
// TestService_DeleteWorkflow_ArchivesChildTasks verifies the cascade fix for
// issue #1279: workflow deletion archives any active child tasks instead of
// leaving them with a dangling workflow_id (tasks.workflow_id has no FK, so
// SQLite cannot CASCADE for us).
func TestService_DeleteWorkflow_ArchivesChildTasks(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-1", Name: "WS"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-doomed", WorkspaceID: "ws-1", Name: "Doomed"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-keep", WorkspaceID: "ws-1", Name: "Keep"})
tasks := []*models.Task{
{ID: "task-a", WorkspaceID: "ws-1", WorkflowID: "wf-doomed", WorkflowStepID: "step-1", Title: "A"},
{ID: "task-b", WorkspaceID: "ws-1", WorkflowID: "wf-doomed", WorkflowStepID: "step-1", Title: "B"},
{ID: "task-other", WorkspaceID: "ws-1", WorkflowID: "wf-keep", WorkflowStepID: "step-1", Title: "Other"},
}
for _, task := range tasks {
if err := repo.CreateTask(ctx, task); err != nil {
t.Fatalf("CreateTask %s: %v", task.ID, err)
}
}
if err := svc.DeleteWorkflow(ctx, "wf-doomed"); err != nil {
t.Fatalf("DeleteWorkflow: %v", err)
}
if _, err := svc.workflows.GetWorkflow(ctx, "wf-doomed"); err == nil {
t.Fatalf("expected workflow to be deleted")
}
for _, id := range []string{"task-a", "task-b"} {
got, err := repo.GetTask(ctx, id)
if err != nil {
t.Fatalf("GetTask %s after cascade: %v", id, err)
}
if got.ArchivedAt == nil {
t.Errorf("task %s: expected archived_at to be set, got nil", id)
}
}
other, err := repo.GetTask(ctx, "task-other")
if err != nil {
t.Fatalf("GetTask task-other: %v", err)
}
if other.ArchivedAt != nil {
t.Errorf("task in unrelated workflow should not be archived, got archived_at=%v", other.ArchivedAt)
}
}
// leakyListTaskRepo wraps the real TaskRepository and injects extra tasks
// into ListTasks results, simulating a TOCTOU race where a task is archived
// between the snapshot and the cascade loop.
type leakyListTaskRepo struct {
repository.TaskRepository
extra []*models.Task
}
func (l leakyListTaskRepo) ListTasks(ctx context.Context, workflowID string) ([]*models.Task, error) {
real, err := l.TaskRepository.ListTasks(ctx, workflowID)
if err != nil {
return nil, err
}
return append(real, l.extra...), nil
}
// TestService_DeleteWorkflow_SkipsConcurrentlyArchivedTask covers the
// TOCTOU race window between Service.tasks.ListTasks and Service.ArchiveTask:
// if a task is archived by another caller in that window, ArchiveTask
// returns ErrTaskAlreadyArchived and the cascade must continue rather than
// abort, so the workflow row still gets deleted.
func TestService_DeleteWorkflow_SkipsConcurrentlyArchivedTask(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-1", Name: "WS"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-doomed", WorkspaceID: "ws-1", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-live", WorkspaceID: "ws-1", WorkflowID: "wf-doomed", WorkflowStepID: "step-1", Title: "Live",
}); err != nil {
t.Fatalf("CreateTask live: %v", err)
}
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-raced", WorkspaceID: "ws-1", WorkflowID: "wf-doomed", WorkflowStepID: "step-1", Title: "Raced",
}); err != nil {
t.Fatalf("CreateTask raced: %v", err)
}
if err := repo.ArchiveTask(ctx, "task-raced"); err != nil {
t.Fatalf("pre-archive raced task: %v", err)
}
raced, err := repo.GetTask(ctx, "task-raced")
if err != nil {
t.Fatalf("GetTask raced: %v", err)
}
svc.tasks = leakyListTaskRepo{TaskRepository: repo, extra: []*models.Task{raced}}
if err := svc.DeleteWorkflow(ctx, "wf-doomed"); err != nil {
t.Fatalf("DeleteWorkflow should swallow ErrTaskAlreadyArchived: %v", err)
}
if _, err := svc.workflows.GetWorkflow(ctx, "wf-doomed"); err == nil {
t.Fatalf("expected workflow to be deleted despite race")
}
got, err := repo.GetTask(ctx, "task-live")
if err != nil {
t.Fatalf("GetTask live: %v", err)
}
if got.ArchivedAt == nil {
t.Errorf("live task should be archived by cascade")
}
}
// TestService_DeleteWorkflow_PartialArchiveErrorPreservesWorkflow verifies
// the fail-fast contract: when ArchiveTask returns a non-sentinel error
// part-way through the cascade, DeleteWorkflow surfaces it, leaves the
// workflow row intact, and the tasks archived before the failure stay
// archived. Retries are safe because ListTasks filters them out.
func TestService_DeleteWorkflow_PartialArchiveErrorPreservesWorkflow(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-1", Name: "WS"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-doomed", WorkspaceID: "ws-1", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-first", WorkspaceID: "ws-1", WorkflowID: "wf-doomed", WorkflowStepID: "step-1", Title: "First",
}); err != nil {
t.Fatalf("CreateTask first: %v", err)
}
// "task-ghost" never actually exists in the DB — the leaky list returns
// it so the cascade's ArchiveTask call hits a real GetTask error.
ghost := &models.Task{ID: "task-ghost", WorkspaceID: "ws-1", WorkflowID: "wf-doomed", WorkflowStepID: "step-1", Title: "Ghost"}
svc.tasks = leakyListTaskRepo{TaskRepository: repo, extra: []*models.Task{ghost}}
err := svc.DeleteWorkflow(ctx, "wf-doomed")
if err == nil {
t.Fatalf("expected error when ArchiveTask fails mid-cascade")
}
if errors.Is(err, ErrTaskAlreadyArchived) {
t.Fatalf("non-sentinel error must propagate, got sentinel: %v", err)
}
if _, err := svc.workflows.GetWorkflow(ctx, "wf-doomed"); err != nil {
t.Fatalf("workflow row must survive a partial cascade, got: %v", err)
}
first, err := repo.GetTask(ctx, "task-first")
if err != nil {
t.Fatalf("GetTask first: %v", err)
}
if first.ArchivedAt == nil {
t.Errorf("task archived before the failure should remain archived")
}
}
// TestService_ArchiveTask_ReturnsAlreadyArchivedSentinel locks in the
// sentinel-error contract DeleteWorkflow relies on.
func TestService_ArchiveTask_ReturnsAlreadyArchivedSentinel(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-1", Name: "WS"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-1", WorkspaceID: "ws-1", Name: "WF"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-1", WorkspaceID: "ws-1", WorkflowID: "wf-1", WorkflowStepID: "step-1", Title: "T",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
if err := svc.ArchiveTask(ctx, "task-1"); err != nil {
t.Fatalf("first ArchiveTask: %v", err)
}
err := svc.ArchiveTask(ctx, "task-1")
if !errors.Is(err, ErrTaskAlreadyArchived) {
t.Fatalf("second ArchiveTask: want ErrTaskAlreadyArchived, got %v", err)
}
}
// TestApplyRepositoryUpdates_CopyFilesNilLeavesUntouched verifies the
// pointer-nil convention: a nil CopyFiles field on the request must not
// clobber an existing repository value.
func TestApplyRepositoryUpdates_CopyFilesNilLeavesUntouched(t *testing.T) {
repo := &models.Repository{CopyFiles: "existing"}
if err := applyRepositoryUpdates(repo, &UpdateRepositoryRequest{}); err != nil {
t.Fatalf("applyRepositoryUpdates: %v", err)
}
if repo.CopyFiles != "existing" {
t.Errorf("CopyFiles = %q, want %q (nil request field must not overwrite)", repo.CopyFiles, "existing")
}
}
// TestApplyRepositoryUpdates_CopyFilesEmptyStringClears verifies that an
// explicit empty-string pointer clears the value (distinct from "no update").
func TestApplyRepositoryUpdates_CopyFilesEmptyStringClears(t *testing.T) {
repo := &models.Repository{CopyFiles: "existing"}
empty := ""
if err := applyRepositoryUpdates(repo, &UpdateRepositoryRequest{CopyFiles: &empty}); err != nil {
t.Fatalf("applyRepositoryUpdates: %v", err)
}
if repo.CopyFiles != "" {
t.Errorf("CopyFiles = %q, want empty string", repo.CopyFiles)
}
}