Files
Febe/tests/Febe.Tests/Engine/EngineHostTests.cs
T
Alby96andClaude Opus 5.5 31bbbf8bb7
verifica / controlli (push) Successful in 2m10s
verifica / prove (push) Successful in 26m16s
verifica / installatore (push) Successful in 5m39s
verifica / immagine (push) Successful in 28m39s
Instagram: Febe legge le risposte vere (campioni dal HAR del 21/10)
Febe non estraeva nulla da Instagram per due motivi. Instagram manda i
dati di storie e raccolte (GraphQL) come text/javascript, e la cattura
leggeva solo le risposte dichiarate JSON: le scartava tutte. E i file di
Instagram (lettori, bersagli) erano scheletri, quindi le ricette si
rifiutavano di girare.

Alberto ha mandato un HAR del suo browser e una guida. La guida descrive
richieste costruite a mano, vietate dalle regole 2-4, e un formato che
nel HAR non compare: non si usa. Dal HAR si è letta solo la forma; le
risposte utili sono diventate campioni grezzi fuori dal repository,
ripuliti e verificati con febe-sonda (tests/Febe.Tests/campioni/instagram).

Che cosa cambia:
- la cattura legge le risposte text/javascript chieste dalla pagina (mai
  gli script) e ogni blocco JSON incorporato nel documento della pagina,
  e avvisa quando un corpo atteso non arriverà;
- le risposte che non parlano di contenuti (promozioni, «storia vista»)
  si ignorano invece di valere come formato non riconosciuto;
- lettori.instagram.json è confermato, con sole chiavi presenti nei
  campioni; identificativi delle raccolte nella forma dell'indirizzo;
- bersagli.instagram.json ha le pagine viste nel traffico vero; i
  bersagli restano vuoti (H11): storie, raccolte, Taggati e Reel
  aspettano lo script tools/bersagli/raccogli-bersagli.js;
- le ricette del profilo reggono dati in risposte diverse e prendono la
  paginazione solo dalla risposta che porta i loro post; l'elenco dei
  seguiti scarta i profili suggeriti; «Tu» si riconosce anche dal solo
  identificativo dell'account collegato;
- il visualizzatore delle raccolte conta i contenuti (l'indirizzo non
  cambia), chiede il permesso prima di ogni contenuto e si chiude sempre;
- una ricetta che la configurazione non lascia girare è «Da configurare»:
  non è un guasto, non si sospende, non si pianifica; le sospensioni
  dovute ai file vecchi si azzerano una volta al cambio dei file;
- la barra laterale dice «Collegato» dal cookie di sessione; i «Post
  singolo» per gli indirizzi scaduti non vengono più annullati;
- febe-sonda da-har; la ripulitura tiene latest_reel_media e mette un
  riempitivo neutro sotto le chiavi simili a segreti (gitleaks).

Prove su Windows: 783 superate, 76 saltate (Chromium e Xvfb, nella CI).
Nulla è stato provato contro Instagram. Dettagli e decisioni in
docs/stato.md e docs/decisioni.md (righe del 25 ottobre).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 14:22:16 +01:00

