C#: one registered type carries each schema id; a second claimant is refused typed

Registration refuses a type any of whose ids (its own, or one it declares
compatible) another registered type already owns or declares, with
CultSchemaConflictException naming the id, both schema names and both CLR types.
TypeScript already refuses this (cult-cache.ts); before, C# kept whichever type
registered first (Soul F4). An exact wire alias must now also declare the same
compatible ids: a type differing only in its declaration had it dropped when it
registered second (H4), and is refused the same way.

Exact aliases that agree in every respect still register by type, and a record
under their shared id still resolves to the first registered (H3). Removing that
would delete CultMesh's same-schema aliases; it is left for an operator ruling.

Tests: both registration orders for a shared compatible id, an owned id declared
by another type, and a same-schema type with a different declaration; an alias
with the same declaration still registers. The registry tests use the shared
EmittedDocumentTypes helper in place of their own.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-09-30 12:35:52 +02:00
commit 4182c2502b
2 changed files with 91 additions and 45 deletions

View file

@ -688,30 +688,34 @@ namespace GameCult.Caching
return descriptor;
}
if (string.Equals(schemaVersionOwner.SchemaId, descriptor.SchemaId, StringComparison.Ordinal))
throw SchemaIdClaimedTwice(descriptor.SchemaId, schemaVersionOwner, descriptor);
throw DuplicateSchemaRegistration(
$"schema name '{descriptor.SchemaName}' version '{descriptor.SchemaVersion}'",
schemaVersionOwner.DocumentType,
descriptor.DocumentType);
}
if (indexes.BySchemaId.TryGetValue(descriptor.SchemaId, out var schemaIdOwner))
// One type carries each schema id, its own or declared compatible, so which type a record resolves to never
// depends on the order types were registered in.
foreach (var carried in descriptor.CompatibleSchemaIds.Prepend(descriptor.SchemaId))
{
throw DuplicateSchemaRegistration(
$"schema id '{descriptor.SchemaId}'",
schemaIdOwner.DocumentType,
descriptor.DocumentType);
if (indexes.BySchemaId.TryGetValue(carried, out var claimant) || indexes.ByCompatibleSchemaId.TryGetValue(carried, out claimant))
throw SchemaIdClaimedTwice(carried, claimant, descriptor);
}
indexes.ByType[descriptor.DocumentType] = descriptor;
indexes.BySchemaId[descriptor.SchemaId] = descriptor;
foreach (var compatibleSchemaId in descriptor.CompatibleSchemaIds)
indexes.ByCompatibleSchemaId.TryAdd(compatibleSchemaId, descriptor);
indexes.ByCompatibleSchemaId[compatibleSchemaId] = descriptor;
indexes.BySchemaName[descriptor.SchemaName] = schemaNameVersions == null
? [descriptor]
: [.. schemaNameVersions, descriptor];
return descriptor;
}
// An alias is the same schema in every respect a store sees, including the ids it declares compatible: a type whose
// declaration differed would have it dropped by whichever registered second.
private static bool IsExactWireAlias(
CultDocumentDescriptor canonical,
CultDocumentDescriptor candidate) =>
@ -719,7 +723,20 @@ namespace GameCult.Caching
string.Equals(canonical.SchemaVersion, candidate.SchemaVersion, StringComparison.Ordinal) &&
string.Equals(canonical.SchemaId, candidate.SchemaId, StringComparison.Ordinal) &&
string.Equals(canonical.ContentHash, candidate.ContentHash, StringComparison.Ordinal) &&
string.Equals(canonical.CanonicalSchemaJson, candidate.CanonicalSchemaJson, StringComparison.Ordinal);
string.Equals(canonical.CanonicalSchemaJson, candidate.CanonicalSchemaJson, StringComparison.Ordinal) &&
canonical.CompatibleSchemaIds.SequenceEqual(candidate.CompatibleSchemaIds, StringComparer.Ordinal);
private static CultSchemaConflictException SchemaIdClaimedTwice(
string schemaId,
CultDocumentDescriptor existing,
CultDocumentDescriptor claimed) =>
new(
$"CultCache schema id '{schemaId}' is already carried by CLR type '{existing.DocumentType.FullName}' " +
$"(schema '{existing.SchemaName}') and cannot also be claimed by '{claimed.DocumentType.FullName}' " +
$"(schema '{claimed.SchemaName}'). A schema id, owned or declared compatible, belongs to one registered type.",
schemaId,
new[] { existing.SchemaName, claimed.SchemaName },
string.Empty);
private static InvalidOperationException DuplicateSchemaRegistration(
string identity,

View file

@ -1,9 +1,8 @@
using System;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Threading.Tasks;
using NUnit.Framework;
using static GameCult.Caching.Tests.EmittedDocumentTypes;
namespace GameCult.Caching.Tests;
@ -13,8 +12,8 @@ public sealed class CultDocumentRegistryTests
[Test]
public void ForTypesContainsOnlyExplicitDocuments()
{
var requested = CreateDocumentType("explicit", "tests.registry.explicit", "v1");
var unrelated = CreateDocumentType("unrelated", "tests.registry.unrelated", "v1");
var requested = Emit("explicit", "tests.registry.explicit", "v1");
var unrelated = Emit("unrelated", "tests.registry.unrelated", "v1");
var registry = CultDocumentRegistry.ForTypes(new[] { requested, requested });
@ -26,7 +25,7 @@ public sealed class CultDocumentRegistryTests
public void IdenticalTypeRegistrationIsIdempotent()
{
var registry = new CultDocumentRegistry();
var type = CreateDocumentType("idempotent", "tests.registry.idempotent", "v1");
var type = Emit("idempotent", "tests.registry.idempotent", "v1");
var first = registry.GetRequired(type);
var second = registry.GetRequired(type);
@ -38,8 +37,8 @@ public sealed class CultDocumentRegistryTests
public void ExactWireCompatibleAliasRegistersByTypeWithOneCanonicalSchemaDescriptor()
{
var registry = new CultDocumentRegistry();
var firstType = CreateDocumentType("alias_owner", "tests.registry.alias", "v1");
var aliasType = CreateDocumentType("alias_claimant", "tests.registry.alias", "v1");
var firstType = Emit("alias_owner", "tests.registry.alias", "v1");
var aliasType = Emit("alias_claimant", "tests.registry.alias", "v1");
var canonical = registry.GetRequired(firstType);
var alias = registry.GetRequired(aliasType);
@ -60,8 +59,8 @@ public sealed class CultDocumentRegistryTests
public void DifferentVersionsSharingSchemaNameRegisterWithoutReflectionOrderSelection()
{
var registry = new CultDocumentRegistry();
var firstType = CreateDocumentType("version_one", "tests.registry.versioned", "v1");
var secondType = CreateDocumentType("version_two", "tests.registry.versioned", "v2");
var firstType = Emit("version_one", "tests.registry.versioned", "v1");
var secondType = Emit("version_two", "tests.registry.versioned", "v2");
var first = registry.GetRequired(firstType);
var second = registry.GetRequired(secondType);
@ -90,12 +89,12 @@ public sealed class CultDocumentRegistryTests
public void IncompatibleTypesClaimingSameSchemaNameAndVersionFailBeforeMutation()
{
var registry = new CultDocumentRegistry();
var firstType = CreateDocumentType("layout_owner", "tests.registry.layout_collision", "v1");
var secondType = CreateDocumentType(
var firstType = Emit("layout_owner", "tests.registry.layout_collision", "v1");
var secondType = Emit(
"layout_claimant",
"tests.registry.layout_collision",
"v1",
addStringField: true);
new[] { new Field("Value", typeof(string), 0) });
var first = registry.GetRequired(firstType);
Assert.That(
@ -112,7 +111,7 @@ public sealed class CultDocumentRegistryTests
public void ConcurrentRefreshAndReadsObserveCompleteRegistrySnapshots()
{
var registry = new CultDocumentRegistry();
var type = CreateDocumentType("refresh_visible", "tests.registry.refresh_visible", "v1");
var type = Emit("refresh_visible", "tests.registry.refresh_visible", "v1");
var descriptor = registry.GetRequired(type);
Parallel.For(0, 20, _ =>
@ -123,33 +122,63 @@ public sealed class CultDocumentRegistryTests
});
}
private static Type CreateDocumentType(
string typeName,
string schemaName,
string schemaVersion,
bool addStringField = false)
// One type carries each schema id, owned or declared compatible, whichever order the types register in: a second claimant
// is refused, typed, naming both, and the registry keeps what it had.
private static void AssertSecondClaimRefused(Type first, Type second, string schemaId)
{
var assembly = AssemblyBuilder.DefineDynamicAssembly(
new AssemblyName("GameCult.Caching.RegistryTests." + Guid.NewGuid().ToString("N")),
AssemblyBuilderAccess.Run);
var module = assembly.DefineDynamicModule("main");
var type = module.DefineType(
typeName,
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed);
var attributeConstructor = typeof(CultDocumentAttribute).GetConstructor(new[] { typeof(string), typeof(string) })!;
type.SetCustomAttribute(new CustomAttributeBuilder(
attributeConstructor,
new object[] { schemaName, schemaVersion }));
type.SetCustomAttribute(new CustomAttributeBuilder(
typeof(global::MessagePack.MessagePackObjectAttribute).GetConstructor(new[] { typeof(bool) })!,
new object[] { false }));
if (addStringField)
var refusal = Assert.Throws<CultSchemaConflictException>(() => CultDocumentRegistry.ForTypes(new[] { first, second }))!;
Assert.Multiple(() =>
{
type.DefineField("Value", typeof(string), FieldAttributes.Public).SetCustomAttribute(new CustomAttributeBuilder(
typeof(global::MessagePack.KeyAttribute).GetConstructor(new[] { typeof(int) })!,
new object[] { 0 }));
}
Assert.That(refusal.SchemaId, Is.EqualTo(schemaId));
Assert.That(refusal.Message, Does.Contain(first.FullName).And.Contain(second.FullName));
});
return type.CreateType()!;
var registry = CultDocumentRegistry.ForTypes(new[] { first });
Assert.That(() => registry.GetRequired(second), Throws.TypeOf<CultSchemaConflictException>());
Assert.That(registry.AllDescriptors.Select(descriptor => descriptor.DocumentType), Is.EqualTo(new[] { first }));
}
[TestCase(false)]
[TestCase(true)]
public void TwoTypesDeclaringOneCompatibleIdAreRefused(bool reversed)
{
var a = Emit("declares_a", "tests.registry.declares_a", "v1", compatibleSchemaIds: new[] { "tests.registry.shared" });
var b = Emit("declares_b", "tests.registry.declares_b", "v1", compatibleSchemaIds: new[] { "tests.registry.shared" });
AssertSecondClaimRefused(reversed ? b : a, reversed ? a : b, "tests.registry.shared");
}
[TestCase(false)]
[TestCase(true)]
public void ATypeDeclaringAnIdAnotherTypeOwnsIsRefused(bool reversed)
{
var owner = Emit("owns", "tests.registry.owns", "v1");
var ownerId = CultDocumentRegistry.ForTypes(new[] { owner }).GetRequired(owner).SchemaId;
var lister = Emit("lists", "tests.registry.lists", "v1", compatibleSchemaIds: new[] { ownerId });
AssertSecondClaimRefused(reversed ? lister : owner, reversed ? owner : lister, ownerId);
}
// The same schema declaring different compatible ids is not an alias: whichever registered second would lose its declaration.
[TestCase(false)]
[TestCase(true)]
public void TheSameSchemaWithADifferentDeclarationIsNotAnAlias(bool reversed)
{
var bare = Emit("bare", "tests.registry.declared_alias", "v1");
var declaring = Emit("declaring", "tests.registry.declared_alias", "v1", compatibleSchemaIds: new[] { "tests.registry.older" });
var schemaId = CultDocumentRegistry.ForTypes(new[] { bare }).GetRequired(bare).SchemaId;
AssertSecondClaimRefused(reversed ? declaring : bare, reversed ? bare : declaring, schemaId);
}
[Test]
public void TheSameSchemaWithTheSameDeclarationIsAnAlias()
{
var first = Emit("declaring_first", "tests.registry.same_declaration", "v1", compatibleSchemaIds: new[] { "tests.registry.same_older" });
var second = Emit("declaring_second", "tests.registry.same_declaration", "v1", compatibleSchemaIds: new[] { "tests.registry.same_older" });
var registry = CultDocumentRegistry.ForTypes(new[] { first, second });
Assert.That(registry.GetRequired(second).SchemaId, Is.EqualTo(registry.GetRequired(first).SchemaId));
}
}