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:
parent
e163e6b006
commit
abf4f0387a
3 changed files with 194 additions and 0 deletions
|
|
@ -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]
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in a new issue