Files
narratio/internal/app/configuration_commands_test.go

170 lines
6.4 KiB
Go
Raw Normal View History

package app
import (
"bytes"
"context"
"encoding/json"
"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())
}
}