170 lines
6.4 KiB
Go
170 lines
6.4 KiB
Go
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())
|
|
}
|
|
}
|