192 lines
7.6 KiB
Go
192 lines
7.6 KiB
Go
package config
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"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 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")
|
|
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)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
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"
|
|
}
|