eric/notarius
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Migrate location registry to shared resolver

Browse Source
This commit is contained in:
Eric Rakestraw
2026-08-04 13:30:12 +00:00
parent 7f28899730
commit f5fd115046
2 changed files with 102 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
internal/modules/dnd/locations/registry/registry_test.go
View File

@@ -100,18 +100,47 @@ func TestResolveRejectsInvalidReferenceInputs(t *testing.T) {
}
}
func TestNewResolverValidatesStaticReferenceBeforeOperations(t *testing.T) {
if _, err := NewResolver(referenceSet(item([]byte(`{"locations":[`)))); err == nil || !strings.Contains(err.Error(), "invalid approved") {
t.Fatalf("NewResolver() error = %v, want malformed static reference failure", err)
func TestResolverValidatesStaticAndOperationReferences(t *testing.T) {
placeholder, err := NewResolver(referenceSet())
if err != nil || placeholder.Seeded().Bound() {
t.Fatalf("generated placeholder = %#v, %v; want unbound seed", placeholder, err)
}
resolver, err := NewResolver(referenceSet(item(encodeList(t, registryFixture()))))
if err != nil || !resolver.Seeded().Bound() || resolver.Seeded().Count() != 2 {
t.Fatalf("NewResolver() = %#v, %v", resolver, err)
validContent := encodeList(t, registryFixture())
invalidSets := []contracts.ReferenceSet{
referenceSet(item([]byte(`{"locations":[`))),
referenceSet(contracts.ReferenceItem{MediaType: "text/plain", Content: validContent}),
referenceSet(item(make([]byte, MaxBytes+1))),
referenceSet(item(validContent), item(validContent)),
}
for index, references := range invalidSets {
if _, err := NewResolver(references); err == nil {
t.Fatalf("NewResolver(invalid %d) error = nil", index)
}
if _, err := placeholder.Resolve(references); err == nil {
t.Fatalf("Resolve(invalid %d) error = nil", index)
}
}
staticContent := append([]byte(nil), validContent...)
staticReferences := referenceSet(item(staticContent))
seeded, err := NewResolver(staticReferences)
if err != nil {
t.Fatal(err)
}
resolved, err := seeded.Resolve(staticReferences)
if err != nil || resolved != seeded.Seeded() {
t.Fatalf("seed reuse = %p / %p, %v", resolved, seeded.Seeded(), err)
}
staticContent[0] = '['
delete(staticReferences.Slots, ReferenceSlot)
if seeded.Seeded().Count() != 2 || seeded.Seeded().CanonicalBytes()[0] != '{' {
t.Fatalf("seeded registry retained construction references: %#v", seeded.Seeded())
}
}
func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *testing.T) {
resolver, err := NewResolver(contracts.ReferenceSet{})
func TestResolverCachesEquivalentRegistriesConcurrentlyAndIgnoresCallerDigest(t *testing.T) {
resolver, err := NewResolver(referenceSet())
if err != nil {
t.Fatal(err)
}
@@ -130,7 +159,7 @@ func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *tes
}
spaced := append([]byte("\n "), content...)
spaced = append(spaced, '\n')
third, err := resolver.Resolve(referenceSet(item(spaced)))
third, err := resolver.Resolve(referenceSet(contracts.ReferenceItem{MediaType: "APPLICATION/JSON; charset=utf-8", Content: spaced}))
if err != nil || third != first {
t.Fatalf("semantic cache Resolve() = %p, %p, %v", first, third, err)
}
@@ -153,13 +182,29 @@ func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *tes
t.Error(err)
}
firstSet.Slots[ReferenceSlot].Items[0].Content[0] = '['
if registry, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || registry != resolver.Seeded() || registry.Count() != 0 {
t.Fatalf("caller bytes affected resolver: %#v, %v", registry, err)
sharedDigest := "sha256:" + strings.Repeat("0", 64)
firstItem := contracts.ReferenceItem{MediaType: locationcodec.MediaType, Content: content, Digest: sharedDigest}
otherList := registryFixture()
otherList.Locations[0].Name = "Moon Gate"
otherList.Locations[0].ID = identity.DeriveID(otherList.Locations[0].Name, otherList.Locations[0].SourceRefs)
otherContent := encodeList(t, otherList)
otherItem := contracts.ReferenceItem{MediaType: locationcodec.MediaType, Content: otherContent, Digest: sharedDigest}
byDigestFirst, err := resolver.Resolve(referenceSet(firstItem))
if err != nil {
t.Fatal(err)
}
byDigestOther, err := resolver.Resolve(referenceSet(otherItem))
if err != nil || byDigestFirst == byDigestOther || byDigestFirst.Digest() == byDigestOther.Digest() {
t.Fatalf("caller digest aliased different registries: %p / %p, %v", byDigestFirst, byDigestOther, err)
}
firstSet.Slots[ReferenceSlot].Items[0].Content[0] = '['
if got, ok := first.Lookup(registryFixture().Locations[0].ID); !ok || got.Name != "The Tavern" {
t.Fatalf("cached registry retained caller bytes: %#v, %t", got, ok)
}
if fallback, err := resolver.Resolve(contracts.ReferenceSet{}); err != nil || fallback != resolver.Seeded() || fallback.Bound() {
t.Fatalf("fallback = %#v, %v; want unbound seed", fallback, err)
}
}
func registryFixture() dnd.LocationList {