188 lines
7.5 KiB
Go
188 lines
7.5 KiB
Go
package engine
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestMovedRemovedFieldHasConsistentHistory(t *testing.T) {
|
|
type config struct {
|
|
Items []map[string]any `yaml:"items"`
|
|
}
|
|
definition := DefinitionWithSequenceIdentityRegistrations(Definition[config]{
|
|
Resolve: func(value *config, r *Resolution) error {
|
|
delete(value.Items[0], "extra")
|
|
value.Items[0], value.Items[1] = value.Items[1], value.Items[0]
|
|
r.RecordNormalization(Keys("items"), "remove field and reorder")
|
|
return nil
|
|
},
|
|
}, []SequenceIdentityRegistrationInput{{ExactPath: pathPointer(Keys("items")), IdentityFields: []string{"id"}}})
|
|
result, err := testLoad(Bytes("records", []byte("items: [{id: a, extra: own}, {id: b}]\n")), Options[config]{Definition: definition})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
path := Keys("items").Index(1).Key("extra")
|
|
if _, found := result.Metadata().Lookup(path); found {
|
|
t.Fatal("removed field is effective")
|
|
}
|
|
explanation, found := result.Inspection.Explain(path)
|
|
if !found || len(explanation.History) != 2 {
|
|
t.Fatalf("explanation = %#v, %t", explanation, found)
|
|
}
|
|
history := result.Metadata().History(path)
|
|
if len(history) != 2 || history[0].Origin.Layer != LayerMain || history[1].Origin.Operation != ChangeNormalization {
|
|
t.Fatalf("metadata history = %#v", history)
|
|
}
|
|
last := explanation.History[1]
|
|
if last.Before.YAML != "own\n" || last.After.Present {
|
|
t.Fatalf("removal = %#v", last)
|
|
}
|
|
for _, unknown := range []Path{Keys("items", "1", "extra"), Keys("items").Index(1).Key("unknown")} {
|
|
if history := result.Metadata().History(unknown); len(history) != 0 {
|
|
t.Fatalf("unexpected history for %s: %#v", unknown.String(), history)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMovedInheritedHistoryUsesFinalRecordPrefix(t *testing.T) {
|
|
type config struct {
|
|
Items []map[string]any `yaml:"items"`
|
|
}
|
|
field := Keys("items").Index(0).Key("nested").Key("more").Key("value")
|
|
definition := DefinitionWithSequenceIdentityRegistrations(Definition[config]{
|
|
Resolve: func(value *config, r *Resolution) error {
|
|
value.Items[0], value.Items[1] = value.Items[1], value.Items[0]
|
|
r.RecordNormalization(Keys("items"), "reorder")
|
|
r.RecordNormalization(field, "retain inherited field")
|
|
return nil
|
|
},
|
|
}, []SequenceIdentityRegistrationInput{{ExactPath: pathPointer(Keys("items")), IdentityFields: []string{"id"}}})
|
|
result, err := testLoad(Bytes("records", []byte("items:\n - id: parent\n nested: {more: {value: old}}\n - id: child\n extends: {id: parent}\n")), Options[config]{Definition: definition})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
physical := result.Metadata().History(Keys("items"))
|
|
sourceID := result.Inspection.Sources()[0].ID
|
|
for _, query := range []Path{field, Keys("items").Index(0)} {
|
|
inherited, recorded := false, false
|
|
for _, change := range result.Metadata().History(query) {
|
|
if change.Origin.Operation == ChangeInheritance {
|
|
inherited = true
|
|
if !pathContains(Keys("items").Index(0), change.Path) {
|
|
t.Errorf("inheritance path for %s = %s", query.String(), change.Path.String())
|
|
}
|
|
if query.String() == field.String() && change.Path.String() != "/items/0" {
|
|
t.Errorf("container operation replaced by leaf path: %s", change.Path.String())
|
|
}
|
|
for _, location := range change.Origin.Locations {
|
|
if location.SourceID != sourceID || (query.String() == field.String() && location.Line != 3) {
|
|
t.Errorf("source coordinates changed: %#v", location)
|
|
}
|
|
}
|
|
}
|
|
if change.Origin.Layer == LayerResolution && len(change.Reasons) == 1 && change.Reasons[0] == "retain inherited field" {
|
|
recorded = true
|
|
if change.Path.String() != field.String() {
|
|
t.Errorf("final resolution path translated twice: %s", change.Path.String())
|
|
}
|
|
}
|
|
}
|
|
if !inherited || !recorded {
|
|
t.Errorf("missing inherited or recorded evidence for %s", query.String())
|
|
}
|
|
}
|
|
for _, change := range physical {
|
|
if change.Origin.Operation == ChangeInheritance && !pathContains(Keys("items").Index(1), change.Path) {
|
|
t.Errorf("collection history lost physical coordinates: %s", change.Path.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCyclicMatchingProtectsRemovedAndDerivedValues(t *testing.T) {
|
|
type config struct {
|
|
Items []map[string]any `yaml:"items"`
|
|
Derived string `yaml:"derived"`
|
|
}
|
|
removed := Keys("items").Index(1).Key("extra")
|
|
definition := DefinitionWithSequenceIdentityRegistrations(Definition[config]{
|
|
Secret: func(path Path) bool { return path.String() == "/items/0/extra" },
|
|
Resolve: func(value *config, r *Resolution) error {
|
|
value.Derived = value.Items[0]["extra"].(string)
|
|
delete(value.Items[0], "extra")
|
|
last := value.Items[len(value.Items)-1]
|
|
copy(value.Items[1:], value.Items[:len(value.Items)-1])
|
|
value.Items[0] = last
|
|
r.RecordNormalization(Keys("items"), "remove field and rotate")
|
|
r.RecordDerivedDefault(Keys("derived"), "derive from removed value", removed)
|
|
return nil
|
|
},
|
|
}, []SequenceIdentityRegistrationInput{{ExactPath: pathPointer(Keys("items")), IdentityFields: []string{"id"}}})
|
|
result, err := testLoad(Bytes("records", []byte("items: [{id: a, extra: CYCLIC_PRIVATE_CANARY}, {id: b}, {id: c}, {id: d}]\n")), Options[config]{Definition: definition})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, path := range []Path{Keys("items"), removed, Keys("derived")} {
|
|
explanation, found := result.Inspection.Explain(path)
|
|
if !found {
|
|
t.Fatalf("missing explanation for %s", path.String())
|
|
}
|
|
if strings.Contains(explanation.Effective.YAML, "CYCLIC_PRIVATE_CANARY") {
|
|
t.Fatalf("effective value leaked at %s", path.String())
|
|
}
|
|
for _, change := range explanation.History {
|
|
if strings.Contains(change.Before.YAML, "CYCLIC_PRIVATE_CANARY") || strings.Contains(change.After.YAML, "CYCLIC_PRIVATE_CANARY") {
|
|
t.Fatalf("history leaked at %s", path.String())
|
|
}
|
|
}
|
|
}
|
|
var output strings.Builder
|
|
if err := result.Inspection.WriteEffective(&output); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if strings.Contains(output.String(), "CYCLIC_PRIVATE_CANARY") {
|
|
t.Fatal("effective rendering leaked")
|
|
}
|
|
}
|
|
|
|
func TestCorrespondenceIndexPreservesPathShapes(t *testing.T) {
|
|
destination := Keys("groups", "0", "a/b~")
|
|
policy, diagnostics := compileSequenceIdentityPolicy([]sequenceIdentityRegistration{{
|
|
selector: sequenceIdentitySelector{
|
|
literalSequenceSelector("groups"), literalSequenceSelector("0"), literalSequenceSelector("a/b~"),
|
|
},
|
|
identityFields: []string{"id"},
|
|
}})
|
|
if len(diagnostics) != 0 {
|
|
t.Fatal(diagnostics)
|
|
}
|
|
before := parseCompositionDocument(t, "before", "groups: {'0': {'a/b~': [{id: a}, {id: b}]}}")
|
|
after := parseCompositionDocument(t, "after", "groups: {'0': {'a/b~': [{id: b}, {id: a}, {id: new}]}}")
|
|
matching := buildResolutionCorrespondence(before, after, policy)
|
|
parsed, err := ParsePath("/groups/0/a~1b~0/0/field")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, path := range []Path{destination.Index(0).Key("field"), parsed} {
|
|
entry, found := matching.entryPath(path)
|
|
if !found || entry.String() != destination.Index(1).Key("field").String() {
|
|
t.Fatalf("entry = %s, %t", entry.String(), found)
|
|
}
|
|
final, found := matching.finalPath(entry)
|
|
if !found || final.String() != path.String() {
|
|
t.Fatalf("round trip = %s, %t", final.String(), found)
|
|
}
|
|
}
|
|
for _, path := range []Path{
|
|
Keys("groups").Index(0).Key("a/b~").Index(0),
|
|
destination.Key("0"), destination.Index(8), destination,
|
|
} {
|
|
entry, found := matching.entryPath(path)
|
|
if !found || entry.String() != path.String() {
|
|
t.Fatalf("positional path %s became %s, %t", path.String(), entry.String(), found)
|
|
}
|
|
}
|
|
if _, found := matching.entryPath(destination.Index(2)); found {
|
|
t.Fatal("new identity acquired entry evidence")
|
|
}
|
|
}
|