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>
635 lines
33 KiB
C#
635 lines
33 KiB
C#
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.");
|
||
}
|
||
}
|