511 lines
20 KiB
Go
511 lines
20 KiB
Go
package engine
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
type layeredItem struct {
|
|
Value string `yaml:"value"`
|
|
}
|
|
|
|
type layeredConfig struct {
|
|
Shared struct {
|
|
Equal string `yaml:"equal"`
|
|
Imported string `yaml:"imported"`
|
|
Profile string `yaml:"profile"`
|
|
} `yaml:"shared"`
|
|
Values []int `yaml:"values"`
|
|
Items map[string]layeredItem `yaml:"items"`
|
|
Value any `yaml:"value"`
|
|
Nullable *string `yaml:"nullable"`
|
|
Derived int `yaml:"derived"`
|
|
Empty map[string]string `yaml:"empty"`
|
|
}
|
|
|
|
func TestLayeredProvenanceAgreesWithResolvedSnapshot(t *testing.T) {
|
|
directory := t.TempDir()
|
|
mainPath := writeImportFile(t, directory, "main.yml", `configkit:
|
|
imports: [{path: imported.yml}]
|
|
shared: {equal: same}
|
|
values: [1, 2]
|
|
items:
|
|
keep: {value: 'yes'}
|
|
remove: {value: 'no'}
|
|
value: {child: base}
|
|
nullable: base
|
|
empty: {}
|
|
`)
|
|
importPath := writeImportFile(t, directory, "imported.yml", "shared: {imported: base}\n")
|
|
profilePath := writeImportFile(t, directory, "profiles/testing.yml", `shared: {profile: selected}
|
|
values: [3, 4]
|
|
value: selected
|
|
nullable: null
|
|
empty: {}
|
|
`)
|
|
defaultNullable := "default"
|
|
definition := Definition[layeredConfig]{
|
|
Defaults: func() layeredConfig {
|
|
defaults := layeredConfig{
|
|
Values: []int{0, 0}, Value: map[string]any{"child": "default"},
|
|
Nullable: &defaultNullable, Empty: map[string]string{"retained": "default"},
|
|
}
|
|
defaults.Shared.Equal = "same"
|
|
return defaults
|
|
},
|
|
Resolve: func(configuration *layeredConfig, resolution *Resolution) error {
|
|
Normalize(resolution, Keys("values"), &configuration.Values, []int{5},
|
|
"bounded values", Keys("shared", "imported"), Keys("shared", "imported"))
|
|
Normalize(resolution, Keys("values"), &configuration.Values, []int{5},
|
|
"bounded values", Keys("shared", "imported"))
|
|
delete(configuration.Items, "remove")
|
|
resolution.Record(Keys("items"), ChangeNormalization, "removed disabled items")
|
|
Default(resolution, Keys("derived"), &configuration.Derived, 7,
|
|
"derived from equal", Keys("shared", "equal"), Keys("shared", "equal"))
|
|
resolution.Warning(Keys("values"), "values were bounded", Keys("shared", "imported"))
|
|
return nil
|
|
},
|
|
}
|
|
|
|
result, err := testLoad[layeredConfig](File(mainPath), Options[layeredConfig]{
|
|
Imports: true, Profile: "testing", Definition: definition,
|
|
})
|
|
if err != nil {
|
|
var loadError *LoadError
|
|
_ = errors.As(err, &loadError)
|
|
t.Fatalf("%v: %#v", err, loadError.Diagnostics())
|
|
}
|
|
wantSources := []string{canonicalTestPath(t, mainPath), canonicalTestPath(t, importPath), canonicalTestPath(t, profilePath)}
|
|
sources := result.Sources()
|
|
gotSources := make([]string, len(sources))
|
|
for index, source := range sources {
|
|
gotSources[index] = source.Path
|
|
}
|
|
if !reflect.DeepEqual(gotSources, wantSources) || sources[2].Layer != LayerProfile {
|
|
t.Fatalf("sources = %#v", sources)
|
|
}
|
|
if result.Config.Shared.Equal != "same" || result.Config.Shared.Imported != "base" || result.Config.Shared.Profile != "selected" ||
|
|
!reflect.DeepEqual(result.Config.Values, []int{5}) || result.Config.Nullable != nil || result.Config.Derived != 7 ||
|
|
result.Config.Empty["retained"] != "default" {
|
|
t.Fatalf("configuration = %#v", result.Config)
|
|
}
|
|
|
|
metadata := result.Metadata()
|
|
equal, _ := metadata.Lookup(Keys("shared", "equal"))
|
|
derived, _ := metadata.Lookup(Keys("derived"))
|
|
nullable, _ := metadata.Lookup(Keys("nullable"))
|
|
empty, _ := metadata.Lookup(Keys("empty"))
|
|
firstValue, _ := metadata.Lookup(Keys("values").Index(0))
|
|
if !equal.Explicit || equal.Origin.Layer != LayerBase || derived.Explicit || derived.Origin.Operation != ChangeDerivedDefault ||
|
|
!nullable.Explicit || !nullable.Null || nullable.Origin.Layer != LayerProfile ||
|
|
!empty.Explicit || empty.Origin.Layer != LayerProfile || len(empty.Origin.Locations) != 2 ||
|
|
!firstValue.Explicit || firstValue.Origin.Operation != ChangeNormalization {
|
|
t.Fatalf("metadata = equal %#v derived %#v nullable %#v empty %#v value %#v", equal, derived, nullable, empty, firstValue)
|
|
}
|
|
if _, ok := metadata.Lookup(Keys("value", "child")); ok {
|
|
t.Fatal("profile-removed child remains effective")
|
|
}
|
|
if _, ok := metadata.Lookup(Keys("values").Index(1)); ok {
|
|
t.Fatal("resolution-removed sequence index remains effective")
|
|
}
|
|
if _, ok := metadata.Lookup(Keys("items", "remove", "value")); ok {
|
|
t.Fatal("resolution-removed mapping child remains effective")
|
|
}
|
|
|
|
assertHistoryLayersAndPaths(t, metadata.History(Keys("values").Index(1)),
|
|
[]Layer{LayerDefault, LayerBase, LayerProfile, LayerResolution},
|
|
[]string{"/values/1", "/values/1", "/values", "/values"})
|
|
assertHistoryLayersAndPaths(t, metadata.History(Keys("value", "child")),
|
|
[]Layer{LayerDefault, LayerBase, LayerProfile},
|
|
[]string{"/value/child", "/value/child", "/value"})
|
|
removedHistory := metadata.History(Keys("items", "remove", "value"))
|
|
assertHistoryLayersAndPaths(t, removedHistory,
|
|
[]Layer{LayerBase, LayerResolution},
|
|
[]string{"/items/remove/value", "/items"})
|
|
if !reflect.DeepEqual(removedHistory[1].Reasons, []string{"removed disabled items"}) {
|
|
t.Fatalf("removed history = %#v", removedHistory)
|
|
}
|
|
valuesHistory := metadata.History(Keys("values").Index(0))
|
|
lastValue := valuesHistory[len(valuesHistory)-1]
|
|
if !reflect.DeepEqual(lastValue.Reasons, []string{"bounded values"}) || len(lastValue.Dependencies) != 1 || lastValue.Dependencies[0].String() != "/shared/imported" {
|
|
t.Fatalf("canonical resolution history = %#v", lastValue)
|
|
}
|
|
|
|
schema, issue := testBuildSchema(reflect.TypeFor[layeredConfig]())
|
|
if issue != nil {
|
|
t.Fatal(issue)
|
|
}
|
|
projected, projectionIssue := projectConfiguration(schema, reflect.ValueOf(result.Config), defaultProjectionLimits())
|
|
if projectionIssue != nil || !configurationValuesEqual(projected, result.final) {
|
|
t.Fatalf("typed projection and private snapshot disagree: %#v", projectionIssue)
|
|
}
|
|
|
|
metadata.history[Keys("values").Index(0).String()][0].Origin.Layer = "mutated"
|
|
sources[1].ImportedFrom.SourceID = "mutated"
|
|
diagnostics := result.Diagnostics()
|
|
diagnostics[0].Related[0].SourceID = "mutated"
|
|
result.Config.Values[0] = 99
|
|
freshHistory := result.Metadata().History(Keys("values").Index(0))
|
|
if freshHistory[0].Origin.Layer == "mutated" || result.Sources()[1].ImportedFrom.SourceID == "mutated" ||
|
|
result.Diagnostics()[0].Related[0].SourceID == "mutated" {
|
|
t.Fatal("returned inspection records alias private state")
|
|
}
|
|
snapshotValue, ok := documentAtPath(result.final, Keys("values").Index(0))
|
|
if !ok || snapshotValue.Text != "5" {
|
|
t.Fatal("caller configuration mutation changed the private final snapshot")
|
|
}
|
|
}
|
|
|
|
func TestSelectedProfileLoadsRemainIndependentConcurrently(t *testing.T) {
|
|
directory := t.TempDir()
|
|
mainPath := writeImportFile(t, directory, "main.yml", "values: [1, 2]\n")
|
|
writeImportFile(t, directory, "profiles/testing.yml", "values: [3, 4]\n")
|
|
options := Options[layeredConfig]{Profile: "testing"}
|
|
|
|
const loads = 16
|
|
results := make(chan *Result[layeredConfig], loads)
|
|
errors := make(chan error, loads)
|
|
var group sync.WaitGroup
|
|
for index := 0; index < loads; index++ {
|
|
group.Add(1)
|
|
go func() {
|
|
defer group.Done()
|
|
result, err := testLoad[layeredConfig](File(mainPath), options)
|
|
if err != nil {
|
|
errors <- err
|
|
return
|
|
}
|
|
results <- result
|
|
}()
|
|
}
|
|
group.Wait()
|
|
close(results)
|
|
close(errors)
|
|
for err := range errors {
|
|
t.Fatal(err)
|
|
}
|
|
var collected []*Result[layeredConfig]
|
|
for result := range results {
|
|
collected = append(collected, result)
|
|
}
|
|
if len(collected) != loads {
|
|
t.Fatalf("completed loads = %d", len(collected))
|
|
}
|
|
collected[0].Config.Values[0] = 99
|
|
collected[0].metadata.fields[Keys("values").String()] = FieldInfo{}
|
|
for _, result := range collected[1:] {
|
|
if !reflect.DeepEqual(result.Config.Values, []int{3, 4}) {
|
|
t.Fatalf("concurrent result contaminated = %#v", result.Config.Values)
|
|
}
|
|
if info, ok := result.Metadata().Lookup(Keys("values")); !ok || info.Origin.Layer != LayerProfile {
|
|
t.Fatalf("concurrent metadata contaminated = %#v, %v", info, ok)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResolutionInputKeepsLayeredOriginsAndSources(t *testing.T) {
|
|
directory := t.TempDir()
|
|
mainPath := writeImportFile(t, directory, "main.yml", `configkit:
|
|
imports: [{path: first.yml}, {path: second.yml}]
|
|
main: main
|
|
equal: same
|
|
cli_equal: same
|
|
composite: {main: main}
|
|
`)
|
|
firstPath := writeImportFile(t, directory, "first.yml", `imported: imported
|
|
sequence: [first, second]
|
|
composite: {first: first}
|
|
`)
|
|
secondPath := writeImportFile(t, directory, "second.yml", "composite: {second: second}\n")
|
|
profilePath := writeImportFile(t, directory, "profiles/testing.yml", "equal: same\nprofile: profile\n")
|
|
compositeSources := map[string]bool{
|
|
canonicalTestPath(t, mainPath): true,
|
|
canonicalTestPath(t, firstPath): true,
|
|
canonicalTestPath(t, secondPath): true,
|
|
}
|
|
type config struct {
|
|
Main string `yaml:"main"`
|
|
Imported string `yaml:"imported"`
|
|
Sequence []string `yaml:"sequence"`
|
|
Composite map[string]string `yaml:"composite"`
|
|
Equal string `yaml:"equal"`
|
|
Profile string `yaml:"profile"`
|
|
CLIEqual string `yaml:"cli_equal"`
|
|
}
|
|
var callbackErr error
|
|
result, err := testLoad[config](File(mainPath), Options[config]{
|
|
Imports: true, Profile: "testing", Overrides: []Override{{Path: Keys("cli_equal"), Value: "same", Flag: "--cli-equal"}},
|
|
Definition: Definition[config]{Resolve: func(_ *config, resolution *Resolution) error {
|
|
check := func(ok bool, message string) {
|
|
if !ok && callbackErr == nil {
|
|
callbackErr = errors.New(message)
|
|
}
|
|
}
|
|
fileOwner := func(path Path, want string) FieldInfo {
|
|
info, found := resolution.InputInfo(path)
|
|
check(found && len(info.Origin.Locations) == 1, "scalar has no exact origin")
|
|
if !found || len(info.Origin.Locations) != 1 {
|
|
return FieldInfo{}
|
|
}
|
|
source, exists := resolution.Source(info.Origin.Locations[0].SourceID)
|
|
check(exists && source.Path == want, "scalar source does not match its declaration")
|
|
return info
|
|
}
|
|
fileOwner(Keys("main"), canonicalTestPath(t, mainPath))
|
|
fileOwner(Keys("imported"), canonicalTestPath(t, firstPath))
|
|
fileOwner(Keys("sequence").Index(1), canonicalTestPath(t, firstPath))
|
|
profile := fileOwner(Keys("equal"), canonicalTestPath(t, profilePath))
|
|
fileOwner(Keys("profile"), canonicalTestPath(t, profilePath))
|
|
check(profile.Origin.Layer == LayerProfile, "profile replacement retained base ownership")
|
|
cli, found := resolution.InputInfo(Keys("cli_equal"))
|
|
check(found && cli.Origin.Layer == LayerCLI && len(cli.Origin.Locations) == 1, "CLI replacement lost ownership")
|
|
if found && len(cli.Origin.Locations) == 1 {
|
|
source, exists := resolution.Source(cli.Origin.Locations[0].SourceID)
|
|
check(exists && source.Layer == LayerCLI && source.Path == "", "CLI source has a file path or is missing")
|
|
}
|
|
|
|
composite, found := resolution.InputInfo(Keys("composite"))
|
|
check(found && len(composite.Origin.Locations) == 3, "composite mapping did not retain every contributor")
|
|
for _, location := range composite.Origin.Locations {
|
|
source, exists := resolution.Source(location.SourceID)
|
|
check(exists && compositeSources[source.Path], "composite location has no expected source record")
|
|
delete(compositeSources, source.Path)
|
|
}
|
|
check(len(compositeSources) == 0, "composite sources are incomplete")
|
|
|
|
imported, _ := resolution.InputInfo(Keys("imported"))
|
|
importedSourceID := imported.Origin.Locations[0].SourceID
|
|
imported.Origin.Locations[0].SourceID = "mutated"
|
|
importSource, _ := resolution.Source(importedSourceID)
|
|
check(importSource.ImportedFrom != nil, "import source is missing its import location")
|
|
if importSource.ImportedFrom != nil {
|
|
importSource.ImportedFrom.SourceID = "mutated"
|
|
}
|
|
again, _ := resolution.InputInfo(Keys("imported"))
|
|
againSource, _ := resolution.Source(importedSourceID)
|
|
check(again.Origin.Locations[0].SourceID == importedSourceID, "input record is aliased")
|
|
check(againSource.ImportedFrom != nil && againSource.ImportedFrom.SourceID == "source-1", "source record is aliased")
|
|
return callbackErr
|
|
}},
|
|
})
|
|
if callbackErr != nil {
|
|
t.Fatal(callbackErr)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Config.Main != "main" || result.Config.Imported != "imported" || !reflect.DeepEqual(result.Config.Sequence, []string{"first", "second"}) ||
|
|
result.Config.Equal != "same" || result.Config.Profile != "profile" || result.Config.CLIEqual != "same" {
|
|
t.Fatalf("configuration = %#v", result.Config)
|
|
}
|
|
|
|
resultField, _ := result.Metadata().Lookup(Keys("imported"))
|
|
resultSource := result.Sources()[1]
|
|
if resultField.Origin.Locations[0].SourceID != "source-2" || resultSource.ImportedFrom == nil || resultSource.ImportedFrom.SourceID != "source-1" {
|
|
t.Fatal("callback record mutation changed the completed result")
|
|
}
|
|
}
|
|
|
|
func TestResolutionInputUsesEntryShapesAcrossTypedAndDynamicValues(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type Embedded struct {
|
|
Name string `yaml:"name"`
|
|
}
|
|
type config struct {
|
|
Embedded `yaml:",inline"`
|
|
Mappings map[string]string `yaml:"mappings"`
|
|
Array [2]string `yaml:"array"`
|
|
Dynamic any `yaml:"dynamic"`
|
|
}
|
|
var callbackErr error
|
|
_, err := testLoad[config](Bytes("shapes.yml", []byte("name: inlined\nmappings: {'-0': key, 'a/b~': escaped}\narray: [zero, one]\ndynamic: {nested: [dynamic]}\n")), Options[config]{Definition: Definition[config]{Resolve: func(_ *config, resolution *Resolution) error {
|
|
check := func(path Path, want bool) {
|
|
_, found := resolution.InputInfo(path)
|
|
if found != want && callbackErr == nil {
|
|
callbackErr = errors.New("entry shape lookup disagrees with its document container")
|
|
}
|
|
}
|
|
parsedMapping, _ := ParsePath("/mappings/-0")
|
|
escapedMapping, _ := ParsePath("/mappings/a~1b~0")
|
|
check(Keys("name"), true)
|
|
check(parsedMapping, true)
|
|
check(escapedMapping, true)
|
|
check(Keys("mappings").Index(0), false)
|
|
check(Keys("array").Index(1), true)
|
|
check(Keys("array", "1"), false)
|
|
check(Keys("array").Index(2), false)
|
|
check(Keys("dynamic", "nested").Index(0), true)
|
|
check(Keys("dynamic", "nested", "0"), false)
|
|
negative, _ := ParsePath("/array/-1")
|
|
check(negative, false)
|
|
return callbackErr
|
|
}}})
|
|
if callbackErr != nil {
|
|
t.Fatal(callbackErr)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestResolutionInputDistinguishesNonFileRootsAndImportedFiles(t *testing.T) {
|
|
directory := t.TempDir()
|
|
importPath := writeImportFile(t, directory, "fragment.yml", "imported: file\n")
|
|
type config struct {
|
|
Root string `yaml:"root"`
|
|
Imported string `yaml:"imported"`
|
|
Default string `yaml:"default"`
|
|
}
|
|
input := "configkit: {imports: [{path: fragment.yml}]}\nroot: memory\n"
|
|
context := &FilesystemContext{BaseDir: directory, Root: directory}
|
|
for _, test := range []struct {
|
|
name string
|
|
source func() Source
|
|
}{
|
|
{name: "bytes", source: func() Source { return Bytes("memory://config.yml", []byte(input)) }},
|
|
{name: "reader", source: func() Source { return Reader("memory://config.yml", strings.NewReader(input)) }},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
var callbackErr error
|
|
_, err := testLoad[config](test.source(), Options[config]{Imports: true, Filesystem: context, Definition: Definition[config]{
|
|
Defaults: func() config { return config{Default: "retained"} },
|
|
Resolve: func(_ *config, resolution *Resolution) error {
|
|
root, _ := resolution.InputInfo(Keys("root"))
|
|
imported, _ := resolution.InputInfo(Keys("imported"))
|
|
defaulted, _ := resolution.InputInfo(Keys("default"))
|
|
rootSource, rootFound := resolution.Source(root.Origin.Locations[0].SourceID)
|
|
importSource, importFound := resolution.Source(imported.Origin.Locations[0].SourceID)
|
|
if !rootFound || rootSource.Path != "" || !importFound || importSource.Path != canonicalTestPath(t, importPath) || defaulted.Explicit {
|
|
callbackErr = errors.New("non-file root or imported file provenance is wrong")
|
|
}
|
|
if _, found := resolution.Source("unknown"); found {
|
|
callbackErr = errors.New("unknown source was found")
|
|
}
|
|
return callbackErr
|
|
},
|
|
}})
|
|
if callbackErr != nil {
|
|
t.Fatal(callbackErr)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
})
|
|
}
|
|
|
|
var callbackErr error
|
|
_, err := testLoad[config](Bytes("memory://standalone.yml", []byte("root: memory\n")), Options[config]{Definition: Definition[config]{
|
|
Defaults: func() config { return config{Default: "retained"} },
|
|
Resolve: func(_ *config, resolution *Resolution) error {
|
|
root, rootFound := resolution.InputInfo(Keys("root"))
|
|
defaulted, defaultFound := resolution.InputInfo(Keys("default"))
|
|
source, sourceFound := resolution.Source(root.Origin.Locations[0].SourceID)
|
|
if !rootFound || !defaultFound || !sourceFound || source.Path != "" || defaulted.Explicit {
|
|
callbackErr = errors.New("standalone non-file provenance is wrong")
|
|
}
|
|
return callbackErr
|
|
},
|
|
}})
|
|
if callbackErr != nil {
|
|
t.Fatal(callbackErr)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestResolutionInputRemainsFixedAcrossRecordedMutations(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Existing string `yaml:"existing"`
|
|
Values map[string]string `yaml:"values"`
|
|
}
|
|
var callbackErr error
|
|
result, err := testLoad[config](Bytes("mutations.yml", []byte("existing: original\nvalues: {original: move}\n")), Options[config]{Definition: Definition[config]{Resolve: func(value *config, resolution *Resolution) error {
|
|
original, originalFound := resolution.InputInfo(Keys("values", "original"))
|
|
_, destinationFound := resolution.InputInfo(Keys("values", "destination"))
|
|
existing, existingFound := resolution.InputInfo(Keys("existing"))
|
|
Normalize(resolution, Keys("existing"), &value.Existing, "normalized", "normalized existing value")
|
|
value.Values["destination"] = value.Values["original"]
|
|
delete(value.Values, "original")
|
|
resolution.Record(Keys("values"), ChangeNormalization, "moved configured value")
|
|
againOriginal, againOriginalFound := resolution.InputInfo(Keys("values", "original"))
|
|
againDestination, againDestinationFound := resolution.InputInfo(Keys("values", "destination"))
|
|
againExisting, againExistingFound := resolution.InputInfo(Keys("existing"))
|
|
if !originalFound || destinationFound || !existingFound || !againOriginalFound || againDestinationFound || !againExistingFound ||
|
|
!reflect.DeepEqual(original, againOriginal) || !reflect.DeepEqual(existing, againExisting) || !reflect.DeepEqual(againDestination, FieldInfo{}) {
|
|
callbackErr = errors.New("entry view changed during resolution")
|
|
}
|
|
return callbackErr
|
|
}}})
|
|
if callbackErr != nil {
|
|
t.Fatal(callbackErr)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Config.Existing != "normalized" || result.Config.Values["destination"] != "move" {
|
|
t.Fatalf("configuration = %#v", result.Config)
|
|
}
|
|
if _, found := result.Metadata().Lookup(Keys("values", "original")); found {
|
|
t.Fatal("final metadata retained a removed path")
|
|
}
|
|
destination, found := result.Metadata().Lookup(Keys("values", "destination"))
|
|
existing, existingFound := result.Metadata().Lookup(Keys("existing"))
|
|
if !found || destination.Origin.Layer != LayerResolution || !existingFound || existing.Origin.Layer != LayerResolution {
|
|
t.Fatalf("final metadata = destination %#v existing %#v", destination, existing)
|
|
}
|
|
}
|
|
|
|
func TestResolutionInputQueriesRemainIndependentAcrossLoads(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Value string `yaml:"value"`
|
|
}
|
|
const loads = 16
|
|
failures := make(chan error, loads)
|
|
var group sync.WaitGroup
|
|
for index := 0; index < loads; index++ {
|
|
group.Add(1)
|
|
go func() {
|
|
defer group.Done()
|
|
_, err := testLoad[config](Bytes("parallel.yml", []byte("value: stable\n")), Options[config]{Definition: Definition[config]{Resolve: func(_ *config, resolution *Resolution) error {
|
|
info, found := resolution.InputInfo(Keys("value"))
|
|
source, sourceFound := resolution.Source(info.Origin.Locations[0].SourceID)
|
|
if !found || !sourceFound || source.ID != "source-1" {
|
|
return errors.New("independent entry lookup failed")
|
|
}
|
|
info.Origin.Locations[0].SourceID = "mutated"
|
|
source.Label = "mutated"
|
|
return nil
|
|
}}})
|
|
if err != nil {
|
|
failures <- err
|
|
}
|
|
}()
|
|
}
|
|
group.Wait()
|
|
close(failures)
|
|
for err := range failures {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func assertHistoryLayersAndPaths(t *testing.T, history []Change, layers []Layer, paths []string) {
|
|
t.Helper()
|
|
if len(history) != len(layers) || len(history) != len(paths) {
|
|
t.Fatalf("history = %#v", history)
|
|
}
|
|
for index, change := range history {
|
|
if change.Origin.Layer != layers[index] || change.Path.String() != paths[index] {
|
|
t.Fatalf("history[%d] = %#v", index, change)
|
|
}
|
|
}
|
|
}
|