Migrate NPC registry to shared resolver

internal/modules/dnd/npcs/registry/registry_test.go

@@ -2,8 +2,10 @@ package registry
 
 import (
 	"bytes"
+	"fmt"
 	"reflect"
 	"strings"
+	"sync"
 	"testing"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
@@ -122,6 +124,111 @@ func TestResolverReusesEquivalentCanonicalRegistries(t *testing.T) {
 	}
 }
 
+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}}},
@@ -147,8 +254,8 @@ func listReferenceSet(t *testing.T, list dnd.NPCList) contracts.ReferenceSet {
 	return referenceSet(contracts.ReferenceItem{SlotName: ReferenceSlot, MediaType: npccodec.MediaType, Content: content})
 }
 
-func referenceSet(item contracts.ReferenceItem) contracts.ReferenceSet {
-	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: []contracts.ReferenceItem{item}}}}
+func referenceSet(items ...contracts.ReferenceItem) contracts.ReferenceSet {
+	return contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{ReferenceSlot: {Items: items}}}
 }
 
 func TestProjectionIsStableForEquivalentNormalizedRegistries(t *testing.T) {