Improve D&D registry caching and retire the completed roadmap

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

@@ -2,10 +2,8 @@ package registry
 
 import (
 	"bytes"
-	"fmt"
 	"reflect"
 	"strings"
-	"sync"
 	"testing"
 
 	"gitea.maximumdirect.net/eric/notarius/internal/core/source"
@@ -114,17 +112,27 @@ func TestResolveRejectsMalformedOrUnsupportedRegistryInput(t *testing.T) {
 
 func TestResolverReusesEquivalentCanonicalRegistries(t *testing.T) {
 	set := listReferenceSet(t, registryFixture())
-	resolver, err := NewResolver(set)
+	resolver, err := NewResolver(contracts.ReferenceSet{})
 	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())
+	first, err := resolver.Resolve(set)
+	if err != nil {
+		t.Fatal(err)
+	}
+	content := set.Slots[ReferenceSlot].Items[0].Content
+	equivalent := append([]byte("\n "), content...)
+	equivalent = append(equivalent, '\n')
+	second, err := resolver.Resolve(referenceSet(contracts.ReferenceItem{
+		MediaType: "APPLICATION/JSON; charset=utf-8",
+		Content:   equivalent,
+	}))
+	if err != nil || second != first {
+		t.Fatalf("equivalent canonical registry = %p / %p, %v", first, second, err)
 	}
 }
 
-func TestResolverValidatesStaticAndOperationReferences(t *testing.T) {
+func TestResolverHandlesConstructionAndOperationReferences(t *testing.T) {
 	placeholder, err := NewResolver(referenceSet())
 	if err != nil || placeholder.Seeded().Bound() {
 		t.Fatalf("generated placeholder = %#v, %v; want unbound seed", placeholder, err)
@@ -132,22 +140,12 @@ func TestResolverValidatesStaticAndOperationReferences(t *testing.T) {
 
 	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},
-		),
+	malformed := referenceSet(contracts.ReferenceItem{MediaType: npccodec.MediaType, Content: []byte(`{"npcs":[`)})
+	if _, err := NewResolver(malformed); err == nil {
+		t.Fatal("NewResolver(malformed) error = nil")
 	}
-	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)
-		}
+	if _, err := placeholder.Resolve(malformed); err == nil {
+		t.Fatal("Resolve(malformed) error = nil")
 	}
 
 	staticContent := append([]byte(nil), validContent...)
@@ -161,71 +159,8 @@ func TestResolverValidatesStaticAndOperationReferences(t *testing.T) {
 	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)
+	if fallback, err := seeded.Resolve(contracts.ReferenceSet{}); err != nil || fallback != seeded.Seeded() {
+		t.Fatalf("fallback = %#v, %v; want seeded registry", fallback, err)
 	}
 }