package app import ( "bytes" "context" "encoding/json" "errors" "os" "path/filepath" "strings" "testing" "gitea.maximumdirect.net/eric/narratio/internal/config" "go.maximumdirect.net/commandkit" configkit "go.maximumdirect.net/configkit" ) func TestConfigurationCommandsExposeNativeScopesLazily(t *testing.T) { app, err := newApplication(commandDependencies{ loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) { t.Fatal("discovery loaded config") return nil, nil }, loadSecretsDir: func(string) (*configkit.SecretsReport, error) { t.Fatal("discovery bootstrapped secrets") return nil, nil }, }, executePlan) if err != nil { t.Fatal(err) } for _, args := range [][]string{{"config", "scopes", "--format", "json"}, {"config", "--help"}, {"config", "show", "--help"}} { var out, diagnostic bytes.Buffer result := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) if result.Status != 0 { t.Fatalf("%v: %v %s", args, result, diagnostic.String()) } if args[1] == "scopes" { var inventory struct { Scopes []struct { Name string `json:"name"` } `json:"scopes"` } if err := json.Unmarshal(out.Bytes(), &inventory); err != nil { t.Fatal(err) } if len(inventory.Scopes) != 4 { t.Fatalf("scopes=%s", out.String()) } } } } func TestConfigurationCommandsInspectActualDocuments(t *testing.T) { pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir()) campaignCfg, err := config.LoadCampaign(campaign) if err != nil { t.Fatal(err) } party, err := config.ResolveParty(campaign, campaignCfg, nil) if err != nil { t.Fatal(err) } for _, test := range []struct { scope, field string selectors []string }{ {"app", "workspace", []string{"--config", pipeline}}, {"campaign", "campaign_id", []string{"--campaign-file", campaign}}, {"session", "session_id", []string{"--campaign-file", campaign, "--session-file", session}}, {"party", "characters", []string{"--party-file", party.Source.Path}}, } { t.Run(test.scope, func(t *testing.T) { var out, diagnostic bytes.Buffer args := append([]string{"config", "show", "--scope", test.scope, "--format", "json"}, test.selectors...) result := Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) if result.Status != 0 { t.Fatalf("status=%d diagnostics=%s", result.Status, diagnostic.String()) } var document map[string]any if err := json.Unmarshal(out.Bytes(), &document); err != nil { t.Fatal(err) } if _, ok := document[test.field]; !ok { t.Fatalf("missing %s: %s", test.field, out.String()) } }) } } func TestConfigurationCommandsUseNativeSourcesAndValidation(t *testing.T) { dir := t.TempDir() root := filepath.Join(dir, "pipeline.yml") imported := filepath.Join(dir, "platform.yml") if err := os.WriteFile(root, []byte("config:\n imports:\n - path: platform.yml\n"), 0600); err != nil { t.Fatal(err) } if err := os.WriteFile(imported, []byte("workspace: {root: ./workspace}\nwhisperx: {transcribe_url: https://transcription.example.test/transcribe}\n"), 0600); err != nil { t.Fatal(err) } var out, diagnostic bytes.Buffer result := Execute(context.Background(), []string{"config", "sources", "--config", root, "--format", "json"}, commandkit.Streams{Out: &out, Err: &diagnostic}) if result.Status != 0 || !strings.Contains(out.String(), "platform.yml") { t.Fatalf("sources=%s diagnostics=%s", out.String(), diagnostic.String()) } if err := os.WriteFile(imported, []byte("workspace: {unrecognized: value}\n"), 0600); err != nil { t.Fatal(err) } out.Reset() diagnostic.Reset() result = Execute(context.Background(), []string{"config", "validate", "--config", root}, commandkit.Streams{Out: &out, Err: &diagnostic}) if result.Status != 2 || !strings.Contains(diagnostic.String(), "decode.unknown_field") { t.Fatalf("status=%d diagnostics=%s", result.Status, diagnostic.String()) } } func nativeInspectionForTest(t *testing.T, args []string) string { t.Helper() var out, diagnostic bytes.Buffer outcome := Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic}) if outcome.Status != 0 { t.Fatalf("%v: status=%d error=%v diagnostics=%s", args, outcome.Status, outcome.Cause, diagnostic.String()) } return out.String() } func TestConfigurationCommandsExposeNativePathEvidence(t *testing.T) { pipeline, _, _ := writeValidConfigFiles(t, t.TempDir()) for _, args := range [][]string{ {"show", "--path", "/workspace/root"}, {"explain", "--path", "/workspace/root"}, {"explain", "--list", "--under", "/workspace", "--historical"}, } { command := append([]string{"config"}, args...) command = append(command, "--config", pipeline, "--format", "json") output := nativeInspectionForTest(t, command) if !json.Valid([]byte(output)) { t.Fatalf("invalid native report: %s", output) } if args[0] == "explain" && !strings.Contains(output, "/workspace/root") { t.Fatalf("missing native path evidence: %s", output) } } } func TestConfigurationValidationFiltersDoNotHideFailure(t *testing.T) { pipeline := filepath.Join(t.TempDir(), "pipeline.yml") mustWriteTestFile(t, pipeline, "whisperx: {transcribe_url: https://transcription.example.test/transcribe, timeout: invalid}\n") var out, diagnostic bytes.Buffer outcome := Execute(context.Background(), []string{"config", "validate", "--config", pipeline, "--details", "--severity", "warning", "--format", "json"}, commandkit.Streams{Out: &out, Err: &diagnostic}) if outcome.Status != 2 { t.Fatalf("status=%d diagnostics=%s", outcome.Status, diagnostic.String()) } if !json.Valid(out.Bytes()) || !strings.Contains(out.String(), "filtered") { t.Fatalf("filtered failure report=%s", out.String()) } } func TestConfigurationAggregateDoesNotOmitUnavailableContext(t *testing.T) { pipeline := filepath.Join(t.TempDir(), "pipeline.yml") mustWriteTestFile(t, pipeline, "whisperx: {transcribe_url: https://transcription.example.test/transcribe}\n") var out, diagnostic bytes.Buffer outcome := Execute(context.Background(), []string{"config", "validate", "--scope", "all", "--config", pipeline, "--format", "json"}, commandkit.Streams{Out: &out, Err: &diagnostic}) if outcome.Status == 0 || outcome.Cause == nil { t.Fatalf("missing context was silently omitted: %s", out.String()) } if !strings.Contains(out.String(), "campaign") { t.Fatalf("missing aggregate scope report: %s", out.String()) } } func TestConfigurationInspectionExplainsIdentityMismatches(t *testing.T) { _, campaign, session := writeValidConfigFiles(t, t.TempDir()) for _, args := range [][]string{ {"config", "show", "--scope", "campaign", "--campaign-file", campaign, "--campaign", "other-campaign"}, {"config", "show", "--scope", "session", "--campaign-file", campaign, "--session-file", session, "--session", "other-session"}, {"config", "diff", "--scope", "campaign", "--campaign-file", campaign, "--against-campaign-file", campaign, "--against-campaign", "other-campaign"}, } { var output, diagnostics bytes.Buffer result := Execute(context.Background(), args, commandkit.Streams{Out: &output, Err: &diagnostics}) var identity *config.SessionIdentityError if result.Status == 0 || !errors.As(result.Cause, &identity) { t.Fatalf("%v: identity cause missing: %#v", args, result) } if output.Len() != 0 || !strings.Contains(diagnostics.String(), identity.Field) || !strings.Contains(diagnostics.String(), identity.Expected) || !strings.Contains(diagnostics.String(), identity.Actual) { t.Fatalf("%v: assertion not explained: %s", args, diagnostics.String()) } if identity.Field == "campaign_id" && strings.Contains(diagnostics.String(), "session file") { t.Fatalf("campaign assertion mislabeled: %s", diagnostics.String()) } } }