package server import ( "context" "os" "path/filepath" "strings" "sync" "testing" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" ) func TestCancelWaitsForContextIgnoringExecutor(t *testing.T) { ctx, r, pipelineID := concurrentStore(t) entered, release := make(chan struct{}, 1), make(chan struct{}) var releaseOnce sync.Once stopExecutor := func() { releaseOnce.Do(func() { close(release) }) } r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { entered <- struct{}{} <-release // Deliberately ignore the canceled context. return stage.Result{Outcome: "success", Output: stage.Values{}}, nil } defer func() { stopExecutor(); r.wg.Wait() }() workspace := t.TempDir() request := protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "blocking", Workspace: workspace, Input: map[string]any{"prompt": "task"}} run, err := r.start(request) if err != nil { t.Fatal(err) } waitEntered(t, entered) if err := r.cancel(run.ID); err != nil { t.Fatal(err) } if err := r.cancel(run.ID); err != nil { t.Fatal("repeated stop must be idempotent", err) } detail, err := r.getRun(run.ID) if err != nil || detail.Status != "running" || !detail.Executing || !detail.CancelRequested || detail.FinishedAt != "" || detail.Steps[0].Status != "running" || detail.Steps[0].FinishedAt != "" { t.Fatalf("stop request falsely settled execution: %+v %v", detail, err) } request.RequestKey = "conflict" if _, err := r.start(request); err == nil { t.Fatal("stopping workspace was released") } // An actual second server must fail before recovery can touch this live row. other, err := pipeline.Open(filepath.Join(r.store.Directory(), "test.db")) if err != nil { t.Fatal(err) } defer other.Close() if _, err := newRunner(ctx, other); err == nil || !strings.Contains(err.Error(), "another server owns") { t.Fatalf("second server did not fail before recovery: %v", err) } detail, _ = r.store.GetRun(ctx, run.ID) if detail.Status != "running" || detail.Steps[0].Status != "running" { t.Fatal("second server recovered live execution", detail) } stopExecutor() r.wg.Wait() detail, err = r.store.GetRun(ctx, run.ID) if err != nil || detail.Status != "canceled" || detail.Outcome != "" || detail.FinishedAt == "" || detail.Steps[0].Status != "canceled" { t.Fatalf("late success beat stop: %+v %v", detail, err) } r.mu.Lock() err = r.checkWorkspaceFree(workspace) r.mu.Unlock() if err != nil { t.Fatal("confirmed stop did not release workspace", err) } } func TestCleanupUnconfirmedReservesWorkspaceAcrossRecovery(t *testing.T) { ctx := context.Background() r, store, pipelineID := submitRunner(t, ctx, pipeline.Template([]string{"one"}, true)) path := filepath.Join(store.Directory(), "test.db") defer func() { store.Close() }() r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { return stage.Result{}, stage.ErrStageCleanup } workspace := t.TempDir() request := protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "cleanup", Workspace: workspace, Input: map[string]any{"prompt": "task"}} run, err := r.start(request) if err != nil { t.Fatal(err) } r.wg.Wait() if err := r.cancel(run.ID); err != nil { t.Fatal(err) } detail, err := r.getRun(run.ID) if err != nil || detail.Status != "running" || !detail.CleanupUnconfirmed || detail.FinishedAt != "" || !detail.Executing { t.Fatalf("cleanup failure became terminal: %+v %v", detail, err) } request.RequestKey = "blocked" if _, err := r.start(request); err == nil { t.Fatal("unconfirmed cleanup released workspace") } if err := store.Close(); err != nil { t.Fatal(err) } store, err = pipeline.Open(path) if err != nil { t.Fatal(err) } recovered, err := newRunner(ctx, store) if err != nil { t.Fatal(err) } // No recoverable session pointer exists in this fixture: fail closed rather // than claiming a restart proved an external process stopped. if _, err := recovered.start(request); err == nil { t.Fatal("restart released unconfirmed workspace without stop evidence") } detail, _ = recovered.getRun(run.ID) if !detail.CleanupUnconfirmed || detail.Status != "running" || detail.FinishedAt != "" { t.Fatal("recovery invented stop confirmation", detail) } } func TestWorkspaceOverlapIncludesParentsDescendantsAndSymlinks(t *testing.T) { _, r, pipelineID := concurrentStore(t) workspace := t.TempDir() child := filepath.Join(workspace, "child") if err := os.Mkdir(child, 0700); err != nil { t.Fatal(err) } alias := filepath.Join(t.TempDir(), "alias") if err := os.Symlink(child, alias); err != nil { t.Fatal(err) } r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { return stage.Result{}, nil } // Admission resolves aliases; the overlap check must cover both directions. for _, pair := range [][2]string{{workspace, child}, {child, workspace}, {workspace, alias}} { r.mu.Lock() resolved, _ := filepath.EvalSymlinks(pair[0]) r.active[99] = activeRun{cancel: func() {}, workspace: resolved} r.mu.Unlock() _, err := r.start(protocol.Message{PipelineID: pipelineID, Version: 1, RequestKey: "overlap", Workspace: pair[1], Input: map[string]any{"prompt": "task"}}) if err == nil || !strings.Contains(err.Error(), "already active") { t.Fatal("overlapping workspace admission", pair, err) } } for _, pair := range [][2]string{{"/repo", "/repo-other"}, {"/repo/a", "/repo/b"}} { if workspacesOverlap(pair[0], pair[1]) { t.Fatal("sibling/prefix falsely overlaps", pair) } } }