196 lines
9.2 KiB
Go
196 lines
9.2 KiB
Go
package engine
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
|
|
)
|
|
|
|
func TestResolutionSensitivityKeepsLogicalEdgesWithoutSubtreeDuplication(t *testing.T) {
|
|
t.Parallel()
|
|
before := parseDocumentForDecode(t, "settings: {a: old, b: old, c: old}\ncredentials: {private: p, public: q, child: r}\nunrelated: visible\n")
|
|
after := parseDocumentForDecode(t, "settings: {a: new, b: new, c: new}\n")
|
|
beforeSettings, _ := documentAtPath(before, Keys("settings"))
|
|
afterSettings, _ := documentAtPath(after, Keys("settings"))
|
|
beforeChild, _ := documentAtPath(before, Keys("settings", "a"))
|
|
afterChild, _ := documentAtPath(after, Keys("settings", "a"))
|
|
first := parseOverrideTestPath(t, "/credentials/private")
|
|
second := parseOverrideTestPath(t, "/credentials/public")
|
|
child := parseOverrideTestPath(t, "/credentials/child")
|
|
builder := newHistoryBuilder()
|
|
builder.observeBaseline(before)
|
|
builder.setScratch(before)
|
|
builder.observeResolutionEvidence([]resolutionSnapshot{
|
|
{change: Change{Path: Keys("settings"), Origin: Origin{Layer: LayerResolution, Operation: ChangeNormalization}, Dependencies: []Path{first, second}}, before: beforeSettings, after: afterSettings},
|
|
{change: Change{Path: Keys("settings", "a"), Origin: Origin{Layer: LayerResolution, Operation: ChangeNormalization}, Dependencies: []Path{child}}, before: beforeChild, after: afterChild},
|
|
})
|
|
model := builder.freeze()
|
|
dependencies, inherited := model.sensitivityDependencies()
|
|
if len(dependencies) != 3 || len(inherited) != 0 {
|
|
t.Fatalf("got %d ordinary and %d inherited edges; want the three original dependencies", len(dependencies), len(inherited))
|
|
}
|
|
for index, expected := range []struct{ target, dependency string }{
|
|
{"/settings", first.String()}, {"/settings", second.String()}, {"/settings/a", child.String()},
|
|
} {
|
|
if dependencies[index].target.String() != expected.target || dependencies[index].dependency.String() != expected.dependency {
|
|
t.Fatalf("edge %d lost its recorded target/dependency", index)
|
|
}
|
|
}
|
|
classified := classifySecretPaths(nil, func(path Path) bool {
|
|
return path.String() == child.String()
|
|
}, Metadata{historyModel: model})
|
|
if !classified["/settings/a"] || classified["/settings"] || classified["/settings/b"] || classified["/unrelated"] {
|
|
t.Fatalf("original child dependency omitted by replay grouping or propagated to unrelated values: %#v", classified)
|
|
}
|
|
}
|
|
|
|
func TestHistoryResolutionRetainsOriginalShapeAttributionBehindReplayGroup(t *testing.T) {
|
|
before := &document.Node{Kind: document.Mapping, Mapping: []document.Entry{{
|
|
Key: "0", Value: &document.Node{Kind: document.String, Text: "old"},
|
|
}}}
|
|
after := &document.Node{Kind: document.Sequence, Sequence: []*document.Node{{
|
|
Kind: document.String, Text: "new", Sensitive: true,
|
|
}}}
|
|
baseline := &document.Node{Kind: document.Mapping, Mapping: []document.Entry{{
|
|
Key: "settings", Value: before,
|
|
}}}
|
|
parentDependency := Keys("parent-dependency")
|
|
childDependency := Keys("child-dependency")
|
|
snapshots := []resolutionSnapshot{
|
|
{
|
|
change: Change{
|
|
Path: Keys("settings"), Origin: Origin{Layer: LayerResolution, Operation: ChangeDerivedDefault},
|
|
Reasons: []string{"parent normalization"}, Dependencies: []Path{parentDependency},
|
|
},
|
|
before: before, after: after,
|
|
},
|
|
{
|
|
change: Change{
|
|
Path: parseOverrideTestPath(t, "/settings/0"), Origin: Origin{Layer: LayerResolution, Operation: ChangeNormalization},
|
|
Reasons: []string{"child normalization"}, Dependencies: []Path{childDependency},
|
|
},
|
|
before: before.Mapping[0].Value,
|
|
after: after.Sequence[0],
|
|
},
|
|
}
|
|
|
|
builder := newHistoryBuilder()
|
|
builder.observeBaseline(baseline)
|
|
builder.setScratch(baseline)
|
|
builder.observeResolutionEvidence(snapshots)
|
|
model := builder.freeze()
|
|
|
|
if got := model.resolutionPayload.replayGroups; len(got) != 1 ||
|
|
got[0].coveringRecordID != 0 || !reflect.DeepEqual(got[0].originalRecordIDs, []int{0, 1}) ||
|
|
!reflect.DeepEqual(got[0].change.Reasons, []string{"parent normalization", "child normalization"}) ||
|
|
!reflect.DeepEqual(got[0].change.Dependencies, []Path{parentDependency, childDependency}) ||
|
|
got[0].change.Origin.Operation != ChangeNormalization {
|
|
t.Fatalf("replay group lost original references or merged annotations: %#v", got)
|
|
}
|
|
if len(model.resolutionPayload.snapshots) != 2 ||
|
|
model.resolutionPayload.snapshots[1].change.Reasons[0] != "child normalization" ||
|
|
model.resolutionPayload.snapshots[1].change.Dependencies[0].String() != childDependency.String() ||
|
|
model.resolutionPayload.snapshots[0].before != before || model.resolutionPayload.snapshots[1].after != after.Sequence[0] {
|
|
t.Fatalf("original resolution records or their roots were not retained: %#v", model.resolutionPayload.snapshots)
|
|
}
|
|
|
|
keyPath := Keys("settings", "0")
|
|
keySelections := model.selectHistory(keyPath)
|
|
if len(keySelections) != 3 || !keySelections[0].after || keySelections[1].phase != historyPhaseResolution ||
|
|
!keySelections[1].before || keySelections[1].after || !keySelections[2].before || keySelections[2].after {
|
|
t.Fatalf("mapping-key history did not retain its removed side: %#v", keySelections)
|
|
}
|
|
if got := keySelections[1].previous; len(got) != 1 || got[0].Layer != LayerDefault {
|
|
t.Fatalf("removed key previous origin = %#v, want baseline origin", got)
|
|
}
|
|
|
|
indexPath := Keys("settings").Index(0)
|
|
indexSelections := model.selectHistory(indexPath)
|
|
if len(indexSelections) != 2 || indexSelections[0].phase != historyPhaseResolution ||
|
|
!indexSelections[0].after || indexSelections[0].before || !indexSelections[1].after || indexSelections[1].before {
|
|
t.Fatalf("sequence-index history did not retain introduced sides: %#v", indexSelections)
|
|
}
|
|
if len(indexSelections[0].previous) != 0 {
|
|
t.Fatalf("introduced index inherited a different key's previous origin: %#v", indexSelections[0].previous)
|
|
}
|
|
if got := indexSelections[1].attribution; got.origin.Operation != ChangeNormalization ||
|
|
!reflect.DeepEqual(got.reasons, []string{"child normalization"}) ||
|
|
!reflect.DeepEqual(got.dependencies, []Path{childDependency}) {
|
|
t.Fatalf("covered original attribution = %#v", got)
|
|
}
|
|
|
|
foundSensitive := false
|
|
for _, observation := range model.observations {
|
|
if observation.phase == historyPhaseResolution && sameConcreteHistoryPath(observation.path, indexPath) && observation.sensitive {
|
|
foundSensitive = true
|
|
}
|
|
}
|
|
if !foundSensitive {
|
|
t.Fatal("original resolution subtree sensitivity was omitted from observations")
|
|
}
|
|
}
|
|
|
|
func TestMetadataFinalizationRegistersResolutionInventoryAndRoots(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
beforeShape := &document.Node{Kind: document.Mapping, Mapping: []document.Entry{{
|
|
Key: "0", Value: &document.Node{Kind: document.String, Text: "old"},
|
|
}}}
|
|
afterShape := &document.Node{Kind: document.Sequence, Sequence: []*document.Node{{
|
|
Kind: document.String, Text: "new", Sensitive: true,
|
|
}}}
|
|
before := &document.Node{Kind: document.Mapping, Mapping: []document.Entry{{Key: "shape", Value: beforeShape}}}
|
|
final := &document.Node{Kind: document.Mapping, Mapping: []document.Entry{{Key: "shape", Value: afterShape}}}
|
|
changePath := parseOverrideTestPath(t, "/shape/0")
|
|
snapshot := resolutionSnapshot{
|
|
change: Change{
|
|
Path: changePath, Origin: Origin{Layer: LayerResolution, Operation: ChangeNormalization},
|
|
Reasons: []string{"changed dynamic shape"}, Dependencies: []Path{Keys("source")},
|
|
},
|
|
before: beforeShape.Mapping[0].Value,
|
|
after: afterShape.Sequence[0],
|
|
}
|
|
parentSnapshot := resolutionSnapshot{
|
|
change: Change{
|
|
Path: Keys("shape"), Origin: Origin{Layer: LayerResolution, Operation: ChangeNormalization},
|
|
Reasons: []string{"replaced container"},
|
|
},
|
|
before: beforeShape,
|
|
after: afterShape,
|
|
}
|
|
|
|
var metadata Metadata
|
|
snapshots := []resolutionSnapshot{parentSnapshot, snapshot}
|
|
builder := newHistoryBuilder()
|
|
builder.setScratch(before)
|
|
builder.observeDocument(before, historyPhaseBaseline)
|
|
builder.observeDocument(final, historyPhasePostCLI)
|
|
builder.prefixReady = true
|
|
builder.observeResolutionEvidence(snapshots)
|
|
metadata.historyBuilder = builder
|
|
freezeMetadataHistory(&metadata, final)
|
|
if got := metadata.HistoricalPaths(); len(got) != 3 || got[0].String() != "" || got[1].String() != "/shape" || got[2].String() != "/shape/0" {
|
|
t.Fatalf("historical paths = %#v", got)
|
|
}
|
|
keyPath := Keys("shape", "0")
|
|
indexPath := Keys("shape").Index(0)
|
|
if !metadata.hasHistoricalPath(keyPath) || !metadata.hasHistoricalPath(indexPath) {
|
|
t.Fatalf("resolution shape inventory omitted key or index: %#v", metadata.HistoricalPaths())
|
|
}
|
|
if got := metadata.historyModel.selectHistory(keyPath); len(got) != 2 || !got[0].before || got[0].after || !got[1].before || got[1].after {
|
|
t.Fatalf("removed mapping-key resolution selection = %#v", got)
|
|
}
|
|
if got := metadata.historyModel.selectHistory(indexPath); len(got) != 2 || got[0].before || !got[0].after || got[1].before || !got[1].after {
|
|
t.Fatalf("introduced sequence-index resolution selection = %#v", got)
|
|
}
|
|
var retainedBefore, retainedAfter bool
|
|
for _, root := range metadata.historyModel.documentRoots() {
|
|
retainedBefore = retainedBefore || root == snapshot.before
|
|
retainedAfter = retainedAfter || root == snapshot.after
|
|
}
|
|
if !retainedBefore || !retainedAfter {
|
|
t.Fatalf("resolution roots not enumerated: before=%v after=%v", retainedBefore, retainedAfter)
|
|
}
|
|
}
|