Files
Febe/tests/Febe.Tests/Engine/ProfileSearchEngineTests.cs
Alby96andClaude Opus 5.5 9941a2fa1f
verifica / controlli (push) Successful in 20s
verifica / prove (push) Failing after 19m40s
verifica / installatore (push) Skipped
verifica / immagine (push) Skipped
Ricerca dei profili con suggerimenti e foto (#37)
«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>
2026-11-15 16:30:03 +01:00

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);
}
}