package server import ( "context" "encoding/json" "net/http" "net/http/httptest" "path/filepath" "strings" "sync" "testing" "time" "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 TestHandlerRunsRegisteredVerificationFixture(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) var mu sync.Mutex response := map[string]string{"backend": "branch-api", "revision": "abc123", "capability": "controlled-state", "fixture": verificationFixtureID, "state": "ready"} calls := 0 fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { mu.Lock() defer mu.Unlock() calls++ _ = json.NewEncoder(w).Encode(response) })) defer fixture.Close() store, err := pipeline.Open(filepath.Join(t.TempDir(), "fixture.db")) if err != nil { t.Fatal(err) } defer store.Close() source := pipeline.Template([]string{"worker"}, true) source = strings.Replace(source, "```configs", "```verification\nbackend=branch-api\nrevision=abc123\ncapability=controlled-state\nfixture="+verificationFixtureID+"\n```\n\n```configs", 1) if _, err := store.Submit(ctx, "controlled-fixture", source); err != nil { t.Fatal(err) } items, err := store.List(ctx) if err != nil { t.Fatal(err) } handler := HandlerWithOptions(ctx, Options{VerificationFixtures: []VerificationFixture{{ID: verificationFixtureID, Endpoint: fixture.URL, Backend: "branch-api", Revision: "abc123", Capability: "controlled-state", State: "ready"}}}, store).(*runHandler) defer func() { cancel() WaitRuns(handler) }() r := handler.runner if r.verifyTarget == nil { t.Fatal("normal server construction did not wire controlled fixture verification") } r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { // These forged model labels must not influence fixture provenance. return stage.Result{Outcome: "success", Output: stage.Values{"verification": map[string]any{"backend": "old-api", "revision": "stale", "capability": "forged", "fixture": "other"}}}, nil } start := func(key string) *protocol.RunDetail { run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: key, Workspace: t.TempDir(), Input: map[string]any{"prompt": "verify"}}) if err != nil { t.Fatal(err) } r.wg.Wait() detail, err := store.GetRun(ctx, run.ID) if err != nil { t.Fatal(err) } return detail } if detail := start("compatible"); detail.Status != "succeeded" { t.Fatalf("compatible controlled fixture did not settle: %+v", detail) } mu.Lock() response["revision"] = "old-build" mu.Unlock() if detail := start("stale"); detail.Status != "failed" || !strings.Contains(detail.Steps[0].Diagnostic, "incompatible") { t.Fatalf("stale fixture provenance settled as success: %+v", detail) } mu.Lock() if calls != 2 { t.Fatalf("fixture probes = %d, want one per target-aware stage", calls) } mu.Unlock() } func TestVerificationFixtureCancellationClosesProbe(t *testing.T) { started := make(chan struct{}) canceled := make(chan struct{}) fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { close(started) <-r.Context().Done() close(canceled) })) defer fixture.Close() registry := newVerificationFixtureRegistry([]VerificationFixture{{ID: verificationFixtureID, Endpoint: fixture.URL, Backend: "branch-api", Revision: "abc123", Capability: "controlled-state", State: "ready"}}) ctx, cancel := context.WithCancel(context.Background()) done := make(chan error, 1) go func() { _, err := registry.verify(ctx, stage.VerificationTarget{Backend: "branch-api", Revision: "abc123", Capability: "controlled-state", Fixture: verificationFixtureID}) done <- err }() select { case <-started: case <-time.After(time.Second): t.Fatal("fixture probe did not start") } cancel() select { case err := <-done: if err == nil { t.Fatal("canceled fixture probe succeeded") } case <-time.After(time.Second): t.Fatal("canceled fixture probe did not return") } select { case <-canceled: case <-time.After(time.Second): t.Fatal("canceled fixture request was not cleaned up") } } func TestVerificationFixtureRejectsUnknownAndMismatchedProvenance(t *testing.T) { base := map[string]string{"backend": "branch-api", "revision": "abc123", "capability": "controlled-state", "fixture": verificationFixtureID, "state": "ready"} for field, wrong := range map[string]string{"backend": "old-api", "revision": "old-build", "capability": "other-state", "state": "stale"} { t.Run(field, func(t *testing.T) { response := make(map[string]string, len(base)) for key, value := range base { response[key] = value } response[field] = wrong fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _ = json.NewEncoder(w).Encode(response) })) defer fixture.Close() registry := newVerificationFixtureRegistry([]VerificationFixture{{ID: verificationFixtureID, Endpoint: fixture.URL, Backend: base["backend"], Revision: base["revision"], Capability: base["capability"], State: base["state"]}}) _, err := registry.verify(context.Background(), stage.VerificationTarget{Backend: base["backend"], Revision: base["revision"], Capability: base["capability"], Fixture: verificationFixtureID}) if err == nil || !strings.Contains(err.Error(), "incompatible") { t.Fatalf("mismatched %s provenance was accepted: %v", field, err) } }) } registry := newVerificationFixtureRegistry(nil) if _, err := registry.verify(context.Background(), stage.VerificationTarget{Backend: "branch-api", Revision: "abc123", Capability: "controlled-state", Fixture: "unknown"}); err == nil || !strings.Contains(err.Error(), "unknown") { t.Fatalf("unknown fixture was accepted: %v", err) } }