Files
Febe/tests/Febe.Tests.Windows/Support/BrowserBed.cs
T
Alby96andClaude Opus 5.5 2bbad2e9b7 «Pagina iniziale» solo finché Alberto guida, e la vista che non si blocca (#52)
Una verifica indipendente di 654076d ha trovato tre punti deboli.

- «Pagina iniziale» guardava il permesso di guida una volta sola, prima di
  aspettare fino a 15 s la fine della sessione e 15 s il turno della pagina
  (che poi prendeva comunque). Se nel frattempo Alberto chiudeva la finestra,
  Febe navigava senza permesso e fuori dal Governatore (regole 7 e 8). Ora la
  pressione vale finché dura il permesso di chi l'ha premuta: la finestra di
  Windows passa un gettone che si annulla con il suo permesso, la vista remota
  quello della propria vita. Con il turno della pagina in mano la connessione
  guarda di nuovo che Alberto guidi ancora; senza turno rinuncia invece di
  prendere la pagina a un passo della ricerca. L'attesa del turno è
  BrowserConnectionService.PageTurnWait (15 s, le prove la accorciano).
- Nella vista remota «Pagina iniziale» aspettava dentro il ciclo di ricezione:
  la vista restava ferma fino a mezzo minuto e poi riversava clic e tasti sulla
  pagina nuova. Ora la pressione corre a parte, una per volta, e intanto clic,
  tasti, «Indietro» e «Ricarica» si scartano.
- Repaint chiedeva un ridisegno sincrono (RDW_UPDATENOW) a finestre figlie del
  processo del browser di WebView2: uno bloccato avrebbe fermato il thread
  dell'interfaccia. Ora si chiede solo di ridisegnare.

Prove nuove, che senza le correzioni non passano: la pressione dimenticata se
Alberto lascia il browser, quella che finisce con il permesso di chi l'ha
premuta, la pagina mai tolta a un passo della ricerca, la vista che non si
blocca e scarta l'input; su Windows con WebView2 vero, il gettone che si
annulla quando la finestra si chiude. PROTOCOLLO.md, la guida e decisioni.md
dicono il comportamento nuovo.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 13:53:29 +01:00

139 lines
5.5 KiB
C#

using Febe.App;
using Febe.Browser.Cdp;
using Febe.Core.Abstractions;
using Febe.Core.Library;
using Febe.Data;
using Febe.Desktop.Browser;
using Febe.Desktop.Core;
using Febe.Web.Engine;
namespace Febe.Tests.Windows.Support;
/// <summary>
/// The browser of Febe for Windows on its own, as the composition builds it (<see cref="DesktopPlatform"/> through
/// <c>DesktopShell</c>): a <see cref="WebView2Browser"/> with its window «Browser di Febe» and WebView2 on a real UI
/// thread, a profile in a temporary Data folder, the switches of S2 and the log of Febe captured.
/// </summary>
internal sealed class BrowserBed : IAsyncDisposable
{
private BrowserBed(TestFolder folder, UiThread ui, LogLines lines, FebeLog log, FebeDatabase database, BrowserUseTracker tracker, WebView2Browser browser)
{
Folder = folder;
Ui = ui;
Lines = lines;
Log = log;
Database = database;
Tracker = tracker;
Browser = browser;
}
public TestFolder Folder { get; }
public UiThread Ui { get; }
/// <summary>What Febe wrote in its log.</summary>
public LogLines Lines { get; }
public FebeLog Log { get; }
public FebeDatabase Database { get; }
/// <summary>When Alberto last used the browser («Riprendi» after a verification).</summary>
public BrowserUseTracker Tracker { get; }
public WebView2Browser Browser { get; }
/// <param name="name">Prefix of the temporary folder.</param>
/// <param name="hosting">How WebView2 draws (S2).</param>
/// <param name="startPage">
/// Where «Pagina iniziale» goes, opened as the connection would (here without an engine to wait for); null: the button
/// does nothing (never the default login page of the options, which is Instagram's).
/// </param>
/// <param name="openStartPage">What «Pagina iniziale» does instead (it wins over <paramref name="startPage"/>).</param>
public static async Task<BrowserBed> CreateAsync(string name, BrowserHosting hosting = BrowserHosting.Window, Func<string>? startPage = null, Func<CancellationToken, Task>? openStartPage = null)
{
var folder = new TestFolder(name);
var ui = await UiThread.StartAsync();
var lines = new LogLines();
var clock = new SystemClock();
var log = new FebeLog(null, lines, clock);
var data = new DataFolderLayout(folder.Combine("dati"));
var database = await FebeDatabase.OpenAsync(data.Root);
var options = new FebeAppOptions { DataFolder = data.Root, LibraryFolder = folder.Combine("libreria") };
var tracker = new BrowserUseTracker();
WebView2Browser? built = null;
openStartPage ??= startPage is null ? null : async ct => await built!.Cdp.NavigateAsync(startPage(), ct);
var context = new FebePlatformContext(options, data, database, clock, log, tracker, openStartPage);
var settings = new WebView2BrowserSettings(data.BrowserProfile, 1280, 900, hosting, BrowserArguments.ForWebView2());
// Built off the UI thread, as DesktopPlatform.CreateBrowserAsync does after its awaits.
var browser = new WebView2Browser(ui.Dispatcher, settings, context, icon: null);
built = browser;
return new BrowserBed(folder, ui, lines, log, database, tracker, browser);
}
/// <summary>Waits (real time) until <paramref name="condition"/> holds; fails with <paramref name="what"/> and the log otherwise.</summary>
public async Task WaitUntilAsync(Func<bool> condition, TimeSpan timeout, string what, CancellationToken ct)
{
var deadline = DateTime.UtcNow + timeout;
while (!condition())
{
if (DateTime.UtcNow > deadline)
{
Assert.Fail($"Tempo scaduto: {what}.\n{Lines.Text}");
}
await Task.Delay(50, ct);
}
}
/// <summary>Reads a value of the UI thread (the window, its position) through the dispatcher.</summary>
public Task<T> OnUiAsync<T>(Func<T> read) => Ui.InvokeAsync(read);
/// <summary>The class names of the child windows of «Browser di Febe»: one per WebView hosted in it.</summary>
public Task<IReadOnlyList<string>> ChildWindowsAsync() =>
OnUiAsync(() => Browser.Host.Window is { } window ? ChildWindows.Of(window.Handle) : (IReadOnlyList<string>)[]);
/// <summary>
/// Starts the browser from a thread-pool thread, like <c>FebeApp.BringUpBrowserAsync</c>, and waits until
/// <see cref="WebView2Browser.RunAsync"/> returns. Fails at once when the log reports a failed start: the loop of
/// retries would otherwise go on for ever.
/// </summary>
public async Task StartAsync(CancellationToken ct, TimeSpan? timeout = null)
{
var run = Task.Run(() => Browser.RunAsync(ct), ct);
var deadline = DateTime.UtcNow + (timeout ?? TimeSpan.FromSeconds(60));
while (!run.IsCompleted)
{
if (Lines.Any("non parte"))
{
Assert.Fail("Il browser di Febe non è partito al primo tentativo:\n" + Lines.Text);
}
if (DateTime.UtcNow > deadline)
{
Assert.Fail("Il browser di Febe non è diventato disponibile in tempo:\n" + Lines.Text);
}
await Task.Delay(50, ct);
}
await run;
}
public async ValueTask DisposeAsync()
{
try
{
await Browser.DisposeAsync();
}
finally
{
await Ui.DisposeAsync();
await Database.DisposeAsync();
Log.Dispose();
Folder.Dispose();
}
}
}