CultLib/tests/GameCult.Caching.Tests/ForeignRecordTests.cs
Meta Vens 15ccdbb953 Test: a staged write a commit landed is no longer staged
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-02 18:52:42 +02:00

735 lines
36 KiB
C#

#nullable enable
using System;
using System.IO;
using System.Linq;
using GameCult.Caching.MessagePack;
using NUnit.Framework;
using static GameCult.Caching.Tests.EmittedDocumentTypes;
namespace GameCult.Caching.Tests
{
// A record under a schema id no registered type owns or lists as compatible is foreign. CultCache never destroys or relabels
// it: both store kinds carry it byte for byte, list it as foreign, and refuse any write that would replace or remove it.
public class ForeignRecordTests
{
private static readonly Type Deck = Emit("ForeignSuiteDeck", "tests.foreign_deck", "tests.foreign_deck.v1", new[] { new Field("Name", typeof(string), 0, IsName: true) });
private static readonly Type Widget = Emit("ForeignSuiteWidget", "tests.foreign_widget", "tests.foreign_widget.v1", new[] { new Field("Label", typeof(string), 0, IsName: true) });
// A build that has both types, and one that has only the deck: to it the widget is foreign.
private static readonly CultDocumentRegistry Full = CultDocumentRegistry.ForTypes(new[] { Deck, Widget });
private static readonly CultDocumentRegistry DeckOnly = CultDocumentRegistry.ForTypes(new[] { Deck });
private static readonly string WidgetId = Full.GetRequired(Widget).SchemaId;
private static readonly CultRecordKey D = new("d");
private static readonly CultRecordKey E = new("e");
private static readonly CultRecordKey W = new("w");
private const string Canary = "CANARY-7f3c-payload-value";
public enum Write
{
Flush,
Commit,
ConditionalCommit
}
private string _directory = "";
[SetUp]
public void SetUp()
{
_directory = Path.Combine(Path.GetTempPath(), "cultlib-foreign-" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(_directory);
}
[TearDown]
public void TearDown()
{
if (Directory.Exists(_directory))
Directory.Delete(_directory, true);
}
private string PathOf(string name) => Path.Combine(_directory, name);
private static CultCache Open(string path, CultDocumentRegistry registry, bool directory) =>
CultCacheMessagePack.Create(path, new CultCacheOpenOptions { Registry = registry, UseDirectoryStore = directory });
private static object DeckOf(string name) => New(Deck, ("Name", name));
private static object WidgetOf(string label) => New(Widget, ("Label", label));
private static CultPersistedStoreSnapshot Read(string path) =>
CultDocumentMessagePackSerialization.DeserializeSnapshot(File.ReadAllBytes(path));
// Every file of the store, by name, with its bytes: a refused write leaves all of them as they were.
private static string[] Fingerprint(string path)
{
var files = new[] { path }.Concat(Directory.Exists(DirectoryMessagePackBackingStore.DefaultRecordDirectoryPath(path))
? Directory.GetFiles(DirectoryMessagePackBackingStore.DefaultRecordDirectoryPath(path), "*.msgpack")
: Array.Empty<string>())
.OrderBy(file => file, StringComparer.Ordinal);
return files.Select(file => Path.GetFileName(file) + ":" + Convert.ToBase64String(File.ReadAllBytes(file))).ToArray();
}
// What the store holds for one record as the file (single-file) or manifest (directory: the page hash) names it.
private static string Stored(string path, CultRecordKey key)
{
var record = Read(path).Records.Single(candidate => candidate.Key == key.Value);
return $"{record.SchemaId}|{record.StoredAt}|{Convert.ToBase64String(record.Payload)}|{record.Variant == null}";
}
// A store holding a deck d and a widget w, written by the build that has both types.
private string Seeded(string name, bool directory)
{
var path = PathOf(name);
using var cache = Open(path, Full, directory);
cache.Commit(batch =>
{
batch.Upsert(Deck, DeckOf("d"), D);
batch.Upsert(Widget, WidgetOf("w"), W);
});
return path;
}
private static CacheBackingStore StoreOf(CultCache cache) => cache.BackingStores.Single();
private static void Land(CultCache cache, Write write, CultRecordKey key, object document)
{
switch (write)
{
case Write.Flush:
cache.UpsertAsync(document.GetType(), document, key).GetAwaiter().GetResult();
cache.FlushAsync().GetAwaiter().GetResult();
break;
case Write.Commit:
Assert.That(cache.Commit(batch => batch.Upsert(document.GetType(), document, key)), Is.True);
break;
case Write.ConditionalCommit:
Assert.That(cache.Commit(batch =>
{
batch.Expect(D, cache.Get(D));
batch.Upsert(document.GetType(), document, key);
}), Is.True);
break;
}
}
private static void Refused(CultCache cache, Write write, CultRecordKey key, object document, CultRecordKey foreignKey)
{
var refusal = Assert.Throws<CultSchemaConflictException>(() => Land(cache, write, key, document))!;
Assert.Multiple(() =>
{
Assert.That(refusal.RecordKey, Is.EqualTo(foreignKey.Value));
Assert.That(refusal.SchemaId, Is.EqualTo(WidgetId));
Assert.That(refusal.SchemaNames, Is.EqualTo(new[] { "tests.foreign_widget" }));
Assert.That(refusal.Message, Does.Contain(foreignKey.Value).And.Contain(WidgetId));
Assert.That(refusal.Message, Does.Not.Contain(Canary), "a refusal never echoes the document it refused");
});
}
[TestCase(false)]
[TestCase(true)]
public void AForeignRecordLoadsAsForeignAndTheCacheDoesNotHoldIt(bool directory)
{
var path = Seeded("seeded.cc", directory);
var storedAt = Read(path).Records.Single(record => record.Key == W.Value).StoredAt;
using var cache = Open(path, DeckOnly, directory);
var foreign = StoreOf(cache).ForeignRecords.Single();
Assert.Multiple(() =>
{
Assert.That(foreign.Key, Is.EqualTo(W.Value));
Assert.That(foreign.SchemaId, Is.EqualTo(WidgetId));
Assert.That(foreign.SchemaName, Is.EqualTo("tests.foreign_widget"));
Assert.That(foreign.StoredAt, Is.EqualTo(storedAt));
Assert.That(cache.Get(W), Is.Null, "the cache never holds a foreign record");
Assert.That(EmittedDocumentTypes.Read(cache.Get(D)!, "Name"), Is.EqualTo("d"), "the records it claims load as usual");
});
}
// Every write path lays the foreign record back as the file holds it: the single-file store's whole view (a flush and an
// unconditional commit), its commit onto the file, and the directory store's generation.
[Test]
public void AWriteOfAnotherRecordKeepsTheForeignRecordByteForByte(
[Values(false, true)] bool directory,
[Values] Write write)
{
var path = Seeded("kept.cc", directory);
var before = Stored(path, W);
using (var cache = Open(path, DeckOnly, directory))
Land(cache, write, E, DeckOf("e"));
Assert.That(Stored(path, W), Is.EqualTo(before));
Assert.That(Read(path).Records.Select(record => record.Key), Is.EquivalentTo(new[] { "d", "e", "w" }));
using var full = Open(path, Full, directory);
Assert.That(EmittedDocumentTypes.Read(full.Get(W)!, "Label"), Is.EqualTo("w"), "the build that has the type still reads it");
Assert.That(StoreOf(full).ForeignRecords, Is.Empty);
}
[Test]
public void AWriteThatWouldReplaceAForeignRecordIsRefusedAndNothingIsWritten(
[Values(false, true)] bool directory,
[Values] Write write)
{
var path = Seeded("replace.cc", directory);
var before = Fingerprint(path);
using var cache = Open(path, DeckOnly, directory);
Refused(cache, write, W, DeckOf(Canary), W);
Assert.That(Fingerprint(path), Is.EqualTo(before));
Assert.That(cache.Get(W), Is.Null);
}
// Another writer replaced a record this cache holds with a record of a type it does not have. A write that would lay this
// cache's record over it is refused; the file keeps the other writer's record.
[TestCase(false)]
[TestCase(true)]
public void AWriteOverARecordAnotherWriterMadeForeignIsRefused(bool directory)
{
var path = Seeded("replaced.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var before = Fingerprint(path);
var refusal = Assert.Throws<CultSchemaConflictException>(() => Land(cache, Write.Flush, D, DeckOf(Canary)))!;
Assert.That(refusal.RecordKey, Is.EqualTo(D.Value));
Assert.That(refusal.Message, Does.Not.Contain(Canary));
Assert.That(Fingerprint(path), Is.EqualTo(before));
}
// A refusal does not poison the store: what the cache held for the refused record goes with the refusal, so a later write
// to another record lands and the file keeps the other writer's record.
[Test]
public void AfterARefusedWriteAWriteToAnotherRecordLands(
[Values(false, true)] bool directory,
[Values(Write.Flush, Write.Commit)] Write refused)
{
var path = Seeded("unstuck.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
Assert.Throws<CultSchemaConflictException>(() => Land(cache, refused, D, DeckOf(Canary)));
Land(cache, Write.Commit, E, DeckOf("e"));
Assert.That(Stored(path, D), Is.EqualTo(widget), "the other writer's record is as it was");
Assert.That(EmittedDocumentTypes.Read(cache.Get(E)!, "Name"), Is.EqualTo("e"));
Assert.That(Read(path).Records.Select(record => record.Key), Does.Contain("e"));
}
// The cache and the store agree on what a refusal left: the refused record is not served, not after a later write, not after
// a pull, and not by a fresh open. What the cache served before the refusal was never what the file holds.
[Test]
public void ARefusedRecordIsNotServedAfterTheRefusalAfterALaterWriteOrAfterAPull(
[Values(false, true)] bool directory,
[Values(Write.Flush, Write.Commit)] Write refused)
{
var path = Seeded("not-served.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var refusal = Assert.Throws<CultSchemaConflictException>(() => Land(cache, refused, D, DeckOf(Canary)))!;
Assert.That(refusal.Message, Does.StartWith("Record 'd' (schema id '" + WidgetId + "'"), "one refused key reads as one record");
var afterRefusal = cache.Get(D);
Land(cache, Write.Commit, E, DeckOf("e"));
var afterLaterWrite = cache.Get(D);
cache.PullAllBackingStoresAsync().GetAwaiter().GetResult();
var afterPull = cache.Get(D);
using var fresh = Open(path, DeckOnly, directory);
Assert.Multiple(() =>
{
Assert.That(afterRefusal, Is.Null, "after the refusal");
Assert.That(afterLaterWrite, Is.Null, "after a later write");
Assert.That(afterPull, Is.Null, "after a pull");
Assert.That(fresh.Get(D), Is.Null, "a fresh open");
Assert.That(StoreOf(cache).ForeignRecords.Select(record => record.Key), Is.EqualTo(StoreOf(fresh).ForeignRecords.Select(record => record.Key)));
});
}
// A refusal names every key it refused, and every one of them leaves the cache; a record the write did not touch stays.
[Test]
public void ARefusalOfSeveralRecordsNamesEachAndTheCacheDropsEach(
[Values(false, true)] bool directory,
[Values(Write.Flush, Write.Commit)] Write refused)
{
var path = PathOf("several.cc");
var d2 = new CultRecordKey("d2");
using (var seed = Open(path, Full, directory))
seed.Commit(batch =>
{
batch.Upsert(Deck, DeckOf("d"), D);
batch.Upsert(Deck, DeckOf("d2"), d2);
batch.Upsert(Deck, DeckOf("e"), E);
});
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch =>
{
batch.Upsert(Widget, WidgetOf("w1"), D);
batch.Upsert(Widget, WidgetOf("w2"), d2);
});
var refusal = Assert.Throws<CultSchemaConflictException>(() =>
{
if (refused == Write.Flush)
{
cache.UpsertAsync(Deck, DeckOf(Canary), D).GetAwaiter().GetResult();
cache.UpsertAsync(Deck, DeckOf(Canary), d2).GetAwaiter().GetResult();
cache.FlushAsync().GetAwaiter().GetResult();
}
else
{
cache.Commit(batch =>
{
batch.Upsert(Deck, DeckOf(Canary), D);
batch.Upsert(Deck, DeckOf(Canary), d2);
});
}
})!;
cache.PullAllBackingStoresAsync().GetAwaiter().GetResult();
Assert.Multiple(() =>
{
Assert.That(refusal.RecordKey, Is.EqualTo("d"), "the first refused key in key order");
Assert.That(refusal.Message, Does.Contain("Records 'd' (schema id '" + WidgetId + "'").And.Contain("'d2' (schema id '" + WidgetId + "'").And.Not.Contain(Canary));
Assert.That(cache.Get(D), Is.Null);
Assert.That(cache.Get(d2), Is.Null);
Assert.That(EmittedDocumentTypes.Read(cache.Get(E)!, "Name"), Is.EqualTo("e"), "a record the write did not touch stays");
});
}
// A write that never touches a record another writer made foreign is not refused for holding a stale copy of it: it lands
// the first time, in both store kinds, and the next pull drops the copy.
[Test]
public void AWriteThatNeverTouchedARecordAnotherWriterMadeForeignLandsAtOnce(
[Values(false, true)] bool directory,
[Values(Write.Flush, Write.Commit)] Write write)
{
var path = Seeded("untouched.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
Land(cache, write, E, DeckOf("e"));
cache.PullAllBackingStoresAsync().GetAwaiter().GetResult();
Assert.Multiple(() =>
{
Assert.That(Stored(path, D), Is.EqualTo(widget), "the other writer's record is as it was");
Assert.That(Read(path).Records.Select(record => record.Key), Does.Contain("e"));
Assert.That(cache.Get(D), Is.Null, "the pull drops the stale copy");
});
}
// The write carried the file's record for d; it did not store this cache's copy, so the copy's stamp is still what the
// cache read, and a condition on it still fails against the other writer's record.
[Test]
public void ACarriedForeignRecordDoesNotRestampTheStaleCopyTheCacheHolds(
[Values(false, true)] bool directory,
[Values(Write.Flush, Write.Commit)] Write write)
{
var path = Seeded("restamp.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
Land(cache, write, E, DeckOf("e"));
Assert.That(cache.Commit(batch =>
{
batch.Expect(D, cache.Get(D));
batch.Upsert(Deck, DeckOf("e2"), E);
}), Is.False, "the cache never read the other writer's record");
}
// The same when the stale copy was only held, never written: a flush after the other writer's record landed refuses once.
[Test]
public void AFlushRefusedForAStaleCopyOfAForeignRecordRefusesOnce([Values(false, true)] bool directory)
{
var path = Seeded("stale.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
Assert.Throws<CultSchemaConflictException>(() => Land(cache, Write.Commit, D, DeckOf(Canary)));
Land(cache, Write.Flush, E, DeckOf("e"));
Land(cache, Write.Flush, E, DeckOf("e again"));
Assert.That(Stored(path, D), Is.EqualTo(widget));
}
// A key staged and not yet written is refused by any write that carries it, whatever key that write names: an unconditional
// commit writes what a flush would.
[Test]
public void AStagedWriteIsRefusedByACommitOfAnotherRecord([Values(false, true)] bool directory)
{
var path = Seeded("staged-commit.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
cache.UpsertAsync(Deck, DeckOf(Canary), D).GetAwaiter().GetResult();
var refusal = Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch => batch.Upsert(Deck, DeckOf("e"), E)))!;
Assert.That(refusal.RecordKey, Is.EqualTo(D.Value));
Assert.That(Stored(path, D), Is.EqualTo(widget));
}
// What a write landed is no longer staged: a record that becomes foreign afterwards is the other writer's, and writing
// another record is not refused for it.
[Test]
public void AWrittenRecordIsNoLongerStagedSoALaterForeignRecordDoesNotRefuseOtherWrites(
[Values(false, true)] bool directory,
[Values(Write.Flush, Write.Commit)] Write landed)
{
var path = Seeded("landed.cc", directory);
using var cache = Open(path, DeckOnly, directory);
Land(cache, landed, D, DeckOf("d again"));
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
Land(cache, Write.Commit, E, DeckOf("e"));
Assert.That(Stored(path, D), Is.EqualTo(widget));
Assert.That(Read(path).Records.Select(record => record.Key), Does.Contain("e"));
}
// A commit writes the whole view, so what it landed that was staged is no longer staged either.
[Test]
public void AStagedWriteLandedByACommitIsNoLongerStaged([Values(false, true)] bool directory)
{
var path = Seeded("staged-landed.cc", directory);
using var cache = Open(path, DeckOnly, directory);
cache.UpsertAsync(Deck, DeckOf("d staged"), D).GetAwaiter().GetResult();
Land(cache, Write.Commit, E, DeckOf("e"));
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
Land(cache, Write.Commit, new CultRecordKey("e2"), DeckOf("e2"));
Assert.That(Stored(path, D), Is.EqualTo(widget));
Assert.That(Read(path).Records.Select(record => record.Key), Does.Contain("e2"));
}
// A staged removal is a write of its own: a refusal takes it too.
[TestCase(false)]
[TestCase(true)]
public void AStagedRemovalOfARecordAnotherWriterMadeForeignIsRefusedOnceAndThenGone(bool directory)
{
var path = Seeded("staged-removal.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var widget = Stored(path, D);
cache.Remove(D);
var refusal = Assert.Throws<CultSchemaConflictException>(() => cache.FlushAsync().GetAwaiter().GetResult())!;
Land(cache, Write.Commit, E, DeckOf("e"));
Assert.That(refusal.RecordKey, Is.EqualTo(D.Value));
Assert.That(Stored(path, D), Is.EqualTo(widget));
}
// What a refusal leaves staged is exactly what it did not refuse: the other record's write still lands on the next flush,
// and a store with nothing left staged is clean.
[TestCase(false)]
[TestCase(true)]
public void ARefusalLeavesStagedWhatItDidNotRefuse(bool directory)
{
var path = Seeded("pending.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
cache.UpsertAsync(Deck, DeckOf(Canary), D).GetAwaiter().GetResult();
Assert.Throws<CultSchemaConflictException>(() => cache.FlushAsync().GetAwaiter().GetResult());
Assert.That(cache.IsDirty, Is.False, "nothing is left staged");
cache.UpsertAsync(Deck, DeckOf(Canary), D).GetAwaiter().GetResult();
cache.UpsertAsync(Deck, DeckOf("e"), E).GetAwaiter().GetResult();
Assert.Throws<CultSchemaConflictException>(() => cache.FlushAsync().GetAwaiter().GetResult());
Assert.That(cache.IsDirty, Is.True, "e is still staged");
cache.FlushAsync().GetAwaiter().GetResult();
Assert.That(Read(path).Records.Select(record => record.Key), Does.Contain("e"));
Assert.That(cache.IsDirty, Is.False);
}
[TestCase(false)]
[TestCase(true)]
public void RemovingARecordAnotherWriterMadeForeignIsRefused(bool directory)
{
var path = Seeded("removed.cc", directory);
using var cache = Open(path, DeckOnly, directory);
cache.Commit(batch => batch.Upsert(Deck, DeckOf("e"), E));
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
var before = Fingerprint(path);
// A condition keeps the single-file commit on the file as it is, so only the removal reaches d.
var refusal = Assert.Throws<CultSchemaConflictException>(() => cache.Commit(batch =>
{
batch.Expect(E, cache.Get(E));
batch.Remove(D);
}))!;
Assert.That(refusal.RecordKey, Is.EqualTo(D.Value));
Assert.That(Fingerprint(path), Is.EqualTo(before));
}
[TestCase(false)]
[TestCase(true)]
public void ARecordAnotherWriterMadeForeignLeavesTheCacheAtThePull(bool directory)
{
var path = Seeded("pulled.cc", directory);
using var cache = Open(path, DeckOnly, directory);
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("now a widget"), D));
cache.PullAllBackingStoresAsync().GetAwaiter().GetResult();
Assert.That(cache.Get(D), Is.Null);
Assert.That(StoreOf(cache).ForeignRecords.Select(record => record.Key), Is.EqualTo(new[] { "d", "w" }));
}
// A directory load without a lease that a writer's commit forces to retry lists each foreign record once, from the manifest
// the retry read.
[Test]
public void ARetriedDirectoryLoadListsEachForeignRecordOnce()
{
var path = Seeded("retried.cc", directory: true);
var store = new DirectoryMessagePackBackingStore(path);
using var cache = new CultCache(DeckOnly);
cache.AddBackingStore(store);
File.Delete(Path.Combine(DirectoryMessagePackBackingStore.DefaultRecordDirectoryPath(path), ".commit.lock"));
var commits = 0;
// The writer is another cache, so it commits from another thread; it commits once, under the first unleased read.
store.UnleasedManifestRead = () =>
{
if (commits++ > 0)
return;
System.Threading.Tasks.Task.Run(() =>
{
using var writer = Open(path, Full, directory: true);
writer.Commit(batch => batch.Upsert(Deck, DeckOf("e"), E));
}).GetAwaiter().GetResult();
};
cache.PullAllBackingStoresAsync().GetAwaiter().GetResult();
Assert.That(cache.Get(E), Is.Not.Null, "the load retried and read the writer's generation");
Assert.That(store.ForeignRecords.Select(record => record.Key), Is.EqualTo(new[] { "w" }));
}
// The file decides what is carried, not what this cache loaded: a foreign record another writer added since is kept too.
[TestCase(false)]
[TestCase(true)]
public void AForeignRecordAddedAfterTheLoadIsKept(bool directory)
{
var path = Seeded("added.cc", directory);
using var cache = Open(path, DeckOnly, directory);
var z = new CultRecordKey("z");
using (var other = Open(path, Full, directory))
other.Commit(batch => batch.Upsert(Widget, WidgetOf("z"), z));
var before = Stored(path, z);
Land(cache, Write.Flush, E, DeckOf("e"));
Assert.That(Stored(path, z), Is.EqualTo(before));
}
// A writer cannot see whether a foreign record holds element ids, so a store marked as holding them stays marked while it
// carries one. Without one, a whole-view write decides by what it writes, and nothing here holds an id.
[Test]
public void AMarkedHeaderStaysMarkedWhileTheStoreCarriesAForeignRecord(
[Values(Write.Flush, Write.Commit)] Write write,
[Values] bool carriesForeign)
{
var path = Seeded("marked.cc", directory: false);
var snapshot = Read(path);
snapshot.FormatVersion = CultPersistedStoreSnapshot.FormatV3;
if (!carriesForeign)
{
snapshot.Records = snapshot.Records.Where(record => record.Key != W.Value).ToArray();
snapshot.SchemaCatalog = snapshot.SchemaCatalog.Where(entry => entry.SchemaId != WidgetId).ToArray();
}
File.WriteAllBytes(path, CultDocumentMessagePackSerialization.SerializeSnapshot(snapshot));
using (var cache = Open(path, DeckOnly, directory: false))
Land(cache, write, E, DeckOf("e"));
Assert.That(Read(path).FormatVersion, Is.EqualTo(carriesForeign ? CultPersistedStoreSnapshot.FormatV3 : CultPersistedStoreSnapshot.FormatV1));
}
private const string OtherRuntimeId = "other.runtime.deck";
// A deck another runtime wrote under its own id for the deck's schema. This build reads it through the catalog's schema name,
// but does not own the id.
private string OtherRuntimeStore(string name)
{
var path = PathOf(name);
using (var cache = Open(path, DeckOnly, directory: false))
cache.Commit(batch => batch.Upsert(Deck, DeckOf("d"), D));
var snapshot = Read(path);
var entry = snapshot.SchemaCatalog.Single();
entry.SchemaId = OtherRuntimeId;
entry.ContentHash = OtherRuntimeId;
entry.CompatibleSchemaIds = new[] { OtherRuntimeId };
snapshot.Records.Single().SchemaId = OtherRuntimeId;
// An older entry that also lists the id, first in the catalog: the entry that owns the id is the one that publishes it.
snapshot.SchemaCatalog = new[]
{
new CultSchemaCatalogEntry
{
SchemaId = "decoy.older", SchemaName = "tests.decoy", SchemaVersion = "tests.decoy.v1", ContentHash = "decoy.older",
CompatibleSchemaIds = new[] { "decoy.older", OtherRuntimeId }
},
entry
};
File.WriteAllBytes(path, CultDocumentMessagePackSerialization.SerializeSnapshot(snapshot));
return path;
}
// The record and the entry that described it when it loaded travel together: another writer re-describing the id since
// does not change what a whole view lays back.
[Test]
public void AWholeViewLaysBackTheCatalogEntryItLoadedWhateverTheFileSaysNow([Values(Write.Flush, Write.Commit)] Write write)
{
var path = OtherRuntimeStore("redescribed.cc");
var loaded = CatalogEntryBytes(path, OtherRuntimeId);
using var cache = Open(path, DeckOnly, directory: false);
var snapshot = Read(path);
snapshot.SchemaCatalog.Single(entry => entry.SchemaId == OtherRuntimeId).SchemaVersion = "tests.foreign_deck.redescribed";
File.WriteAllBytes(path, CultDocumentMessagePackSerialization.SerializeSnapshot(snapshot));
Land(cache, write, E, DeckOf("e"));
Assert.That(CatalogEntryBytes(path, OtherRuntimeId), Is.EqualTo(loaded));
}
// A store whose file is gone holds nothing, foreign records included.
[Test]
public void AStoreWhoseFileIsGoneListsNoForeignRecords()
{
var path = Seeded("gone.cc", directory: false);
using var cache = Open(path, DeckOnly, directory: false);
File.Delete(path);
cache.PullAllBackingStoresAsync().GetAwaiter().GetResult();
Assert.That(StoreOf(cache).ForeignRecords, Is.Empty);
}
// The registry's public resolution still refuses an id no registered type claims, naming the schema and the id: only a store
// carries such a record.
[Test]
public void ResolvingAnUnclaimedIdThroughTheRegistryRefusesByName()
{
var entry = Full.GetRequired(Widget).ToCatalogEntry();
var refusal = Assert.Throws<InvalidOperationException>(() => DeckOnly.ResolvePersistedSchema(WidgetId, new[] { entry }))!;
Assert.That(refusal.Message, Does.Contain("tests.foreign_widget").And.Contain(WidgetId));
}
private static byte[] CatalogEntryBytes(string path, string schemaId) =>
CultDocumentMessagePackSerialization.SerializeSnapshot(new CultPersistedStoreSnapshot
{
SchemaCatalog = Read(path).SchemaCatalog.Where(entry => entry.SchemaId == schemaId).ToArray()
});
// Records and catalog entries a runtime does not own survive its writes: a write of another record lays the record back with
// its id, storedAt, bytes and catalog entry as they were stored.
[Test]
public void AWriteOfAnotherRecordLaysBackARecordUnderAnIdThisBuildDoesNotOwn([Values] Write write)
{
var path = OtherRuntimeStore("other-runtime.cc");
var before = Stored(path, D);
var entry = CatalogEntryBytes(path, OtherRuntimeId);
using (var cache = Open(path, DeckOnly, directory: false))
{
Assert.That(EmittedDocumentTypes.Read(cache.Get(D)!, "Name"), Is.EqualTo("d"), "this build reads it");
Land(cache, write, E, DeckOf("e"));
}
Assert.That(Stored(path, D), Is.EqualTo(before));
Assert.That(CatalogEntryBytes(path, OtherRuntimeId), Is.EqualTo(entry));
}
// A write of the record itself stores what the cache holds, under the type's own id.
[Test]
public void AWriteOfTheRecordItselfStoresItUnderTheTypesOwnId([Values(Write.Flush, Write.Commit)] Write write)
{
var path = OtherRuntimeStore("rewritten.cc");
using (var cache = Open(path, DeckOnly, directory: false))
Land(cache, write, D, DeckOf("changed"));
Assert.That(Read(path).Records.Single().SchemaId, Is.EqualTo(DeckOnly.GetRequired(Deck).SchemaId));
using var reopened = Open(path, DeckOnly, directory: false);
Assert.That(EmittedDocumentTypes.Read(reopened.Get(D)!, "Name"), Is.EqualTo("changed"));
}
// 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]
public void ACommitInvolvingAVariantIsNotRefusedByAForeignRecord()
{
var path = Seeded("variant.cc", directory: false);
var before = Stored(path, W);
using var cache = Open(path, DeckOnly, directory: false);
var v = new CultRecordKey("v");
cache.UpsertVariantAsync(v, D, new[] { cache.Override(Deck, "Name", "v") }).GetAwaiter().GetResult();
cache.FlushAsync().GetAwaiter().GetResult();
Land(cache, Write.ConditionalCommit, E, DeckOf("e"));
Assert.That(Stored(path, W), Is.EqualTo(before));
Assert.That(Read(path).Records.Select(record => record.Key), Is.EquivalentTo(new[] { "d", "e", "v", "w" }));
}
// A variant's base that another writer replaced with a foreign record is gone from the set the file will hold, so a commit
// onto that file is refused as it would be if the base had been removed.
[Test]
public void ACommitOntoAFileWhereAForeignRecordReplacedAVariantsBaseIsRefused()
{
var path = Seeded("base.cc", directory: false);
using var cache = Open(path, DeckOnly, directory: false);
var v = new CultRecordKey("v");
cache.UpsertVariantAsync(v, D, new[] { cache.Override(Deck, "Name", "v") }).GetAwaiter().GetResult();
cache.FlushAsync().GetAwaiter().GetResult();
var snapshot = Read(path);
var widget = snapshot.Records.Single(record => record.Key == W.Value);
snapshot.Records = snapshot.Records
.Select(record => record.Key == D.Value
? new CultPersistedRecord { Key = D.Value, SchemaId = widget.SchemaId, StoredAt = widget.StoredAt, Payload = widget.Payload }
: record)
.ToArray();
File.WriteAllBytes(path, CultDocumentMessagePackSerialization.SerializeSnapshot(snapshot));
var before = Fingerprint(path);
var refusal = Assert.Throws(Is.InstanceOf<InvalidOperationException>(), () => cache.Commit(batch =>
{
batch.Expect(E, null);
batch.Upsert(Deck, DeckOf("e"), E);
}))!;
Assert.That(refusal.Message, Does.Contain(v.Value).And.Contain(D.Value));
Assert.That(Fingerprint(path), Is.EqualTo(before));
}
}
}