WriteOwnershipTests, ForeignRecordTests, VariantTests: pin the one-batch retype, the store-less refusal, the late declarer's removal and the rebase refusal

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-10-28 05:11:09 +01:00
commit abf4f0387a
3 changed files with 194 additions and 0 deletions

View file

@ -831,6 +831,26 @@ namespace GameCult.Caching.Tests
Assert.That(EmittedDocumentTypes.Read(reopened.Get(D)!, "Name"), Is.EqualTo("claimed"));
}
// The removal rule asks the registry as it is when the removal is judged: a record read-only at load becomes removable once a
// type that declares its id is registered. The write rule is not the removal rule (the test above): the late type may remove
// the record, and a removal is judged by what the registry declares, not by the type that last wrote the key.
[Test]
public void ATypeRegisteredAfterLoadThatDeclaresTheIdMakesTheRecordRemovable()
{
var path = OtherRuntimeStore("late-remove.cc");
var registry = CultDocumentRegistry.ForTypes(new[] { Deck });
using (var cache = Open(path, registry, directory: false))
{
Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch => batch.Remove(D)), "no registered type declares the id yet");
registry.GetRequired(LateClaimingDeck);
Assert.That(cache.Commit(batch => batch.Remove(D)), Is.True);
Assert.That(cache.Get(D), Is.Null);
}
Assert.That(Read(path).Records, Is.Empty);
}
// A commit onto the file that involves a variant is judged on the set the file will hold. A foreign record is not decoded
// for that judgement, so it neither fails the commit nor joins the set.
[Test]

View file

