package server import ( "context" "errors" "path/filepath" "strings" "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 TestRunnerRoutingPersistenceAndIdempotency(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() store, err := pipeline.Open(filepath.Join(t.TempDir(), "runs.db")) if err != nil { t.Fatal(err) } defer store.Close() if _, err := store.Submit(ctx, "test", pipeline.Template([]string{"one", "two"}, true)); err != nil { t.Fatal(err) } items, _ := store.List(ctx) r, err := newRunner(ctx, store) if err != nil { t.Fatal(err) } entered := make(chan struct{}) release := make(chan struct{}) r.execute = func(ctx context.Context, def stage.Definition, input stage.Values) (stage.Result, error) { if def.Key == "one" { if len(input) != 2 || input["prompt"] != "task" || input["pwd"] == "" { t.Error("entry input must be the user prompt unchanged") } close(entered) <-release return stage.Result{Outcome: "success", Output: stage.Values{"handoff": "evidence"}}, nil } if len(input) != 1 || input["handoff"] != "evidence" { t.Error("handoff not propagated") } return stage.Result{Outcome: "success", Output: stage.Values{"verified": true}}, nil } request := protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "same", Input: map[string]any{"prompt": "task"}} run, err := r.start(request) if err != nil { t.Fatal(err) } <-entered duplicate, err := r.start(request) if err != nil || duplicate.ID != run.ID { t.Fatal("active repeat was not idempotent", err) } other := request other.RequestKey = "other" if _, err := r.start(other); err == nil { t.Fatal("overlapping execution accepted") } close(release) r.wg.Wait() detail, err := store.GetRun(ctx, run.ID) if err != nil { t.Fatal(err) } if detail.Status != "succeeded" || len(detail.Steps) != 2 || detail.Steps[1].Input["handoff"] != "evidence" || detail.Output["verified"] != true { t.Fatalf("invalid persisted run: %+v", detail) } duplicate, err = r.start(request) if err != nil || duplicate.ID != run.ID { t.Fatal("finished repeat not idempotent") } request.RequestKey = "failure" r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { return stage.Result{}, errors.New("provider failed") } failed, err := r.start(request) if err != nil { t.Fatal(err) } r.wg.Wait() detail, _ = store.GetRun(ctx, failed.ID) if detail.Status != "failed" || detail.Steps[0].Outcome != "error" || detail.Steps[0].Target != protocol.FailureEnd { t.Fatal("execution error did not follow mandatory error edge") } request.RequestKey = "cancel" r.execute = func(ctx context.Context, _ stage.Definition, _ stage.Values) (stage.Result, error) { <-ctx.Done() return stage.Result{}, ctx.Err() } canceled, err := r.start(request) if err != nil { t.Fatal(err) } if err := r.cancel(canceled.ID); err != nil { t.Fatal(err) } r.wg.Wait() detail, _ = store.GetRun(ctx, canceled.ID) if detail.Status != "canceled" { t.Fatal("cancel not persisted") } request.RequestKey = "budget" r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { return stage.Result{Outcome: "success", Output: stage.Values{}}, nil } // A new version with a self-loop remains reachable to a terminal via error. source := pipeline.Template([]string{"loop"}, true) source = strings.Replace(source, "success -> #success", "success -> loop", 1) if _, err := store.Submit(ctx, "loop", source); err != nil { t.Fatal(err) } items, _ = store.List(ctx) for _, p := range items { if p.Name == "loop" { request.PipelineID = p.ID } } bounded, err := r.start(request) if err != nil { t.Fatal(err) } r.wg.Wait() detail, _ = store.GetRun(ctx, bounded.ID) if detail.Status != "failed" || len(detail.Steps) != 5 { t.Fatalf("cycle not bounded: %+v", detail) } }