635 lines
33 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using Febe.Core.Abstractions;
using Febe.Core.Domain;
using Febe.Core.Engine;
using Febe.Core.Storage;
using Febe.Tests.Engine.Support;
namespace Febe.Tests.Engine;
[TestClass]
public sealed class EngineHostTests
{
private static readonly DateTimeOffset Morning = EngineTestBed.Local(2026, 10, 14, 6, 0);
private static async Task<IReadOnlyList<SessionRecord>> SessionsAsync(EngineTestBed bed) =>
await bed.Db.Sessions.ListAsync(bed.Clock.Now.AddDays(-30), bed.Clock.Now.AddDays(1));
[TestMethod]
public async Task SessionsStayInsideTheWindowAndRespectThePauseFloor()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
await bed.AddAccountAsync("uno.demo", followed: false, Frequency.High);
await bed.AddAccountAsync("due.demo", followed: true);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(2));
var sessions = await SessionsAsync(bed);
Assert.IsTrue(sessions.Count > 20, $"{sessions.Count} sessions");
for (var i = 1; i < sessions.Count; i++)
{
var pause = sessions[i].StartedAt - sessions[i - 1].EndedAt!.Value;
Assert.IsTrue(pause >= TimeSpan.FromMinutes(20), $"pause of {pause}");
}
foreach (var session in sessions)
{
Assert.IsNotNull(await bed.Services.Planner.GetWindowAtAsync(session.StartedAt), $"session at {session.StartedAt:O}");
}
Assert.HasCount(0, await BudgetAudit.OutsideWindowAsync(bed.Db, bed.Services.Planner, Morning, bed.Clock.Now));
Assert.HasCount(0, await BudgetAudit.OverrunsAsync(bed.Db, bed.Runtime.Profile, EngineTestBed.Zone, Morning, bed.Clock.Now));
Assert.AreEqual(sessions.Count(s => s.EndedAt is not null), runner.Rests, "Every session ends on the empty page.");
// The first session comes 2–10 minutes after the start, but not before the window.
var window = await bed.Services.Planner.GetWindowAsync(new DateOnly(2026, 10, 14));
Assert.IsTrue(sessions[0].StartedAt >= window!.Start);
}
[TestMethod]
public async Task TheFirstSessionComesTwoToTenMinutesAfterTheStart()
{
await using var bed = await EngineTestBed.CreateAsync(EngineTestBed.Noon);
await bed.AddAccountAsync("uno.demo", followed: true);
bed.Start(new ScriptedRunner(bed.Governor, bed.Clock));
await bed.RunForAsync(TimeSpan.FromMinutes(30));
var first = (await SessionsAsync(bed))[0].StartedAt - EngineTestBed.Noon;
Assert.IsTrue(first >= TimeSpan.FromMinutes(2) && first <= TimeSpan.FromMinutes(10), $"first session after {first}");
}
[TestMethod]
public async Task ARestartResetsNoCountsAndDoesNotShortenPauses()
{
// 60 profiles a day, and no hourly limit in the way: demand is far above it.
var custom = CautionProfile.Prudent with
{
Budgets = new Dictionary<ActionKind, Budget>(CautionProfile.Prudent.Budgets) { [ActionKind.ProfileOpen] = new Budget(60, 60) },
};
await using var bed = await EngineTestBed.CreateAsync(Morning, settings: new EngineSettings { GradualStart = false }.WithCustomValues(custom));
for (var i = 0; i < 30; i++)
{
await bed.AddAccountAsync($"pubblico{i}.demo", followed: false, Frequency.High, types: ContentTypes.PostPhotos | ContentTypes.PostVideos);
}
await bed.AddAccountAsync("seguito.demo", followed: true);
bed.Start(new ScriptedRunner(bed.Governor, bed.Clock));
var window = await bed.Services.Planner.GetWindowAsync(new DateOnly(2026, 10, 14));
await bed.RunUntilAsync(window!.Start + TimeSpan.FromMinutes(70));
var openedBefore = await bed.Db.ActionLog.SumAsync(ActionKind.ProfileOpen, Morning, bed.Clock.Now);
Assert.IsTrue(openedBefore is > 0 and < 60, $"{openedBefore} profiles opened before the restart");
await bed.StopAsync();
var plannedNext = DateTimeOffset.FromUnixTimeMilliseconds((await bed.Db.Settings.GetInt64Async(EngineSettingKeys.NextSession))!.Value);
var lastEnd = (await SessionsAsync(bed)).Max(s => s.EndedAt!.Value);
var restartAt = bed.Clock.Now + TimeSpan.FromMinutes(1);
bed.Clock.AdvanceTo(restartAt);
await bed.ReopenAsync(seed: 4242);
bed.Start(new ScriptedRunner(bed.Governor, bed.Clock));
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 15, 0, 0));
var after = (await SessionsAsync(bed)).Where(s => s.StartedAt >= restartAt).ToList();
Assert.IsNotEmpty(after);
Assert.IsTrue(after[0].StartedAt >= plannedNext, "Not earlier than the session planned before the restart.");
Assert.IsTrue(after[0].StartedAt - lastEnd >= TimeSpan.FromMinutes(20), "The pause floor holds across the restart.");
Assert.IsTrue(after[0].StartedAt - restartAt >= TimeSpan.FromMinutes(2));
// Demand is far above the budget: the day ends exactly at the daily budget, counting the morning before the restart.
var openedToday = await bed.Db.ActionLog.SumAsync(ActionKind.ProfileOpen, Morning, bed.Clock.Now);
Assert.AreEqual(60L, openedToday);
Assert.HasCount(0, await BudgetAudit.OverrunsAsync(bed.Db, bed.Runtime.Profile, EngineTestBed.Zone, Morning, bed.Clock.Now));
}
[TestMethod]
public async Task RepeatedRestartsDoNotProduceMoreSessions()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
await bed.AddAccountAsync("uno.demo", followed: true);
var seed = 500;
for (var hour = 0; hour < 18; hour++)
{
bed.Start(new ScriptedRunner(bed.Governor, bed.Clock));
await bed.RunForAsync(TimeSpan.FromMinutes(59));
await bed.StopAsync();
await bed.ReopenAsync(++seed);
}
var sessions = await SessionsAsync(bed);
for (var i = 1; i < sessions.Count; i++)
{
Assert.IsTrue(sessions[i].StartedAt - sessions[i - 1].EndedAt!.Value >= TimeSpan.FromMinutes(20));
}
// A program that stays on makes at most 16 h / 20 min sessions in a window; restarts every hour stay well below.
Assert.IsTrue(sessions.Count <= 48, $"{sessions.Count} sessions");
}
[TestMethod]
public async Task MostSessionsOpenWithTheSweepAndAccountsComeInRandomOrder()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
for (var i = 0; i < 8; i++)
{
await bed.AddAccountAsync($"pubblico{i}.demo", followed: false, Frequency.High, types: ContentTypes.PostPhotos | ContentTypes.PostVideos);
}
await bed.AddAccountAsync("seguito.demo", followed: true);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(3));
var bySession = runner.Runs.GroupBy(r => r.SessionId).ToList();
var openedWithSweep = bySession.Count(g => g.First().Request.Kind == RecipeKind.FollowingSweep) / (double)bySession.Count;
Assert.IsTrue(openedWithSweep is > 0.75 and < 0.99, $"sweep first in {openedWithSweep:P0} of sessions");
var orders = bySession
.Select(g => string.Join(",", g.Where(r => r.Request.Kind == RecipeKind.ProfileCheck).Select(r => r.Request.AccountId)))
.Where(o => o.Contains(',', StringComparison.Ordinal))
.ToList();
Assert.IsTrue(orders.Distinct().Count() > orders.Count / 2, "The order of the accounts changes from session to session.");
// About one session in three stops after sweep and stories even with profile checks due.
var withChecks = bySession.Count(g => g.Any(r => r.Request.Kind == RecipeKind.ProfileCheck)) / (double)bySession.Count;
Assert.IsTrue(withChecks is > 0.45 and < 0.85, $"{withChecks:P0} of sessions with profile checks");
}
[TestMethod]
public async Task BackfillWaitsWhileTheAccountHasMoreThanSixtyFilesToDownload()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var account = await bed.AddAccountAsync("storico.demo", followed: true, state: AccountState.Backfilling, postCount: 3000);
for (var i = 0; i < 61; i++)
{
await bed.Db.Entries.AddAsync(
new Entry { AccountId = account.Id, Kind = EntryKind.Post, InstagramId = "attesa" + i, PublishedAt = Morning.AddDays(-400 + i), DiscoveredAt = Morning.AddDays(-1) },
[new Media { Position = 1, Kind = MediaKind.Photo, State = MediaState.ToDownload }]);
}
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(1));
Assert.IsFalse(runner.Runs.Any(r => r.Request.Kind == RecipeKind.Backfill));
Assert.IsTrue((await bed.Db.Events.ListAsync(new EventQuery())).Any(e => e.Code == EngineEventCodes.BackfillWaiting && e.AccountId == account.Id));
// Down to 60 waiting files: the backfill goes on.
var pending = await bed.Db.Media.ListPendingDownloadsAsync(10);
await bed.Db.Media.MarkStoredAsync(pending[0].Media.Id, new StoredFile("post/a.jpg", 10, new string('a', 64)), MediaState.Downloaded, bed.Clock.Now);
await bed.RunUntilAsync(Morning.AddDays(2));
Assert.IsTrue(runner.Runs.Any(r => r.Request.Kind == RecipeKind.Backfill && r.Request.AccountId == account.Id));
}
[TestMethod]
public async Task BackfillWaitsWhenTheDataBudgetIsReached()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
await bed.AddAccountAsync("storico.demo", followed: true, state: AccountState.Backfilling, postCount: 3000);
await bed.Governor.RecordAsync(4L * 1024 * 1024 * 1024, null, CancellationToken.None);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
bed.Start(runner);
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 15, 0, 0));
Assert.IsFalse(runner.Runs.Any(r => r.Request.Kind == RecipeKind.Backfill));
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 15, 23, 0));
Assert.IsTrue(runner.Runs.Any(r => r.Request.Kind == RecipeKind.Backfill));
}
[TestMethod]
public async Task BackfillAlternatesAmongAccountsAndPausesAfterTheSingleDownload()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var first = await bed.AddAccountAsync("primo.demo", followed: true, state: AccountState.Backfilling, postCount: 500);
var second = await bed.AddAccountAsync("secondo.demo", followed: true, state: AccountState.Backfilling, postCount: 500);
await bed.Db.Accounts.UpdateAsync((await bed.Db.Accounts.GetAsync(second.Id))! with { KeepUpdated = false });
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var backfills = 0;
DateTimeOffset? finishedAt = null;
runner.Script = request =>
{
if (request.Kind != RecipeKind.Backfill || request.AccountId != second.Id || ++backfills < 3)
{
return null;
}
finishedAt = bed.Clock.Now;
return new RecipeOutcome(RecipeStatus.Completed, 1, 12) { BackfillFinished = true };
};
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(1));
var sequence = runner.Runs.Where(r => r.Request.Kind == RecipeKind.Backfill).Select(r => r.Request.AccountId!.Value).Take(4).ToList();
CollectionAssert.AreEqual(new[] { first.Id, second.Id, first.Id, second.Id }, sequence, "One account per session, alternating.");
Assert.IsTrue(runner.Runs.GroupBy(r => r.SessionId).All(g => g.Count(r => r.Request.Kind == RecipeKind.Backfill) <= 1));
var finished = await bed.Db.Accounts.GetAsync(second.Id);
Assert.AreEqual(AccountState.Paused, finished!.State, "«Tieni aggiornato» off: one download, then paused.");
Assert.IsNotNull(finished.BackfillCompletedAt);
Assert.IsTrue((await bed.Db.Events.ListAsync(new EventQuery())).Any(e => e.Code == EngineEventCodes.BackfillCompleted));
Assert.IsFalse(runner.Runs.Any(r => r.Request.AccountId == second.Id && r.At > finishedAt), "A paused account is not contacted.");
}
[TestMethod]
public async Task ThreeUnrecognizedFormatsInARowSuspendTheRecipe()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var account = await bed.AddAccountAsync("strano.demo", followed: false, Frequency.High);
var runner = new ScriptedRunner(bed.Governor, bed.Clock)
{
Script = r => r.Kind == RecipeKind.ProfileCheck ? new RecipeOutcome(RecipeStatus.UnrecognizedFormat, 1, 0) : null,
};
var host = bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(2));
Assert.AreEqual(3, runner.Runs.Count(r => r.Request.Kind == RecipeKind.ProfileCheck));
Assert.IsTrue(host.SuspendedRecipes.ContainsKey(RecipeKind.ProfileCheck));
var events = await bed.Db.Events.ListAsync(new EventQuery());
Assert.AreEqual(3, events.Count(e => e.Code == EngineEventCodes.FormatUnrecognized));
Assert.IsTrue(events.Any(e => e.Code == EngineEventCodes.RecipeSuspended && e.Severity == EventSeverity.Error));
Assert.IsTrue((await bed.Db.Accounts.GetAsync(account.Id))!.Notices.HasFlag(AccountNotices.UnrecognizedFormat));
var snapshot = await host.Monitor.GetSnapshotAsync();
Assert.HasCount(1, snapshot.SuspendedRecipes);
runner.Script = null;
Assert.IsTrue(await host.ResumeRecipeAsync(RecipeKind.ProfileCheck));
await bed.RunUntilAsync(Morning.AddDays(3));
Assert.IsTrue(runner.Runs.Any(r => r.Request.Kind == RecipeKind.ProfileCheck && r.Status == RecipeStatus.Completed));
}
[TestMethod]
public async Task AnUnreachableAccountIsNotContactedAnyMore()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var account = await bed.AddAccountAsync("sparito.demo", followed: false, Frequency.High);
var runner = new ScriptedRunner(bed.Governor, bed.Clock)
{
Script = r => r.AccountId == account.Id ? new RecipeOutcome(RecipeStatus.AccountUnreachable, 1, 0) : null,
};
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(1));
Assert.AreEqual(1, runner.Runs.Count(r => r.Request.AccountId == account.Id));
Assert.AreEqual(AccountState.Unreachable, (await bed.Db.Accounts.GetAsync(account.Id))!.State);
Assert.IsTrue((await bed.Db.Events.ListAsync(new EventQuery())).Any(e => e.Code == EngineEventCodes.AccountUnreachable));
}
[TestMethod]
public async Task AThrottleClosesTheSessionAtOnceAndStopsForAnHour()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
await bed.AddAccountAsync("uno.demo", followed: false, Frequency.High);
await bed.AddAccountAsync("due.demo", followed: false, Frequency.High);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
DateTimeOffset? throttledAt = null;
runner.AfterGrant = r =>
{
if (throttledAt is null && r.Kind == RecipeKind.ProfileCheck)
{
throttledAt = bed.Clock.Now;
bed.Breaker.Report(new Signal(SignalLevel.Throttle, "http-429", null, bed.Clock.Now));
}
};
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(1));
Assert.IsNotNull(throttledAt);
var sessions = await SessionsAsync(bed);
var stopped = sessions.Single(s => s.StartedAt <= throttledAt && s.EndedAt >= throttledAt);
Assert.AreEqual(SessionOutcome.Throttled, stopped.Outcome);
Assert.IsTrue(stopped.EndedAt - throttledAt < TimeSpan.FromSeconds(30), "The session closes at once.");
var during = await bed.Db.ActionLog.ListAsync(throttledAt.Value.AddMilliseconds(1), throttledAt.Value + TimeSpan.FromHours(1));
Assert.HasCount(0, during.Where(a => a.Category != ActionKind.DataDownload).ToList());
Assert.IsTrue(sessions.Any(s => s.StartedAt > throttledAt.Value + TimeSpan.FromHours(1)), "It starts again by itself.");
}
[TestMethod]
public async Task AfterAVerificationNothingStartsUntilResumeWhichRestartsTheGradualStart()
{
await using var bed = await EngineTestBed.CreateAsync(Morning, gradualStart: true);
await bed.AddAccountAsync("uno.demo", followed: false, Frequency.High);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var challenged = false;
runner.AfterGrant = r =>
{
if (!challenged)
{
challenged = true;
bed.Breaker.Report(new Signal(SignalLevel.Challenge, "challenge-url", "https://sito.prova/challenge", bed.Clock.Now));
}
};
var host = bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(3));
Assert.IsTrue(challenged);
Assert.AreEqual(1, runner.Runs.Count, "Nothing after the verification signal.");
Assert.AreEqual(0, runner.Rests, "The page is left as it is.");
var snapshot = await host.Monitor.GetSnapshotAsync();
Assert.AreEqual(EngineMode.StoppedForVerification, snapshot.Mode);
Assert.IsNotNull(snapshot.Banner);
Assert.AreEqual(BannerLevel.Error, snapshot.Banner!.Level);
var resume = await host.ResumeAsync();
Assert.IsTrue(resume.Resumed);
Assert.AreEqual(0.5, bed.Governor.GetEffectiveBudgets(bed.Clock.Now).Factor, 1e-9);
await bed.RunForAsync(TimeSpan.FromHours(6));
Assert.IsTrue(runner.Runs.Count > 1, "Work goes on after «Riprendi».");
}
[TestMethod]
public async Task PauseStopsEverythingUntilResume()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
await bed.AddAccountAsync("uno.demo", followed: true);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var host = bed.Start(runner);
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 10, 0));
await host.PauseAsync();
var count = runner.Runs.Count;
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 20, 0));
Assert.AreEqual(count, runner.Runs.Count);
Assert.AreEqual(EngineMode.Paused, (await host.Monitor.GetSnapshotAsync()).Mode);
Assert.IsTrue(await bed.Db.Settings.GetBoolAsync(EngineSettingKeys.Paused, false));
await host.ResumeAsync();
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 22, 0));
Assert.IsTrue(runner.Runs.Count > count);
}
[TestMethod]
public async Task WhileAlbertoUsesTheBrowserTheEngineDoesNotAct()
{
var driving = false;
await using var bed = await EngineTestBed.CreateAsync(Morning, userIsDriving: () => driving);
await bed.AddAccountAsync("uno.demo", followed: true);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var host = bed.Start(runner);
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 10, 0));
driving = true;
host.NotifyUserDrivingChanged();
var count = runner.Runs.Count;
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 14, 0));
Assert.AreEqual(count, runner.Runs.Count);
Assert.AreEqual(EngineMode.UserDriving, (await host.Monitor.GetSnapshotAsync()).Mode);
driving = false;
host.NotifyUserDrivingChanged();
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 16, 0));
Assert.IsTrue(runner.Runs.Count > count);
}
[TestMethod]
public async Task WithoutAnInstagramSessionNothingStarts()
{
var connected = false;
await using var bed = await EngineTestBed.CreateAsync(Morning, isConnected: () => connected);
await bed.AddAccountAsync("uno.demo", followed: true);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var host = bed.Start(runner);
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 14, 0));
Assert.IsEmpty(runner.Runs);
Assert.AreEqual(EngineMode.NotConnected, (await host.Monitor.GetSnapshotAsync()).Mode);
connected = true;
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 16, 0));
Assert.IsNotEmpty(runner.Runs);
}
[TestMethod]
public async Task CheckNowOutsideTheWindowNeedsConfirmationAndRunsOnlyThatCheck()
{
var night = EngineTestBed.Local(2026, 10, 14, 1, 0);
await using var bed = await EngineTestBed.CreateAsync(night);
var asked = await bed.AddAccountAsync("chiesto.demo", followed: false);
await bed.AddAccountAsync("altro.demo", followed: false, Frequency.High);
await bed.AddAccountAsync("seguito.demo", followed: true);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var host = bed.Start(runner);
await bed.RunForAsync(TimeSpan.FromMinutes(20));
Assert.IsEmpty(runner.Runs, "Nothing at night on the engine's initiative.");
var first = await host.CheckNowAsync(asked.Id);
Assert.AreEqual(CheckNowStatus.NeedsConfirmation, first.Status);
Assert.IsNotNull(first.ConfirmationToken);
StringAssert.Contains(first.Message, "fuori dalla fascia");
Assert.AreEqual(CheckNowStatus.NeedsConfirmation, (await host.CheckNowAsync(asked.Id, "gettone-sbagliato")).Status);
var confirmed = await host.CheckNowAsync(asked.Id, first.ConfirmationToken);
Assert.AreEqual(CheckNowStatus.Queued, confirmed.Status);
await bed.RunForAsync(TimeSpan.FromHours(2));
Assert.IsNotEmpty(runner.Runs);
Assert.IsTrue(runner.Runs.All(r => r.Request.AccountId == asked.Id), "Only the confirmed check.");
Assert.IsTrue(runner.Runs.Any(r => r.Request.Kind == RecipeKind.ProfileCheck && r.Request.Manual));
Assert.HasCount(1, runner.Runs.Select(r => r.SessionId).Distinct().ToList());
var actions = await bed.Db.ActionLog.ListAsync(night, bed.Clock.Now);
Assert.IsTrue(actions.All(a => a.AccountId == asked.Id));
// The token was used: a second check needs a new confirmation.
Assert.AreEqual(CheckNowStatus.NeedsConfirmation, (await host.CheckNowAsync(asked.Id, first.ConfirmationToken)).Status);
// Normal work waits for the window.
var window = await bed.Services.Planner.GetWindowAsync(new DateOnly(2026, 10, 14));
await bed.RunUntilAsync(window!.Start + TimeSpan.FromHours(2));
Assert.IsTrue(runner.Runs.Where(r => r.Request.AccountId != asked.Id).All(r => r.At >= window.Start));
Assert.IsTrue(runner.Runs.Any(r => r.Request.AccountId != asked.Id));
}
[TestMethod]
public async Task CheckNowInsideTheWindowGoesOnTopOfTheQueueButAfterThePauseFloor()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var asked = await bed.AddAccountAsync("chiesto.demo", followed: true, Frequency.Low);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
var host = bed.Start(runner);
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 12, 0));
var before = runner.Runs.Count(r => r.Request.Manual);
var askedAt = bed.Clock.Now;
var result = await host.CheckNowAsync(asked.Id);
Assert.AreEqual(CheckNowStatus.Queued, result.Status);
StringAssert.Contains(result.Message, "cima alla coda");
await bed.RunForAsync(TimeSpan.FromMinutes(45));
var manual = runner.Runs.Where(r => r.Request.Manual).ToList();
Assert.AreEqual(before + 2, manual.Count, "Profile check and stories, on request.");
var session = (await SessionsAsync(bed)).Single(s => s.Id == manual[^1].SessionId);
var previous = (await SessionsAsync(bed)).Where(s => s.EndedAt <= session.StartedAt).Max(s => s.EndedAt!.Value);
Assert.IsTrue(session.StartedAt - previous >= TimeSpan.FromMinutes(20));
if (session.StartedAt >= askedAt)
{
Assert.IsTrue(runner.Runs.First(r => r.SessionId == session.Id).Request.Manual, "First thing of the session.");
}
}
[TestMethod]
public async Task CheckNowWithTheBudgetExhaustedIsRefused()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var asked = await bed.AddAccountAsync("chiesto.demo", followed: false);
for (var i = 0; i < 100; i++)
{
await bed.Db.ActionLog.AppendAsync(new ActionLogRecord { At = Morning.AddSeconds(i), Category = ActionKind.ProfileOpen });
}
var host = bed.Start(new ScriptedRunner(bed.Governor, bed.Clock));
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 12, 0));
var result = await host.CheckNowAsync(asked.Id);
Assert.AreEqual(CheckNowStatus.Refused, result.Status);
StringAssert.Contains(result.Message, "tetto giornaliero");
}
[TestMethod]
public async Task WhenAlbertoLetsGoOfTheBrowserThePageGoesBackToRestUnlessAVerificationKeepsIt()
{
var driving = false;
await using var bed = await EngineTestBed.CreateAsync(Morning, userIsDriving: () => driving);
await bed.AddAccountAsync("uno.demo", followed: true);
await bed.AddAccountAsync("due.demo", followed: false, Frequency.High);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
EngineHost? host = null;
int? restsWhenTaken = null;
// He takes the browser in the middle of a recipe (a story viewer may be open): the session ends and leaves the
// page to him.
runner.Before = r =>
{
if (restsWhenTaken is null && r.Kind != RecipeKind.FollowingSweep)
{
restsWhenTaken = runner.Rests;
driving = true;
host!.NotifyUserDrivingChanged();
}
return Task.CompletedTask;
};
host = bed.Start(runner);
await bed.RunUntilAsync(EngineTestBed.Local(2026, 10, 14, 12, 0));
Assert.IsNotNull(restsWhenTaken, "Alberto took the browser during a session.");
Assert.AreEqual(restsWhenTaken, runner.Rests, "While he drives the page is his.");
// He lets go during a pause: nothing starts, but nothing of what was open stays on the site either (§6.1, §6.3).
await host.PauseAsync();
driving = false;
host.NotifyUserDrivingChanged();
await bed.RunForAsync(TimeSpan.FromSeconds(1));
Assert.AreEqual(restsWhenTaken + 1, runner.Rests, "Back to rest as soon as he lets go.");
// After a verification the page stays as it is until «Riprendi» (§7.6), also when he lets go.
bed.Breaker.Report(new Signal(SignalLevel.Challenge, "challenge-url", "https://sito.prova/challenge", bed.Clock.Now));
await bed.Breaker.FlushAsync();
driving = true;
host.NotifyUserDrivingChanged();
await bed.RunForAsync(TimeSpan.FromMinutes(5));
driving = false;
host.NotifyUserDrivingChanged();
await bed.RunForAsync(TimeSpan.FromMinutes(5));
Assert.AreEqual(restsWhenTaken + 1, runner.Rests, "The verification page is left as it is.");
}
[TestMethod]
public async Task ChangingTheAccountsDuringARecipeDoesNotBringItsNextCheckForward()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var watched = await bed.AddAccountAsync("uno.demo", followed: false, Frequency.Low, types: ContentTypes.PostPhotos | ContentTypes.PostVideos);
await bed.AddAccountAsync("due.demo", followed: false, Frequency.Low, types: ContentTypes.PostPhotos | ContentTypes.PostVideos);
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
EngineHost? host = null;
DateTimeOffset? checkedAt = null;
// While the profile check of uno.demo runs (its task is «Running»), Alberto saves the settings of an account.
runner.Before = async r =>
{
if (checkedAt is null && r.Kind == RecipeKind.ProfileCheck && r.AccountId == watched.Id)
{
checkedAt = bed.Clock.Now;
await host!.NotifyAccountsChangedAsync();
}
};
host = bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(1));
Assert.IsNotNull(checkedAt);
var visits = runner.Runs
.Where(r => r.Request.Kind == RecipeKind.ProfileCheck && r.Request.AccountId == watched.Id && r.Status == RecipeStatus.Completed)
.Select(r => r.At)
.ToList();
// «Bassa», not followed: about every 12 hours, never sooner than 0.6 × 12 h.
for (var i = 1; i < visits.Count; i++)
{
Assert.IsTrue(visits[i] - visits[i - 1] >= TimeSpan.FromHours(7), $"Visit after {visits[i] - visits[i - 1]}: the interval of the frequency holds.");
}
var pending = (await bed.Db.Tasks.ListPendingAsync(1000))
.Where(t => t.Kind == EngineTaskKind.ProfileCheck && t.AccountId == watched.Id)
.ToList();
Assert.HasCount(1, pending, "One planned check, not a second one from the queue sync.");
Assert.IsTrue(pending[0].DueAt >= visits[^1] + TimeSpan.FromHours(7), $"Next check at {pending[0].DueAt:O}, after {visits[^1]:O}.");
}
[TestMethod]
public async Task HighlightCollectionsAreLookedAtOncePerIntervalAndNoLongerOnceGone()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var account = await bed.AddAccountAsync("uno.demo", followed: true, Frequency.High);
await bed.Db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "17900000001", Title = "Viaggi", DiscoveredAt = Morning });
var food = await bed.Db.Highlights.UpsertAsync(new Highlight { AccountId = account.Id, InstagramId = "17900000002", Title = "Cucina", Position = 1, DiscoveredAt = Morning });
var noStories = await bed.AddAccountAsync("due.demo", followed: true, Frequency.High, types: ContentTypes.PostPhotos);
await bed.Db.Highlights.UpsertAsync(new Highlight { AccountId = noStories.Id, InstagramId = "17900000003", Title = "Altro", DiscoveredAt = Morning });
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
// Like the real recipe: the collection is marked as looked at.
runner.Before = async r =>
{
if (r.Kind == RecipeKind.Highlight && await bed.Db.Highlights.FindAsync(account.Id, r.HighlightId!) is { } highlight)
{
await bed.Db.Highlights.UpsertAsync(highlight with { LastCheckedAt = bed.Clock.Now });
}
};
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(3));
List<RunRecord> Looks(string id) => [.. runner.Runs.Where(r => r.Request.Kind == RecipeKind.Highlight && r.Request.HighlightId == id)];
foreach (var id in new[] { "17900000001", "17900000002" })
{
var looks = Looks(id);
Assert.IsNotEmpty(looks, $"Collection {id} of an account that wants «Storie in evidenza» is looked at.");
Assert.IsTrue(looks.All(l => l.Request.AccountId == account.Id));
for (var i = 1; i < looks.Count; i++)
{
// «Alta»: every 24 hours or so, never sooner than 0.6 × 24 h.
Assert.IsTrue(looks[i].At - looks[i - 1].At >= TimeSpan.FromHours(14), $"Look after {looks[i].At - looks[i - 1].At}.");
}
}
Assert.IsEmpty(Looks("17900000003"), "«Storie in evidenza» off: not looked at.");
var all = runner.Runs.Where(r => r.Request.Kind == RecipeKind.Highlight).ToList();
Assert.AreEqual(all.Count, all.Select(r => r.SessionId).Distinct().Count(), "One collection per account and session.");
// A collection that left the profile is no longer looked at; the other one still is.
await bed.Db.Highlights.MarkRemovedAsync(food.Id, bed.Clock.Now);
var foodLooks = Looks("17900000002").Count;
var travelLooks = Looks("17900000001").Count;
await bed.RunUntilAsync(Morning.AddDays(6));
Assert.HasCount(foodLooks, Looks("17900000002"));
Assert.IsTrue(Looks("17900000001").Count > travelLooks);
}
[TestMethod]
public async Task ASinglePostQueuedByTheCollectionRunsInsteadOfBeingCancelledByTheQueue()
{
await using var bed = await EngineTestBed.CreateAsync(Morning);
var account = await bed.AddAccountAsync("uno.demo", followed: true);
var paused = await bed.AddAccountAsync("due.demo", followed: true, state: AccountState.Paused);
// As CollectionWriter.QueueSinglePostAsync queues it for an address that expired (spec §6.5 point 5).
EngineTask SinglePost(Account a, string entryId) =>
new() { Kind = EngineTaskKind.SinglePost, AccountId = a.Id, Payload = entryId, DueAt = Morning, CreatedAt = Morning };
var refresh = await bed.Db.Tasks.EnqueueAsync(SinglePost(account, "41"));
var held = await bed.Db.Tasks.EnqueueAsync(SinglePost(paused, "42"));
var runner = new ScriptedRunner(bed.Governor, bed.Clock);
bed.Start(runner);
await bed.RunUntilAsync(Morning.AddDays(1));
var runs = runner.Runs.Where(r => r.Request.Kind == RecipeKind.SinglePost).ToList();
Assert.HasCount(1, runs, "The expired address is refreshed once, on the account that may be contacted.");
Assert.AreEqual(41L, runs[0].Request.EntryId);
Assert.AreEqual(account.Id, runs[0].Request.AccountId);
Assert.AreEqual(EngineTaskState.Done, (await bed.Db.Tasks.GetAsync(refresh.Id))!.State);
Assert.AreEqual(EngineTaskState.Cancelled, (await bed.Db.Tasks.GetAsync(held.Id))!.State, "«In pausa»: not contacted.");
}
}