457 lines
23 KiB
Go
457 lines
23 KiB
Go
package cli
|
|
|
|
import (
|
|
"bytes"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/config"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
|
|
)
|
|
|
|
func TestReferenceSelectorsParseAndApplyAllDocumentedForms(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
selector string
|
|
only []string
|
|
wantStage pipeline.ModuleStage
|
|
wantLane string
|
|
wantSlot string
|
|
}{
|
|
{name: "flat", selector: "alpha-slot", wantStage: pipeline.StageExtract, wantLane: "alpha", wantSlot: "alpha-slot"},
|
|
{name: "chunk", selector: "chunk.chunk-slot", wantStage: pipeline.StageChunk, wantSlot: "chunk-slot"},
|
|
{name: "merge", selector: "merge.alpha-merge", only: []string{"alpha"}, wantStage: pipeline.StageMerge, wantLane: "alpha", wantSlot: "alpha-merge"},
|
|
{name: "lane", selector: "alpha.alpha-slot", wantStage: pipeline.StageExtract, wantLane: "alpha", wantSlot: "alpha-slot"},
|
|
{name: "lane extract", selector: "alpha.extract.alpha-slot", wantStage: pipeline.StageExtract, wantLane: "alpha", wantSlot: "alpha-slot"},
|
|
{name: "lane merge", selector: "alpha.merge.alpha-merge", wantStage: pipeline.StageMerge, wantLane: "alpha", wantSlot: "alpha-merge"},
|
|
{name: "lane normalize", selector: "alpha.normalize.alpha-normalize", wantStage: pipeline.StageNormalize, wantLane: "alpha", wantSlot: "alpha-normalize"},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
cfg := referenceContractConfig()
|
|
catalog := referenceContractCatalog(t, true, true)
|
|
selector, err := parseReferenceSelector(tt.selector, "--reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
overrides, _, err := resolveCLIReferenceRequests(cfg, "demo", tt.only, catalog, []cliReferenceRequest{{Selector: selector, Source: "reference.txt"}}, nil)
|
|
if err != nil {
|
|
t.Fatalf("resolve selector: %v", err)
|
|
}
|
|
if len(overrides) != 1 {
|
|
t.Fatalf("overrides = %#v, want one binding", overrides)
|
|
}
|
|
got := overrides[0]
|
|
if got.Stage != tt.wantStage || got.LaneID != tt.wantLane || got.SlotName != tt.wantSlot || got.BindingSource != contracts.ReferenceBindingSourceCLI {
|
|
t.Fatalf("binding = %#v, want %s/%s/%s from CLI", got, tt.wantStage, tt.wantLane, tt.wantSlot)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReferenceSelectorsRejectAmbiguityWithSpecificSuggestions(t *testing.T) {
|
|
cfg := referenceContractConfig()
|
|
catalog := referenceContractCatalog(t, true, true)
|
|
for _, tt := range []struct {
|
|
name string
|
|
selector string
|
|
want []string
|
|
}{
|
|
{name: "flat shared slot", selector: "shared", want: []string{"alpha.extract.shared", "beta.extract.shared"}},
|
|
{name: "lane shared slot", selector: "alpha.shared", want: []string{"alpha.extract.shared", "alpha.merge.shared", "alpha.normalize.shared"}},
|
|
{name: "all mergers", selector: "merge.shared", want: []string{"alpha.merge.shared", "beta.merge.shared"}},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
selector, err := parseReferenceSelector(tt.selector, "--reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _, err = resolveCLIReferenceRequests(cfg, "demo", nil, catalog, []cliReferenceRequest{{Selector: selector, Source: "reference.txt"}}, nil)
|
|
if err == nil {
|
|
t.Fatal("resolve selector succeeded, want ambiguity error")
|
|
}
|
|
for _, fragment := range tt.want {
|
|
if !strings.Contains(err.Error(), fragment) {
|
|
t.Fatalf("error = %q, want suggestion %q", err, fragment)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReferenceSelectorsRespectSelectedLanesBeforeMaterialization(t *testing.T) {
|
|
cfg := referenceContractConfig()
|
|
catalog := referenceContractCatalog(t, true, true)
|
|
for _, tt := range []struct {
|
|
name string
|
|
selector string
|
|
want string
|
|
}{
|
|
{name: "unselected lane", selector: "beta.extract.beta-slot", want: `reference lane "beta" is not selected`},
|
|
{name: "unknown lane", selector: "missing.extract.beta-slot", want: `reference lane "missing" is not selected`},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
selector, err := parseReferenceSelector(tt.selector, "--reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _, err = resolveCLIReferenceRequests(cfg, "demo", []string{"alpha"}, catalog, []cliReferenceRequest{{Selector: selector, Source: filepath.Join(t.TempDir(), "missing.txt")}}, nil)
|
|
if err == nil || !strings.Contains(err.Error(), tt.want) || strings.Contains(err.Error(), "missing.txt") {
|
|
t.Fatalf("error = %v, want selection failure before file access", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReferenceSyntaxErrorsReturnTwo(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
args []string
|
|
}{
|
|
{name: "reference missing value", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--reference"}},
|
|
{name: "reference missing selector", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--reference", "=path.txt"}},
|
|
{name: "reference missing separator", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--reference", "slot"}},
|
|
{name: "reference missing path", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--reference", "slot="}},
|
|
{name: "reference excess segments", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--reference", "a.b.c.d=path.txt"}},
|
|
{name: "unbind with path", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--without-reference", "slot=path.txt"}},
|
|
{name: "unbind excess segments", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--without-reference", "a.b.c.d"}},
|
|
{name: "unbind missing value", args: []string{"run", "demo", "--config", "missing.yml", "--input", "input.txt", "--without-reference"}},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
code := RunWithOptions(tt.args, &stdout, &stderr, Options{LookupEnv: emptyLookup})
|
|
if code != 2 || stdout.Len() != 0 || stderr.Len() == 0 {
|
|
t.Fatalf("code=%d stdout=%q stderr=%q", code, stdout.String(), stderr.String())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReferenceOverridesUseFinalExactTargetBinding(t *testing.T) {
|
|
cfg := referenceContractConfig()
|
|
catalog := referenceContractCatalog(t, true, true)
|
|
alphaShared, err := parseReferenceSelector("alpha.extract.shared", "--reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
betaShared, err := parseReferenceSelector("beta.extract.shared", "--reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
overrides, unbinds, err := resolveCLIReferenceRequests(cfg, "demo", nil, catalog, []cliReferenceRequest{
|
|
{Selector: alphaShared, Source: "alpha-first.txt"},
|
|
{Selector: alphaShared, Source: "alpha-final.txt"},
|
|
{Selector: betaShared, Source: "beta-only.txt"},
|
|
}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(unbinds) != 0 {
|
|
t.Fatalf("unbinds = %#v, want none", unbinds)
|
|
}
|
|
effective, err := cfg.Resolve(config.ResolveInput{PipelineID: "demo", Catalog: catalog, ReferenceOverrides: overrides})
|
|
if err != nil {
|
|
t.Fatalf("resolve pipeline: %v", err)
|
|
}
|
|
alpha := referenceContractLane(t, effective.ResolvedPipeline, "alpha")
|
|
beta := referenceContractLane(t, effective.ResolvedPipeline, "beta")
|
|
if source := referenceContractBindingSource(alpha.ExtractReferences.Bindings, "shared"); source != "alpha-final.txt" {
|
|
t.Fatalf("alpha shared source = %q, want final exact-target override", source)
|
|
}
|
|
if source := referenceContractBindingSource(beta.ExtractReferences.Bindings, "shared"); source != "beta-only.txt" {
|
|
t.Fatalf("beta shared source = %q, want target-specific override", source)
|
|
}
|
|
}
|
|
|
|
func TestReferenceUnbindsRemoveOptionalAndProtectRequiredSlots(t *testing.T) {
|
|
cfg := referenceContractConfig()
|
|
catalog := referenceContractCatalog(t, true, true)
|
|
optional, err := parseReferenceSelector("alpha.extract.alpha-slot", "--without-reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, without, err := resolveCLIReferenceRequests(cfg, "demo", nil, catalog, nil, []cliReferenceUnbindRequest{{Selector: optional}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
effective, err := cfg.Resolve(config.ResolveInput{PipelineID: "demo", Catalog: catalog, ReferenceUnbinds: without})
|
|
if err != nil {
|
|
t.Fatalf("optional unbind: %v", err)
|
|
}
|
|
if binding := referenceContractFindBinding(referenceContractLane(t, effective.ResolvedPipeline, "alpha").ExtractReferences.Bindings, "alpha-slot"); binding != nil {
|
|
t.Fatalf("optional binding after unbind = %#v, want absent", binding)
|
|
}
|
|
|
|
for _, tt := range []struct {
|
|
name string
|
|
selector string
|
|
}{
|
|
{name: "chunk", selector: "chunk.required-chunk"},
|
|
{name: "extract", selector: "alpha.extract.required-extract"},
|
|
{name: "merge", selector: "alpha.merge.required-merge"},
|
|
{name: "normalize", selector: "alpha.normalize.required-normalize"},
|
|
} {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
selector, err := parseReferenceSelector(tt.selector, "--without-reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, unbinds, err := resolveCLIReferenceRequests(cfg, "demo", nil, catalog, nil, []cliReferenceUnbindRequest{{Selector: selector}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err = cfg.Resolve(config.ResolveInput{PipelineID: "demo", Catalog: catalog, ReferenceUnbinds: unbinds})
|
|
if err == nil || !strings.Contains(err.Error(), "required reference slot") {
|
|
t.Fatalf("resolve error = %v, want required-slot failure", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestReferenceMaterializationSeparatesCLIAndConfigPathOrigins(t *testing.T) {
|
|
configDir := t.TempDir()
|
|
workingDir := t.TempDir()
|
|
cfg := referenceContractConfig()
|
|
configPath := filepath.Join(configDir, "config.yml")
|
|
if err := os.WriteFile(configPath, []byte("version: 4\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(configDir, "required.txt"), []byte("config reference"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(configDir, "optional.txt"), []byte("optional reference"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(workingDir, "cli-reference.txt"), []byte("CLI reference"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
catalog := referenceContractCatalog(t, true, true)
|
|
selector, err := parseReferenceSelector("alpha.extract.alpha-slot", "--reference")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
overrides, unbinds, err := resolveCLIReferenceRequests(cfg, "demo", nil, catalog, []cliReferenceRequest{{Selector: selector, Source: "cli-reference.txt"}}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
effective, err := cfg.Resolve(config.ResolveInput{PipelineID: "demo", Catalog: catalog, ReferenceOverrides: overrides, ReferenceUnbinds: unbinds})
|
|
if err != nil {
|
|
t.Fatalf("resolve pipeline: %v", err)
|
|
}
|
|
materialized, _, err := pipeline.MaterializeReferences(effective.ResolvedPipeline, catalog, pipeline.ReferenceMaterializationOptions{ConfigPath: configPath, WorkingDir: workingDir})
|
|
if err != nil {
|
|
t.Fatalf("materialize references: %v", err)
|
|
}
|
|
alpha := referenceContractLane(t, materialized, "alpha")
|
|
cliItem := alpha.ExtractReferences.ReferenceSet.Slots["alpha-slot"].Items[0]
|
|
if string(cliItem.Content) != "CLI reference" || cliItem.BindingSource != contracts.ReferenceBindingSourceCLI || cliItem.Origin.URI != referenceContractFileURI(filepath.Join(workingDir, "cli-reference.txt")) {
|
|
t.Fatalf("CLI materialization = %#v, want working-directory provenance", cliItem)
|
|
}
|
|
configItem := alpha.ExtractReferences.ReferenceSet.Slots["required-extract"].Items[0]
|
|
if string(configItem.Content) != "config reference" || configItem.BindingSource != contracts.ReferenceBindingSourceConfig || configItem.Origin.URI != referenceContractFileURI(filepath.Join(configDir, "required.txt")) {
|
|
t.Fatalf("config materialization = %#v, want config-directory provenance", configItem)
|
|
}
|
|
}
|
|
|
|
func TestReferenceTargetLookupUsesArtifactVariantsAndReportsMissingContext(t *testing.T) {
|
|
cfg := referenceContractConfig()
|
|
full := referenceContractCatalog(t, true, true)
|
|
targets, err := selectedReferenceTargets(cfg, "demo", nil, full)
|
|
if err != nil {
|
|
t.Fatalf("select reference targets: %v", err)
|
|
}
|
|
var alphaMerge, betaMerge selectedReferenceTarget
|
|
for _, target := range targets {
|
|
if target.stage == pipeline.StageMerge && target.laneID == "alpha" {
|
|
alphaMerge = target
|
|
}
|
|
if target.stage == pipeline.StageMerge && target.laneID == "beta" {
|
|
betaMerge = target
|
|
}
|
|
}
|
|
if _, ok := alphaMerge.slots["alpha-merge"]; !ok {
|
|
t.Fatalf("alpha merger slots = %#v, want alpha artifact variant", alphaMerge.slots)
|
|
}
|
|
if _, ok := betaMerge.slots["beta-merge"]; !ok {
|
|
t.Fatalf("beta merger slots = %#v, want beta artifact variant", betaMerge.slots)
|
|
}
|
|
if _, ok := betaMerge.slots["alpha-merge"]; ok {
|
|
t.Fatalf("beta merger slots = %#v, must not use alpha variant", betaMerge.slots)
|
|
}
|
|
|
|
missingMerger := referenceContractCatalog(t, false, true)
|
|
_, err = selectedReferenceTargets(cfg, "demo", nil, missingMerger)
|
|
if err == nil || !strings.Contains(err.Error(), "merger") || !strings.Contains(err.Error(), string(referenceContractKindBeta)) {
|
|
t.Fatalf("missing merger error = %v, want artifact variant context", err)
|
|
}
|
|
missingNormalizer := referenceContractCatalog(t, true, false)
|
|
_, err = selectedReferenceTargets(cfg, "demo", nil, missingNormalizer)
|
|
if err == nil || !strings.Contains(err.Error(), "normalizer") || !strings.Contains(err.Error(), string(referenceContractKindBeta)) {
|
|
t.Fatalf("missing normalizer error = %v, want artifact variant context", err)
|
|
}
|
|
missingExtractor := referenceContractCatalog(t, true, true)
|
|
missingExtractor.Extractors = pipeline.NewExtractorRegistry()
|
|
_, err = selectedReferenceTargets(cfg, "demo", nil, missingExtractor)
|
|
if err == nil || !strings.Contains(err.Error(), `lane "alpha" extract module`) || !strings.Contains(err.Error(), "not registered") {
|
|
t.Fatalf("missing extractor error = %v, want lane/module context", err)
|
|
}
|
|
}
|
|
|
|
const (
|
|
referenceContractKindAlpha contracts.ArtifactKind = "reference/alpha"
|
|
referenceContractKindBeta contracts.ArtifactKind = "reference/beta"
|
|
)
|
|
|
|
func referenceContractConfig() config.Config {
|
|
cfg := config.Default()
|
|
cfg.Pipelines = map[string]pipeline.PipelineProfile{
|
|
"demo": {
|
|
ID: "demo",
|
|
Input: pipeline.Binding("reference/input"),
|
|
Chunk: pipeline.Binding("reference/chunk"),
|
|
Output: pipeline.Binding("reference/output"),
|
|
Artifacts: map[string]pipeline.ArtifactLaneProfile{
|
|
"alpha": {
|
|
Extract: pipeline.Binding("reference/extract-alpha"),
|
|
Merge: pipeline.Binding("reference/shared-merge"),
|
|
Normalize: pipeline.Binding("reference/shared-normalize"),
|
|
References: pipeline.ExternalReferenceMap(map[string]string{"required-extract": "required.txt"}),
|
|
},
|
|
"beta": {
|
|
Extract: pipeline.Binding("reference/extract-beta"),
|
|
Merge: pipeline.Binding("reference/shared-merge"),
|
|
Normalize: pipeline.Binding("reference/shared-normalize"),
|
|
References: pipeline.ExternalReferenceMap(map[string]string{"required-extract": "required.txt"}),
|
|
},
|
|
},
|
|
},
|
|
}
|
|
profile := cfg.Pipelines["demo"]
|
|
profile.Chunk.References = pipeline.ExternalReferenceMap(map[string]string{"required-chunk": "required.txt"})
|
|
alpha := profile.Artifacts["alpha"]
|
|
alpha.Extract.References = pipeline.ExternalReferenceMap(map[string]string{"required-extract": "required.txt", "alpha-slot": "optional.txt"})
|
|
alpha.Merge.References = pipeline.ExternalReferenceMap(map[string]string{"required-merge": "required.txt"})
|
|
alpha.Normalize.References = pipeline.ExternalReferenceMap(map[string]string{"required-normalize": "required.txt"})
|
|
profile.Artifacts["alpha"] = alpha
|
|
beta := profile.Artifacts["beta"]
|
|
beta.Extract.References = pipeline.ExternalReferenceMap(map[string]string{"required-extract": "required.txt"})
|
|
beta.Merge.References = pipeline.ExternalReferenceMap(map[string]string{"required-merge": "required.txt"})
|
|
beta.Normalize.References = pipeline.ExternalReferenceMap(map[string]string{"required-normalize": "required.txt"})
|
|
profile.Artifacts["beta"] = beta
|
|
cfg.Pipelines["demo"] = profile
|
|
return cfg
|
|
}
|
|
|
|
func referenceContractCatalog(t *testing.T, includeBetaMerger, includeBetaNormalizer bool) pipeline.ModuleCatalog {
|
|
t.Helper()
|
|
registries := pipeline.Registries{
|
|
Inputs: pipeline.NewInputAdapterRegistry(),
|
|
Chunkers: pipeline.NewChunkerRegistry(),
|
|
ArtifactCodecs: pipeline.NewArtifactCodecRegistry(),
|
|
Extractors: pipeline.NewExtractorRegistry(),
|
|
Mergers: pipeline.NewMergerRegistry(),
|
|
Normalizers: pipeline.NewNormalizerRegistry(),
|
|
Validators: pipeline.NewValidatorRegistry(),
|
|
ValidatorChains: pipeline.NewValidatorChainRegistry(),
|
|
Outputs: pipeline.NewOutputEncoderRegistry(),
|
|
}
|
|
register := func(err error) {
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
register(registries.Inputs.RegisterBuilderWithSpec(pipeline.ModuleSpec{Key: "reference/input", Stage: pipeline.StageInput, Provides: []string{"source"}}, func(map[string]any) error { return nil }, func(pipeline.BuildRequest) (contracts.InputAdapter, error) { return stateTestInput{}, nil }))
|
|
register(registries.Chunkers.RegisterWithSpec(pipeline.ModuleSpec{Key: "reference/chunk", Stage: pipeline.StageChunk, Requires: []string{"source"}, Provides: []string{"chunks"}, ReferenceSlots: []contracts.ReferenceSlot{{Name: "chunk-slot"}, {Name: "required-chunk", Required: true}}}, func() (contracts.Chunker, error) { return stateTestChunker{}, nil }))
|
|
register(pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, referenceContractCodecA{}))
|
|
register(pipeline.RegisterArtifactCodec(registries.ArtifactCodecs, referenceContractCodecB{}))
|
|
register(pipeline.RegisterExtractor(registries.Extractors, pipeline.ModuleSpec{Key: "reference/extract-alpha", Stage: pipeline.StageExtract, Requires: []string{"chunks"}, Provides: []string{"artifact"}, ArtifactKind: referenceContractKindAlpha, ReferenceSlots: []contracts.ReferenceSlot{{Name: "shared"}, {Name: "alpha-slot"}, {Name: "required-extract", Required: true}}}, func() (contracts.Extractor[stateTestArtifact], error) { return stateTestExtractor{}, nil }))
|
|
register(pipeline.RegisterExtractor(registries.Extractors, pipeline.ModuleSpec{Key: "reference/extract-beta", Stage: pipeline.StageExtract, Requires: []string{"chunks"}, Provides: []string{"artifact"}, ArtifactKind: referenceContractKindBeta, ReferenceSlots: []contracts.ReferenceSlot{{Name: "shared"}, {Name: "beta-slot"}, {Name: "required-extract", Required: true}}}, func() (contracts.Extractor[stateTestArtifact], error) { return stateTestExtractor{}, nil }))
|
|
register(pipeline.RegisterMerger(registries.Mergers, pipeline.ModuleSpec{Key: "reference/shared-merge", Stage: pipeline.StageMerge, Requires: []string{"artifact"}, Provides: []string{"merged"}, ArtifactKind: referenceContractKindAlpha, ReferenceSlots: []contracts.ReferenceSlot{{Name: "shared"}, {Name: "alpha-merge"}, {Name: "required-merge", Required: true}}}, func() (contracts.Merger[stateTestArtifact], error) { return stateTestMerger{}, nil }))
|
|
if includeBetaMerger {
|
|
register(pipeline.RegisterMerger(registries.Mergers, pipeline.ModuleSpec{Key: "reference/shared-merge", Stage: pipeline.StageMerge, Requires: []string{"artifact"}, Provides: []string{"merged"}, ArtifactKind: referenceContractKindBeta, ReferenceSlots: []contracts.ReferenceSlot{{Name: "shared"}, {Name: "beta-merge"}, {Name: "required-merge", Required: true}}}, func() (contracts.Merger[stateTestArtifact], error) { return stateTestMerger{}, nil }))
|
|
}
|
|
register(pipeline.RegisterNormalizer(registries.Normalizers, pipeline.ModuleSpec{Key: "reference/shared-normalize", Stage: pipeline.StageNormalize, Requires: []string{"merged"}, Provides: []string{"normalized"}, ArtifactKind: referenceContractKindAlpha, ReferenceSlots: []contracts.ReferenceSlot{{Name: "shared"}, {Name: "alpha-normalize"}, {Name: "required-normalize", Required: true}}}, func() (contracts.Normalizer[stateTestArtifact], error) { return stateTestNormalizer{}, nil }))
|
|
if includeBetaNormalizer {
|
|
register(pipeline.RegisterNormalizer(registries.Normalizers, pipeline.ModuleSpec{Key: "reference/shared-normalize", Stage: pipeline.StageNormalize, Requires: []string{"merged"}, Provides: []string{"normalized"}, ArtifactKind: referenceContractKindBeta, ReferenceSlots: []contracts.ReferenceSlot{{Name: "shared"}, {Name: "beta-normalize"}, {Name: "required-normalize", Required: true}}}, func() (contracts.Normalizer[stateTestArtifact], error) { return stateTestNormalizer{}, nil }))
|
|
}
|
|
register(registries.Outputs.RegisterWithSpec(pipeline.ModuleSpec{Key: "reference/output", Stage: pipeline.StageOutput, Requires: []string{"normalized"}, Provides: []string{"output"}}, func() (contracts.OutputEncoder, error) { return stateTestOutput{}, nil }))
|
|
return catalogFromRegistries(registries)
|
|
}
|
|
|
|
type referenceContractCodecB struct{}
|
|
|
|
type referenceContractCodecA struct{}
|
|
|
|
func (referenceContractCodecA) Kind() contracts.ArtifactKind { return referenceContractKindAlpha }
|
|
func (referenceContractCodecA) Schema() contracts.ArtifactSchema {
|
|
return contracts.ArtifactSchema{ID: "reference.alpha", Name: "reference_alpha", Version: "v1", JSONSchema: []byte(`{"type":"object"}`)}
|
|
}
|
|
func (referenceContractCodecA) MediaType() string { return "application/json" }
|
|
func (referenceContractCodecA) EncodeCandidate(stateTestArtifact) ([]byte, error) {
|
|
return []byte(`{"value":"ok"}`), nil
|
|
}
|
|
func (referenceContractCodecA) Encode(stateTestArtifact) ([]byte, error) {
|
|
return []byte(`{"value":"ok"}`), nil
|
|
}
|
|
func (referenceContractCodecA) Decode([]byte) (stateTestArtifact, error) {
|
|
return stateTestArtifact{Value: "ok"}, nil
|
|
}
|
|
|
|
func (referenceContractCodecB) Kind() contracts.ArtifactKind { return referenceContractKindBeta }
|
|
func (referenceContractCodecB) Schema() contracts.ArtifactSchema {
|
|
return contracts.ArtifactSchema{ID: "reference.beta", Name: "reference_beta", Version: "v1", JSONSchema: []byte(`{"type":"object"}`)}
|
|
}
|
|
func (referenceContractCodecB) MediaType() string { return "application/json" }
|
|
func (referenceContractCodecB) EncodeCandidate(stateTestArtifact) ([]byte, error) {
|
|
return []byte(`{"value":"ok"}`), nil
|
|
}
|
|
func (referenceContractCodecB) Encode(stateTestArtifact) ([]byte, error) {
|
|
return []byte(`{"value":"ok"}`), nil
|
|
}
|
|
func (referenceContractCodecB) Decode([]byte) (stateTestArtifact, error) {
|
|
return stateTestArtifact{Value: "ok"}, nil
|
|
}
|
|
|
|
func referenceContractLane(t *testing.T, resolved pipeline.ResolvedPipeline, id string) pipeline.ResolvedArtifactLane {
|
|
t.Helper()
|
|
for _, step := range resolved.Steps {
|
|
for _, lane := range step.ArtifactLanes {
|
|
if lane.ID == id {
|
|
return lane
|
|
}
|
|
}
|
|
}
|
|
t.Fatalf("lane %q not found", id)
|
|
return pipeline.ResolvedArtifactLane{}
|
|
}
|
|
|
|
func referenceContractBindingSource(bindings []pipeline.ReferenceBinding, slot string) string {
|
|
for _, binding := range bindings {
|
|
if binding.SlotName == slot {
|
|
return binding.Source
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func referenceContractFindBinding(bindings []pipeline.ReferenceBinding, slot string) *pipeline.ReferenceBinding {
|
|
for i := range bindings {
|
|
if bindings[i].SlotName == slot {
|
|
return &bindings[i]
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func referenceContractFileURI(path string) string {
|
|
absolute, err := filepath.Abs(path)
|
|
if err != nil {
|
|
absolute = path
|
|
}
|
|
return "file://" + filepath.ToSlash(absolute)
|
|
}
|