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().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(() => 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); } }