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
327 lines
19 KiB
C#
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);
|
|
}
|
|
}
|