diff --git a/src/GameCult.Caching/CultCache.cs b/src/GameCult.Caching/CultCache.cs index 48adc00b..afb35c23 100644 --- a/src/GameCult.Caching/CultCache.cs +++ b/src/GameCult.Caching/CultCache.cs @@ -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, diff --git a/tests/GameCult.Caching.Tests/CultDocumentRegistryTests.cs b/tests/GameCult.Caching.Tests/CultDocumentRegistryTests.cs index 2e061f47..6126146d 100644 --- a/tests/GameCult.Caching.Tests/CultDocumentRegistryTests.cs +++ b/tests/GameCult.Caching.Tests/CultDocumentRegistryTests.cs @@ -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(() => 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()); + 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)); } }