Validate source equivalence and layered scaling

internal/engine/load_request_test.go

@@ -208,3 +208,73 @@ func groupedErrorCode(t *testing.T, err error) Code {
 	}
 	return loadError.Diagnostics()[0].Code
 }
+
+func TestGroupedAccountingChargesMixedOccurrencesOnce(t *testing.T) {
+	const (
+		one   = "configkit: {imports: [{path: child-one.yml}]}\nleft: first\n"
+		child = "extra: imported\n"
+		two   = "configkit: {imports: [{path: child-two.yml}]}\nright: second\n"
+	)
+	filesystem := NewFilesystem("bundle", fstest.MapFS{
+		"one.yml":       &fstest.MapFile{Data: []byte(one)},
+		"child-one.yml": &fstest.MapFile{Data: []byte(child)},
+		"two.yml":       &fstest.MapFile{Data: []byte(two)},
+		"child-two.yml": &fstest.MapFile{Data: []byte(child)},
+	})
+	accounting := &importAccounting{}
+	first, sources, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: []loadInput{{source: filesystem.File("one.yml"), imports: true}}}, 1, nil, accounting)
+	if len(diagnostics) != 0 || first == nil || len(sources) != 2 || accounting.sources != 2 || accounting.bytes != int64(len(one)+len(child)) {
+		t.Fatalf("first acquisition = %#v, %#v, %#v, accounting %#v", first, sources, diagnostics, accounting)
+	}
+	second, sources, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: []loadInput{{source: filesystem.File("two.yml"), imports: true}}}, 2, nil, accounting)
+	if len(diagnostics) != 0 || second == nil || len(sources) != 2 || sources[0].ID != "source-3" || sources[1].ID != "source-4" || accounting.sources != 4 || accounting.bytes != int64(len(one)+len(two)+2*len(child)) {
+		t.Fatalf("second acquisition = %#v, %#v, %#v, accounting %#v", second, sources, diagnostics, accounting)
+	}
+	var wantNodes int
+	for _, text := range []string{one, child, two, child} {
+		parsed, diagnostics := parseSource(Bytes("fixture", []byte(text)), "source-1", defaultParseLimits())
+		if len(diagnostics) != 0 {
+			t.Fatal(diagnostics)
+		}
+		wantNodes += countInputNodes(parsed.document)
+	}
+	if accounting.nodes != wantNodes {
+		t.Fatalf("charged nodes = %d, want %d", accounting.nodes, wantNodes)
+	}
+	if first.inputBytes != int64(len(one)+len(child)) || second.inputBytes != int64(len(two)+len(child)) {
+		t.Fatalf("composition costs = %d, %d, accounting %d", first.inputBytes, second.inputBytes, accounting.bytes)
+	}
+}
+
+func TestGroupedGlobEntryBudgetIsShared(t *testing.T) {
+	filesystem := NewFilesystem("bundle", fstest.MapFS{
+		"main.yml":    &fstest.MapFile{Data: []byte("configkit: {imports: [{glob: 'parts/*.yml'}]}\n")},
+		"parts/a.yml": &fstest.MapFile{Data: []byte("left: one\n")},
+		"parts/b.yml": &fstest.MapFile{Data: []byte("right: two\n")},
+	})
+	accounting := &importAccounting{entries: maxGlobEntries - 1}
+	_, _, _, diagnostics := acquireUnderlayGroup(loadGroup{inputs: []loadInput{{source: filesystem.File("main.yml"), imports: true}}}, 1, nil, accounting)
+	if len(diagnostics) == 0 || diagnostics[0].Code != CodeImportLimitExceeded || accounting.entries <= maxGlobEntries {
+		t.Fatalf("shared glob budget = %#v, accounting %#v", diagnostics, accounting)
+	}
+}
+
+func TestGroupedMixedSourcesShareCLIRecordLimit(t *testing.T) {
+	filesystem := NewFilesystem("bundle", fstest.MapFS{"main.yml": &fstest.MapFile{Data: []byte("value: base\n")}})
+	inputs := make([]Input, maxImportSources-1)
+	inputs[0] = Input{Source: Bytes("empty-bytes", []byte("{}\n"))}
+	for index := 1; index < len(inputs); index++ {
+		inputs[index] = Input{Source: Mapping("empty-map", map[string]any{})}
+	}
+	type config struct {
+		Value string `yaml:"value"`
+	}
+	_, err := LoadLayered(Input{Source: filesystem.File("main.yml")}, testSecretBinding(), LayeredOptions[config]{
+		Underlays: []Underlay{{Inputs: inputs}},
+		Overrides: []Override{{Path: Keys("value"), Value: "cli", Flag: "--value"}},
+	})
+	loadError, ok := err.(*LoadError)
+	if !ok || len(loadError.Diagnostics()) == 0 || loadError.Diagnostics()[0].Code != CodeOverrideLimitExceeded || len(loadError.Sources()) != maxImportSources {
+		t.Fatalf("mixed source/CLI limit = %#v", err)
+	}
+}