@ -282,6 +282,24 @@ namespace GameCult.Caching.Tests
Assert.That(load.Message, Does.Contain("other-variant").And.Contain("gear-base"));
}
// Rebasing a variant onto a base of another type would retype its key: refused with or without a store, the record untouched.
[Test]
public void ARebaseOntoABaseOfAnotherTypeIsRefusedWithoutAStore()
{
using var cache = new CultCache(Registry);
SeedBase(cache);
SeedBig(cache);
var other = new CultRecordKey("other");
cache.Commit(batch => batch.Upsert(typeof(VariantOther), new VariantOther { Name = "other" }, other));
var rebase = Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch => batch.UpsertVariant(BigKey, other)))!;
Assert.That(rebase.RecordKey, Is.EqualTo(BigKey.Value));
Assert.That(cache.GetStored(BigKey)!.Variant!.BaseKey, Is.EqualTo(BaseKey.Value));
Assert.That(cache.GetStored(BigKey)!.Descriptor.DocumentType, Is.EqualTo(typeof(VariantGear)));
Assert.Throws<CultSchemaConflictException>(() => cache.UpsertVariantAsync(BigKey, other).GetAwaiter().GetResult());
}
[Test]
public void AVariantOfAGlobalIsRefused()
{

View file

@ -252,5 +252,161 @@ namespace GameCult.Caching.Tests
Assert.That(reopened.GetStored(K1), Is.Null);
Assert.That(reopened.GetStored(K2)!.Descriptor.DocumentType, Is.EqualTo(typeof(WoB)), "the bystander is untouched");
}
// The ruling's retype: one batch holds the removal and the add, in the order they were called. The removal half is judged as a
// removal (a registered type's record is removable), and the record lands at the key.
[TestCaseSource(nameof(StoreKinds))]
public void ARetypeIsOneBatchHoldingTheRemovalAndTheAdd(bool directory)
{
var path = SeedAAtK1BAtK2(directory);
using (var cache = Open(path, directory, ABRegistry))
{
Assert.That(cache.Commit(batch =>
{
batch.Remove(K2);
batch.Upsert(new WoA { Name = "k2", Value = 9 }, new CultRecordHandle<WoA>(K2));
}), Is.True);
Assert.That(cache.GetStored(K2)!.Descriptor.DocumentType, Is.EqualTo(typeof(WoA)));
}
Assert.That(TypeAt(path, directory, ABRegistry, K2), Is.EqualTo(typeof(WoA)));
Assert.That(TypeAt(path, directory, ABRegistry, K1), Is.EqualTo(typeof(WoA)), "the bystander is untouched");
}
// The order is the meaning: a removal called after the add leaves the key removed.
[TestCaseSource(nameof(StoreKinds))]
public void ARemovalCalledAfterTheAddLeavesTheKeyRemoved(bool directory)
{
var path = SeedAAtK1BAtK2(directory);
using (var cache = Open(path, directory, ABRegistry))
{
Assert.That(cache.Commit(batch =>
{
batch.Remove(K2);
batch.Upsert(new WoA { Name = "k2", Value = 9 }, new CultRecordHandle<WoA>(K2));
batch.Remove(K2);
}), Is.True);
Assert.That(cache.GetStored(K2), Is.Null);
}
using var reopened = Open(path, directory, ABRegistry);
Assert.That(reopened.GetStored(K2), Is.Null);
}
// The removal half is a removal and nothing more: a record no registered type owns is not replaced by adding after its removal.
[TestCaseSource(nameof(StoreKinds))]
public void ARetypeOfARecordNoRegisteredTypeOwnsIsStillRefused(bool directory)
{
var path = SeedAAtK1BAtK2(directory);
var before = Fingerprint(path);
using (var cache = Open(path, directory, ARegistry))
{
Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch =>
{
batch.Remove(K2);
batch.Upsert(new WoA { Name = "k2", Value = 9 }, new CultRecordHandle<WoA>(K2));
}));
}
Assert.That(Fingerprint(path), Is.EqualTo(before));
}
// A removal of a key the cache does not hold is judged under the store's lock, and so is the add after it: another writer put
// B there, this cache never loaded it, and removing then adding A is a retype of whatever is stored.
[TestCaseSource(nameof(StoreKinds))]
public void ARetypeOfAKeyTheCacheDoesNotHoldCommitsInOneBatch(bool directory)
{
var path = PathFor(directory);
using var early = Open(path, directory, ABRegistry);
using (var other = Open(path, directory, ABRegistry))
Assert.That(other.Commit(batch => batch.Upsert(new WoB { Name = "k1", Value = 1 }, new CultRecordHandle<WoB>(K1))), Is.True);
Assert.That(early.Commit(batch =>
{
batch.Remove(K1);
batch.Upsert(new WoA { Name = "k1", Value = 2 }, new CultRecordHandle<WoA>(K1));
}), Is.True);
Assert.That(TypeAt(path, directory, ABRegistry, K1), Is.EqualTo(typeof(WoA)));
}
// A removal and an add called separately on the cache are one retype too: the add, staged after the removal, is not lost to the
// flush that judges it, and the type changes in the file.
[TestCaseSource(nameof(StoreKinds))]
public void AStagedRemovalAndAddOfAnotherTypeIsNotLostAtTheFlush(bool directory)
{
var path = SeedAAtK1BAtK2(directory);
using (var cache = Open(path, directory, ABRegistry))
{
Assert.That(cache.Remove(K2), Is.True);
cache.UpsertAsync(typeof(WoA), new WoA { Name = "k2", Value = 9 }, K2).GetAwaiter().GetResult();
cache.FlushAllBackingStores();
Assert.That(cache.GetStored(K2)!.Descriptor.DocumentType, Is.EqualTo(typeof(WoA)));
}
Assert.That(TypeAt(path, directory, ABRegistry, K2), Is.EqualTo(typeof(WoA)));
}
[TestCaseSource(nameof(StoreKinds))]
public void AStagedRemovalOfAKeyTheCacheDoesNotHoldAndAnAddOfAnotherTypeIsNotLostAtTheFlush(bool directory)
{
var path = PathFor(directory);
using var early = Open(path, directory, ABRegistry);
using (var other = Open(path, directory, ABRegistry))
Assert.That(other.Commit(batch => batch.Upsert(new WoB { Name = "k1", Value = 1 }, new CultRecordHandle<WoB>(K1))), Is.True);
Assert.That(early.Remove(K1), Is.False, "the cache holds nothing there");
early.UpsertAsync(typeof(WoA), new WoA { Name = "k1", Value = 2 }, K1).GetAwaiter().GetResult();
early.FlushAllBackingStores();
Assert.That(TypeAt(path, directory, ABRegistry, K1), Is.EqualTo(typeof(WoA)));
}
// A removal is spent by the flush that judged it: a later add of another type with no removal in front of it is refused as ever.
[TestCaseSource(nameof(StoreKinds))]
public void ARemovalIsSpentByTheFlushThatJudgedIt(bool directory)
{
var path = SeedAAtK1BAtK2(directory);
using var cache = Open(path, directory, ABRegistry);
Assert.That(cache.Remove(K2), Is.True);
cache.FlushAllBackingStores();
cache.UpsertAsync(typeof(WoB), new WoB { Name = "k2", Value = 4 }, K2).GetAwaiter().GetResult();
cache.FlushAllBackingStores();
Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch => batch.Upsert(new WoA { Name = "k2", Value = 5 }, new CultRecordHandle<WoA>(K2))));
Assert.That(TypeAt(path, directory, ABRegistry, K2), Is.EqualTo(typeof(WoB)));
}
// No store, same rule: a cache holding A and B refuses one's write over the other's record, on Commit and on UpsertAsync, and
// a retype is a removal and an add, in one batch or staged apart.
[Test]
public void AStorelessCacheRefusesToWriteOneRegisteredTypeOverAnothersRecord()
{
using var cache = new CultCache(ABRegistry);
Assert.That(cache.Commit(batch => batch.Upsert(new WoB { Name = "k2", Value = 2 }, new CultRecordHandle<WoB>(K2))), Is.True);
var commit = Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch => batch.Upsert(new WoA { Name = "k2", Value = 9 }, new CultRecordHandle<WoA>(K2))))!;
Assert.That(commit.RecordKey, Is.EqualTo(K2.Value));
Assert.Throws<CultSchemaConflictException>(() => cache.UpsertAsync(typeof(WoA), new WoA { Name = "k2", Value = 9 }, K2));
Assert.That(cache.GetStored(K2)!.Descriptor.DocumentType, Is.EqualTo(typeof(WoB)));
// The pair that differs only in the type written: B over B's own record.
Assert.That(cache.Commit(batch => batch.Upsert(new WoB { Name = "k2", Value = 3 }, new CultRecordHandle<WoB>(K2))), Is.True);
Assert.That(cache.Commit(batch =>
{
batch.Remove(K2);
batch.Upsert(new WoA { Name = "k2", Value = 9 }, new CultRecordHandle<WoA>(K2));
}), Is.True);
Assert.That(cache.GetStored(K2)!.Descriptor.DocumentType, Is.EqualTo(typeof(WoA)));
Assert.That(cache.Remove(K2), Is.True);
cache.UpsertAsync(typeof(WoB), new WoB { Name = "k2", Value = 4 }, K2).GetAwaiter().GetResult();
Assert.That(cache.GetStored(K2)!.Descriptor.DocumentType, Is.EqualTo(typeof(WoB)));
}
}
}