package app import ( "bytes" "context" "io" "os" "path/filepath" "strings" "testing" "gitea.maximumdirect.net/eric/narratio/internal/config" configkit "go.maximumdirect.net/configkit" ) func TestExecuteConfigUsesInvocationPipelineLoader(t *testing.T) { dir := t.TempDir() pipelinePath := filepath.Join(dir, "pipeline.yml") mustWriteTestFile(t, pipelinePath, "workspace:\n root: "+filepath.Join(dir, "workspace")+"\nwhisperx:\n transcribe_url: https://transcription.example.com/transcribe\n") for _, subcommand := range []string{"validate", "show", "sources"} { t.Run(subcommand, func(t *testing.T) { calls := 0 deps := commandDependencies{ loadPipelineConfig: func(path string, opts config.PipelineLoadOptions) (*config.PipelineConfig, error) { calls++ return config.LoadPipelineWithOptions(path, opts) }, } var stdout, stderr bytes.Buffer code := executeWithDependencies( []string{"config", subcommand, "--config", pipelinePath}, &stdout, &stderr, deps, executePlan, ) if code != 0 { t.Fatalf("exit code = %d, want 0; stdout=%q stderr=%q", code, stdout.String(), stderr.String()) } if calls != 1 { t.Fatalf("pipeline loader calls = %d, want 1", calls) } }) } } func TestConfigDiffReportsSemanticOverlayChanges(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, _, _ := writeValidConfigFiles(t, workspaceRoot) writeInspectionOverlays(t, pipelinePath, `workspace: cleanup_after_publish: true publish: upload_run: true whisperx: language: en audita: modules: [glossary, grammar] scriptorium: artifacts: production_only: enabled: false output_path: artifacts/production.md `, `workspace: cleanup_after_publish: false whisperx: language: fr audita: modules: [] scriptorium: artifacts: testing_only: enabled: false output_path: artifacts/testing.md `) args := []string{"production", "testing", "--config", pipelinePath} var first, second bytes.Buffer if err := ConfigDiff(context.Background(), args, &first); err != nil { t.Fatalf("ConfigDiff() error = %v", err) } if err := ConfigDiff(context.Background(), args, &second); err != nil { t.Fatalf("second ConfigDiff() error = %v", err) } if first.String() != second.String() { t.Fatalf("diff output is not deterministic:\nfirst=%q\nsecond=%q", first.String(), second.String()) } output := first.String() for _, want := range []string{ "changed\t/audita/modules\t[\"glossary\",\"grammar\"]\t[]\n", "changed\t/workspace/cleanup_after_publish\ttrue\tfalse\n", "changed\t/whisperx/language\t\"en\"\t\"fr\"\n", "removed\t/scriptorium/artifacts/production_only\t{", "added\t/scriptorium/artifacts/testing_only\t{", } { if !strings.Contains(output, want) { t.Fatalf("diff output missing %q:\n%s", want, output) } } if strings.Index(output, "/audita/modules") > strings.Index(output, "/workspace/cleanup_after_publish") { t.Fatalf("diff records are not sorted by path:\n%s", output) } var reversed bytes.Buffer if err := ConfigDiff(context.Background(), []string{"testing", "production", "--config", pipelinePath}, &reversed); err != nil { t.Fatalf("reversed ConfigDiff() error = %v", err) } if !strings.Contains(reversed.String(), "changed\t/whisperx/language\t\"fr\"\t\"en\"\n") { t.Fatalf("reversed diff did not independently resolve overlays:\n%s", reversed.String()) } } func TestConfigDiffComparesExpandedFamiliesAndPublishRules(t *testing.T) { pipelinePath, campaignPath := writeInspectionFamilyConfig(t) writeInspectionOverlays(t, pipelinePath, `scriptorium: artifact_families: character_note: enabled: false member_vars: character_name: character.name publish: enabled: true required: false `, `scriptorium: artifact_families: character_note: enabled: true prompt_id: dnd.character_note member_vars: character_name: character.class_summary publish: enabled: true required: true `) var out bytes.Buffer if err := ConfigDiff(context.Background(), []string{ "production", "testing", "--config", pipelinePath, "--campaign-file", campaignPath, }, &out); err != nil { t.Fatalf("ConfigDiff() error = %v", err) } output := out.String() for _, want := range []string{ "changed\t/scriptorium/artifacts/character_note_arannis/enabled\tfalse\ttrue\n", "changed\t/scriptorium/artifacts/character_note_arannis/vars/character_name\t\"Arannis\"\t\"wizard\"\n", "changed\t/publish/outputs\t", } { if !strings.Contains(output, want) { t.Fatalf("family diff output missing %q:\n%s", want, output) } } } func TestConfigDiffReportsEqualityAndRejectsInvalidInput(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, campaignPath, _ := writeValidConfigFiles(t, workspaceRoot) writeInspectionOverlays(t, pipelinePath, "whisperx:\n language: en\n", "whisperx:\n language: en\n") var equal bytes.Buffer if err := ConfigDiff(context.Background(), []string{"production", "testing", "--config", pipelinePath}, &equal); err != nil { t.Fatalf("ConfigDiff() equal overlays error = %v", err) } if got := equal.String(); got != "no differences\n" { t.Fatalf("equal diff output = %q", got) } for _, args := range [][]string{ {"production", "testing", "extra", "--config", pipelinePath}, {"production", "--config", pipelinePath}, {"production", "production", "--config", pipelinePath}, {"unknown", "testing", "--config", pipelinePath}, {"production", "testing", "--config", pipelinePath, "--overlay", "production"}, {"production", "testing", "--config", pipelinePath, "--config", pipelinePath}, {"production", "testing", "--config", pipelinePath, "--campaign", "sample-campaign", "--campaign-file", campaignPath}, } { if err := ConfigDiff(context.Background(), args, io.Discard); err == nil { t.Fatalf("ConfigDiff(%q) succeeded, want error", args) } } } func TestConfigDiffBootstrapsSecretsOnceForBothOverlays(t *testing.T) { workspaceRoot := t.TempDir() pipelinePath, _, _ := writeValidConfigFiles(t, workspaceRoot) writeInspectionOverlays(t, pipelinePath, "whisperx:\n language: en\n", "whisperx:\n language: fr\n") secretsDir := t.TempDir() const secretName = "NARRATIO_DIFF_BOOTSTRAP_REPORT" restoreEnvAfterTest(t, secretName) if err := os.Unsetenv(secretName); err != nil { t.Fatal(err) } mustWriteSecretFile(t, filepath.Join(secretsDir, secretName), "diff-secret-must-not-appear\n") bootstrapCalls := 0 var loadedPaths []string var diagnostics bytes.Buffer deps := commandDependencies{loadSecretsDir: func(got string) (*configkit.SecretsReport, error) { bootstrapCalls++ if got != secretsDir { t.Fatalf("secrets directory = %q, want %q", got, secretsDir) } return configkit.LoadSecretsIntoEnvironment(got) }, diagnostics: &diagnostics} search := configkit.SearchPaths(pipelinePath) deps.pipelineSearch = &search deps.loadPipelineConfig = func(path string, opts config.PipelineLoadOptions) (*config.PipelineConfig, error) { loadedPaths = append(loadedPaths, path) return config.LoadPipelineWithOptions(path, opts) } if err := configDiffWithDependencies(context.Background(), []string{ "production", "testing", "--secrets-dir", secretsDir, }, io.Discard, deps); err != nil { t.Fatalf("config diff: %v", err) } if bootstrapCalls != 1 { t.Fatalf("bootstrap calls = %d, want 1", bootstrapCalls) } if len(loadedPaths) != 2 || loadedPaths[0] != "" || loadedPaths[1] != pipelinePath { t.Fatalf("pipeline load paths = %q, want discovery then selected root %q", loadedPaths, pipelinePath) } if got := diagnostics.String(); strings.Count(got, `name="`+secretName+`"`) != 1 { t.Fatalf("bootstrap report count = %d, want 1; diagnostics = %q", strings.Count(got, `name="`+secretName+`"`), got) } if strings.Contains(diagnostics.String(), "diff-secret-must-not-appear") { t.Fatalf("bootstrap diagnostics exposed secret value: %q", diagnostics.String()) } } func writeInspectionOverlays(t *testing.T, pipelinePath, production, testing string) { t.Helper() overlaysDir := filepath.Join(filepath.Dir(pipelinePath), "overlays") mustWriteTestFile(t, filepath.Join(overlaysDir, "production.yml"), production) mustWriteTestFile(t, filepath.Join(overlaysDir, "testing.yml"), testing) } func writeInspectionFamilyConfig(t *testing.T) (string, string) { t.Helper() dir := t.TempDir() campaignRoot := filepath.Join(dir, "campaigns") campaignDir := filepath.Join(campaignRoot, "sample-campaign") pipelinePath := filepath.Join(dir, "pipeline.yml") campaignPath := filepath.Join(campaignDir, "campaign.yml") mustWriteTestFile(t, pipelinePath, `workspace: root: `+filepath.Join(dir, "workspace")+` campaigns: root: `+campaignRoot+` whisperx: transcribe_url: https://transcription.example.com/transcribe scriptorium: artifact_families: character_meta: enabled: false for_each: party.characters output_path_pattern: artifacts/characters/{character_id}/meta.md character_note: enabled: false for_each: party.characters output_path_pattern: artifacts/characters/{character_id}/note.md member_dependencies: [character_meta] inputs: prior: {source: narratio.member_artifact.character_meta, required: true} member_vars: character_name: character.name publish: enabled: true required: true publish: enabled: true upload_run: false `) mustWriteTestFile(t, campaignPath, `campaign_id: sample-campaign inputs: speakers_file: ./speakers.yml autocorrect_file: ./autocorrect.yml glossary_file: ./glossary.yml party_file: ./party.yml `) mustWriteTestFile(t, filepath.Join(campaignDir, "party.yml"), `schema_version: narratio.party.v1 characters: arannis: player: {name: Eric} character: {name: Arannis, classes: [{name: wizard}]} `) return pipelinePath, campaignPath } func TestNativeBundleInspectionAndExecutionAgree(t *testing.T) { examples, err := filepath.Abs(filepath.Join("..", "..", "examples")) if err != nil { t.Fatal(err) } bundle := t.TempDir() if err := os.CopyFS(bundle, os.DirFS(examples)); err != nil { t.Fatal(err) } root := filepath.Join(bundle, "production-testing") pipeline := filepath.Join(root, "narratio.yml") if err := os.Rename(filepath.Join(root, "pipeline.yml"), pipeline); err != nil { t.Fatal(err) } f, err := os.OpenFile(pipeline, os.O_APPEND|os.O_WRONLY, 0) if err != nil { t.Fatal(err) } if _, err := f.WriteString("\naudita:\n credentials: [NARRATIO_BUNDLE_TEST_KEY]\n"); err != nil { t.Fatal(err) } if err := f.Close(); err != nil { t.Fatal(err) } const secretName = "NARRATIO_BUNDLE_TEST_KEY" const secretValue = "synthetic-bundle-secret" restoreEnvAfterTest(t, secretName) if err := os.Unsetenv(secretName); err != nil { t.Fatal(err) } secrets := filepath.Join(bundle, "secrets") mustWriteSecretFile(t, filepath.Join(secrets, secretName), secretValue) t.Chdir(root) campaign := filepath.Join(bundle, "campaigns", "sample-campaign", "campaign.yml") common := []string{"--campaign-file", campaign, "--secrets-dir", secrets} for _, operation := range []string{"validate", "show", "sources"} { args := []string{"config", operation, "--secrets-dir", secrets} out := nativeInspectionForTest(t, args) if strings.Contains(out, secretValue) { t.Fatalf("%s exposed credential value", operation) } if operation == "show" && !strings.Contains(out, "artifact_families") { t.Fatal("native show omitted authored families") } } var catalog bytes.Buffer if err := ConfigArtifacts(context.Background(), common, &catalog); err != nil { t.Fatal(err) } if !strings.Contains(catalog.String(), "character_meta_arannis") { t.Fatal("domain catalog omitted concrete family member") } var diff bytes.Buffer args := append([]string{"default", "testing"}, common...) if err := ConfigDiff(context.Background(), args, &diff); err != nil { t.Fatal(err) } if !strings.Contains(diff.String(), "/audita/proposal_profile") || strings.Contains(diff.String(), secretValue) { t.Fatalf("unexpected diff: %s", diff.String()) } workspace := filepath.Join(root, "conf.d", "workspace") if _, err := os.Stat(workspace); !os.IsNotExist(err) { t.Fatalf("inspection created workspace: %v", err) } var execution *config.Config executor := func(_ context.Context, cfg *config.Config, _ BoundedPlan, _ RunOptions) (*RunSummary, error) { execution = cfg return &RunSummary{SessionID: "2026-05-03"}, nil } runArgs := append([]string{"2026-05-03", "--session", filepath.Join(bundle, "session.local-audio.yml"), "--overlay", "testing"}, common...) var plan bytes.Buffer planArgs := append(append([]string{}, runArgs...), "--from", "prepare", "--through", "prepare") if err := Plan(context.Background(), planArgs, &plan); err != nil { t.Fatal(err) } if !strings.Contains(plan.String(), "prepare: run") { t.Fatalf("unexpected plan: %s", plan.String()) } if _, err := os.Stat(workspace); !os.IsNotExist(err) { t.Fatalf("plan created workspace: %v", err) } if err := runWithPipelineExecutor(context.Background(), runArgs, io.Discard, executor); err != nil { t.Fatal(err) } if execution == nil || execution.Session.Inputs.AudioDir != filepath.Join(bundle, "audio") || execution.Campaign.Inputs.PartyFile != filepath.Join(bundle, "campaigns", "sample-campaign", "party.yml") { t.Fatalf("execution did not resolve imported session and campaign resources: %+v", execution) } if execution.Pipeline.Audita.ProposalProfile != "narratio-testing-model-placeholder" { t.Fatalf("execution did not use the inspected overlay: %q", execution.Pipeline.Audita.ProposalProfile) } if _, ok := execution.ArtifactCatalog.Artifacts["character_meta_arannis"]; !ok { t.Fatal("execution did not expand the inspected party family") } }