Files
narratio/internal/app/config_commands_test.go

380 lines
14 KiB
Go
Raw Normal View History

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:
2026-08-30 14:56:22 +00:00
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
2026-08-30 14:56:22 +00:00
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")
}
}