Add shared sequence identity primitives
This commit is contained in:
209
internal/engine/sequence_identity_test.go
Normal file
209
internal/engine/sequence_identity_test.go
Normal file
@@ -0,0 +1,209 @@
|
||||
package engine
|
||||
|
||||
import (
|
||||
"math/big"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
|
||||
)
|
||||
|
||||
func TestNormalizeSequenceIdentityFields(t *testing.T) {
|
||||
got, err := normalizeSequenceIdentityFields([]string{"name", "id", "id", ""})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if want := []string{"", "id", "name"}; !reflect.DeepEqual(got, want) {
|
||||
t.Fatalf("normalized fields = %#v, want %#v", got, want)
|
||||
}
|
||||
if _, err := normalizeSequenceIdentityFields(nil); err == nil {
|
||||
t.Fatal("empty field set unexpectedly succeeded")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeSequenceIdentityNumbers(t *testing.T) {
|
||||
tests := []struct {
|
||||
left, right string
|
||||
equal bool
|
||||
}{
|
||||
{left: "1", right: "1.0", equal: true},
|
||||
{left: "1", right: "1e0", equal: true},
|
||||
{left: "0", right: "-0.000e999", equal: true},
|
||||
{left: "0.0012300", right: "123e-5", equal: true},
|
||||
{left: "9007199254740992", right: "9007199254740993", equal: false},
|
||||
{left: "1.0000000000000000001", right: "1.0000000000000000002", equal: false},
|
||||
}
|
||||
for _, test := range tests {
|
||||
left, leftErr := normalizeSequenceIdentityNumber(test.left)
|
||||
right, rightErr := normalizeSequenceIdentityNumber(test.right)
|
||||
if leftErr != nil || rightErr != nil {
|
||||
t.Fatalf("normalize(%q, %q) errors = %v, %v", test.left, test.right, leftErr, rightErr)
|
||||
}
|
||||
if (left == right) != test.equal {
|
||||
t.Errorf("normalize(%q) = %q; normalize(%q) = %q; equal = %t, want %t", test.left, left, test.right, right, left == right, test.equal)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestNormalizeSequenceIdentityNumberLargeExponentWithoutExpansion(t *testing.T) {
|
||||
exponent := "999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
|
||||
left, err := normalizeSequenceIdentityNumber("1e" + exponent)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
plusOne, ok := new(big.Int).SetString(exponent, 10)
|
||||
if !ok {
|
||||
t.Fatal("test exponent did not parse")
|
||||
}
|
||||
plusOne.Add(plusOne, big.NewInt(1))
|
||||
right, err := normalizeSequenceIdentityNumber("10e" + exponent)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if want := "1e" + plusOne.String(); right != want {
|
||||
t.Fatalf("normalized large exponent = %q, want %q", right, want)
|
||||
}
|
||||
if left == right {
|
||||
t.Fatal("unequal large exponents normalized to equal values")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSequenceIdentityTupleUsesTypeTagsAndLengthBoundaries(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
left []*document.Node
|
||||
right []*document.Node
|
||||
equal bool
|
||||
}{
|
||||
{name: "empty string differs from null", left: []*document.Node{stringNode("")}, right: []*document.Node{nullNode()}, equal: false},
|
||||
{name: "empty strings match exactly", left: []*document.Node{stringNode("")}, right: []*document.Node{stringNode("")}, equal: true},
|
||||
{name: "explicit null matches explicit null", left: []*document.Node{nullNode()}, right: []*document.Node{nullNode()}, equal: true},
|
||||
{name: "string and number differ", left: []*document.Node{stringNode("1")}, right: []*document.Node{numberNode("1.0")}, equal: false},
|
||||
{name: "boolean and number differ", left: []*document.Node{booleanNode("true")}, right: []*document.Node{numberNode("1")}, equal: false},
|
||||
{name: "compound boundaries are encoded", left: []*document.Node{stringNode("ab"), stringNode("c")}, right: []*document.Node{stringNode("a"), stringNode("bc")}, equal: false},
|
||||
{name: "number spelling is normalized", left: []*document.Node{numberNode("1")}, right: []*document.Node{numberNode("1e0")}, equal: true},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
left, leftErr := sequenceIdentityTuple(test.left)
|
||||
right, rightErr := sequenceIdentityTuple(test.right)
|
||||
if leftErr != nil || rightErr != nil {
|
||||
t.Fatalf("tuple errors = %v, %v", leftErr, rightErr)
|
||||
}
|
||||
if (left == right) != test.equal {
|
||||
t.Fatalf("tuple equality = %t, want %t", left == right, test.equal)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateSequenceIdentityUsesOneTupleIndexAndPreservesNodes(t *testing.T) {
|
||||
first := identityRecord(map[string]*document.Node{
|
||||
"namespace": stringNode("support"),
|
||||
"id": numberNode("1.0"),
|
||||
})
|
||||
second := identityRecord(map[string]*document.Node{
|
||||
"id": numberNode("1e0"),
|
||||
"namespace": stringNode("support"),
|
||||
})
|
||||
sequence := &document.Node{Kind: document.Sequence, Location: document.Location{SourceID: "source", Line: 1}, Sequence: []*document.Node{first, second}}
|
||||
_, diagnostics := validateSequenceIdentity(sequence, Keys("prompts"), []string{"namespace", "id", "id"}, sequenceIdentityDiagnosticCodes{invalid: CodeComposeInvalid, conflict: CodeComposeConflict})
|
||||
if len(diagnostics) != 1 {
|
||||
t.Fatalf("diagnostics = %#v, want one duplicate diagnostic", diagnostics)
|
||||
}
|
||||
diagnostic := diagnostics[0]
|
||||
if diagnostic.Code != CodeComposeConflict || diagnostic.Path.String() != "/prompts" || diagnostic.Primary == nil || len(diagnostic.Related) != 1 {
|
||||
t.Fatalf("duplicate diagnostic = %#v", diagnostic)
|
||||
}
|
||||
if diagnostic.Message == "" || strings.Contains(diagnostic.Message, "support") || strings.Contains(diagnostic.Message, "1.0") {
|
||||
t.Fatalf("diagnostic unexpectedly contains identity data: %#v", diagnostic)
|
||||
}
|
||||
if first.Mapping[0].Value.Text != "1.0" || second.Mapping[0].Value.Text != "1e0" {
|
||||
t.Fatalf("identity validation rewrote authored values: %q, %q", first.Mapping[0].Value.Text, second.Mapping[0].Value.Text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateSequenceIdentityReportsMalformedFieldsWithoutValues(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
item *document.Node
|
||||
wantPath string
|
||||
}{
|
||||
{name: "non-mapping item", item: stringNode("private"), wantPath: "/items/0"},
|
||||
{name: "missing field", item: identityRecord(map[string]*document.Node{"other": stringNode("private")}), wantPath: "/items/0/id"},
|
||||
{name: "mapping field", item: identityRecord(map[string]*document.Node{"id": {Kind: document.Mapping}}), wantPath: "/items/0/id"},
|
||||
{name: "sequence field", item: identityRecord(map[string]*document.Node{"id": {Kind: document.Sequence}}), wantPath: "/items/0/id"},
|
||||
}
|
||||
for _, test := range tests {
|
||||
t.Run(test.name, func(t *testing.T) {
|
||||
sequence := &document.Node{Kind: document.Sequence, Sequence: []*document.Node{test.item}}
|
||||
_, diagnostics := validateSequenceIdentity(sequence, Keys("items"), []string{"id"}, sequenceIdentityDiagnosticCodes{invalid: CodeOptionsInvalid, conflict: CodeComposeConflict})
|
||||
if len(diagnostics) != 1 || diagnostics[0].Code != CodeOptionsInvalid || diagnostics[0].Path.String() != test.wantPath {
|
||||
t.Fatalf("diagnostics = %#v", diagnostics)
|
||||
}
|
||||
if diagnostics[0].Message == "" || strings.Contains(diagnostics[0].Message, "private") {
|
||||
t.Fatalf("diagnostic exposed value or lacked message: %#v", diagnostics[0])
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestSequenceIdentityExcludesStructuralExtendsField(t *testing.T) {
|
||||
item := identityRecord(map[string]*document.Node{
|
||||
"extends": nullNode(),
|
||||
"name": stringNode("ordinary payload"),
|
||||
})
|
||||
sequence := &document.Node{Kind: document.Sequence, Sequence: []*document.Node{item}}
|
||||
_, diagnostics := validateSequenceIdentity(sequence, Keys("items"), []string{"extends"}, sequenceIdentityDiagnosticCodes{invalid: CodeComposeInvalid, conflict: CodeComposeConflict})
|
||||
if len(diagnostics) != 1 || diagnostics[0].Path.String() != "/items/0/extends" || diagnostics[0].Code != CodeComposeInvalid {
|
||||
t.Fatalf("diagnostics = %#v, want structural field treated as absent", diagnostics)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSequenceIdentityUsesLiteralPunctuationFieldNames(t *testing.T) {
|
||||
item := identityRecord(map[string]*document.Node{"metadata.id": stringNode("literal"), "metadata": identityRecord(map[string]*document.Node{"id": stringNode("nested")})})
|
||||
sequence := &document.Node{Kind: document.Sequence, Sequence: []*document.Node{item}}
|
||||
identities, diagnostics := validateSequenceIdentity(sequence, Keys("items"), []string{"metadata.id"}, sequenceIdentityDiagnosticCodes{invalid: CodeComposeInvalid, conflict: CodeComposeConflict})
|
||||
if len(diagnostics) != 0 {
|
||||
t.Fatalf("diagnostics = %#v", diagnostics)
|
||||
}
|
||||
if len(identities) != 1 {
|
||||
t.Fatalf("identity index has %d entries, want 1", len(identities))
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateSequenceIdentityUsesCallerDiagnosticCodes(t *testing.T) {
|
||||
item := identityRecord(map[string]*document.Node{"id": stringNode("same")})
|
||||
sequence := &document.Node{Kind: document.Sequence, Sequence: []*document.Node{item, document.Clone(item)}}
|
||||
_, diagnostics := validateSequenceIdentity(sequence, Keys("items"), []string{"id"}, sequenceIdentityDiagnosticCodes{invalid: CodeOptionsInvalid, conflict: CodeValidateMutation})
|
||||
if len(diagnostics) != 1 || diagnostics[0].Code != CodeValidateMutation {
|
||||
t.Fatalf("diagnostics = %#v, want caller-selected conflict code", diagnostics)
|
||||
}
|
||||
}
|
||||
|
||||
func identityRecord(fields map[string]*document.Node) *document.Node {
|
||||
entries := make([]document.Entry, 0, len(fields))
|
||||
keys := make([]string, 0, len(fields))
|
||||
for key := range fields {
|
||||
keys = append(keys, key)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
for _, key := range keys {
|
||||
value := fields[key]
|
||||
entries = append(entries, document.Entry{Key: key, Value: value, ValueLocation: value.Location})
|
||||
}
|
||||
return &document.Node{Kind: document.Mapping, Mapping: entries, Location: document.Location{SourceID: "source", Line: 2}}
|
||||
}
|
||||
|
||||
func stringNode(value string) *document.Node {
|
||||
return &document.Node{Kind: document.String, Text: value}
|
||||
}
|
||||
func numberNode(value string) *document.Node {
|
||||
return &document.Node{Kind: document.Number, Text: value}
|
||||
}
|
||||
func booleanNode(value string) *document.Node {
|
||||
return &document.Node{Kind: document.Boolean, Text: value}
|
||||
}
|
||||
func nullNode() *document.Node { return &document.Node{Kind: document.Null} }
|
||||
Reference in New Issue
Block a user