package app import ( "context" "errors" "gitea.maximumdirect.net/eric/narratio/internal/adapters/storage" "os" "path/filepath" "testing" "gitea.maximumdirect.net/eric/narratio/internal/config" "go.maximumdirect.net/commandkit" configkit "go.maximumdirect.net/configkit" ) func suppliedSelection(value string) commandkit.Supplied[string] { return commandkit.Supplied[string]{Value: value, Set: true} } func TestConfigurationAcquisitionLoadsOnlyReachedDocuments(t *testing.T) { _, campaignPath, _ := writeValidConfigFiles(t, t.TempDir()) pipelineLoads, bootstrapCalls := 0, 0 deps := commandDependencies{ loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) { pipelineLoads++ return nil, errors.New("unavailable pipeline") }, loadSecretsDir: func(string) (*configkit.SecretsReport, error) { bootstrapCalls++ return nil, nil }, } selection := configurationSelection{ CampaignFile: suppliedSelection(campaignPath), Campaign: suppliedSelection("sample-campaign"), SecretsDir: suppliedSelection(t.TempDir()), } acquired := newConfigurationAcquisition(selection, deps) campaign, err := acquired.Campaign(context.Background()) if err != nil { t.Fatal(err) } repeated, err := acquired.Campaign(context.Background()) if err != nil || repeated != campaign { t.Fatalf("campaign was not retained: %v", err) } if campaign.ConfigKitResult() == nil { t.Fatal("missing native campaign result") } party, err := acquired.Party(context.Background()) if err != nil { t.Fatal(err) } if party.Canonical.ConfigKitResult() == nil { t.Fatal("missing native party result") } if pipelineLoads != 0 || bootstrapCalls != 1 { t.Fatalf("pipeline loads=%d bootstrap calls=%d", pipelineLoads, bootstrapCalls) } explicit := newConfigurationAcquisition(configurationSelection{PartyFile: suppliedSelection(party.Source.Path)}, deps) if _, err := explicit.Party(context.Background()); err != nil { t.Fatal(err) } if pipelineLoads != 0 { t.Fatal("explicit party acquired pipeline") } } func TestConfigurationAcquisitionIdentityAndExplicitEmpty(t *testing.T) { _, campaignPath, _ := writeValidConfigFiles(t, t.TempDir()) acquired := newConfigurationAcquisition(configurationSelection{ CampaignFile: suppliedSelection(campaignPath), Campaign: suppliedSelection("other-campaign"), }, commandDependencies{}) _, err := acquired.Campaign(context.Background()) var identity *config.SessionIdentityError if !errors.As(err, &identity) || identity.Field != "campaign_id" { t.Fatalf("identity error=%v", err) } acquired = newConfigurationAcquisition(configurationSelection{CampaignFile: suppliedSelection("")}, commandDependencies{}) _, err = acquired.Campaign(context.Background()) var input *inputError if !errors.As(err, &input) { t.Fatalf("empty explicit selection error=%v", err) } } func TestConfigurationAcquisitionRetainsBootstrapFailure(t *testing.T) { failure := errors.New("bootstrap unavailable") calls := 0 acquired := newConfigurationAcquisition(configurationSelection{SecretsDir: suppliedSelection(t.TempDir())}, commandDependencies{ loadSecretsDir: func(string) (*configkit.SecretsReport, error) { calls++; return nil, failure }, }) for range 2 { if _, err := acquired.Pipeline(context.Background()); !errors.Is(err, failure) { t.Fatalf("bootstrap error=%v", err) } } if calls != 1 { t.Fatalf("bootstrap calls=%d", calls) } } func TestSessionAcquisitionUsesExactFileWithoutPipelineOrParty(t *testing.T) { _, campaign, session := writeValidConfigFiles(t, t.TempDir()) acquired := newConfigurationAcquisition(configurationSelection{ CampaignFile: suppliedSelection(campaign), SessionFile: suppliedSelection(session), }, commandDependencies{loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) { t.Fatal("local session inspection acquired pipeline") return nil, nil }}) got, err := acquired.Session(context.Background()) if err != nil { t.Fatal(err) } if got.SessionID != "2026-05-03" || got.ConfigKitResult() == nil || acquired.party != nil { t.Fatalf("session=%#v party=%#v", got, acquired.party) } for _, file := range []string{session, filepath.Join(t.TempDir(), "missing.yml")} { selected := acquired.selection selected.SessionFile = suppliedSelection(file) selected.Session = suppliedSelection("wrong-identity") next := newConfigurationAcquisition(selected, acquired.deps) if _, err := next.Session(context.Background()); err == nil { t.Fatal("explicit selection error was ignored") } } } func TestSessionAcquisitionRemoteIsReadOnlyAndReleasesDownload(t *testing.T) { pipeline, campaign, _ := writeValidConfigFiles(t, t.TempDir()) fake := &storage.FakeBackend{} seedRemoteSessionConfig(t, fake, "2026-05-03", "session_id: 2026-05-03\ninputs: {audio_s3: {prefix: audio/}}\n") setSessionConfigSearchPaths(t, []string{filepath.Join(t.TempDir(), "absent.yml")}) deps, calls := remoteSessionLoaderDependencies(fake) loads := 0 deps.loadPipelineConfig = func(path string, opts config.PipelineLoadOptions) (*config.PipelineConfig, error) { loads++ return config.LoadPipelineWithOptions(path, opts) } acquired := newConfigurationAcquisition(configurationSelection{Config: suppliedSelection(pipeline), CampaignFile: suppliedSelection(campaign), Session: suppliedSelection("2026-05-03")}, deps) got, err := acquired.Session(context.Background()) if err != nil { t.Fatal(err) } if acquired.party != nil || acquired.domain != nil || got.ConfigKitResult() == nil { t.Fatal("session inspection derived domain state or lost native result") } if _, err := acquired.Session(context.Background()); err != nil { t.Fatal(err) } if loads != 1 || *calls != 1 { t.Fatalf("pipeline loads=%d storage calls=%d", loads, *calls) } temporary := acquired.session.Path if _, err := os.Stat(temporary); err != nil { t.Fatal(err) } if err := acquired.Close(); err != nil { t.Fatal(err) } if err := acquired.Close(); err != nil { t.Fatal(err) } if _, err := os.Stat(temporary); !errors.Is(err, os.ErrNotExist) { t.Fatalf("download remains: %v", err) } } func TestSessionAcquisitionInvalidDiscoveryNeverReadsRemote(t *testing.T) { _, campaign, _ := writeValidConfigFiles(t, t.TempDir()) invalid := filepath.Join(t.TempDir(), "invalid.yml") if err := os.WriteFile(invalid, []byte("unexpected: value\n"), 0600); err != nil { t.Fatal(err) } setSessionConfigSearchPaths(t, []string{invalid}) acquired := newConfigurationAcquisition(configurationSelection{CampaignFile: suppliedSelection(campaign), Session: suppliedSelection("2026-05-03")}, commandDependencies{loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) { t.Fatal("invalid local discovery triggered remote acquisition") return nil, nil }}) if _, err := acquired.Session(context.Background()); err == nil { t.Fatal("invalid local content accepted") } } func TestSessionAcquisitionPreservesRemoteFailureCause(t *testing.T) { pipeline, campaign, _ := writeValidConfigFiles(t, t.TempDir()) setSessionConfigSearchPaths(t, []string{filepath.Join(t.TempDir(), "absent.yml")}) failure := errors.New("storage unavailable") acquired := newConfigurationAcquisition(configurationSelection{Config: suppliedSelection(pipeline), CampaignFile: suppliedSelection(campaign), Session: suppliedSelection("2026-05-03")}, commandDependencies{ newObjectStore: func(context.Context, *config.Config) (storage.ObjectStore, error) { return nil, failure }, }) if _, err := acquired.Session(context.Background()); !errors.Is(err, failure) { t.Fatalf("remote failure cause=%v", err) } if err := acquired.Close(); err != nil { t.Fatal(err) } }