Quando lo storico si chiudeva con una corsa finita per un segnale o un'interruzione, il compito dello Storico tornava in coda come «Fermata da un segnale» o «Interrotta». Fino alla sessione dopo (dopo una verifica, fino a «Riprendi») la Coda mostrava uno Storico da fare per un account già «Aggiornato» o «In pausa». Lo stesso accadeva con lo storico chiuso dal controllo del profilo, e per un account rimasto in pausa restavano in coda anche i suoi controlli (rilievo F3 della revisione). - La corsa dello Storico arrivata in fondo chiude il suo compito anche se poi si è fermata. - FinishBackfillAsync toglie dalla coda lo Storico dell'account e, se l'account resta in pausa, tutto ciò che era pianificato per lui, come farebbe la sessione dopo. I comandi di Alberto restano. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
255 lines
14 KiB
C#
255 lines
14 KiB
C#
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;
|
|
|
|
/// <summary>
|
|
/// «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.
|
|
/// </summary>
|
|
[TestClass]
|
|
public sealed class BackfillCompletedTests
|
|
{
|
|
private static readonly DateTimeOffset Morning = EngineTestBed.Local(2026, 10, 14, 6, 0);
|
|
|
|
/// <summary>Found testing Febe for Windows on the test site: two lines in «Avvisi» for one history, at 14:31.</summary>
|
|
[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.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// 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).
|
|
/// </summary>
|
|
[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)));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
[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);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
[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)));
|
|
}
|
|
|
|
/// <summary>The real recipes over the scripted site, on the engine's database, clock, Governor and breaker.</summary>
|
|
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);
|
|
}
|
|
|
|
/// <summary>An account «Storico in corso» for a scripted account: posts only, so that a visit is the profile check.</summary>
|
|
private static Task<Account> 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,
|
|
});
|
|
}
|