using Febe.Core.Abstractions; using Febe.Core.Alerts; using Febe.Core.Collection; using Febe.Core.Collection.Readers; using Febe.Core.Collection.Recipes; using Febe.Core.Domain; using Febe.Core.Engine; using Febe.Core.Storage; using Febe.Tests.Alerts.Support; using Febe.Tests.Collection.Support; using Febe.Tests.Engine.Support; using Febe.Web.Api; namespace Febe.Tests.Engine; /// /// «Storico completato» is one line of Attività and one alert per history, written by the engine with its numbers: /// the real recipes on the scripted site (no browser) under the real engine, and the runs that end otherwise right /// after the last page. /// [TestClass] public sealed class BackfillCompletedTests { private static readonly DateTimeOffset Morning = EngineTestBed.Local(2026, 10, 14, 6, 0); /// Found testing Febe for Windows on the test site: two lines in «Avvisi» for one history, at 14:31. [TestMethod] public async Task AHistoryCompletedByTheRecipesIsOneLineOfAvvisiWithItsNumbersAndOneNotification() { await using var bed = await AlertBed.CreateAsync(start: Morning); var engine = bed.Engine; var (runner, site) = RealRecipes(engine); var marta = site.Add(new ScriptedAccount("2002", "marta.prova") { Followed = false }); marta.Posts.AddRange(ScriptedBed.Posts(0, 18, Morning.AddDays(-30))); var account = await AddBackfillingAsync(engine, marta, postCount: 18); engine.Start(runner); await engine.RunUntilAsync(Morning.AddDays(2)); await engine.StopAsync(); await bed.Alerts.FlushAsync(); const string Expected = "Storico di @marta.prova completato: 18 post in libreria. Da ora lo tengo aggiornato."; var done = await engine.Db.Accounts.GetAsync(account.Id); Assert.IsNotNull(done!.BackfillCompletedAt, "The history reached the beginning of the profile."); Assert.AreEqual(AccountState.UpToDate, done.State); Assert.HasCount(18, await engine.Db.Entries.ListByAccountAsync(account.Id, new EntryListOptions { Kind = EntryKind.Post, Limit = 100 })); var lines = await engine.Db.Events.ListAsync(new EventQuery { Codes = [EngineEventCodes.BackfillCompleted] }); Assert.HasCount(1, lines, "One line for one history: " + string.Join(" | ", lines.Select(e => e.Message))); Assert.AreEqual(Expected, lines[0].Message); Assert.AreEqual(EventSeverity.Success, lines[0].Severity); Assert.AreEqual(account.Id, lines[0].AccountId); Assert.IsNotNull(lines[0].SessionId); // The «Avvisi» list of Attività. var alerts = (await ActivityApi.AlertsAsync(engine.Db, engine.Clock, CancellationToken.None)).Items.Where(i => i.Kind == "backfillDone").ToList(); Assert.HasCount(1, alerts); Assert.AreEqual(Expected, alerts[0].Message); // One Windows notification and one Telegram message, with the same full text. var notification = bed.Shell.Notifications.Single(n => n.Title == AlertCatalog.Title(AlertKind.BackfillDone)); Assert.AreEqual(Expected, notification.Message); var telegram = bed.Telegram.Requests.Where(r => r.Text.StartsWith("Febe · Storico completato\n", StringComparison.Ordinal)).ToList(); Assert.HasCount(1, telegram); Assert.AreEqual("Febe · Storico completato\n" + Expected, telegram[0].Text); Assert.HasCount(1, bed.Outcomes.Where(o => o.Alert.Kind == AlertKind.BackfillDone), "Nothing held back as a repeat either."); } /// /// A run that completes the history: the walk reached the beginning of the profile and stored it, then a signal or /// a cancellation changed how the run ended; or a profile check found the whole profile on its first page. The /// history is closed with its line (it would never be walked again), and right after that run the Coda shows /// nothing planned for the account, now paused: no «Storico» put back in the queue (review F3). /// [TestMethod] [DataRow(RecipeKind.Backfill, RecipeStatus.StoppedBySignal)] [DataRow(RecipeKind.Backfill, RecipeStatus.Cancelled)] [DataRow(RecipeKind.ProfileCheck, RecipeStatus.Completed)] public async Task AHistoryCompletedByARunIsClosedWithItsLineAndLeavesNothingInTheQueue(RecipeKind kind, RecipeStatus status) { await using var bed = await AlertBed.CreateAsync(start: Morning); var engine = bed.Engine; var account = await engine.AddAccountAsync("luca.prova", followed: true, state: AccountState.Backfilling, postCount: 30); await engine.Db.Accounts.UpdateAsync((await engine.Db.Accounts.GetAsync(account.Id))! with { KeepUpdated = false }); var runner = new ScriptedRunner(engine.Governor, engine.Clock); RecipeRequest? closing = null; var walksAfter = 0; runner.Before = async r => { if (r.AccountId != account.Id) { return; } if (closing is not null) { walksAfter += r.Kind == RecipeKind.Backfill ? 1 : 0; } else if (r.Kind == kind) { // What the recipe stores: the walk met the end of the list, or the whole profile is on its first page. await engine.Db.Accounts.SetBackfillAsync(account.Id, null, engine.Clock.Now); closing = r; } }; runner.Script = r => ReferenceEquals(r, closing) ? new RecipeOutcome(status, 1, 6) { BackfillFinished = true } : null; engine.Start(runner); var end = Morning.AddDays(2); while (closing is null && engine.Clock.Now < end) { await engine.RunForAsync(TimeSpan.FromMinutes(1)); } // Right after that run, before the next session tidies the queue. Assert.IsNotNull(closing); var queued = (await engine.Db.Tasks.ListPendingAsync(1000)).Where(t => t.AccountId == account.Id).ToList(); Assert.HasCount(0, queued, "Planned for a paused account: " + string.Join(", ", queued.Select(t => $"{t.Kind} «{t.LastError}»"))); await engine.RunUntilAsync(end); await engine.StopAsync(); await bed.Alerts.FlushAsync(); Assert.AreEqual(0, walksAfter, "Never walked again."); var finished = await engine.Db.Accounts.GetAsync(account.Id); Assert.AreEqual(AccountState.Paused, finished!.State, "«Tieni aggiornato» off: one download, then paused."); var lines = await engine.Db.Events.ListAsync(new EventQuery { Codes = [EngineEventCodes.BackfillCompleted] }); Assert.HasCount(1, lines); Assert.AreEqual("Storico di @luca.prova completato: 0 post in libreria. «Tieni aggiornato» è spento: l'account resta in pausa.", lines[0].Message); Assert.HasCount(1, bed.Shell.Notifications.Where(n => n.Title == AlertCatalog.Title(AlertKind.BackfillDone))); } /// /// A profile that fits on its first page: the profile check completes its history. When the walk of the session /// went to another account «Storico in corso», the small one stayed so for ever, with no line and no alert (review /// F1). Added first, the small one is the walk's next pick in that very session: it must not get a second line. /// An account that keeps only the new posts has no history to announce. /// [TestMethod] [DataRow(false)] [DataRow(true)] public async Task AHistoryCompletedByTheProfileCheckIsClosedAtOnceWithOneLine(bool smallFirst) { await using var bed = await AlertBed.CreateAsync(start: Morning); var engine = bed.Engine; var (runner, site) = RealRecipes(engine); var big = site.Add(new ScriptedAccount("3003", "grande.prova") { Followed = false }); big.Posts.AddRange(ScriptedBed.Posts(0, 400, Morning.AddDays(-30), prefix: "g")); var small = site.Add(new ScriptedAccount("4004", "piccolo.prova") { Followed = false }); small.Posts.AddRange(ScriptedBed.Posts(0, 5, Morning.AddDays(-30), prefix: "s")); var news = site.Add(new ScriptedAccount("5005", "nuovi.prova") { Followed = false }); news.Posts.AddRange(ScriptedBed.Posts(0, 3, Morning.AddDays(-30), prefix: "n")); // Among the accounts «Storico in corso» the walk takes the lowest id first. Account smallAccount; if (smallFirst) { smallAccount = await AddBackfillingAsync(engine, small, postCount: 5); await AddBackfillingAsync(engine, big, postCount: 400); } else { await AddBackfillingAsync(engine, big, postCount: 400); smallAccount = await AddBackfillingAsync(engine, small, postCount: 5); } var newsAccount = await engine.Db.Accounts.AddAsync(Account.Create(news.Username, StartingPoint.OnlyNewFromToday, engine.Clock.Now, EngineTestBed.Zone, engine.Runtime.Profile) with { InstagramId = news.Id, IsFollowed = news.Followed, ContentTypes = ContentTypes.PostPhotos | ContentTypes.PostVideos, PostCount = 3, }); Assert.AreEqual(AccountState.UpToDate, newsAccount.State); engine.Start(runner); await engine.RunUntilAsync(Morning.AddDays(4)); await engine.StopAsync(); await bed.Alerts.FlushAsync(); var lines = await engine.Db.Events.ListAsync(new EventQuery { Codes = [EngineEventCodes.BackfillCompleted] }); var all = string.Join(" | ", lines.Select(e => e.Message)); var done = await engine.Db.Accounts.GetAsync(smallAccount.Id); Assert.IsNotNull(done!.BackfillCompletedAt, "The whole profile is on its first page."); Assert.AreEqual(AccountState.UpToDate, done.State, all); const string Expected = "Storico di @piccolo.prova completato: 5 post in libreria. Da ora lo tengo aggiornato."; Assert.HasCount(1, lines.Where(e => e.AccountId == smallAccount.Id).ToList(), all); Assert.AreEqual(Expected, lines.Single(e => e.AccountId == smallAccount.Id).Message); Assert.AreEqual(1, bed.Shell.Notifications.Count(n => n.Message == Expected)); Assert.IsFalse(lines.Any(e => e.AccountId == newsAccount.Id), "«Solo i nuovi»: no history. " + all); Assert.AreEqual(AccountState.UpToDate, (await engine.Db.Accounts.GetAsync(newsAccount.Id))!.State); Assert.IsTrue(lines.GroupBy(e => e.AccountId).All(g => g.Count() == 1), "One line per history: " + all); } /// /// An account «Storico in corso» whose history is already complete (a profile check closed it and Febe stopped /// before recording the outcome, or a version that left it so): closed when the next session starts, with its /// line, without walking anything. /// [TestMethod] public async Task AnAccountLeftStoricoInCorsoWithItsHistoryCompleteIsClosedWhenASessionStarts() { await using var bed = await AlertBed.CreateAsync(start: Morning); var engine = bed.Engine; var account = await engine.AddAccountAsync("anna.prova", followed: true, state: AccountState.Backfilling, postCount: 7); await engine.Db.Accounts.SetBackfillAsync(account.Id, null, engine.Clock.Now); var runner = new ScriptedRunner(engine.Governor, engine.Clock); engine.Start(runner); await engine.RunUntilAsync(Morning.AddDays(1)); await engine.StopAsync(); await bed.Alerts.FlushAsync(); Assert.AreEqual(AccountState.UpToDate, (await engine.Db.Accounts.GetAsync(account.Id))!.State); var lines = await engine.Db.Events.ListAsync(new EventQuery { Codes = [EngineEventCodes.BackfillCompleted] }); Assert.HasCount(1, lines); Assert.AreEqual("Storico di @anna.prova completato: 0 post in libreria. Da ora lo tengo aggiornato.", lines[0].Message); Assert.IsNotNull(lines[0].SessionId); Assert.IsFalse(runner.Runs.Any(r => r.Request.Kind == RecipeKind.Backfill), "Nothing left to walk."); Assert.HasCount(1, bed.Shell.Notifications.Where(n => n.Title == AlertCatalog.Title(AlertKind.BackfillDone))); } /// The real recipes over the scripted site, on the engine's database, clock, Governor and breaker. private static (RecipeRunner Runner, ScriptedSite Site) RealRecipes(EngineTestBed engine) { var capture = new CaptureCollector(new ShapeReader(ReaderVocabulary.LoadTestSite()), engine.Clock); var site = new ScriptedSite(capture, engine.Clock); var runner = new RecipeRunner(new RecipeEnvironment { Driver = site, Capture = capture, Governor = engine.Governor, Budget = engine.Governor, DataBudget = engine.Governor, Signals = new SignalDetector(SignalRules.LoadTestSite(), engine.Breaker, engine.Clock), Storage = engine.Db, SiteMap = SiteMap.LoadTestSite(), Clock = engine.Clock, Random = new SeededRandom(7), Breaker = engine.Breaker, }); return (runner, site); } /// An account «Storico in corso» for a scripted account: posts only, so that a visit is the profile check. private static Task AddBackfillingAsync(EngineTestBed engine, ScriptedAccount scripted, int postCount) => engine.Db.Accounts.AddAsync(Account.Create(scripted.Username, StartingPoint.EverythingAndKeepUpdated, engine.Clock.Now, EngineTestBed.Zone, engine.Runtime.Profile) with { InstagramId = scripted.Id, IsFollowed = scripted.Followed, State = AccountState.Backfilling, ContentTypes = ContentTypes.PostPhotos | ContentTypes.PostVideos, PostCount = postCount, }); }