199 lines
7.5 KiB
Go
199 lines
7.5 KiB
Go
package registry
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd"
|
|
locationcodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/locations"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/locations/identity"
|
|
)
|
|
|
|
func TestResolveUnboundRegistryHasEmptyProjection(t *testing.T) {
|
|
registry, err := Resolve(contracts.ReferenceSet{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
input := registry.PromptInput()
|
|
if registry.Bound() || registry.Digest() != "" || registry.Count() != 0 || string(input.Content) != emptyPrompt {
|
|
t.Fatalf("unbound registry = %#v, input = %#v", registry, input)
|
|
}
|
|
if registry.ProjectionDigest() == "" || input.Digest != registry.ProjectionDigest() || input.OriginURI != "" {
|
|
t.Fatalf("projection digest/input = %q/%#v", registry.ProjectionDigest(), input)
|
|
}
|
|
}
|
|
|
|
func TestResolveProjectsOrderedLocationsWithoutEvidence(t *testing.T) {
|
|
registry := resolveList(t, registryFixture())
|
|
if !registry.Bound() || registry.Count() != 2 || registry.Digest() == "" {
|
|
t.Fatalf("registry identity = bound %t count %d digest %q", registry.Bound(), registry.Count(), registry.Digest())
|
|
}
|
|
projection := string(registry.PromptInput().Content)
|
|
if !strings.Contains(projection, `"locations":[{"id":`) || !strings.Contains(projection, `"name":"The Tavern"`) || !strings.Contains(projection, `"name":"The Tavern"},{"id":`) {
|
|
t.Fatalf("projection ordering = %s", projection)
|
|
}
|
|
for _, forbidden := range []string{"source_refs", "source_id", "session-alpha"} {
|
|
if strings.Contains(projection, forbidden) {
|
|
t.Fatalf("projection leaked %q: %s", forbidden, projection)
|
|
}
|
|
}
|
|
if registry.PromptInput().Digest != registry.ProjectionDigest() || registry.Digest() == registry.ProjectionDigest() {
|
|
t.Fatalf("full/projection digests = %q/%q", registry.Digest(), registry.ProjectionDigest())
|
|
}
|
|
}
|
|
|
|
func TestRegistryLookupUsesIDAndReturnsDefensiveCopies(t *testing.T) {
|
|
registry := resolveList(t, registryFixture())
|
|
first := registry.Locations()[0]
|
|
if got, ok := registry.Lookup(first.ID); !ok || got.Name != first.Name || !registry.Matches(first.ID, first.Name) || registry.Matches(first.ID, "Other Tavern") {
|
|
t.Fatalf("ID lookup/match = %#v, %t", got, ok)
|
|
}
|
|
if _, ok := registry.Lookup("The Tavern"); ok {
|
|
t.Fatal("Lookup accepted a name as an ID")
|
|
}
|
|
|
|
locations := registry.Locations()
|
|
locations[0].Name = "changed"
|
|
locations[0].SourceRefs[0].SourceID = "changed"
|
|
canonical := registry.CanonicalBytes()
|
|
canonical[0] = '['
|
|
input := registry.PromptInput()
|
|
input.Content[0] = '['
|
|
if next, ok := registry.Lookup(first.ID); !ok || next.Name != first.Name || next.SourceRefs[0].SourceID != "session-alpha" {
|
|
t.Fatalf("registry mutated through accessor: %#v, %t", next, ok)
|
|
}
|
|
if registry.CanonicalBytes()[0] != '{' || registry.PromptInput().Content[0] != '{' {
|
|
t.Fatal("registry bytes mutated through accessor")
|
|
}
|
|
}
|
|
|
|
func TestResolveRejectsInvalidReferenceInputs(t *testing.T) {
|
|
valid := registryFixture()
|
|
content, err := locationcodec.New().Encode(valid)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
invalidIdentity := append([]byte(nil), content...)
|
|
invalidIdentity = bytes.Replace(invalidIdentity, []byte(valid.Locations[0].ID), []byte("location:sha256:0000000000000000000000000000000000000000000000000000000000000000"), 1)
|
|
for _, test := range []struct {
|
|
name string
|
|
set contracts.ReferenceSet
|
|
want string
|
|
}{
|
|
{"empty bound slot", referenceSet(), "exactly one item"},
|
|
{"multiple items", referenceSet(item(content), item(content)), "exactly one item"},
|
|
{"malformed JSON", referenceSet(item([]byte(`{"locations":[`))), "invalid approved"},
|
|
{"wrong media type", referenceSet(contracts.ReferenceItem{MediaType: "text/plain", Content: content}), "media type must be"},
|
|
{"oversized", referenceSet(item(make([]byte, MaxBytes+1))), "limit"},
|
|
{"invalid identity", referenceSet(item(invalidIdentity)), "id_mismatch"},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
if _, err := Resolve(test.set); err == nil || !strings.Contains(err.Error(), test.want) {
|
|
t.Fatalf("Resolve() error = %v, want %q", err, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
|
|
func TestResolverCachesRawAndSemanticallyEquivalentRegistriesConcurrently(t *testing.T) {
|
|
resolver, err := NewResolver(contracts.ReferenceSet{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
content, err := locationcodec.New().Encode(registryFixture())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
firstSet := referenceSet(item(content))
|
|
first, err := resolver.Resolve(firstSet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
second, err := resolver.Resolve(firstSet)
|
|
if err != nil || first != second {
|
|
t.Fatalf("raw cache Resolve() = %p, %p, %v", first, second, err)
|
|
}
|
|
spaced := append([]byte("\n "), content...)
|
|
spaced = append(spaced, '\n')
|
|
third, err := resolver.Resolve(referenceSet(item(spaced)))
|
|
if err != nil || third != first {
|
|
t.Fatalf("semantic cache Resolve() = %p, %p, %v", first, third, err)
|
|
}
|
|
|
|
var group sync.WaitGroup
|
|
errs := make(chan error, 24)
|
|
for range 24 {
|
|
group.Add(1)
|
|
go func() {
|
|
defer group.Done()
|
|
resolved, err := resolver.Resolve(firstSet)
|
|
if err != nil || resolved != first {
|
|
errs <- fmt.Errorf("resolved %p, want %p: %w", resolved, first, err)
|
|
}
|
|
}()
|
|
}
|
|
group.Wait()
|
|
close(errs)
|
|
for err := range errs {
|
|
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)
|
|
}
|
|
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)
|
|
}
|
|
}
|
|
|
|
func registryFixture() dnd.LocationList {
|
|
firstRefs := []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 1}}
|
|
secondRefs := []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 2, EndUnitID: 2}}
|
|
return dnd.LocationList{Locations: []dnd.Location{
|
|
{ID: identity.DeriveID("The Tavern", firstRefs), Name: "The Tavern", SourceRefs: firstRefs},
|
|
{ID: identity.DeriveID("The Tavern", secondRefs), Name: "The Tavern", SourceRefs: secondRefs},
|
|
}}
|
|
}
|
|
|
|
func resolveList(t *testing.T, list dnd.LocationList) *Registry {
|
|
t.Helper()
|
|
registry, err := Resolve(referenceSet(item(encodeList(t, list))))
|
|
if err != nil {
|
|
t.Fatalf("Resolve() error = %v", err)
|
|
}
|
|
return registry
|
|
}
|
|
|
|
func encodeList(t *testing.T, list dnd.LocationList) []byte {
|
|
t.Helper()
|
|
content, err := locationcodec.New().Encode(list)
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v", err)
|
|
}
|
|
return content
|
|
}
|
|
|
|
func item(content []byte) contracts.ReferenceItem {
|
|
return contracts.ReferenceItem{SlotName: ReferenceSlot, MediaType: locationcodec.MediaType, Content: content}
|
|
}
|
|
|
|
func referenceSet(items ...contracts.ReferenceItem) contracts.ReferenceSet {
|
|
return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: items}}}
|
|
}
|