355 lines
14 KiB
Go
355 lines
14 KiB
Go
package config
|
|
|
|
import (
|
|
"io/fs"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestRepresentativeLoadDefaultsAndValidation(t *testing.T) {
|
|
pipelinePath, sessionPath := writeConfigFiles(t, `whisperx:
|
|
transcribe_url: https://transcription.example.com/transcribe
|
|
`, `session_id: 2026-05-03
|
|
inputs:
|
|
audio_dir: ./audio
|
|
`)
|
|
|
|
cfg, err := Load(pipelinePath, sessionPath)
|
|
if err != nil {
|
|
t.Fatalf("Load() error = %v", err)
|
|
}
|
|
if cfg.Pipeline.Workspace.Root != DefaultWorkspaceRoot {
|
|
t.Fatalf("workspace.root = %q, want %q", cfg.Pipeline.Workspace.Root, DefaultWorkspaceRoot)
|
|
}
|
|
if cfg.Pipeline.Storage.Backend != StorageBackendLocal || cfg.Pipeline.Storage.S3 != nil {
|
|
t.Fatalf("storage = %#v, want local backend without S3 configuration", cfg.Pipeline.Storage)
|
|
}
|
|
if cfg.Pipeline.WhisperX.Timeout != DefaultWhisperXTimeout || cfg.Pipeline.WhisperX.RetryDelay != DefaultWhisperXRetryDelay {
|
|
t.Fatalf("whisperx defaults = %#v, want timeout and retry-delay defaults", cfg.Pipeline.WhisperX)
|
|
}
|
|
if err := Validate(cfg); err != nil {
|
|
t.Fatalf("Validate() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestMarshalEffectivePipelineRendersStablePublicConfiguration(t *testing.T) {
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "pipeline.yml")
|
|
if err := os.WriteFile(path, []byte(`scriptorium:
|
|
artifacts:
|
|
zeta:
|
|
enabled: false
|
|
output_path: artifacts/zeta.md
|
|
alpha:
|
|
enabled: false
|
|
output_path: artifacts/alpha.md
|
|
workspace:
|
|
root: /srv/narratio
|
|
whisperx:
|
|
transcribe_url: https://transcription.example.com/transcribe
|
|
`), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
first, err := LoadPipeline(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
second, err := LoadPipeline(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
firstYAML, err := MarshalEffectivePipeline(first)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
secondYAML, err := MarshalEffectivePipeline(second)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(firstYAML) != string(secondYAML) || !strings.HasSuffix(string(firstYAML), "\n") {
|
|
t.Fatalf("effective YAML is not stable: first=%q second=%q", firstYAML, secondYAML)
|
|
}
|
|
output := string(firstYAML)
|
|
if strings.Contains(output, "artifact_families") || strings.Contains(output, "resolution") {
|
|
t.Fatalf("effective YAML leaked runtime fields: %q", output)
|
|
}
|
|
if strings.Index(output, "alpha:") > strings.Index(output, "zeta:") {
|
|
t.Fatalf("configured artifacts are not sorted: %q", output)
|
|
}
|
|
}
|
|
|
|
func TestValidateMissingAudioSource(t *testing.T) {
|
|
cfg := loadedValidConfig(t)
|
|
cfg.Session.Inputs.AudioDir = ""
|
|
cfg.Session.Inputs.AudioFiles = nil
|
|
cfg.Session.Inputs.AudioS3 = nil
|
|
|
|
err := Validate(cfg)
|
|
if err == nil {
|
|
t.Fatal("expected validation error, got nil")
|
|
}
|
|
if !strings.Contains(err.Error(), "audio_dir, at least one audio_files entry, or audio_s3") {
|
|
t.Fatalf("error = %q, want audio source guidance", err.Error())
|
|
}
|
|
if !strings.Contains(err.Error(), "session config") {
|
|
t.Fatalf("error = %q, want session config context", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestExamplesLoadAndValidate(t *testing.T) {
|
|
examplesDir := filepath.Join("..", "..", "examples")
|
|
if got, want := maintainedPipelineRoots(t, examplesDir), []string{
|
|
"pipeline.extraction-subset.yml",
|
|
"pipeline.full.annotated.yml",
|
|
"pipeline.minimal.yml",
|
|
"pipeline.production.yml",
|
|
filepath.Join("production-testing", "pipeline.yml"),
|
|
}; !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("maintained pipeline roots = %#v, want %#v", got, want)
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
pipelineFile string
|
|
sessionFile string
|
|
}{
|
|
{
|
|
name: "minimal pipeline with local audio session",
|
|
pipelineFile: "pipeline.minimal.yml",
|
|
sessionFile: "session.local-audio.yml",
|
|
},
|
|
{
|
|
name: "production pipeline with s3 audio session",
|
|
pipelineFile: "pipeline.production.yml",
|
|
sessionFile: "session.s3-audio.yml",
|
|
},
|
|
{
|
|
name: "full annotated pipeline with local audio session",
|
|
pipelineFile: "pipeline.full.annotated.yml",
|
|
sessionFile: "session.local-audio.yml",
|
|
},
|
|
{
|
|
name: "extraction subset pipeline with local audio session",
|
|
pipelineFile: "pipeline.extraction-subset.yml",
|
|
sessionFile: "session.local-audio.yml",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
pipelinePath := filepath.Join(examplesDir, tt.pipelineFile)
|
|
campaignPath := filepath.Join(examplesDir, "campaigns", "sample-campaign", "campaign.yml")
|
|
sessionPath := filepath.Join(examplesDir, tt.sessionFile)
|
|
|
|
cfg, err := Load(pipelinePath, campaignPath, sessionPath)
|
|
if err != nil {
|
|
t.Fatalf("load example config error = %v", err)
|
|
}
|
|
if err := Validate(cfg); err != nil {
|
|
t.Fatalf("validate example config error = %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
t.Run("split production and testing bundle", func(t *testing.T) {
|
|
pipelinePath := filepath.Join(examplesDir, "production-testing", "pipeline.yml")
|
|
campaignPath := filepath.Join(examplesDir, "campaigns", "sample-campaign", "campaign.yml")
|
|
sessionPath := filepath.Join(examplesDir, "session.local-audio.yml")
|
|
campaign, err := LoadCampaign(campaignPath)
|
|
if err != nil {
|
|
t.Fatalf("load split bundle campaign: %v", err)
|
|
}
|
|
for _, profile := range []struct {
|
|
name string
|
|
model string
|
|
}{
|
|
{name: "production", model: "narratio-production-model-placeholder"},
|
|
{name: "testing", model: "narratio-testing-model-placeholder"},
|
|
} {
|
|
t.Run(profile.name, func(t *testing.T) {
|
|
selected := profile.name
|
|
pipeline, err := LoadPipelineWithOptions(pipelinePath, PipelineLoadOptions{Profile: &selected})
|
|
if err != nil {
|
|
t.Fatalf("load split bundle pipeline: %v", err)
|
|
}
|
|
loaded, err := LoadPipelineCampaign(pipelinePath, pipeline, campaignPath, campaign)
|
|
if err != nil {
|
|
t.Fatalf("resolve split bundle campaign: %v", err)
|
|
}
|
|
cfg, err := LoadSessionWithPipelineCampaignOptions(loaded, sessionPath, SessionLoadOptions{})
|
|
if err != nil {
|
|
t.Fatalf("load split bundle session: %v", err)
|
|
}
|
|
if err := Validate(cfg); err != nil {
|
|
t.Fatalf("validate split bundle: %v", err)
|
|
}
|
|
if cfg.Pipeline.Audita.Model != profile.model {
|
|
t.Fatalf("audita model = %q, want %q", cfg.Pipeline.Audita.Model, profile.model)
|
|
}
|
|
if cfg.Pipeline.Secrets != nil || cfg.Pipeline.Audita.LLMAPIKeyEnv != "" || cfg.Pipeline.Storage.Backend != StorageBackendLocal || cfg.Pipeline.Storage.S3 != nil {
|
|
t.Fatalf("split bundle must remain offline and secret-free: secrets=%#v audita=%#v storage=%#v", cfg.Pipeline.Secrets, cfg.Pipeline.Audita, cfg.Pipeline.Storage)
|
|
}
|
|
if selectedProfile, ok := SelectedPipelineProfile(cfg.Pipeline); !ok || selectedProfile.Name != profile.name {
|
|
t.Fatalf("selected profile = %#v, want %q", selectedProfile, profile.name)
|
|
}
|
|
for _, key := range []string{
|
|
"character_meta_arannis",
|
|
"character_meta_brenna",
|
|
"character_items_arannis",
|
|
"character_items_brenna",
|
|
} {
|
|
if _, exists := cfg.Pipeline.Scriptorium.Artifacts[key]; !exists {
|
|
t.Fatalf("expanded artifact %q is absent", key)
|
|
}
|
|
}
|
|
if got := cfg.Pipeline.Scriptorium.Artifacts["character_items_arannis"].Inputs["character_meta"].Source; got != "narratio.artifact.character_meta_arannis" {
|
|
t.Fatalf("same-member input source = %q", got)
|
|
}
|
|
if cfg.Party.Mode != PartyModeCanonical || cfg.Party.Canonical == nil || len(cfg.Party.Canonical.Characters) != 2 {
|
|
t.Fatalf("canonical party = %#v", cfg.Party)
|
|
}
|
|
characters := cfg.Party.Canonical.Characters
|
|
if characters[0].Player.Name != characters[1].Player.Name || len(characters[0].Character.Aliases) != 2 || len(characters[1].Character.Classes) != 2 {
|
|
t.Fatalf("canonical party does not preserve repeated player, aliases, and multiclass data: %#v", characters)
|
|
}
|
|
if len(cfg.Pipeline.Publish.Outputs) != 3 {
|
|
t.Fatalf("publish outputs = %#v, want transcript plus two family outputs", cfg.Pipeline.Publish.Outputs)
|
|
}
|
|
if profile.name == "testing" {
|
|
artifact, exists := cfg.Pipeline.Scriptorium.Artifacts["testing_notes"]
|
|
if !exists || artifact.Enabled {
|
|
t.Fatalf("testing-only disabled artifact = %#v", artifact)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
func maintainedPipelineRoots(t *testing.T, examplesDir string) []string {
|
|
t.Helper()
|
|
var roots []string
|
|
err := filepath.WalkDir(examplesDir, func(path string, entry fs.DirEntry, walkErr error) error {
|
|
if walkErr != nil {
|
|
return walkErr
|
|
}
|
|
if entry.IsDir() {
|
|
return nil
|
|
}
|
|
name := entry.Name()
|
|
if name != "pipeline.yml" && !(strings.HasPrefix(name, "pipeline.") && (strings.HasSuffix(name, ".yml") || strings.HasSuffix(name, ".yaml"))) {
|
|
return nil
|
|
}
|
|
relative, err := filepath.Rel(examplesDir, path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
roots = append(roots, relative)
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("discover maintained pipeline roots: %v", err)
|
|
}
|
|
sort.Strings(roots)
|
|
return roots
|
|
}
|
|
|
|
func TestMaintainedExtractionExamplesPreservePublishedContracts(t *testing.T) {
|
|
examplesDir := filepath.Join("..", "..", "examples")
|
|
full, err := LoadPipeline(filepath.Join(examplesDir, "pipeline.full.annotated.yml"))
|
|
if err != nil {
|
|
t.Fatalf("load full example error = %v", err)
|
|
}
|
|
want := map[string]NotariusOutputConfig{
|
|
"item_registry": {LaneID: "item-registry", MediaType: "application/json", SchemaID: "notarius.dnd.item_registry", SchemaVersion: "v1", ModuleKey: "dnd/item-registry"},
|
|
"npc_registry": {LaneID: "npc-registry", MediaType: "application/json", SchemaID: "notarius.dnd.npc_registry", SchemaVersion: "v1", ModuleKey: "dnd/npc-registry"},
|
|
"location_registry": {LaneID: "location-registry", MediaType: "application/json", SchemaID: "notarius.dnd.location_registry", SchemaVersion: "v1", ModuleKey: "dnd/location-registry"},
|
|
"scene_descriptions": {LaneID: "scene-descriptions", MediaType: "application/json", SchemaID: "notarius.dnd.scene_descriptions", SchemaVersion: "v1", ModuleKey: "dnd/scene-descriptions"},
|
|
"item_occurrences": {LaneID: "item-occurrences", MediaType: "application/json", SchemaID: "notarius.dnd.item_occurrences", SchemaVersion: "v1", ModuleKey: "dnd/item-occurrences"},
|
|
"spells": {LaneID: "spells", MediaType: "application/json", SchemaID: "notarius.dnd.spells", SchemaVersion: "v1", ModuleKey: "dnd/spells"},
|
|
"combat_turns": {LaneID: "combat-turns", MediaType: "application/json", SchemaID: "notarius.dnd.combat_turns", SchemaVersion: "v1", ModuleKey: "dnd/combat-turns"},
|
|
"npc_occurrences": {LaneID: "npc-occurrences", MediaType: "application/json", SchemaID: "notarius.dnd.npc_occurrences", SchemaVersion: "v1", ModuleKey: "dnd/npc-occurrences"},
|
|
"location_occurrences": {LaneID: "location-occurrences", MediaType: "application/json", SchemaID: "notarius.dnd.location_occurrences", SchemaVersion: "v1", ModuleKey: "dnd/location-occurrences"},
|
|
"enemy_events": {LaneID: "enemy-events", MediaType: "application/json", SchemaID: "notarius.dnd.enemy_events", SchemaVersion: "v1", ModuleKey: "dnd/enemy-events"},
|
|
}
|
|
if full.Notarius == nil || !reflect.DeepEqual(full.Notarius.Outputs, want) {
|
|
t.Fatalf("full example outputs = %#v, want %#v", full.Notarius, want)
|
|
}
|
|
|
|
subset, err := LoadPipeline(filepath.Join(examplesDir, "pipeline.extraction-subset.yml"))
|
|
if err != nil {
|
|
t.Fatalf("load subset example error = %v", err)
|
|
}
|
|
brief := subset.Scriptorium.Artifacts["session_brief"]
|
|
wantSources := map[string]string{
|
|
"npcs": "narratio.extraction.npc_registry",
|
|
"locations": "narratio.extraction.location_registry",
|
|
"scenes": "narratio.extraction.scene_descriptions",
|
|
}
|
|
gotSources := make(map[string]string, len(brief.Inputs))
|
|
for name, input := range brief.Inputs {
|
|
gotSources[name] = input.Source
|
|
}
|
|
if !reflect.DeepEqual(gotSources, wantSources) {
|
|
t.Fatalf("subset example sources = %#v, want %#v", gotSources, wantSources)
|
|
}
|
|
}
|
|
|
|
func writeConfigFiles(t *testing.T, pipelineYAML, sessionYAML string) (string, string) {
|
|
t.Helper()
|
|
if !strings.Contains(pipelineYAML, "\naudita:") && !strings.HasPrefix(pipelineYAML, "audita:") {
|
|
if !strings.HasSuffix(pipelineYAML, "\n") {
|
|
pipelineYAML += "\n"
|
|
}
|
|
pipelineYAML += "audita:\n binary: audita\n"
|
|
}
|
|
if !strings.Contains(sessionYAML, "\ncampaign:") && !strings.HasPrefix(sessionYAML, "campaign:") {
|
|
if !strings.HasSuffix(sessionYAML, "\n") {
|
|
sessionYAML += "\n"
|
|
}
|
|
sessionYAML += "campaign: sample-campaign\n"
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
pipelinePath := filepath.Join(dir, "pipeline.yml")
|
|
campaignPath := filepath.Join(dir, "campaign.yml")
|
|
sessionPath := filepath.Join(dir, "session.yml")
|
|
|
|
if err := os.WriteFile(pipelinePath, []byte(pipelineYAML), 0o644); err != nil {
|
|
t.Fatalf("write pipeline.yml: %v", err)
|
|
}
|
|
campaignYAML := `campaign_id: ` + campaignNameFromSessionYAML(sessionYAML) + `
|
|
inputs:
|
|
speakers_file: ./speakers.yml
|
|
autocorrect_file: ./autocorrect.yml
|
|
glossary_file: ./glossary.yml
|
|
players_file: ./players.yml
|
|
party_file: ./party.yml
|
|
`
|
|
if err := os.WriteFile(campaignPath, []byte(campaignYAML), 0o644); err != nil {
|
|
t.Fatalf("write campaign.yml: %v", err)
|
|
}
|
|
if err := os.WriteFile(sessionPath, []byte(sessionYAML), 0o644); err != nil {
|
|
t.Fatalf("write session.yml: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "party.yml"), []byte("legacy: party\n"), 0o644); err != nil {
|
|
t.Fatalf("write party.yml: %v", err)
|
|
}
|
|
|
|
return pipelinePath, sessionPath
|
|
}
|
|
|
|
func campaignNameFromSessionYAML(sessionYAML string) string {
|
|
for _, line := range strings.Split(sessionYAML, "\n") {
|
|
trimmed := strings.TrimSpace(line)
|
|
if strings.HasPrefix(trimmed, "campaign:") {
|
|
return strings.Trim(strings.TrimSpace(strings.TrimPrefix(trimmed, "campaign:")), `"'`)
|
|
}
|
|
}
|
|
return "sample-campaign"
|
|
}
|