Modello del dominio e interfacce degli archivi in Febe.Core; implementazione SQLite in Febe.Data (WAL, chiavi esterne, migrazioni numerate in transazione, coda di scrittura su un solo thread); logica della libreria in Febe.Core/Library; 164 prove MSTest, compresa la ricostruzione del database da una libreria di prova e la scala a 200.000 elementi. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
145 lines
5.4 KiB
C#
145 lines
5.4 KiB
C#
using System.Diagnostics;
|
|
using Febe.Core.Abstractions;
|
|
using Febe.Core.Domain;
|
|
using Febe.Data;
|
|
using Febe.Tests.Support;
|
|
using Microsoft.Data.Sqlite;
|
|
|
|
namespace Febe.Tests.Data;
|
|
|
|
[TestClass]
|
|
public sealed class SingleWriterTests
|
|
{
|
|
[TestMethod]
|
|
public async Task ConcurrentWritesAreSerializedAndAllCommitted()
|
|
{
|
|
using var temp = new TempFolder();
|
|
await using var db = await TestDatabase.OpenAsync(temp);
|
|
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
const int writers = 24;
|
|
const int perWriter = 50;
|
|
|
|
using var stopReaders = new CancellationTokenSource();
|
|
var readers = Enumerable.Range(0, 4).Select(_ => Task.Run(async () =>
|
|
{
|
|
var reads = 0;
|
|
while (!stopReaders.IsCancellationRequested)
|
|
{
|
|
await db.ActionLog.SumAsync(ActionKind.StoryView, Make.T0.AddDays(-1), Make.T0.AddDays(1));
|
|
reads++;
|
|
}
|
|
|
|
return reads;
|
|
})).ToList();
|
|
|
|
var tasks = Enumerable.Range(0, writers).Select(w => Task.Run(async () =>
|
|
{
|
|
for (var i = 0; i < perWriter; i++)
|
|
{
|
|
await db.ActionLog.AppendAsync(new ActionLogRecord
|
|
{
|
|
At = Make.T0.AddSeconds((w * perWriter) + i),
|
|
Category = ActionKind.StoryView,
|
|
AccountId = account.Id,
|
|
});
|
|
}
|
|
}));
|
|
await Task.WhenAll(tasks);
|
|
await stopReaders.CancelAsync();
|
|
var readCounts = await Task.WhenAll(readers);
|
|
|
|
var total = await db.ActionLog.SumAsync(ActionKind.StoryView, Make.T0.AddDays(-1), Make.T0.AddDays(1));
|
|
Assert.AreEqual((long)writers * perWriter, total);
|
|
Assert.AreEqual(1, db.Writer.MaxObservedConcurrency, "Le scritture devono passare una alla volta.");
|
|
Assert.IsTrue(readCounts.All(c => c > 0), "Le letture proseguono mentre si scrive.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task WritesRunOnTheWriterThread()
|
|
{
|
|
using var temp = new TempFolder();
|
|
await using var db = await TestDatabase.OpenAsync(temp);
|
|
var threads = await Task.WhenAll(Enumerable.Range(0, 20).Select(_ => Task.Run(() => db.WriteAsync(_ => Environment.CurrentManagedThreadId, default))));
|
|
Assert.IsTrue(threads.All(t => t == db.Writer.ThreadId));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFailingWriteDoesNotUndoTheOthers()
|
|
{
|
|
using var temp = new TempFolder();
|
|
await using var db = await TestDatabase.OpenAsync(temp);
|
|
using var gate = new ManualResetEventSlim(false);
|
|
|
|
// Hold the writer so that the next writes are queued together and share one transaction.
|
|
var blocker = db.WriteAsync(_ => gate.Wait(TimeSpan.FromSeconds(10)), default);
|
|
var good1 = db.Settings.SetAsync("a", "1");
|
|
var bad = db.WriteAsync(w => w.Command("INSERT INTO media (entry_id, position, kind, state) VALUES (424242, 1, 'Photo', 'ToDownload')").ExecuteNonQuery(), default);
|
|
var good2 = db.Settings.SetAsync("b", "2");
|
|
gate.Set();
|
|
|
|
await blocker;
|
|
await good1;
|
|
await good2;
|
|
await Assert.ThrowsExactlyAsync<SqliteException>(() => bad);
|
|
Assert.AreEqual("1", await db.Settings.GetAsync("a"));
|
|
Assert.AreEqual("2", await db.Settings.GetAsync("b"));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AWriteCancelledWhileQueuedIsNotExecuted()
|
|
{
|
|
using var temp = new TempFolder();
|
|
await using var db = await TestDatabase.OpenAsync(temp);
|
|
using var gate = new ManualResetEventSlim(false);
|
|
using var cancel = new CancellationTokenSource();
|
|
|
|
var blocker = db.WriteAsync(_ => gate.Wait(TimeSpan.FromSeconds(10)), default);
|
|
var cancelled = db.Settings.SetAsync("annullata", "1", cancel.Token);
|
|
await cancel.CancelAsync();
|
|
gate.Set();
|
|
await blocker;
|
|
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => cancelled);
|
|
await db.Settings.SetAsync("dopo", "1");
|
|
Assert.IsNull(await db.Settings.GetAsync("annullata"));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ReadsAreNotBlockedByALongWrite()
|
|
{
|
|
using var temp = new TempFolder();
|
|
await using var db = await TestDatabase.OpenAsync(temp);
|
|
await db.Settings.SetAsync("prima", "1");
|
|
using var gate = new ManualResetEventSlim(false);
|
|
|
|
var longWrite = db.WriteAsync(
|
|
w =>
|
|
{
|
|
w.Command("INSERT INTO setting (key, value) VALUES ('durante', '1')").ExecuteNonQuery();
|
|
gate.Wait(TimeSpan.FromSeconds(10));
|
|
},
|
|
default);
|
|
|
|
var watch = Stopwatch.StartNew();
|
|
var value = await db.Settings.GetAsync("prima");
|
|
var during = await db.Settings.GetAsync("durante");
|
|
watch.Stop();
|
|
gate.Set();
|
|
await longWrite;
|
|
|
|
Assert.AreEqual("1", value);
|
|
Assert.IsNull(during, "Una lettura non vede una scrittura non ancora confermata.");
|
|
Assert.IsLessThan(2000L, watch.ElapsedMilliseconds);
|
|
Assert.AreEqual("1", await db.Settings.GetAsync("durante"));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task WritesAfterDisposeFail()
|
|
{
|
|
using var temp = new TempFolder();
|
|
var db = await TestDatabase.OpenAsync(temp);
|
|
await db.DisposeAsync();
|
|
await Assert.ThrowsExactlyAsync<ObjectDisposedException>(() => db.Settings.SetAsync("x", "1"));
|
|
}
|
|
}
|