package app import ( "bytes" "context" "net/http" "net/http/httptest" "path/filepath" "testing" "time" "gitea.maximumdirect.net/eric/narratio/internal/artifacts" "gitea.maximumdirect.net/eric/narratio/internal/manifest" ) func TestRunContinuesAfterCompletedStages(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") store := &manifest.LocalStore{} materializePrepareResumeFixture(t, pipelinePath, campaignPath, sessionPath) m, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load prepared manifest: %v", err) } m.MarkStageSucceeded("transcribe", time.Date(2026, 5, 3, 10, 2, 0, 0, time.UTC), nil) seedCurrentSemanticEvidence(t, loadConfigForSemanticEvidence(t, pipelinePath, campaignPath, sessionPath), m, "prepare", "transcribe") if err := store.Save(context.Background(), manifestPath, m); err != nil { t.Fatalf("save manifest: %v", err) } workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") mustWriteTestFile(t, filepath.Join(workRoot, "transcripts", "raw", "alice.json"), `{"segments":[]}`) var out bytes.Buffer err = invokeNativeCommand(context.Background(), []string{"run", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("Run() error = %v", err) } if !runCountsMatch(t, out.Bytes(), 10, 4, "") { t.Fatalf("output = %q, want executed=10 skipped=4", out.String()) } loaded, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load manifest: %v", err) } if loaded.Stages["trim"] == nil || loaded.Stages["trim"].Status != manifest.StatusSucceeded { t.Fatalf("trim stage = %#v, want succeeded", loaded.Stages["trim"]) } } func TestRunNoRemainingStagesRecordsSkippedStages(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") store := &manifest.LocalStore{} materializePrepareResumeFixture(t, pipelinePath, campaignPath, sessionPath) m, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load prepared manifest: %v", err) } for _, name := range []string{"prepare", "transcribe", "merge", "polish", "normalize", "trim", "render", "analyze", "publish", "notify"} { m.MarkStageSucceeded(name, time.Date(2026, 5, 3, 10, 1, 0, 0, time.UTC), nil) } m.MarkStageSkipped("extract", time.Date(2026, 5, 3, 10, 1, 0, 0, time.UTC), "notarius_disabled") seedCurrentSemanticEvidence(t, loadConfigForSemanticEvidence(t, pipelinePath, campaignPath, sessionPath), m, "prepare", "transcribe", "merge", "polish", "normalize", "trim", "render", "publish", "notify") if err := store.Save(context.Background(), manifestPath, m); err != nil { t.Fatalf("save manifest: %v", err) } var out bytes.Buffer err = invokeNativeCommand(context.Background(), []string{"run", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("Run() error = %v", err) } if !runCountsMatch(t, out.Bytes(), 2, 12, "") { t.Fatalf("output = %q, want disabled extraction to self-skip", out.String()) } loaded, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load migrated manifest: %v", err) } if loaded.Stages["extract"] == nil || loaded.Stages["extract"].Status != manifest.StatusSkipped { t.Fatalf("extract record = %#v, want stable disabled skip", loaded.Stages["extract"]) } } func TestRunForceRerunsSucceeded(t *testing.T) { workspaceRoot := t.TempDir() srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"source":"run-force-test","segments":[{"speaker":"alice"}]}`)) })) defer srv.Close() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot, srv.URL) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") store := &manifest.LocalStore{} m := manifest.New("2026-05-03", time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)) for _, name := range []string{"prepare", "transcribe", "merge", "polish", "normalize", "trim", "extract", "render", "analyze", "publish", "notify", "cleanup"} { m.MarkStageSucceeded(name, time.Date(2026, 5, 3, 10, 1, 0, 0, time.UTC), nil) } if err := store.Save(context.Background(), manifestPath, m); err != nil { t.Fatalf("save manifest: %v", err) } var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath, "--force"}, &out) if err != nil { t.Fatalf("Run() error = %v", err) } if !runCountsMatch(t, out.Bytes(), 12, 2, "") { t.Fatalf("output = %q, want forced full rerun", out.String()) } } func TestRunSingleStageExecutesOnlySelectedStage(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") basePath := filepath.Join(workRoot, "transcripts", "base.json") mustWriteTestFile(t, basePath, `{"segments":[]}`) seedCurrentBuiltInEvidence(t, manifestPath, "2026-05-03", "sample-campaign", "merge", artifacts.TranscriptOutputKindBase, artifacts.ArtifactTranscriptBase, basePath) mustWriteTestFile(t, filepath.Join(workRoot, "inputs", "glossary.yml"), "terms: []\n") seedInvocationPrerequisites(t, workspaceRoot, "polish") var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "--stage", "polish", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("single-stage run error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 0, "polish") { t.Fatalf("output = %q, want stage executed", out.String()) } store := &manifest.LocalStore{} m, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load manifest: %v", err) } if m.Stages["polish"] == nil || m.Stages["polish"].Status != manifest.StatusSucceeded { t.Fatalf("polish stage = %#v, want succeeded", m.Stages["polish"]) } if m.Stages["prepare"] != nil && m.Stages["prepare"].StartedAt != nil { t.Fatalf("prepare was attempted outside the selected range: %#v", m.Stages["prepare"]) } } func TestRunSingleStageExtractIsAcceptedAndSelfSkipsWhenDisabled(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) seedInvocationPrerequisites(t, workspaceRoot, "extract") var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "--stage", "extract", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("single-stage run (extract) error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 1, "extract") { t.Fatalf("output = %q, want disabled extraction self-skip", out.String()) } loaded, err := (&manifest.LocalStore{}).Load(context.Background(), filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json")) if err != nil { t.Fatalf("Load() error = %v", err) } if loaded.Stages["extract"] == nil || loaded.Stages["extract"].Status != manifest.StatusSkipped { t.Fatalf("extract record = %#v, want skipped", loaded.Stages["extract"]) } } func TestRunSingleStageSkipAndForce(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") basePath := filepath.Join(workRoot, "transcripts", "base.json") mustWriteTestFile(t, basePath, `{"segments":[]}`) mustWriteTestFile(t, filepath.Join(workRoot, "inputs", "glossary.yml"), "terms: []\n") store := &manifest.LocalStore{} m := manifest.New("2026-05-03", time.Date(2026, 5, 3, 10, 0, 0, 0, time.UTC)) setCurrentBuiltInEvidence(t, m, "merge", artifacts.TranscriptOutputKindBase, artifacts.ArtifactTranscriptBase, basePath) m.MarkStageSucceeded("polish", time.Date(2026, 5, 3, 10, 1, 0, 0, time.UTC), nil) seedCurrentSemanticEvidence(t, loadConfigForSemanticEvidence(t, pipelinePath, campaignPath, sessionPath), m, "polish") if err := store.Save(context.Background(), manifestPath, m); err != nil { t.Fatalf("save manifest: %v", err) } seedInvocationPrerequisites(t, workspaceRoot, "polish") var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "--stage", "polish", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("single-stage run error = %v", err) } if !runCountsMatch(t, out.Bytes(), 0, 1, "polish") { t.Fatalf("output = %q, want skip", out.String()) } out.Reset() err = invokeNativeCommand(context.Background(), []string{"run", "--stage", "polish", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath, "--force"}, &out) if err != nil { t.Fatalf("single-stage run (force) error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 0, "polish") { t.Fatalf("output = %q, want force rerun", out.String()) } } func TestRunSingleStageForceMarksDownstreamStaleAndRunContinuesFromStale(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") basePath := filepath.Join(workRoot, "transcripts", "base.json") mustWriteTestFile(t, basePath, `{"segments":[]}`) seedCurrentBuiltInEvidence(t, manifestPath, "2026-05-03", "sample-campaign", "merge", artifacts.TranscriptOutputKindBase, artifacts.ArtifactTranscriptBase, basePath) store := &manifest.LocalStore{} materializePrepareResumeFixture(t, pipelinePath, campaignPath, sessionPath) seed, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load prepared manifest: %v", err) } for _, name := range []string{"prepare", "transcribe", "merge", "polish", "normalize", "trim", "extract", "render", "analyze", "publish", "notify", "cleanup"} { seed.MarkStageSucceeded(name, time.Date(2026, 5, 3, 10, 1, 0, 0, time.UTC), nil) } setCurrentBuiltInEvidence(t, seed, "merge", artifacts.TranscriptOutputKindBase, artifacts.ArtifactTranscriptBase, basePath) seedCurrentSemanticEvidence(t, loadConfigForSemanticEvidence(t, pipelinePath, campaignPath, sessionPath), seed, "prepare", "transcribe", "merge") if err := store.Save(context.Background(), manifestPath, seed); err != nil { t.Fatalf("save manifest: %v", err) } var out bytes.Buffer err = invokeNativeCommand(context.Background(), []string{"run", "--stage", "polish", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath, "--force"}, &out) if err != nil { t.Fatalf("single-stage run (force) error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 0, "polish") { t.Fatalf("output = %q, want forced polish rerun", out.String()) } afterForce, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load manifest after force: %v", err) } for _, name := range []string{"normalize", "trim", "render", "extract", "analyze", "publish", "notify", "cleanup"} { if afterForce.Stages[name] == nil || afterForce.Stages[name].Status != manifest.StatusStale { t.Fatalf("stage %q = %#v, want stale", name, afterForce.Stages[name]) } } out.Reset() err = invokeNativeCommand(context.Background(), []string{"run", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("Run() error = %v", err) } if !runCountsMatch(t, out.Bytes(), 8, 6, "") { t.Fatalf("output = %q, want run to execute stale downstream stages", out.String()) } } func TestRunSingleStageTrimExecutes(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") finalPath := filepath.Join(workRoot, "transcripts", "final.json") mustWriteTestFile(t, finalPath, `{"segments":[{"id":1},{"id":2}]}`) seedCurrentBuiltInEvidence(t, manifestPath, "2026-05-03", "sample-campaign", "normalize", artifacts.TranscriptOutputKindFinal, artifacts.ArtifactTranscriptFinal, finalPath) seedInvocationPrerequisites(t, workspaceRoot, "trim") var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "--stage", "trim", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("single-stage run (trim) error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 0, "trim") { t.Fatalf("output = %q, want stage=trim executed", out.String()) } store := &manifest.LocalStore{} m, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load manifest: %v", err) } if m.Stages["trim"] == nil || m.Stages["trim"].Status != manifest.StatusSucceeded { t.Fatalf("trim stage = %#v, want succeeded", m.Stages["trim"]) } if m.Stages["trim"].Metadata == nil || m.Stages["trim"].Metadata["trim_action"] != "copy" { t.Fatalf("trim stage metadata = %#v, want trim_action=copy", m.Stages["trim"].Metadata) } } func TestRunSingleStageNormalizeExecutes(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") polishedPath := filepath.Join(workRoot, "transcripts", "polished.json") mustWriteTestFile(t, polishedPath, `{"segments":[{"id":1},{"id":2}]}`) seedCurrentBuiltInEvidence(t, manifestPath, "2026-05-03", "sample-campaign", "polish", artifacts.TranscriptOutputKindPolished, artifacts.ArtifactTranscriptPolished, polishedPath) seedInvocationPrerequisites(t, workspaceRoot, "normalize") var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "--stage", "normalize", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("single-stage run (normalize) error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 0, "normalize") { t.Fatalf("output = %q, want stage=normalize executed", out.String()) } store := &manifest.LocalStore{} m, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load manifest: %v", err) } if m.Stages["normalize"] == nil || m.Stages["normalize"].Status != manifest.StatusSucceeded { t.Fatalf("normalize stage = %#v, want succeeded", m.Stages["normalize"]) } } func TestRunSingleStageRenderExecutes(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, sessionPath := writeValidConfigFiles(t, workspaceRoot) manifestPath := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03", "manifest.json") workRoot := filepath.Join(workspaceRoot, "work", "sample-campaign", "2026-05-03") finalPath := filepath.Join(workRoot, "transcripts", "final.json") trimmedPath := filepath.Join(workRoot, "transcripts", "final.trimmed.json") mustWriteTestFile(t, finalPath, `{"segments":[{"id":1}]}`) mustWriteTestFile(t, trimmedPath, `{"segments":[{"id":2}]}`) seed := manifest.New("2026-05-03", time.Now().UTC()) seed.Campaign = "sample-campaign" setCurrentBuiltInEvidence(t, seed, "normalize", artifacts.TranscriptOutputKindFinal, artifacts.ArtifactTranscriptFinal, finalPath) setCurrentBuiltInEvidence(t, seed, "trim", artifacts.TranscriptOutputKindFinalTrimmed, artifacts.ArtifactTranscriptFinalTrimmed, trimmedPath) if err := (&manifest.LocalStore{}).Save(context.Background(), manifestPath, seed); err != nil { t.Fatal(err) } seedInvocationPrerequisites(t, workspaceRoot, "render") var out bytes.Buffer err := invokeNativeCommand(context.Background(), []string{"run", "--stage", "render", "2026-05-03", "--config", pipelinePath, "--campaign-file", campaignPath, "--session-file", sessionPath}, &out) if err != nil { t.Fatalf("single-stage run (render) error = %v", err) } if !runCountsMatch(t, out.Bytes(), 1, 0, "render") { t.Fatalf("output = %q, want stage=render executed", out.String()) } store := &manifest.LocalStore{} m, err := store.Load(context.Background(), manifestPath) if err != nil { t.Fatalf("load manifest: %v", err) } if m.Stages["render"] == nil || m.Stages["render"].Status != manifest.StatusSucceeded { t.Fatalf("render stage = %#v, want succeeded", m.Stages["render"]) } }