293 lines
13 KiB
Go
293 lines
13 KiB
Go
package engine
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
|
|
)
|
|
|
|
func TestCollectionPolicyWithoutValueRetainsIdentityAndMode(t *testing.T) {
|
|
lower := collectionPolicy{
|
|
identityFields: []string{"id"},
|
|
identityPresent: true,
|
|
explicitMode: sequenceModeAppend,
|
|
explicitModePresent: true,
|
|
}
|
|
lower.setRecordPolicy(newCollectionRecordPolicy())
|
|
current := collectionPolicy{explicitMode: sequenceModeReplace, explicitModePresent: true}
|
|
retained, diagnostics := collectionPolicyWithoutValue(&lower, current, nil, Keys("prompts"))
|
|
if len(diagnostics) != 0 || !retained.identityPresent || !reflect.DeepEqual(retained.identityFields, []string{"id"}) {
|
|
t.Fatalf("no-value replace reset identity: %#v, %#v", retained, diagnostics)
|
|
}
|
|
if retained.explicitMode != sequenceModeReplace || !retained.explicitModePresent || len(retained.recordOrder) != 1 {
|
|
t.Fatalf("no-value policy update lost mode or record ownership: %#v", retained)
|
|
}
|
|
retainedRecord, _ := retained.recordPolicyAt(0)
|
|
lowerRecord, _ := lower.recordPolicyAt(0)
|
|
if retainedRecord.owner != lowerRecord.owner {
|
|
t.Fatal("no-value policy update changed record ownership")
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyWithoutValueLeavesAbsentAndNonSequenceDestinationsUnconstrained(t *testing.T) {
|
|
current := collectionPolicy{identityFields: []string{"id"}, identityPresent: true}
|
|
for _, value := range []*document.Node{nil, parsePolicyNode(t, "value: scalar\n").Mapping[0].Value} {
|
|
retained, diagnostics := collectionPolicyWithoutValue(nil, current, value, Keys("prompts"))
|
|
if len(diagnostics) != 0 || !retained.identityPresent || !reflect.DeepEqual(retained.identityFields, []string{"id"}) {
|
|
t.Fatalf("pending identity at absent/non-sequence destination = %#v, %#v", retained, diagnostics)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyWithoutValueValidatesRetainedSequenceImmediately(t *testing.T) {
|
|
current := collectionPolicy{identityFields: []string{"id"}, identityPresent: true}
|
|
valid := parsePolicyNode(t, "items: [{id: one}, {id: two}]\n").Mapping[0].Value
|
|
retained, diagnostics := collectionPolicyWithoutValue(nil, current, valid, Keys("prompts"))
|
|
if len(diagnostics) != 0 || !retained.identityPresent {
|
|
t.Fatalf("valid retained records were rejected: %#v, %#v", retained, diagnostics)
|
|
}
|
|
|
|
invalid := parsePolicyNode(t, "items: [{name: missing-id}]\n").Mapping[0].Value
|
|
retained, diagnostics = collectionPolicyWithoutValue(nil, current, invalid, Keys("prompts"))
|
|
if !reflect.DeepEqual(retained, collectionPolicy{}) || len(diagnostics) != 1 || diagnostics[0].Code != CodeSequenceInvalid || diagnostics[0].Path.String() != "/prompts/0/id" {
|
|
t.Fatalf("invalid retained records = %#v, %#v", retained, diagnostics)
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyWithoutValueRejectsIdentityChange(t *testing.T) {
|
|
lower := collectionPolicy{identityFields: []string{"id"}, identityPresent: true}
|
|
current := collectionPolicy{identityFields: []string{"name"}, identityPresent: true}
|
|
retained, diagnostics := collectionPolicyWithoutValue(&lower, current, nil, Keys("prompts"))
|
|
if !reflect.DeepEqual(retained, collectionPolicy{}) || len(diagnostics) != 1 || diagnostics[0].Code != CodeSequenceConflict {
|
|
t.Fatalf("no-value identity change = %#v, %#v", retained, diagnostics)
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyLifetimePersistenceAndReplacementTable(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
current collectionPolicy
|
|
replaceValue bool
|
|
wantIdentity []string
|
|
wantIdentitySet bool
|
|
wantMode sequenceMode
|
|
wantRecords int
|
|
}{
|
|
{
|
|
name: "mode-only replace declaration does not reset retained identity",
|
|
current: collectionPolicy{
|
|
explicitMode: sequenceModeReplace, explicitModePresent: true,
|
|
},
|
|
wantIdentity: []string{"id"}, wantIdentitySet: true,
|
|
wantMode: sequenceModeReplace, wantRecords: 1,
|
|
},
|
|
{
|
|
name: "whole-sequence replacement resets lower identity",
|
|
replaceValue: true,
|
|
wantIdentitySet: false,
|
|
wantMode: sequenceModeAppend,
|
|
wantRecords: 0,
|
|
},
|
|
{
|
|
name: "replacement can establish a new identity",
|
|
current: collectionPolicy{identityFields: []string{"name"}, identityPresent: true},
|
|
replaceValue: true,
|
|
wantIdentity: []string{"name"},
|
|
wantIdentitySet: true,
|
|
wantMode: sequenceModeAppend,
|
|
wantRecords: 0,
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
lower := collectionPolicy{
|
|
identityFields: []string{"id"}, identityPresent: true,
|
|
explicitMode: sequenceModeAppend, explicitModePresent: true,
|
|
}
|
|
lower.setRecordPolicy(newCollectionRecordPolicy())
|
|
var got collectionPolicy
|
|
if test.replaceValue {
|
|
got = collectionPolicyForReplacement(&lower, test.current)
|
|
} else {
|
|
var diagnostics []Diagnostic
|
|
got, diagnostics = collectionPolicyWithoutValue(&lower, test.current, nil, Keys("prompts"))
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("policy diagnostics = %#v", diagnostics)
|
|
}
|
|
}
|
|
if got.identityPresent != test.wantIdentitySet || !reflect.DeepEqual(got.identityFields, test.wantIdentity) || got.explicitMode != test.wantMode || len(got.recordOrder) != test.wantRecords {
|
|
t.Fatalf("transition result = %#v", got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyValueReplacementResetsIdentityButRetainsExplicitMode(t *testing.T) {
|
|
lower := collectionPolicy{
|
|
identityFields: []string{"id"},
|
|
identityPresent: true,
|
|
explicitMode: sequenceModeAppend,
|
|
explicitModePresent: true,
|
|
}
|
|
lower.setRecordPolicy(newCollectionRecordPolicy())
|
|
current := collectionPolicy{identityFields: []string{"name"}, identityPresent: true}
|
|
replaced := collectionPolicyForReplacement(&lower, current)
|
|
if !replaced.identityPresent || !reflect.DeepEqual(replaced.identityFields, []string{"name"}) {
|
|
t.Fatalf("replacement identity was not reset: %#v", replaced)
|
|
}
|
|
if replaced.explicitMode != sequenceModeAppend || !replaced.explicitModePresent || len(replaced.recordOrder) != 0 {
|
|
t.Fatalf("replacement failed to retain explicit mode or retire lower record policy: %#v", replaced)
|
|
}
|
|
|
|
cleared := collectionPolicyForReplacement(&lower, collectionPolicy{})
|
|
if cleared.identityPresent || len(cleared.identityFields) != 0 || cleared.explicitMode != sequenceModeAppend || !cleared.explicitModePresent {
|
|
t.Fatalf("replacement without a new key did not clear YAML identity while retaining mode: %#v", cleared)
|
|
}
|
|
}
|
|
|
|
func TestCollectionRecordRetentionAndReplacementUseOpaqueOwners(t *testing.T) {
|
|
oldRecord := newCollectionRecordPolicy()
|
|
oldRecord.scope.set(Keys("steps"), collectionPolicy{identityFields: []string{"id"}, identityPresent: true})
|
|
retained := retainedCollectionRecordPolicy(oldRecord)
|
|
if retained.owner != oldRecord.owner {
|
|
t.Fatal("retained record did not keep its owner")
|
|
}
|
|
if got, ok := retained.scope.at(Keys("steps")); !ok || !got.identityPresent {
|
|
t.Fatalf("retained record lost its local policy: %#v, %t", got, ok)
|
|
}
|
|
if retained.scope.collections["/steps"].policy.identityFields[0] = "changed"; oldRecord.scope.collections["/steps"].policy.identityFields[0] != "id" {
|
|
t.Fatal("retained record policy aliases its source")
|
|
}
|
|
|
|
// A whole-record replacement at the same list position, even with equal
|
|
// authored identity/source metadata, receives new ownership and no old rules.
|
|
replacement := replacedCollectionRecordPolicy()
|
|
if replacement.owner == oldRecord.owner || len(replacement.scope.collections) != 0 {
|
|
t.Fatal("replacement record inherited discarded owner policy")
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyAncestorRetirementPreservesIndependentMode(t *testing.T) {
|
|
var scope collectionPolicyScope
|
|
owner := newCollectionRecordPolicy()
|
|
owner.scope.set(Keys("steps"), collectionPolicy{identityFields: []string{"id"}, identityPresent: true})
|
|
scope.set(Keys("catalog", "prompts"), collectionPolicyWithRecords(collectionPolicy{
|
|
identityFields: []string{"id"},
|
|
identityPresent: true,
|
|
explicitMode: sequenceModeAppend,
|
|
explicitModePresent: true,
|
|
}, owner))
|
|
scope.retireCollectionPoliciesAtOrBelow(Keys("catalog"))
|
|
policy, ok := scope.at(Keys("catalog", "prompts"))
|
|
if !ok || policy.identityPresent || len(policy.recordOrder) != 0 || policy.explicitMode != sequenceModeAppend || !policy.explicitModePresent {
|
|
t.Fatalf("ancestor retirement = %#v, %t", policy, ok)
|
|
}
|
|
reintroduced, diagnostics := collectionPolicyWithoutValue(&policy, collectionPolicy{}, nil, Keys("catalog", "prompts"))
|
|
if len(diagnostics) != 0 || reintroduced.identityPresent || reintroduced.explicitMode != sequenceModeAppend {
|
|
t.Fatalf("retired identity was resurrected while mode persisted: %#v, %#v", reintroduced, diagnostics)
|
|
}
|
|
}
|
|
|
|
func TestEqualOuterIdentitiesHaveDistinctRecordOwners(t *testing.T) {
|
|
retained := newCollectionRecordPolicy()
|
|
replacement := replacedCollectionRecordPolicy()
|
|
if retained.owner == replacement.owner {
|
|
t.Fatal("replacement with the same outer identity reused the old owner")
|
|
}
|
|
if retained.owner == nil || replacement.owner == nil {
|
|
t.Fatal("record owner token is missing")
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyScopesKeepRootAndItemRulesIndependent(t *testing.T) {
|
|
var root collectionPolicyScope
|
|
root.set(Keys("steps"), collectionPolicy{identityFields: []string{"root-id"}, identityPresent: true})
|
|
owner := newCollectionRecordPolicy()
|
|
owner.scope.set(Keys("steps"), collectionPolicy{identityFields: []string{"item-id"}, identityPresent: true})
|
|
root.set(Keys("items"), collectionPolicyWithRecords(collectionPolicy{}, owner))
|
|
|
|
root.retireCollectionPoliciesAtOrBelow(Keys("steps"))
|
|
rootPolicy, ok := root.at(Keys("steps"))
|
|
if !ok || rootPolicy.identityPresent {
|
|
t.Fatalf("root-local policy was not retired: %#v", rootPolicy)
|
|
}
|
|
itemPolicy, ok := root.at(Keys("items"))
|
|
if !ok || len(itemPolicy.recordOrder) != 1 {
|
|
t.Fatalf("unrelated item owner disappeared: %#v", itemPolicy)
|
|
}
|
|
itemRecord, _ := itemPolicy.recordPolicyAt(0)
|
|
nested, ok := itemRecord.scope.at(Keys("steps"))
|
|
if !ok || !nested.identityPresent || !reflect.DeepEqual(nested.identityFields, []string{"item-id"}) {
|
|
t.Fatalf("item-local policy was coupled to root destination: %#v", nested)
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyProjectionUsesConcretePlacement(t *testing.T) {
|
|
first := newCollectionRecordPolicy()
|
|
first.scope.set(Keys("steps"), collectionPolicy{identityFields: []string{"step"}, identityPresent: true})
|
|
second := newCollectionRecordPolicy()
|
|
second.scope.set(Keys("steps"), collectionPolicy{explicitMode: sequenceModeAppend, explicitModePresent: true})
|
|
var scope collectionPolicyScope
|
|
scope.set(Keys("items"), collectionPolicyWithRecords(collectionPolicy{}, first, second))
|
|
|
|
projected := projectCollectionPolicyScope(scope, Keys("mounted"))
|
|
if len(projected) != 3 {
|
|
t.Fatalf("projected policies = %#v", projected)
|
|
}
|
|
want := []string{"/mounted/items", "/mounted/items/0/steps", "/mounted/items/1/steps"}
|
|
for index, policy := range projected {
|
|
if policy.path.String() != want[index] {
|
|
t.Fatalf("projected path[%d] = %q, want %q", index, policy.path.String(), want[index])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCollectionPolicyInheritanceCopiesOwnersAndState(t *testing.T) {
|
|
owner := newCollectionRecordPolicy()
|
|
owner.scope.set(Keys("steps"), collectionPolicy{identityFields: []string{"id"}, identityPresent: true})
|
|
original := collectionPolicyWithRecords(collectionPolicy{}, owner)
|
|
copy := cloneCollectionPolicyForInheritance(original)
|
|
copyOwner := copy.recordOrder[0]
|
|
if copyOwner == owner.owner {
|
|
t.Fatal("inheritance copy retained the source record owner")
|
|
}
|
|
copy.recordPolicies[copyOwner].collections["/steps"].policy.identityFields[0] = "changed"
|
|
if owner.scope.collections["/steps"].policy.identityFields[0] != "id" {
|
|
t.Fatal("inheritance copy aliases source policy")
|
|
}
|
|
}
|
|
|
|
func TestAcquisitionScopeCloneOwnsCollectionPolicyCopy(t *testing.T) {
|
|
owner := newCollectionRecordPolicy()
|
|
owner.scope.set(Keys("steps"), collectionPolicy{identityFields: []string{"id"}, identityPresent: true})
|
|
var scope acquisitionScope
|
|
scope.collectionPolicies.set(Keys("items"), collectionPolicyWithRecords(collectionPolicy{}, owner))
|
|
cloned := cloneAcquisitionScope(scope)
|
|
clonedOwner := cloned.collectionPolicies.collections["/items"].policy.recordOrder[0]
|
|
cloned.collectionPolicies.collections["/items"].policy.recordPolicies[clonedOwner].collections["/steps"].policy.identityFields[0] = "changed"
|
|
sourceOwner := scope.collectionPolicies.collections["/items"].policy.recordOrder[0]
|
|
if scope.collectionPolicies.collections["/items"].policy.recordPolicies[sourceOwner].collections["/steps"].policy.identityFields[0] != "id" {
|
|
t.Fatal("acquisition scope clone aliases collection policy")
|
|
}
|
|
if clonedOwner != owner.owner {
|
|
t.Fatal("acquisition scope clone changed record ownership")
|
|
}
|
|
}
|
|
|
|
func collectionPolicyWithRecords(policy collectionPolicy, records ...collectionRecordPolicy) collectionPolicy {
|
|
for _, record := range records {
|
|
policy.setRecordPolicy(record)
|
|
}
|
|
return policy
|
|
}
|
|
|
|
func parsePolicyNode(t *testing.T, input string) *document.Node {
|
|
t.Helper()
|
|
parsed, diagnostics := parseSource(Bytes("collection-policy-state.yml", []byte(input)), "collection-policy-state", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("parse policy value: %#v", diagnostics)
|
|
}
|
|
return parsed.document
|
|
}
|