Files
Febe/tests/Febe.Tests/Data/SingleWriterTests.cs
T
Claude 3aeaa17da7 M1 Dati e libreria: modello, archivi SQLite con scrittore unico, nomi dei file, scrittura sicura, miniature, impronte, _febe.jsonl, copie, eliminazione e ricostruzione
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
2026-10-13 16:06:15 +00:00

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"));
}
}