Files
Febe/tests/Febe.Tests/Server/RemoteViewStartTests.cs
T
Alby96andClaude Opus 5.5 654076d280 Browser vuoto: correzioni dopo la revisione (#52)
La revisione di c49df4c ha trovato alcuni punti deboli. Si correggono qui.

- Fuori vista la pagina torna al 100%. Lo zoom calcolato per uno schermo
  piccolo restava anche per le sessioni del motore, e le pagine vedevano un
  devicePixelRatio diverso (regola 4). Il rapporto si ricalcola solo quando
  la finestra viene sullo schermo.
- Pulsante nella barra delle applicazioni. WPF lo cambia nascondendo la
  finestra e mostrandola di nuovo (verificato con un aggancio a
  WM_WINDOWPOSCHANGED). Ora il pulsante cambia solo mentre la finestra è
  fuori vista. Sullo schermo la finestra chiede di ridisegnarsi
  (RedrawWindow), senza nulla che la pagina veda. Una prova con WebView2
  vero controlla che la finestra non si nasconda mai sullo schermo.
- Ridotta a icona troppo a lungo, la finestra si ripristina coperta (DWM) e
  senza prendere il fuoco, e si sposta fuori vista prima di scoprirsi. Prima
  ricompariva per un attimo dove stava. Spostare la posizione di ripristino
  non basta: Windows la riporta su uno schermo (provato).
- Dopo un riavvio del processo GPU i bordi della pagina cambiano davvero: un
  pixel in meno, poi quelli veri. Gli stessi bordi di nuovo potevano non
  servire a nulla.
- «Pagina iniziale», sulla barra di Windows e nella vista remota, passa da
  BrowserConnectionService.OpenStartPageAsync. Aspetta la fine della
  sessione del motore e il turno della pagina, come l'apertura dal riposo,
  e agisce solo mentre Alberto guida.
- Vista remota.
  - Dopo un riavvio dei fotogrammi la vista aspetta il primo fotogramma per
    mezzo secondo prima dell'immagine ferma: Chromium lo manda solo dopo la
    risposta allo start, e prima quasi ogni riavvio costava una cattura.
  - L'immagine ferma si scarta se nel frattempo arriva un fotogramma vero.
  - Il silenzio si conta dall'avvio.
  - Un riavvio del browser durante la chiusura non lascia eccezioni non
    osservate.
- Un POST vuoto senza Content-Length (a pezzi, HTTP/2) non dà più 400 su
  begin, cancel e browser/show (ApiHttp.OptionalBodyAsync).
- La pagina Browser toglie ?accesso=1 dall'indirizzo. Ricaricarla riapriva
  la pagina di accesso.
- RemoteViewFramesTests aspetta fino a 20 s invece di 5. Controlla che
  l'immagine arrivi, non quanto in fretta; il tempo va nell'uscita della
  prova.

Aggiornati PROTOCOLLO.md, la guida (Primo collegamento, Installazione
Windows) e docs/decisioni.md con le righe di #52.

Prove nuove:
- AFrameSoonAfterARestartNeedsNoStillPicture
- PaginaInizialeWaitsForThePageTurnAndActsOnlyWhileAlbertoIsAtTheBrowser
- ABodyWithoutALengthIsReadAndAnEmptyOneIsNoBody
- nella prova della finestra vera: nessun nascondere sullo schermo e pagina
  al 100% fuori vista

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

328 lines
13 KiB
C#

using System.Diagnostics;
using System.Text.Json.Nodes;
using Febe.App;
using Febe.Browser.Cdp;
using Febe.Browser.Hosting;
using Febe.Browser.RemoteView;
using Febe.Core.Abstractions;
using Febe.Server;
using Febe.Tests.Browser.TestSupport;
using Febe.Web.Connection;
using Febe.Web.Engine;
namespace Febe.Tests.Server;
/// <summary>
/// Opening the remote view while the page changes document (Gitea issue #3), without a browser. From
/// <c>ReadyToCommitNavigation</c> of a navigation in a new RenderFrameHost until it commits, Chromium answers
/// <c>Page.startScreencast</c> with -32000 «Not attached to an active page»: the view must open once the new document is
/// there, a page that never gets there must still end in «non risponde» within a few seconds, and a browser that is gone
/// must say so at once.
/// </summary>
[TestClass]
public sealed class RemoteViewStartTests
{
public TestContext TestContext { get; set; } = null!;
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task AViewOpenedWhileThePageChangesDocumentOpensOnceTheNewDocumentIsThere()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(attempt => attempt == 1 ? InactivePage() : null);
var view = await bed.Host.OpenAsync(ct);
Assert.IsNull(view.Ended, "the view is open");
Assert.AreEqual(2, bed.Starts, "the start refused while the page changed document was sent again");
Assert.AreEqual(1, bed.Browser.UserDriving.Leases, "the open view holds the browser");
Assert.IsLessThan(TimeSpan.FromSeconds(1), bed.Elapsed, "a short pause, not the whole budget");
// Frames flow to the view: meta first, then the JPEG.
bed.Cdp.Raise("Page.screencastFrame", Frame());
var outputs = await ReadUntilFrameAsync(view, ct);
Assert.IsInstanceOfType<RemoteViewMeta>(outputs[0]);
Assert.IsInstanceOfType<RemoteViewFrame>(outputs[^1]);
await view.DisposeAsync();
Assert.AreEqual(0, bed.Browser.UserDriving.Leases, "no view, no lease");
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task APageThatStaysBetweenTwoDocumentsStillEndsInNonRispondeWithinTheBudget()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => InactivePage());
var watch = Stopwatch.StartNew();
var error = await Assert.ThrowsExactlyAsync<RemoteViewUnavailableException>(() => bed.Host.OpenAsync(ct));
StringAssert.Contains(error.Message, "non risponde");
Assert.IsTrue(error.InnerException is CdpCommandException { IsInactivePage: true }, "the browser's answer stays the cause");
Assert.IsLessThanOrEqualTo(ScreencastSession.InactivePageBudget, bed.Elapsed, "never longer than the budget");
Assert.IsGreaterThan(TimeSpan.FromSeconds(4), bed.Elapsed, "tried for the whole budget");
Assert.IsInRange(5, 15, bed.Starts, "a few attempts, spaced out");
Assert.IsLessThan(TimeSpan.FromSeconds(10), watch.Elapsed, "the pauses are the clock's, not a hang");
Assert.AreEqual(0, bed.Browser.UserDriving.Leases, "nothing of the view stays behind");
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task ABrowserThatIsGoneIsNotTriedAgain()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => new CdpDisconnectedException("Il collegamento con il browser si è chiuso."));
var error = await Assert.ThrowsExactlyAsync<RemoteViewUnavailableException>(() => bed.Host.OpenAsync(ct));
StringAssert.Contains(error.Message, "non risponde");
Assert.AreEqual(1, bed.Starts);
Assert.AreEqual(TimeSpan.Zero, bed.Elapsed, "no pause at all");
Assert.AreEqual(0, bed.Browser.UserDriving.Leases);
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task AnotherRefusalOfTheBrowserIsNotTriedAgain()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => new CdpCommandException("Page.startScreencast", CdpCommandException.ServerErrorCode, "Not attached to a page"));
await Assert.ThrowsExactlyAsync<RemoteViewUnavailableException>(() => bed.Host.OpenAsync(ct));
Assert.AreEqual(1, bed.Starts, "only «Not attached to an active page» is the moment of a navigation");
Assert.AreEqual(TimeSpan.Zero, bed.Elapsed);
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task ReplacingAViewKeepsAlbertoAtTheBrowserThroughout()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => null);
var gate = bed.Browser.UserDriving;
var older = await bed.Host.OpenAsync(ct);
var released = 0;
void OnChanged(object? sender, bool driving)
{
if (!driving)
{
Interlocked.Increment(ref released);
}
}
gate.Changed += OnChanged;
try
{
var newer = await bed.Host.OpenAsync(ct);
Assert.AreEqual(RemoteViewEnd.Replaced, older.Ended);
Assert.IsNull(newer.Ended);
Assert.AreEqual(0, released, "the engine never sees nobody at the browser between the two views (it would rest the page under the new one)");
Assert.AreEqual(1, gate.Leases);
await newer.DisposeAsync();
Assert.AreEqual(1, released, "closing the last view lets the engine go on");
Assert.AreEqual(0, gate.Leases);
}
finally
{
gate.Changed -= OnChanged;
}
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task PaginaInizialeOpensTheStartPageOfTheMoment()
{
var ct = TestContext.CancellationToken;
var start = "http://127.0.0.1:8481/benvenuto";
await using var bed = new Bed(_ => null, () => start);
var view = await bed.Host.OpenAsync(ct);
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
Assert.AreEqual(start, bed.LastNavigation, "not connected: the login page");
// Connected meanwhile: the same button opens the site's home.
start = "http://127.0.0.1:8481/";
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
Assert.AreEqual(start, bed.LastNavigation);
Assert.AreEqual(2, bed.Cdp.Sent.Count(c => c.Method == "Page.navigate"), "Alberto's own navigations, one per press");
await view.DisposeAsync();
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task WithoutAStartPageTheButtonDoesNothing()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => null);
var view = await bed.Host.OpenAsync(ct);
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
Assert.IsFalse(bed.Cdp.Sent.Any(c => c.Method == "Page.navigate"));
await view.DisposeAsync();
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task IndietroNeverLandsOnTheEmptyRestPage()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => null);
var view = await bed.Host.OpenAsync(ct);
// The view opened on the rest page; then a page, the rest page again (a session of the engine), another page.
bed.Navigated("http://127.0.0.1:8481/profilo/marta.prova/");
bed.Navigated("about:blank");
bed.Navigated("http://127.0.0.1:8481/esplora/");
await view.NavigateAsync(RemoteViewNavigation.Back, ct);
Assert.AreEqual("http://127.0.0.1:8481/profilo/marta.prova/", bed.LastNavigation, "the rest page in between is skipped");
// Before that only the rest page: «Indietro» stays where it is instead of turning the view white.
bed.Cdp.ClearSent();
await view.NavigateAsync(RemoteViewNavigation.Back, ct);
Assert.IsFalse(bed.Cdp.Sent.Any(c => c.Method == "Page.navigate"));
await view.DisposeAsync();
}
private static CdpCommandException InactivePage() =>
new("Page.startScreencast", CdpCommandException.ServerErrorCode, CdpCommandException.InactivePageMessage);
private static JsonObject Frame() => new()
{
["sessionId"] = 1,
["data"] = Convert.ToBase64String([0xFF, 0xD8, 0xFF, 0xD9]),
["metadata"] = new JsonObject { ["deviceWidth"] = Bed.Width, ["deviceHeight"] = Bed.Height, ["pageScaleFactor"] = 1 },
};
private static async Task<List<RemoteViewOutput>> ReadUntilFrameAsync(IRemoteViewConnection view, CancellationToken ct)
{
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromSeconds(10));
var outputs = new List<RemoteViewOutput>();
await foreach (var output in view.ReadAsync(timeout.Token))
{
outputs.Add(output);
if (output is RemoteViewFrame)
{
break;
}
}
return outputs;
}
/// <summary>The host over a fake page whose answer to each <c>Page.startScreencast</c> is chosen by the test.</summary>
private sealed class Bed : IAsyncDisposable
{
public const int Width = 1280;
public const int Height = 900;
private readonly FebeLog _log;
private readonly DateTimeOffset _start;
private int _starts;
/// <param name="startFailure">For the n-th start (from 1), the exception the browser answers with; null: started.</param>
/// <param name="startPage">
/// Where «Pagina iniziale» goes, as the connection would open it (BrowserConnectionService.OpenStartPageAsync,
/// tested in BrowserStartPageTests); null: nowhere.
/// </param>
public Bed(Func<int, Exception?> startFailure, Func<string>? startPage = null)
{
Clock = new VirtualClock();
_start = Clock.Now;
Cdp = new FakeCdpSession(Clock)
{
Responder = (method, _) =>
{
switch (method)
{
case "Page.getFrameTree":
return new JsonObject { ["frameTree"] = new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = "about:blank" } } };
case "Page.startScreencast":
if (startFailure(Interlocked.Increment(ref _starts)) is { } failure)
{
throw failure;
}
return null;
default:
return null;
}
},
};
Browser = new PageBrowser(Cdp);
_log = new FebeLog(null, null, Clock);
Host = new BrowserRemoteViewHost(Browser, new BrowserUseTracker(), Clock, _log, browserClock: Clock, openStartPage: startPage is null ? null : async ct => await Cdp.NavigateAsync(startPage(), ct))
{
// The virtual clock moves only in the pauses: a watchdog on it would never wait.
Watchdog = null,
};
}
public VirtualClock Clock { get; }
public FakeCdpSession Cdp { get; }
public PageBrowser Browser { get; }
public BrowserRemoteViewHost Host { get; }
public int Starts => Volatile.Read(ref _starts);
/// <summary>The address of the last <c>Page.navigate</c>.</summary>
public string? LastNavigation => Cdp.Sent.LastOrDefault(c => c.Method == "Page.navigate")?.Parameters?["url"]?.GetValue<string>();
/// <summary>The main frame committed a new document.</summary>
public void Navigated(string url) =>
Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } });
/// <summary>Time spent in the host's pauses (the virtual clock moves only there).</summary>
public TimeSpan Elapsed => Clock.Now - _start;
public async ValueTask DisposeAsync()
{
await Host.ShutdownAsync();
_log.Dispose();
}
}
/// <summary>A running browser on one page, as the remote view host sees it.</summary>
private sealed class PageBrowser(ICdpSession cdp) : IFebeBrowser
{
public ICdpSession Cdp { get; } = cdp;
public UserDrivingGate UserDriving { get; } = new();
public bool UserIsDriving => UserDriving.IsDriving;
public bool IsAvailable => true;
public string? LastError => null;
public string ProfileDirectory => "browser";
public int WindowWidth => Bed.Width;
public int WindowHeight => Bed.Height;
public Task RunAsync(CancellationToken ct) => Task.CompletedTask;
public Task<NavigationResult> RestAsync(CancellationToken ct) => Cdp.RestAsync(ct);
public Task ShowToUserAsync(CancellationToken ct) => Task.CompletedTask;
public Task HideFromUserAsync(CancellationToken ct) => Task.CompletedTask;
public Task RestartWithEmptyProfileAsync(CancellationToken ct) => Task.CompletedTask;
public ValueTask DisposeAsync() => ValueTask.CompletedTask;
}
}