270 lines
10 KiB
Go
270 lines
10 KiB
Go
package registry
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"reflect"
|
|
"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"
|
|
npccodec "gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/codec/npcs"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/modules/dnd/npcs/identity"
|
|
)
|
|
|
|
func TestResolveUnboundRegistryHasExactEmptyProjection(t *testing.T) {
|
|
registry, err := Resolve(contracts.ReferenceSet{})
|
|
if err != nil {
|
|
t.Fatalf("Resolve() error = %v", err)
|
|
}
|
|
input := registry.PromptInput()
|
|
if registry.Bound() || registry.Digest() != "" || registry.Count() != 0 || string(input.Content) != emptyPrompt {
|
|
t.Fatalf("registry = %#v input = %#v, want unbound empty registry", registry, input)
|
|
}
|
|
if registry.ProjectionDigest() == "" || input.Digest != registry.ProjectionDigest() || input.OriginURI != "" {
|
|
t.Fatalf("projection digest/input = %q/%#v", registry.ProjectionDigest(), input)
|
|
}
|
|
}
|
|
|
|
func TestResolveKeepsDurableProvenanceAndProjectsOnlyOrderedNames(t *testing.T) {
|
|
list := registryFixture()
|
|
registry := resolveList(t, list)
|
|
if !registry.Bound() || registry.Digest() == "" || registry.Count() != 2 {
|
|
t.Fatalf("registry identity = bound %t digest %q count %d", registry.Bound(), registry.Digest(), registry.Count())
|
|
}
|
|
if got := string(registry.PromptInput().Content); got != `{"npcs":[{"name":"Mira Thorn"},{"name":"Captain Vale"}]}` {
|
|
t.Fatalf("prompt projection = %s", got)
|
|
}
|
|
for _, forbidden := range []string{"npc:sha256:", "source_refs", "source_id", "session-alpha"} {
|
|
if strings.Contains(string(registry.PromptInput().Content), forbidden) {
|
|
t.Fatalf("projection leaked %q: %s", forbidden, registry.PromptInput().Content)
|
|
}
|
|
}
|
|
if registry.PromptInput().Digest != registry.ProjectionDigest() || registry.Digest() == registry.ProjectionDigest() {
|
|
t.Fatalf("full/projection digests = %q/%q", registry.Digest(), registry.ProjectionDigest())
|
|
}
|
|
}
|
|
|
|
func TestNameProjectionDigestTracksOnlyNamesAndOrder(t *testing.T) {
|
|
base := registryFixture()
|
|
evidenceChanged := registryFixture()
|
|
evidenceChanged.NPCs[0].ID = "different application id"
|
|
evidenceChanged.NPCs[0].SourceRefs = []source.SourceRef{{SourceID: "other", StartUnitID: 40, EndUnitID: 41}}
|
|
baseBytes, err := nameProjection(base)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
changedBytes, err := nameProjection(evidenceChanged)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !bytes.Equal(baseBytes, changedBytes) || semanticDigest(baseBytes) != semanticDigest(changedBytes) {
|
|
t.Fatalf("equivalent name projections differ: %s / %s", baseBytes, changedBytes)
|
|
}
|
|
|
|
nameChanged := registryFixture()
|
|
nameChanged.NPCs[0].Name = "The Greencloak"
|
|
nameBytes, _ := nameProjection(nameChanged)
|
|
orderChanged := registryFixture()
|
|
orderChanged.NPCs[0], orderChanged.NPCs[1] = orderChanged.NPCs[1], orderChanged.NPCs[0]
|
|
orderBytes, _ := nameProjection(orderChanged)
|
|
if bytes.Equal(baseBytes, nameBytes) || bytes.Equal(baseBytes, orderBytes) {
|
|
t.Fatalf("name/order changes did not change projection: %s %s %s", baseBytes, nameBytes, orderBytes)
|
|
}
|
|
}
|
|
|
|
func TestRegistryLookupAndAccessorsAreImmutable(t *testing.T) {
|
|
registry := resolveList(t, registryFixture())
|
|
if npc, ok := registry.Lookup(" mIRA\u2003thorn "); !ok || npc.Name != "Mira Thorn" {
|
|
t.Fatalf("Lookup() = %#v, %t", npc, ok)
|
|
}
|
|
if _, ok := registry.Lookup("The Greencloak"); ok {
|
|
t.Fatal("Lookup() accepted a non-canonical name")
|
|
}
|
|
|
|
npcs := registry.NPCs()
|
|
npcs[0].Name = "changed"
|
|
npcs[0].SourceRefs[0].SourceID = "changed"
|
|
content := registry.CanonicalBytes()
|
|
content[0] = '['
|
|
input := registry.PromptInput()
|
|
input.Content[0] = '['
|
|
if next := registry.NPCs()[0]; next.Name != "Mira Thorn" || next.SourceRefs[0].SourceID != "session-alpha" {
|
|
t.Fatalf("registry mutated through accessor: %#v", next)
|
|
}
|
|
if registry.CanonicalBytes()[0] != '{' || registry.PromptInput().Content[0] != '{' {
|
|
t.Fatal("registry bytes mutated through accessor")
|
|
}
|
|
}
|
|
|
|
func TestResolveRejectsMalformedOrUnsupportedRegistryInput(t *testing.T) {
|
|
for _, item := range []contracts.ReferenceItem{
|
|
{MediaType: "application/json", Content: []byte(`{"npcs":[`)},
|
|
{MediaType: "text/plain", Content: []byte(`{"npcs":[]}`)},
|
|
} {
|
|
_, err := Resolve(referenceSet(item))
|
|
if err == nil {
|
|
t.Fatalf("Resolve(%s) error = nil", item.Content)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResolverReusesEquivalentCanonicalRegistries(t *testing.T) {
|
|
set := listReferenceSet(t, registryFixture())
|
|
resolver, err := NewResolver(set)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
resolved, err := resolver.Resolve(set)
|
|
if err != nil || resolved != resolver.Seeded() {
|
|
t.Fatalf("Resolve() = %p, %v; seeded %p", resolved, err, resolver.Seeded())
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
|
|
valid := listReferenceSet(t, registryFixture())
|
|
validContent := valid.Slots[ReferenceSlot].Items[0].Content
|
|
invalidSets := []contracts.ReferenceSet{
|
|
referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: []byte(`{"npcs":[`)}),
|
|
referenceSet(contracts.ReferenceItem{MediaType: "text/plain", Content: validContent}),
|
|
referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: make([]byte, MaxBytes+1)}),
|
|
referenceSet(
|
|
contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: validContent},
|
|
contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: 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(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: staticContent})
|
|
seeded, err := NewResolver(staticReferences)
|
|
if err != nil {
|
|
t.Fatal(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 TestResolverCachesEquivalentRegistriesConcurrentlyAndIgnoresCallerDigest(t *testing.T) {
|
|
resolver, err := NewResolver(referenceSet())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
content := listReferenceSet(t, registryFixture()).Slots[ReferenceSlot].Items[0].Content
|
|
references := referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: content})
|
|
first, err := resolver.Resolve(references)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
second, err := resolver.Resolve(references)
|
|
if err != nil || second != first {
|
|
t.Fatalf("raw reuse = %p / %p, %v", first, second, err)
|
|
}
|
|
spaced := append([]byte("\n "), content...)
|
|
spaced = append(spaced, '\n')
|
|
equivalent, err := resolver.Resolve(referenceSet(contracts.ReferenceItem{MediaType: "APPLICATION/JSON; charset=utf-8", Content: spaced}))
|
|
if err != nil || equivalent != first {
|
|
t.Fatalf("semantic reuse = %p / %p, %v", first, equivalent, err)
|
|
}
|
|
|
|
const callers = 24
|
|
var group sync.WaitGroup
|
|
errors := make(chan error, callers)
|
|
for range callers {
|
|
group.Add(1)
|
|
go func() {
|
|
defer group.Done()
|
|
resolved, err := resolver.Resolve(references)
|
|
if err != nil || resolved != first {
|
|
errors <- fmt.Errorf("resolved %p, want %p: %w", resolved, first, err)
|
|
}
|
|
}()
|
|
}
|
|
group.Wait()
|
|
close(errors)
|
|
for err := range errors {
|
|
t.Error(err)
|
|
}
|
|
|
|
sharedDigest := "sha256:" + strings.Repeat("0", 64)
|
|
firstItem := contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: content, Digest: sharedDigest}
|
|
otherList := registryFixture()
|
|
otherList.NPCs[0].Name = "The Greencloak"
|
|
otherList.NPCs[0].ID = identity.DeriveID(otherList.NPCs[0].Name)
|
|
otherContent := listReferenceSet(t, otherList).Slots[ReferenceSlot].Items[0].Content
|
|
otherItem := contracts.ReferenceItem{MediaType: npccodec.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)
|
|
}
|
|
|
|
content[0] = '['
|
|
if npc, ok := first.Lookup("Mira Thorn"); !ok || npc.Name != "Mira Thorn" {
|
|
t.Fatalf("resolved registry retained operation bytes: %#v, %t", npc, 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.NPCList {
|
|
return dnd.NPCList{NPCs: []dnd.NPC{
|
|
{ID: identity.DeriveID("Mira Thorn"), Name: "Mira Thorn", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 1, EndUnitID: 2}}},
|
|
{ID: identity.DeriveID("Captain Vale"), Name: "Captain Vale", SourceRefs: []source.SourceRef{{SourceID: "session-alpha", StartUnitID: 3, EndUnitID: 3}}},
|
|
}}
|
|
}
|
|
|
|
func resolveList(t *testing.T, list dnd.NPCList) *Registry {
|
|
t.Helper()
|
|
registry, err := Resolve(listReferenceSet(t, list))
|
|
if err != nil {
|
|
t.Fatalf("Resolve() error = %v", err)
|
|
}
|
|
return registry
|
|
}
|
|
|
|
func listReferenceSet(t *testing.T, list dnd.NPCList) contracts.ReferenceSet {
|
|
t.Helper()
|
|
content, err := npccodec.New().Encode(list)
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v", err)
|
|
}
|
|
return referenceSet(contracts.ReferenceItem{SlotName: ReferenceSlot, MediaType: npccodec.MediaType, Content: content})
|
|
}
|
|
|
|
func referenceSet(items ...contracts.ReferenceItem) contracts.ReferenceSet {
|
|
return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: items}}}
|
|
}
|
|
|
|
func TestProjectionIsStableForEquivalentNormalizedRegistries(t *testing.T) {
|
|
first := resolveList(t, registryFixture())
|
|
secondList := registryFixture()
|
|
secondList.NPCs[0].SourceRefs = append(secondList.NPCs[0].SourceRefs, source.SourceRef{SourceID: "session-beta", StartUnitID: 8, EndUnitID: 8})
|
|
second := resolveList(t, secondList)
|
|
if !reflect.DeepEqual(first.PromptInput().Content, second.PromptInput().Content) || first.ProjectionDigest() != second.ProjectionDigest() || first.Digest() == second.Digest() {
|
|
t.Fatalf("projection/full identity mismatch: %#v %#v", first, second)
|
|
}
|
|
}
|