Files
Febe/tests/Febe.Tests/Data/EngineStoreTests.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

327 lines
19 KiB
C#

using Febe.Core.Abstractions;
using Febe.Core.Domain;
using Febe.Core.Storage;
using Febe.Tests.Support;
namespace Febe.Tests.Data;
[TestClass]
public sealed class EngineStoreTests
{
[TestMethod]
public async Task ActionCountsUseARolling60MinuteWindowAndTheLocalDay()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
// now = 13 October 2026, 00:20 in Rome (22:20 UTC on the 12th).
var now = new DateTimeOffset(2026, 10, 12, 22, 20, 0, TimeSpan.Zero);
async Task Log(ActionKind kind, DateTimeOffset at, long amount = 1) =>
await db.ActionLog.AppendAsync(new ActionLogRecord { At = at, Category = kind, AccountId = account.Id, Amount = amount });
await Log(ActionKind.ProfileOpen, now.AddMinutes(-60)); // just out of the window; yesterday locally
await Log(ActionKind.ProfileOpen, now.AddMinutes(-59).AddSeconds(-59)); // in the window; yesterday locally (23:20:01)
await Log(ActionKind.ProfileOpen, now.AddMinutes(-15)); // in the window; today (00:05)
await Log(ActionKind.ProfileOpen, now); // now
await Log(ActionKind.StoryView, now.AddMinutes(-5));
await Log(ActionKind.DataDownload, now.AddMinutes(-1), 5_000_000);
await Log(ActionKind.DataDownload, now.AddMinutes(-90), 1_000_000); // yesterday locally (22:50)
var usage = await db.ActionLog.GetUsageAsync(now, TestZones.Rome);
Assert.AreEqual(new BudgetUsage(3, 2), usage[ActionKind.ProfileOpen]);
Assert.AreEqual(new BudgetUsage(1, 1), usage[ActionKind.StoryView]);
Assert.AreEqual(new BudgetUsage(5_000_000, 5_000_000), usage[ActionKind.DataDownload]);
Assert.AreEqual(default, usage[ActionKind.Home]);
Assert.HasCount(Enum.GetValues<ActionKind>().Length, usage);
Assert.AreEqual(4L, await db.ActionLog.SumAsync(ActionKind.ProfileOpen, now.AddHours(-2), now.AddSeconds(1), account.Id));
Assert.AreEqual(0L, await db.ActionLog.SumAsync(ActionKind.ProfileOpen, now.AddHours(-2), now.AddSeconds(1), account.Id + 1));
Assert.AreEqual(now, await db.ActionLog.GetLastActionAtAsync());
Assert.AreEqual(now.AddMinutes(-5), await db.ActionLog.GetLastActionAtAsync(ActionKind.StoryView));
Assert.AreEqual(2, await db.ActionLog.PruneAsync(now.AddMinutes(-59).AddSeconds(-59)));
Assert.HasCount(5, await db.ActionLog.ListAsync(now.AddDays(-1), now.AddDays(1)));
}
[TestMethod]
public async Task CountsSurviveARestart()
{
using var temp = new TempFolder();
await using (var db = await TestDatabase.OpenAsync(temp))
{
await db.ActionLog.AppendAsync(new ActionLogRecord { At = Make.T0, Category = ActionKind.Home });
}
await using (var db = await TestDatabase.OpenAsync(temp))
{
var usage = await db.ActionLog.GetUsageAsync(Make.T0.AddMinutes(10), TestZones.Rome);
Assert.AreEqual(new BudgetUsage(1, 1), usage[ActionKind.Home]);
}
}
[TestMethod]
public async Task TaskQueueEnqueuesPeeksAndCompletes()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var now = Make.T0;
var later = await db.Tasks.EnqueueAsync(new EngineTask { Kind = EngineTaskKind.ProfileCheck, AccountId = account.Id, DueAt = now.AddHours(1), CreatedAt = now });
var sweep = await db.Tasks.EnqueueAsync(new EngineTask { Kind = EngineTaskKind.FollowingSweep, DueAt = now.AddMinutes(-10), CreatedAt = now });
var stories = await db.Tasks.EnqueueAsync(new EngineTask { Kind = EngineTaskKind.AccountStories, AccountId = account.Id, DueAt = now.AddMinutes(-5), Priority = 5, CreatedAt = now });
// «Controlla ora»: the same pending task moves earlier and up instead of being duplicated.
var manual = await db.Tasks.EnqueueAsync(new EngineTask { Kind = EngineTaskKind.ProfileCheck, AccountId = account.Id, DueAt = now, Priority = 100, IsManual = true, CreatedAt = now });
Assert.AreEqual(later.Id, manual.Id);
Assert.HasCount(3, await db.Tasks.ListPendingAsync(10));
var due = await db.Tasks.PeekDueAsync(now, 10);
Assert.IsTrue(due.Select(t => t.Id).SequenceEqual([manual.Id, stories.Id, sweep.Id]));
Assert.IsTrue(due[0].IsManual);
Assert.IsTrue(await db.Tasks.TryStartAsync(manual.Id, now));
Assert.IsFalse(await db.Tasks.TryStartAsync(manual.Id, now), "Un'attività si avvia una volta sola.");
await db.Tasks.CompleteAsync(manual.Id, now.AddMinutes(1));
Assert.AreEqual(EngineTaskState.Done, (await db.Tasks.GetAsync(manual.Id))!.State);
Assert.IsTrue(await db.Tasks.TryStartAsync(stories.Id, now));
await db.Tasks.FailAsync(stories.Id, now, "Rifiutato dal Governatore", now.AddMinutes(30));
var retried = (await db.Tasks.GetAsync(stories.Id))!;
Assert.AreEqual(EngineTaskState.Pending, retried.State);
Assert.AreEqual(now.AddMinutes(30), retried.DueAt);
Assert.AreEqual(1, retried.Attempts);
Assert.IsTrue(await db.Tasks.TryStartAsync(sweep.Id, now));
Assert.AreEqual(1, await db.Tasks.RequeueRunningAsync());
Assert.AreEqual(EngineTaskState.Pending, (await db.Tasks.GetAsync(sweep.Id))!.State);
Assert.AreEqual(1, await db.Tasks.CancelForAccountAsync(account.Id, now));
await db.Tasks.FailAsync(sweep.Id, now, "Errore", null);
Assert.AreEqual(EngineTaskState.Failed, (await db.Tasks.GetAsync(sweep.Id))!.State);
Assert.IsEmpty(await db.Tasks.ListPendingAsync(10));
Assert.AreEqual(3, await db.Tasks.PurgeFinishedAsync(now.AddDays(1)));
}
[TestMethod]
public async Task SessionsIncidentsAndEvents()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var first = await db.Sessions.StartAsync(Make.T0);
await db.Sessions.EndAsync(first.Id, Make.T0.AddMinutes(6), SessionOutcome.Completed, 14, "Giro e storie");
var second = await db.Sessions.StartAsync(Make.T0.AddHours(1));
Assert.AreEqual(second.Id, (await db.Sessions.GetLastAsync())!.Id);
Assert.HasCount(2, await db.Sessions.ListAsync(Make.T0.AddMinutes(5), Make.T0.AddHours(2)));
Assert.HasCount(1, await db.Sessions.ListAsync(Make.T0.AddMinutes(30), Make.T0.AddHours(2)));
Assert.AreEqual(1, await db.Sessions.CloseInterruptedAsync(Make.T0.AddHours(3)));
Assert.AreEqual(SessionOutcome.Interrupted, (await db.Sessions.GetAsync(second.Id))!.Outcome);
var throttle = await db.Incidents.OpenAsync(new Incident { At = Make.T0, Level = SignalLevel.Throttle, Signal = "http-429", Url = "https://www.instagram.com/x/", StoppedUntil = Make.T0.AddHours(1), SessionId = first.Id });
await db.Incidents.OpenAsync(new Incident { At = Make.T0.AddDays(-3), Level = SignalLevel.Throttle, Signal = "http-429" });
var challenge = await db.Incidents.OpenAsync(new Incident { At = Make.T0.AddHours(2), Level = SignalLevel.Challenge, Signal = "challenge-url" });
await db.Incidents.ResolveAsync(throttle.Id, Make.T0.AddHours(1));
Assert.HasCount(2, await db.Incidents.ListOpenAsync());
Assert.AreEqual(2, await db.Incidents.CountAsync(SignalLevel.Throttle, Make.T0.AddDays(-7)));
Assert.AreEqual(1, await db.Incidents.CountAsync(SignalLevel.Throttle, Make.T0.AddHours(-24)));
Assert.IsTrue((await db.Incidents.GetAsync(challenge.Id))!.IsOpen);
Assert.HasCount(2, await db.Incidents.ListAsync(Make.T0, Make.T0.AddDays(1)));
for (var i = 0; i < 12; i++)
{
await db.Events.AppendAsync(new EventRecord
{
At = Make.T0.AddMinutes(i),
Code = "prova",
Message = $"Evento {i}",
Severity = i % 4 == 0 ? EventSeverity.Warning : EventSeverity.Info,
AccountId = i % 2 == 0 ? account.Id : null,
});
}
var page1 = await db.Events.ListAsync(new EventQuery { Limit = 5 });
var page2 = await db.Events.ListAsync(new EventQuery { Limit = 5, BeforeId = page1[^1].Id });
Assert.IsTrue(page1.Concat(page2).Select(e => e.Message).SequenceEqual(Enumerable.Range(2, 10).Reverse().Select(i => $"Evento {i}")));
Assert.HasCount(6, await db.Events.ListAsync(new EventQuery { AccountId = account.Id }));
Assert.HasCount(3, await db.Events.ListAsync(new EventQuery { MinSeverity = EventSeverity.Warning }));
var after = await db.Events.ListAfterAsync(page1[1].Id);
Assert.IsTrue(after.Select(e => e.Message).SequenceEqual(["Evento 11"]));
Assert.AreEqual(3, await db.Events.PruneAsync(Make.T0.AddMinutes(3)));
}
[TestMethod]
public async Task FollowingListIsReadOverSeveralSessions()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var read1 = Make.T0;
await db.Following.UpsertAsync([
new FollowingRecord { InstagramId = "1", Username = "marta.demo", Position = 0, ReadAt = read1 },
new FollowingRecord { InstagramId = "2", Username = "luca.demo", Position = 1, ReadAt = read1, IsPrivate = true },
]);
await db.Following.UpsertAsync([new FollowingRecord { Username = "senza.id", Position = 2, ReadAt = read1 }]);
Assert.AreEqual(3, await db.Following.CountAsync());
// A new complete read: marta renamed, luca unfollowed.
var read2 = Make.T0.AddDays(2);
await db.Following.UpsertAsync([
new FollowingRecord { InstagramId = "1", Username = "marta.nuova", Position = 0, ReadAt = read2 },
new FollowingRecord { Username = "senza.id", DisplayName = "Senza", Position = 1, ReadAt = read2 },
]);
Assert.AreEqual(1, await db.Following.RemoveNotReadSinceAsync(read2));
var list = await db.Following.ListAsync();
Assert.IsTrue(list.Select(f => f.Username).SequenceEqual(["marta.nuova", "senza.id"]));
Assert.AreEqual(read2, await db.Following.GetLastReadAtAsync());
await db.Following.ClearAsync();
Assert.AreEqual(0, await db.Following.CountAsync());
}
[TestMethod]
public async Task HighlightsKeepTheirOrderAndContents()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var e1 = (await db.Entries.AddAsync(Make.Entry(account.Id, "1", Make.T0, EntryKind.Highlight), [Make.Photo()])).Stored.Entry.Id;
var e2 = (await db.Entries.AddAsync(Make.Entry(account.Id, "2", Make.T0, EntryKind.Story), [Make.Photo()])).Stored.Entry.Id;
var summer = await db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "h1", Title = "Estate", Position = 0, DiscoveredAt = Make.T0 });
var food = await db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "h2", Title = "Cucina", Position = 1, DiscoveredAt = Make.T0 });
var renamed = await db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "h1", Title = "Estate 2025", Position = 0, DiscoveredAt = Make.T0 });
Assert.AreEqual(summer.Id, renamed.Id);
await db.Highlights.SetOrderAsync(account.Id, [food.Id, summer.Id]);
Assert.IsTrue((await db.Highlights.ListAsync(account.Id)).Select(h => h.Title).SequenceEqual(["Cucina", "Estate 2025"]));
await db.Highlights.SetItemsAsync(summer.Id, [e2, e1]);
await db.Highlights.AddItemAsync(summer.Id, e1);
await db.Highlights.AddItemAsync(food.Id, e1);
Assert.IsTrue((await db.Highlights.ListItemsAsync(summer.Id)).Select(i => i.EntryId).SequenceEqual([e2, e1]));
Assert.HasCount(2, await db.Highlights.ListForEntryAsync(e1));
await db.Highlights.MarkRemovedAsync(food.Id, Make.T0.AddDays(1));
Assert.HasCount(1, await db.Highlights.ListAsync(account.Id));
Assert.HasCount(2, await db.Highlights.ListAsync(account.Id, includeRemoved: true));
Assert.AreEqual(food.Id, (await db.Highlights.FindByTitleAsync(account.Id, "Cucina"))!.Id);
}
[TestMethod]
public async Task DuplicatePairsWaitForADecision()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var a = (await db.Entries.AddAsync(Make.Entry(account.Id, "1", Make.T0), [Make.Stored(Make.Photo(), Make.Sha(1), "a.jpg")])).Stored.Media[0];
var b = (await db.Entries.AddAsync(Make.Entry(account.Id, "2", Make.T0), [Make.Stored(Make.Photo(), Make.Sha(2), "b.jpg")])).Stored.Media[0];
var pair = new DuplicatePair { Origin = DuplicateOrigin.Download, Reason = DuplicateReason.VisuallySimilar, ExistingMediaId = a.Id, CandidateMediaId = b.Id, Distance = 4, CreatedAt = Make.T0 };
var stored = await db.Duplicates.AddAsync(pair);
var again = await db.Duplicates.AddAsync(pair);
Assert.AreEqual(stored.Id, again.Id);
Assert.AreEqual(1, await db.Duplicates.CountPendingAsync());
Assert.AreEqual(0, await db.Duplicates.CountPendingAsync(DuplicateOrigin.Import));
await Assert.ThrowsExactlyAsync<ArgumentException>(() => db.Duplicates.AddAsync(pair with { CandidateImportFileId = 1 }));
await db.Duplicates.DecideAsync(stored.Id, DuplicateDecision.KeepBoth, Make.T0.AddHours(1));
Assert.IsEmpty(await db.Duplicates.ListPendingAsync());
var decided = (await db.Duplicates.GetAsync(stored.Id))!;
Assert.AreEqual(DuplicateDecision.KeepBoth, decided.Decision);
Assert.AreEqual(Make.T0.AddHours(1), decided.DecidedAt);
}
[TestMethod]
public async Task ImportsResumeAndAssociateFolders()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var run = await db.Imports.CreateRunAsync(new ImportRun { SourcePath = "/importa/stogram", SourceReadOnly = true, StartedAt = Make.T0 });
ImportFile File(string path, string folder) => new() { RunId = run.Id, RelativePath = path, Folder = folder, Bytes = 100 };
await db.Imports.AddFilesAsync([File("marta/a.jpg", "marta"), File("marta/b.jpg", "marta"), File("altro/c.mp4", "altro")]);
await db.Imports.AddFilesAsync([File("marta/a.jpg", "marta") with { Bytes = 999 }]); // resumed analysis: unchanged
var a = (await db.Imports.FindFileAsync(run.Id, "marta/a.jpg"))!;
Assert.AreEqual(100L, a.Bytes);
await db.Imports.UpdateFileAsync(a with
{
Sha256 = Make.Sha(5),
MediaKind = MediaKind.Photo,
PerceptualHash = ulong.MaxValue,
Outcome = ImportOutcome.New,
State = ImportFileState.Analyzed,
ProbableAccount = "marta.demo",
ProbableKind = EntryKind.Story,
TakenAt = Make.T0,
DateSource = ImportDateSource.FileName,
});
var b = (await db.Imports.FindFileAsync(run.Id, "marta/b.jpg"))!;
await db.Imports.UpdateFilesAsync([b with { Sha256 = Make.Sha(5), Outcome = ImportOutcome.ProbableDuplicate, State = ImportFileState.Analyzed }]);
Assert.HasCount(2, await db.Imports.FindFilesBySha256Async(run.Id, Make.Sha(5)));
var reread = (await db.Imports.GetFileAsync(a.Id))!;
Assert.AreEqual(ulong.MaxValue, reread.PerceptualHash);
Assert.AreEqual(EntryKind.Story, reread.ProbableKind);
await db.Imports.SetFolderTargetAsync(run.Id, "marta", account.Id);
var folders = await db.Imports.ListFoldersAsync(run.Id);
Assert.HasCount(2, folders);
Assert.AreEqual(new ImportFolder("marta", 2, "marta.demo", account.Id), folders.Single(f => f.Folder == "marta"));
var summary = await db.Imports.GetSummaryAsync(run.Id);
Assert.AreEqual(3, summary.Total);
Assert.AreEqual(1, summary.ByOutcome[ImportOutcome.New]);
Assert.AreEqual(1, summary.ByOutcome[ImportOutcome.Pending]);
Assert.AreEqual(2, summary.ByState[ImportFileState.Analyzed]);
Assert.AreEqual(300L, summary.Bytes);
var pendingOnly = await db.Imports.ListFilesAsync(new ImportFileQuery { RunId = run.Id, State = ImportFileState.Pending });
Assert.AreEqual("altro/c.mp4", pendingOnly.Single().RelativePath);
await db.Imports.UpdateRunAsync(run with { State = ImportRunState.Reviewing, AnalyzedAt = Make.T0.AddMinutes(5) });
Assert.AreEqual(ImportRunState.Reviewing, (await db.Imports.GetRunAsync(run.Id))!.State);
Assert.HasCount(1, await db.Imports.ListRunsAsync());
}
[TestMethod]
public async Task SettingsStoreAndLibrarySettings()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
await db.Settings.SetAsync("a", "1");
await db.Settings.SetAsync("a", "2");
await db.Settings.SetBoolAsync("b", true);
await db.Settings.SetInt64Async("c", 42);
Assert.AreEqual("2", await db.Settings.GetAsync("a"));
Assert.IsTrue(await db.Settings.GetBoolAsync("b", false));
Assert.AreEqual(42L, await db.Settings.GetInt64Async("c"));
await db.Settings.SetAsync("a", null);
Assert.IsNull(await db.Settings.GetAsync("a"));
var defaults = await Core.Library.LibrarySettings.LoadAsync(db.Settings, "/libreria");
Assert.AreEqual("/libreria", defaults.LibraryRoot);
Assert.AreEqual(Core.Library.NamingScheme.DefaultGeneral, defaults.Naming.General.Text);
Assert.IsTrue(defaults.SetFileTimeToPublication);
var custom = defaults with
{
LibraryRoot = "/altrove",
Naming = defaults.Naming with { General = Core.Library.NamingScheme.Parse(@"{account}\{tipo}\{data}_{codice}_{n}", false) },
SetFileTimeToPublication = false,
};
await custom.SaveAsync(db.Settings);
var loaded = await Core.Library.LibrarySettings.LoadAsync(db.Settings, "/libreria");
Assert.AreEqual("/altrove", loaded.LibraryRoot);
Assert.AreEqual(@"{account}\{tipo}\{data}_{codice}_{n}", loaded.Naming.General.Text);
Assert.IsFalse(loaded.SetFileTimeToPublication);
await db.Settings.SetAsync(SettingKeys.NamingScheme, "{sconosciuto}");
var fallback = await Core.Library.LibrarySettings.LoadAsync(db.Settings, "/libreria");
Assert.AreEqual(Core.Library.NamingScheme.DefaultGeneral, fallback.Naming.General.Text);
}
}