80 lines
2.5 KiB
Go
80 lines
2.5 KiB
Go
package engine
|
|
|
|
import "testing"
|
|
|
|
func TestSecretPathCollectionKeepsParsedContributions(t *testing.T) {
|
|
for _, pointer := range []string{"", "/", "/records/0", "/records/a~1b~0/01"} {
|
|
t.Run(pointer, func(t *testing.T) {
|
|
paths := make(map[string]Path)
|
|
for repeat := 0; repeat < 3; repeat++ {
|
|
addSecretPath(paths, pointer)
|
|
path, found := paths[pointer]
|
|
if !found || !path.valid() || path.String() != pointer {
|
|
t.Fatalf("collected path = %#v, found %v; want %q", path, found, pointer)
|
|
}
|
|
for _, segment := range path.segments {
|
|
if segment.kind != pathSegmentParsed {
|
|
t.Fatalf("collected path %q retained a typed segment: %#v", pointer, segment)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSecretClassificationParsesTypedHistoryAfterNumericShapeChanges(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
earlier string
|
|
final string
|
|
historical Path
|
|
}{
|
|
{"mapping to sequence", "items: {'0': old}", "items: [new]", Keys("items", "0")},
|
|
{"sequence to mapping", "items: [old]", "items: {'0': new}", Keys("items").Index(0)},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
earlier := parseCompositionDocument(t, "earlier", test.earlier)
|
|
final := parseCompositionDocument(t, "final", test.final)
|
|
pointer := test.historical.String()
|
|
metadata := Metadata{history: map[string][]Change{pointer: {{Path: test.historical}}}}
|
|
seen := false
|
|
classified := classifySecretPaths(nil, func(path Path) bool {
|
|
if path.String() != pointer {
|
|
return false
|
|
}
|
|
seen = true
|
|
for _, segment := range path.segments {
|
|
if segment.kind != pathSegmentParsed {
|
|
t.Fatalf("predicate received typed history after final projection: %#v", path)
|
|
}
|
|
}
|
|
return true
|
|
}, metadata, final, []historyApplication{{value: earlier}}, earlier)
|
|
if !seen || !classified[pointer] {
|
|
t.Fatalf("historical/final numeric path was not classified: %#v", classified)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSecretPredicateReceivesDetachedHistoricalPath(t *testing.T) {
|
|
path := Keys("records").Key("1")
|
|
metadata := Metadata{history: map[string][]Change{
|
|
path.String(): {{Path: path}},
|
|
}}
|
|
seen := false
|
|
classified := classifySecretPaths(nil, func(candidate Path) bool {
|
|
if candidate.String() != path.String() {
|
|
return false
|
|
}
|
|
seen = true
|
|
candidate.segments[0].key = "changed"
|
|
return true
|
|
}, metadata, nil, nil)
|
|
|
|
if !seen || !classified[path.String()] || classified["/changed/1"] {
|
|
t.Fatalf("classification after predicate mutation = %#v, predicate called: %v", classified, seen)
|
|
}
|
|
}
|