380 lines
15 KiB
Go
380 lines
15 KiB
Go
package engine
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"testing/fstest"
|
|
|
|
"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
|
|
)
|
|
|
|
func TestDestinationPlacementCountsAgainstSharedNodeBudget(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
limits := defaultImportLimits()
|
|
destination := Keys("collections", "entry")
|
|
empty := Mapping("empty", map[string]any{})
|
|
parsed, diagnostics := parseSource(empty, "fixture", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatal(diagnostics)
|
|
}
|
|
perInput := countInputNodes(parsed.document) + destinationWrapperNodeCount(destination)
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
delta int
|
|
wantError bool
|
|
wantCharge int
|
|
}{
|
|
{name: "below aggregate bound", delta: -1, wantCharge: perInput},
|
|
{name: "at aggregate bound", delta: 0, wantCharge: perInput},
|
|
{name: "above aggregate bound", delta: 1, wantError: true},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
accounting := &importAccounting{nodes: limits.nodes - perInput + test.delta}
|
|
composition, _, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: []loadInput{{
|
|
source: empty, destination: destination,
|
|
}}}, 1, nil, accounting)
|
|
if test.wantError {
|
|
if composition != nil || len(diagnostics) != 1 || diagnostics[0].Code != CodeSourceLimitExceeded {
|
|
t.Fatalf("over-budget placement = %#v, %#v", composition, diagnostics)
|
|
}
|
|
return
|
|
}
|
|
if composition == nil || len(diagnostics) != 0 || composition.inputNodes != test.wantCharge {
|
|
t.Fatalf("bounded placement = %#v, %#v", composition, diagnostics)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMultipleMountedInputsSharePlacementCharges(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
limits := defaultImportLimits()
|
|
inputs := []loadInput{
|
|
{source: Mapping("one", map[string]any{}), destination: Keys("collection", "one")},
|
|
{source: Mapping("two", map[string]any{}), destination: Keys("collection", "two")},
|
|
{source: Mapping("three", map[string]any{}), destination: Keys("collection", "three")},
|
|
}
|
|
perInput := countInputNodes(&document.Node{Kind: document.Mapping}) + destinationWrapperNodeCount(Keys("collection", "one"))
|
|
charge := len(inputs) * perInput
|
|
accounting := &importAccounting{nodes: limits.nodes - charge}
|
|
composition, _, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: inputs}, 1, nil, accounting)
|
|
if len(diagnostics) != 0 || composition == nil || accounting.nodes != limits.nodes || composition.inputNodes != charge {
|
|
t.Fatalf("shared placement accounting = %#v, %#v, accounting %#v; want charge %d", composition, diagnostics, accounting, charge)
|
|
}
|
|
}
|
|
|
|
func TestImportedEmptyBodiesChargeEachDestinationWrapper(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
filesystem := NewFilesystem("bundle", fstest.MapFS{
|
|
"main.yml": &fstest.MapFile{Data: []byte("configkit: {imports: [{path: fragment.yml}]}\n")},
|
|
"fragment.yml": &fstest.MapFile{Data: []byte("{}\n")},
|
|
})
|
|
mainSource := filesystem.File("main.yml")
|
|
mainParsed, diagnostics := parseSource(mainSource, "fixture", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatal(diagnostics)
|
|
}
|
|
fragmentParsed, diagnostics := parseSource(Bytes("fragment", []byte("{}\n")), "fixture", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatal(diagnostics)
|
|
}
|
|
rawNodes := countInputNodes(mainParsed.document) + countInputNodes(fragmentParsed.document)
|
|
destination := Keys("collection", "empty")
|
|
placementNodes := 2 * destinationWrapperNodeCount(destination)
|
|
limits := defaultImportLimits()
|
|
for _, test := range []struct {
|
|
name string
|
|
delta int
|
|
wantError bool
|
|
}{
|
|
{name: "below aggregate bound", delta: -1},
|
|
{name: "at aggregate bound", delta: 0},
|
|
{name: "above aggregate bound", delta: 1, wantError: true},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
accounting := &importAccounting{nodes: limits.nodes - rawNodes - placementNodes + test.delta}
|
|
composition, sources, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: []loadInput{{
|
|
source: mainSource, imports: true, destination: destination,
|
|
}}}, 1, nil, accounting)
|
|
if test.wantError {
|
|
if composition != nil || len(diagnostics) == 0 || diagnostics[0].Code != CodeImportLimitExceeded {
|
|
t.Fatalf("over-budget imports = %#v, %#v", composition, diagnostics)
|
|
}
|
|
return
|
|
}
|
|
if len(diagnostics) != 0 || composition == nil || len(sources) != 2 {
|
|
t.Fatalf("bounded imports = %#v, sources %#v, diagnostics %#v", composition, sources, diagnostics)
|
|
}
|
|
if composition.inputNodes != rawNodes+placementNodes || accounting.nodes != limits.nodes+test.delta {
|
|
t.Fatalf("import node charge = %d, accounting %d; want %d and %d", composition.inputNodes, accounting.nodes, rawNodes+placementNodes, limits.nodes+test.delta)
|
|
}
|
|
if node, present := documentAtPath(composition.root, Keys("collection", "empty")); !present || node.Kind != document.Mapping || len(node.Mapping) != 0 {
|
|
t.Fatalf("placed empty import body = %#v, present %v", node, present)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestImportedEmptyBodiesChargeFullRelativeDestinations(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
directory := t.TempDir()
|
|
mainPath := writeImportFile(t, directory, "main.yml", `configkit:
|
|
imports:
|
|
- path: empty.yml
|
|
destination: [groups, empty]
|
|
`)
|
|
fragmentPath := writeImportFile(t, directory, "empty.yml", "{}\n")
|
|
main := parseImportMain(t, mainPath)
|
|
fragment, diagnostics := parseSource(File(fragmentPath), "source-2", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("empty fragment diagnostics = %#v", diagnostics)
|
|
}
|
|
entryDestination := Keys("collections", "entry")
|
|
importDestination := appendDestination(entryDestination, Keys("groups", "empty"))
|
|
wantNodes := countInputNodes(main.document) + countInputNodes(fragment.document) +
|
|
destinationWrapperNodeCount(entryDestination) + destinationWrapperNodeCount(importDestination)
|
|
limits := defaultImportLimits()
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
delta int
|
|
wantError bool
|
|
}{
|
|
{name: "below aggregate bound", delta: -1, wantError: true},
|
|
{name: "at aggregate bound"},
|
|
{name: "above aggregate bound", delta: 1},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
currentLimits := limits
|
|
currentLimits.nodes = wantNodes + test.delta
|
|
accounting := &importAccounting{}
|
|
composed, sources, diagnostics := loadImportedDocumentsTracked(
|
|
File(mainPath), nil, main, entryDestination, nil, currentLimits, accounting, nil, nil,
|
|
)
|
|
if test.wantError {
|
|
if composed != nil || len(diagnostics) != 1 || diagnostics[0].Code != CodeImportLimitExceeded {
|
|
t.Fatalf("below-bound relative placement = %#v, %#v", composed, diagnostics)
|
|
}
|
|
return
|
|
}
|
|
if len(diagnostics) != 0 || composed == nil || len(sources) != 2 {
|
|
t.Fatalf("bounded relative placement = %#v, %#v, %#v", composed, sources, diagnostics)
|
|
}
|
|
if composed.inputNodes != wantNodes || accounting.nodes != wantNodes {
|
|
t.Fatalf("relative placement node charge = %d/%d, want %d", composed.inputNodes, accounting.nodes, wantNodes)
|
|
}
|
|
if sources[1].Destination.String() != importDestination.String() {
|
|
t.Fatalf("empty import destination = %q, want %q", sources[1].Destination.String(), importDestination.String())
|
|
}
|
|
if node, present := documentAtPath(composed.root, importDestination); !present || node.Kind != document.Mapping || len(node.Mapping) != 0 {
|
|
t.Fatalf("empty relative import body = %#v, present %v", node, present)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGlobMatchesChargeTheirSharedRelativeDestination(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
directory := t.TempDir()
|
|
mainPath := writeImportFile(t, directory, "main.yml", `configkit:
|
|
imports:
|
|
- glob: fragments/*.yml
|
|
destination: [groups, empty]
|
|
`)
|
|
fragmentPaths := []string{
|
|
writeImportFile(t, directory, "fragments/a.yml", "{}\n"),
|
|
writeImportFile(t, directory, "fragments/b.yml", "{}\n"),
|
|
writeImportFile(t, directory, "fragments/c.yml", "{}\n"),
|
|
}
|
|
main := parseImportMain(t, mainPath)
|
|
fragment, diagnostics := parseSource(File(fragmentPaths[0]), "source-fragment", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("glob fragment diagnostics = %#v", diagnostics)
|
|
}
|
|
entryDestination := Keys("collections", "entry")
|
|
importDestination := appendDestination(entryDestination, Keys("groups", "empty"))
|
|
wantNodes := countInputNodes(main.document) + len(fragmentPaths)*countInputNodes(fragment.document) +
|
|
destinationWrapperNodeCount(entryDestination) + len(fragmentPaths)*destinationWrapperNodeCount(importDestination)
|
|
limits := defaultImportLimits()
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
delta int
|
|
wantError bool
|
|
}{
|
|
{name: "below aggregate bound", delta: -1, wantError: true},
|
|
{name: "at aggregate bound"},
|
|
{name: "above aggregate bound", delta: 1},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
currentLimits := limits
|
|
currentLimits.nodes = wantNodes + test.delta
|
|
accounting := &importAccounting{}
|
|
composed, sources, diagnostics := loadImportedDocumentsTracked(
|
|
File(mainPath), nil, main, entryDestination, nil, currentLimits, accounting, nil, nil,
|
|
)
|
|
if test.wantError {
|
|
if composed != nil || len(diagnostics) != 1 || diagnostics[0].Code != CodeImportLimitExceeded {
|
|
t.Fatalf("below-bound glob placement = %#v, %#v", composed, diagnostics)
|
|
}
|
|
return
|
|
}
|
|
if len(diagnostics) != 0 || composed == nil || len(sources) != len(fragmentPaths)+1 {
|
|
t.Fatalf("bounded glob placement = %#v, %#v, %#v", composed, sources, diagnostics)
|
|
}
|
|
if composed.inputNodes != wantNodes || accounting.nodes != wantNodes {
|
|
t.Fatalf("glob relative placement node charge = %d/%d, want %d", composed.inputNodes, accounting.nodes, wantNodes)
|
|
}
|
|
for index, source := range sources[1:] {
|
|
if source.Destination.String() != importDestination.String() {
|
|
t.Errorf("glob source %d destination = %q, want %q", index, source.Destination.String(), importDestination.String())
|
|
}
|
|
}
|
|
if node, present := documentAtPath(composed.root, importDestination); !present || node.Kind != document.Mapping || len(node.Mapping) != 0 {
|
|
t.Fatalf("empty glob contributions = %#v, present %v", node, present)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRelativeImportDestinationUsesAccumulatedDocumentDepth(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
directory := t.TempDir()
|
|
mainPath := writeImportFile(t, directory, "main.yml", "configkit: {imports: [{path: fragment.yml, destination: [extra]}]}\n")
|
|
writeImportFile(t, directory, "fragment.yml", "value: nested\n")
|
|
destination := Path{segments: make([]pathSegment, maxDocumentDepth)}
|
|
for index := range destination.segments {
|
|
destination.segments[index] = pathSegment{kind: pathSegmentKey, key: "entry"}
|
|
}
|
|
_, err := LoadLayered(
|
|
Input{Source: File(mainPath), Imports: true, Destination: destination}, testSecretBinding(),
|
|
LayeredOptions[map[string]any]{},
|
|
)
|
|
loadError, ok := err.(*LoadError)
|
|
if !ok || len(loadError.Diagnostics()) != 1 || loadError.Diagnostics()[0].Code != CodeImportLimitExceeded {
|
|
t.Fatalf("accumulated depth result = %v", err)
|
|
}
|
|
sources := loadError.Sources()
|
|
if len(sources) != 2 || len(sources[0].Destination.segments) != maxDocumentDepth || len(sources[1].Destination.segments) != maxDocumentDepth+1 {
|
|
t.Fatalf("depth failure source destinations = %#v", sources)
|
|
}
|
|
}
|
|
|
|
func TestAbsentOptionalImportsDoNotChargeUnusedDeepDestinations(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
destination := Path{segments: make([]pathSegment, maxDocumentDepth)}
|
|
for index := range destination.segments {
|
|
destination.segments[index] = pathSegment{kind: pathSegmentKey, key: "entry"}
|
|
}
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
body string
|
|
setup func(*testing.T, string)
|
|
}{
|
|
{
|
|
name: "optional missing path",
|
|
body: "configkit: {imports: [{path: missing.yml, optional: true, destination: [unused]}]}\n",
|
|
},
|
|
{
|
|
name: "optional unmatched glob",
|
|
body: "configkit: {imports: [{glob: empty/*.yml, optional: true, destination: [unused]}]}\n",
|
|
setup: func(t *testing.T, directory string) {
|
|
if err := os.Mkdir(filepath.Join(directory, "empty"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
},
|
|
},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
directory := t.TempDir()
|
|
if test.setup != nil {
|
|
test.setup(t, directory)
|
|
}
|
|
mainPath := writeImportFile(t, directory, "main.yml", test.body)
|
|
main := parseImportMain(t, mainPath)
|
|
limits := defaultImportLimits()
|
|
accounting := &importAccounting{}
|
|
composed, sources, diagnostics := loadImportedDocumentsTracked(
|
|
File(mainPath), nil, main, destination, nil, limits, accounting, nil, nil,
|
|
)
|
|
if len(diagnostics) != 0 || composed == nil || len(sources) != 1 {
|
|
t.Fatalf("absent optional import = %#v, %#v, %#v", composed, sources, diagnostics)
|
|
}
|
|
wantNodes := countInputNodes(main.document) + destinationWrapperNodeCount(destination)
|
|
if composed.inputNodes != wantNodes || accounting.nodes != wantNodes {
|
|
t.Fatalf("absent optional node charge = %d/%d, want %d", composed.inputNodes, accounting.nodes, wantNodes)
|
|
}
|
|
if node, present := documentAtPath(composed.root, destination); !present || node.Kind != document.Mapping || len(node.Mapping) != 0 {
|
|
t.Fatalf("empty entry body = %#v, present %v", node, present)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNoSourceAndRootPlacementAddNoWrapperCharges(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
accounting := &importAccounting{}
|
|
composition, sources, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: []loadInput{
|
|
{source: NoSource(), destination: Keys("absent")},
|
|
{source: Mapping("root", map[string]any{})},
|
|
}}, 1, nil, accounting)
|
|
if len(diagnostics) != 0 || composition == nil || len(sources) != 1 || accounting.nodes != 1 || composition.inputNodes != 1 {
|
|
t.Fatalf("root and absent placement = %#v, sources %#v, diagnostics %#v, accounting %#v", composition, sources, diagnostics, accounting)
|
|
}
|
|
}
|
|
|
|
func TestSelectedOverlayAndCLIUsePlacementNodeCharges(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
limits := defaultImportLimits()
|
|
baseNodes := countInputNodes(&document.Node{Kind: document.Mapping}) + destinationWrapperNodeCount(Keys("mounted"))
|
|
|
|
t.Run("selected overlay", func(t *testing.T) {
|
|
t.Parallel()
|
|
filesystem := NewFilesystem("bundle", fstest.MapFS{
|
|
"overlays/test.yml": &fstest.MapFile{Data: []byte("{}\n")},
|
|
})
|
|
request := loadRequest[map[string]any]{
|
|
underlays: []loadGroup{{inputs: []loadInput{{source: Mapping("empty", map[string]any{}), destination: Keys("mounted")}}}},
|
|
overlay: "test", overlayFilesystem: &FilesystemContext{Root: ".", BaseDir: ".", FS: &filesystem},
|
|
}
|
|
accounting := &importAccounting{nodes: limits.nodes - baseNodes}
|
|
_, diagnostics := assembleLayeredInput(request, assembledInput{}, accounting)
|
|
if len(diagnostics) != 1 || diagnostics[0].Code != CodeOverlayLimitExceeded {
|
|
t.Fatalf("overlay diagnostics = %#v", diagnostics)
|
|
}
|
|
})
|
|
|
|
t.Run("CLI override", func(t *testing.T) {
|
|
t.Parallel()
|
|
override := Override{Path: Keys("mounted", "value"), Value: "x", Flag: "--value"}
|
|
builder := valueBuilder{sourceID: "fixture", active: make(map[valueVisit]bool)}
|
|
if _, issue := builder.build(override.Value, override.Path, len(override.Path.segments)); issue != nil {
|
|
t.Fatal(issue)
|
|
}
|
|
overrideNodes := builder.nodes + destinationWrapperNodeCount(override.Path)
|
|
request := loadRequest[map[string]any]{
|
|
underlays: []loadGroup{{inputs: []loadInput{{source: Mapping("empty", map[string]any{}), destination: Keys("mounted")}}}},
|
|
overrides: []Override{override},
|
|
}
|
|
accounting := &importAccounting{nodes: limits.nodes - baseNodes - overrideNodes + 1}
|
|
_, diagnostics := assembleLayeredInput(request, assembledInput{}, accounting)
|
|
if len(diagnostics) != 1 || diagnostics[0].Code != CodeOverrideLimitExceeded {
|
|
t.Fatalf("override diagnostics = %#v", diagnostics)
|
|
}
|
|
})
|
|
}
|