216 lines
8.3 KiB
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 *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)
|
|
}
|
|
}
|
|
|
|
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")
|
|
}
|
|
}
|