«Aggiungi account» ha una sola casella: mentre Alberto scrive compaiono subito i suggerimenti locali, poi i profili di Instagram con la foto, come chiesto in #37. Il browser di Febe scrive nella casella «Cerca» di Instagram con tasti veri da una mappa chiusa (mai Invio, Tab o Esc), controlla prima il fuoco, legge la risposta della pagina e non clicca mai un risultato. La ricerca ha una categoria propria nel Governatore, con tetti larghi che non consumano quelli della raccolta, e si dà il turno con il motore sull'unica pagina; a fine sessione la pagina torna comunque al riposo. Le foto passano dal CDN con un permesso ciascuna e restano solo in memoria. Le risposte di Alberto del 15 novembre (controllo del fuoco, turni, evento requestWillBeSent, niente foto dei seguiti per ora) sono in §6.1 e in docs/decisioni.md. Su Instagram vero la ricerca parte quando i bersagli search-open e search-box saranno raccolti dal vivo. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
226 lines
10 KiB
C#
226 lines
10 KiB
C#
using Febe.Core.Abstractions;
|
|
using Febe.Core.Domain;
|
|
using Febe.Core.Engine;
|
|
using Febe.Tests.Engine.Support;
|
|
|
|
namespace Febe.Tests.Engine;
|
|
|
|
/// <summary>The profile search in the engine (issue #37): its own Governor category and the turns of the page.</summary>
|
|
[TestClass]
|
|
public sealed class ProfileSearchEngineTests
|
|
{
|
|
[TestMethod]
|
|
public async Task ASearchStepNeedsNoSessionAndIsLoggedWithoutOne()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
|
|
var permit = await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None);
|
|
|
|
Assert.IsTrue(permit.Granted, permit.Message);
|
|
var logged = await bed.Db.ActionLog.ListAsync(bed.Clock.Now.AddMinutes(-1), bed.Clock.Now.AddMinutes(1));
|
|
Assert.HasCount(1, logged);
|
|
Assert.AreEqual(ActionKind.ProfileSearch, logged[0].Category);
|
|
Assert.IsNull(logged[0].SessionId);
|
|
Assert.IsNull(logged[0].AccountId);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task InsideASessionTheSearchIsNotAnActionOfTheSession()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
var session = await bed.BeginSessionAsync();
|
|
|
|
Assert.IsTrue((await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None)).Granted);
|
|
|
|
Assert.AreEqual(0, session.ActionCount, "a search step does not count toward the session's actions");
|
|
var logged = await bed.Db.ActionLog.ListAsync(bed.Clock.Now.AddMinutes(-1), bed.Clock.Now.AddMinutes(1));
|
|
Assert.IsNull(logged.Single().SessionId);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OutsideTheWindowTheSearchDoesNotOpenTheSite()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync(EngineTestBed.Local(2026, 10, 14, 3, 0));
|
|
|
|
var permit = await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None);
|
|
|
|
Assert.AreEqual(DenialReason.OutsideActiveWindow, permit.Reason);
|
|
StringAssert.Contains(permit.Message!, "Fuori dalla fascia oraria");
|
|
StringAssert.Contains(permit.Message!, "profili che segui");
|
|
Assert.IsNotNull(permit.RetryAfter);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task EveryStopOfTheBreakerStopsTheSearch()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
await bed.Breaker.ReportAsync(new Signal(SignalLevel.Throttle, "http-429", null, bed.Clock.Now));
|
|
|
|
var permit = await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None);
|
|
|
|
Assert.AreEqual(DenialReason.BreakerOpen, permit.Reason);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AlbertoAtTheBrowserAndThePauseStopTheSearch()
|
|
{
|
|
var driving = true;
|
|
await using var bed = await EngineTestBed.CreateAsync(userIsDriving: () => driving);
|
|
|
|
var atBrowser = await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None);
|
|
Assert.AreEqual(DenialReason.UserIsDriving, atBrowser.Reason);
|
|
StringAssert.Contains(atBrowser.Message!, "ricerca su Instagram");
|
|
|
|
driving = false;
|
|
bed.Runtime.IsPaused = true;
|
|
Assert.AreEqual(DenialReason.Paused, (await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None)).Reason);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheSearchHasItsOwnBudgetThatDoesNotTouchTheCollection()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
bed.Clock.AutoAdvance = true;
|
|
var homeBefore = await bed.Governor.RemainingAsync(ActionKind.Home);
|
|
var profileBefore = await bed.Governor.RemainingAsync(ActionKind.ProfileOpen);
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
Assert.IsTrue((await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None)).Granted);
|
|
}
|
|
|
|
Assert.AreEqual(homeBefore, await bed.Governor.RemainingAsync(ActionKind.Home));
|
|
Assert.AreEqual(profileBefore, await bed.Governor.RemainingAsync(ActionKind.ProfileOpen));
|
|
Assert.AreEqual(240 - 5, await bed.Governor.RemainingAsync(ActionKind.ProfileSearch), "«Prudente»: 240 search steps per hour");
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TheSearchBudgetsAreWideButBelowTwiceRapido()
|
|
{
|
|
var prudent = CautionProfile.Prudent.Budgets[ActionKind.ProfileSearch];
|
|
var balanced = CautionProfile.Balanced.Budgets[ActionKind.ProfileSearch];
|
|
var fast = CautionProfile.Fast.Budgets[ActionKind.ProfileSearch];
|
|
Assert.IsTrue(prudent.PerHour <= balanced.PerHour && balanced.PerHour <= fast.PerHour);
|
|
Assert.IsTrue(prudent.PerDay <= balanced.PerDay && balanced.PerDay <= fast.PerDay);
|
|
Assert.IsTrue(prudent.PerHour > CautionProfile.Fast.Budgets[ActionKind.ProfileOpen].PerHour, "wide: typing a name takes several steps");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task HalvedBudgetsAfterAThrottleApplyToTheSearchToo()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
await bed.Breaker.ReportAsync(new Signal(SignalLevel.Throttle, "http-429", null, bed.Clock.Now));
|
|
bed.Clock.Advance(TimeSpan.FromHours(1));
|
|
var budgets = bed.Governor.GetEffectiveBudgets(bed.Clock.Now);
|
|
Assert.AreEqual(new Budget(120, 600), budgets.Budgets[ActionKind.ProfileSearch]);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheSearchKeepsItsOwnSpacingAndAGapFromTheEngineBothWays()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
await bed.BeginSessionAsync();
|
|
var spacing = bed.Governor.SearchSpacing;
|
|
|
|
Assert.IsTrue((await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None)).Granted);
|
|
var again = await bed.Governor.EvaluateAsync(ActionKind.ProfileSearch, null);
|
|
Assert.AreEqual(DenialReason.MinimumSpacing, again.Reason, "the search's own spacing");
|
|
|
|
// The engine right after a search step waits the crossing gap, not its own 4 s spacing.
|
|
var engine = await bed.Governor.EvaluateAsync(ActionKind.Home, null);
|
|
Assert.AreEqual(DenialReason.MinimumSpacing, engine.Reason);
|
|
Assert.AreEqual(bed.Clock.Now + spacing, engine.RetryAfter);
|
|
|
|
bed.Clock.Advance(spacing);
|
|
Assert.IsTrue((await bed.Governor.RequestAsync(ActionKind.Home, null, CancellationToken.None)).Granted);
|
|
|
|
// And the search right after an engine action waits the same gap.
|
|
var search = await bed.Governor.EvaluateAsync(ActionKind.ProfileSearch, null);
|
|
Assert.AreEqual(DenialReason.MinimumSpacing, search.Reason);
|
|
Assert.AreEqual(bed.Clock.Now + spacing, search.RetryAfter);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheEngineSpacingIgnoresTheSearchSteps()
|
|
{
|
|
await using var bed = await EngineTestBed.CreateAsync();
|
|
await bed.BeginSessionAsync();
|
|
Assert.IsTrue((await bed.Governor.RequestAsync(ActionKind.Home, null, CancellationToken.None)).Granted);
|
|
var home = bed.Clock.Now;
|
|
bed.Clock.Advance(TimeSpan.FromSeconds(2));
|
|
Assert.IsTrue((await bed.Governor.RequestAsync(ActionKind.ProfileSearch, null, CancellationToken.None)).Granted);
|
|
|
|
Assert.AreEqual(home, await bed.Db.ActionLog.GetLastActionAtAsync(null), "the engine's last action is not a search step");
|
|
Assert.AreEqual(bed.Clock.Now, await bed.Db.ActionLog.GetLastActionAtAsync(ActionKind.ProfileSearch));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------------------- page turns
|
|
|
|
[TestMethod]
|
|
public async Task TurnsAreGivenInOrderOneAtATime()
|
|
{
|
|
var turns = new PageTurns();
|
|
var engine = await turns.TakeAsync(PageUser.Engine, CancellationToken.None);
|
|
Assert.AreEqual(PageUser.Engine, turns.Holder);
|
|
var searchTask = turns.TakeAsync(PageUser.Search, CancellationToken.None).AsTask();
|
|
Assert.IsFalse(searchTask.IsCompleted);
|
|
Assert.IsTrue(turns.IsWaiting(PageUser.Search));
|
|
|
|
await engine.DisposeAsync();
|
|
var search = await searchTask.WaitAsync(TimeSpan.FromSeconds(5));
|
|
Assert.AreEqual(PageUser.Search, turns.Holder);
|
|
search.Dispose();
|
|
Assert.IsNull(turns.Holder);
|
|
await turns.WhenFreeAsync(CancellationToken.None).WaitAsync(TimeSpan.FromSeconds(5));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheEngineYieldsOnlyWhenTheSearchWaits()
|
|
{
|
|
var turns = new PageTurns();
|
|
var engine = await turns.TakeAsync(PageUser.Engine, CancellationToken.None);
|
|
Assert.IsFalse(await turns.YieldAsync(engine, CancellationToken.None), "nobody waits: no yield");
|
|
|
|
var searchTask = turns.TakeAsync(PageUser.Search, CancellationToken.None).AsTask();
|
|
var yieldTask = turns.YieldAsync(engine, CancellationToken.None).AsTask();
|
|
var search = await searchTask.WaitAsync(TimeSpan.FromSeconds(5));
|
|
Assert.IsFalse(yieldTask.IsCompleted, "the engine waits for the search step");
|
|
await search.DisposeAsync();
|
|
Assert.IsTrue(await yieldTask.WaitAsync(TimeSpan.FromSeconds(5)));
|
|
Assert.AreSame(engine, turns.EngineTurn);
|
|
engine.Dispose();
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ACancelledWaitLeavesTheQueue()
|
|
{
|
|
var turns = new PageTurns();
|
|
var engine = await turns.TakeAsync(PageUser.Engine, CancellationToken.None);
|
|
using var cts = new CancellationTokenSource();
|
|
var waiting = turns.TakeAsync(PageUser.Search, cts.Token).AsTask();
|
|
await cts.CancelAsync();
|
|
await Assert.ThrowsAsync<OperationCanceledException>(async () => await waiting);
|
|
Assert.IsFalse(turns.IsWaiting(PageUser.Search));
|
|
engine.Dispose();
|
|
Assert.IsNull(turns.Holder);
|
|
}
|
|
|
|
[TestMethod]
|
|
public void TheSearchMarksThePageAndARestClearsIt()
|
|
{
|
|
var turns = new PageTurns();
|
|
var rested = 0;
|
|
turns.Rested += () => rested++;
|
|
turns.NoteOpened(PageUser.Search);
|
|
Assert.AreEqual(PageUser.Search, turns.LastUser);
|
|
Assert.IsTrue(turns.SearchTouchedPage);
|
|
turns.NoteOpened(PageUser.Engine);
|
|
Assert.IsFalse(turns.SearchTouchedPage);
|
|
turns.NoteSearchUsedPage();
|
|
Assert.IsTrue(turns.SearchTouchedPage);
|
|
turns.NoteRested();
|
|
Assert.IsNull(turns.LastUser);
|
|
Assert.IsFalse(turns.SearchTouchedPage);
|
|
Assert.AreEqual(1, rested);
|
|
}
|
|
}
|