Files
narratio/internal/app/configuration_acquisition_test.go

216 lines
8.3 KiB
Go

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 *configkit.LoadError
if !errors.As(err, &identity) {
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)
}
}
func TestConfigurationAcquisitionStopsAfterSynchronousCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
loadErr := errors.New("native configuration load failed")
acquired := newConfigurationAcquisition(configurationSelection{Config: suppliedSelection("synthetic.yaml")}, commandDependencies{loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) {
cancel()
return nil, loadErr
}})
_, err := acquired.Pipeline(ctx)
if !errors.Is(err, context.Canceled) || !errors.Is(err, loadErr) || operationOutcome(err).Status != 1 {
t.Fatalf("lost canceled native load causes: %v", err)
}
if acquired.pipeline != nil {
t.Fatal("cached a canceled native load")
}
}