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;
///
/// Opening the remote view while the page changes document (Gitea issue #3), without a browser. From
/// ReadyToCommitNavigation of a navigation in a new RenderFrameHost until it commits, Chromium answers
/// Page.startScreencast 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.
///
[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(outputs[0]);
Assert.IsInstanceOfType(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(() => 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(() => 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(() => 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);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), 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);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), 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 PaginaInizialeWaitsBesideTheViewDroppingItsInputAndEndsWithIt()
{
var ct = TestContext.CancellationToken;
var presses = 0;
var pressedWith = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
await using var bed = new Bed(_ => null, open: async token =>
{
Interlocked.Increment(ref presses);
pressedWith.TrySetResult(token);
// As the connection while a session ends or a search step holds the page: up to half a minute.
await Task.Delay(Timeout.Infinite, token);
});
var view = await bed.Host.OpenAsync(ct);
bed.Cdp.Raise("Page.screencastFrame", Frame());
await ReadUntilFrameAsync(view, ct);
bed.Cdp.ClearSent();
// The receive loop goes on at once: the press waits beside it.
await view.NavigateAsync(RemoteViewNavigation.Home, ct).WaitAsync(TimeSpan.FromSeconds(5), ct);
var token = await pressedWith.Task.WaitAsync(TimeSpan.FromSeconds(10), ct);
Assert.IsFalse(StartPageOf(view).IsCompleted, "still waiting for its turn");
// Meanwhile clicks, keys and the other buttons are dropped (they would land on the start page as it loads), and a
// second press waits for the first.
await view.MouseAsync(new RemoteViewMouse(RemoteViewMouseAction.Down, 0.5, 0.5, RemoteViewButton.Left, 1, 0, 0), ct);
await view.KeyAsync(new RemoteViewKey(RemoteViewKeyAction.Char, "a", "KeyA", "a", 0), ct);
await view.NavigateAsync(RemoteViewNavigation.Reload, ct);
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
Assert.IsFalse(bed.Cdp.Sent.Any(c => IsInputOrNavigation(c.Method)), "nothing reached the browser: " + string.Join(", ", bed.Cdp.Sent.Select(c => c.Method)));
Assert.AreEqual(1, Volatile.Read(ref presses));
// The view closes: its lease is gone, and so is the press.
Assert.IsFalse(token.IsCancellationRequested);
await view.DisposeAsync();
Assert.IsTrue(token.IsCancellationRequested, "the press lasts as long as the view");
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), ct);
}
[TestMethod]
[Timeout(30_000, CooperativeCancellation = true)]
public async Task AfterPaginaInizialeTheInputReachesTheBrowserAgain()
{
var ct = TestContext.CancellationToken;
await using var bed = new Bed(_ => null, () => "http://127.0.0.1:8481/benvenuto");
var view = await bed.Host.OpenAsync(ct);
await view.NavigateAsync(RemoteViewNavigation.Home, ct);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), ct);
bed.Cdp.ClearSent();
await view.KeyAsync(new RemoteViewKey(RemoteViewKeyAction.Char, "a", "KeyA", "a", 0), ct);
Assert.IsTrue(bed.Cdp.Sent.Any(c => c.Method.StartsWith("Input.", StringComparison.Ordinal)), string.Join(", ", bed.Cdp.Sent.Select(c => c.Method)));
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);
await StartPageOf(view).WaitAsync(TimeSpan.FromSeconds(10), 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 bool IsInputOrNavigation(string method) =>
method.StartsWith("Input.", StringComparison.Ordinal) || method is "Page.navigate" or "Page.reload";
private static Task StartPageOf(IRemoteViewConnection view) => ((BrowserRemoteViewConnection)view).StartPageOpening;
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> ReadUntilFrameAsync(IRemoteViewConnection view, CancellationToken ct)
{
using var timeout = CancellationTokenSource.CreateLinkedTokenSource(ct);
timeout.CancelAfter(TimeSpan.FromSeconds(10));
var outputs = new List();
await foreach (var output in view.ReadAsync(timeout.Token))
{
outputs.Add(output);
if (output is RemoteViewFrame)
{
break;
}
}
return outputs;
}
/// The host over a fake page whose answer to each Page.startScreencast is chosen by the test.
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;
/// For the n-th start (from 1), the exception the browser answers with; null: started.
///
/// Where «Pagina iniziale» goes, as the connection would open it (BrowserConnectionService.OpenStartPageAsync,
/// tested in BrowserStartPageTests); null: nowhere.
///
/// What «Pagina iniziale» does instead (it wins over ).
public Bed(Func startFailure, Func? startPage = null, Func? open = 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: open ?? (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);
/// The address of the last Page.navigate.
public string? LastNavigation => Cdp.Sent.LastOrDefault(c => c.Method == "Page.navigate")?.Parameters?["url"]?.GetValue();
/// The main frame committed a new document.
public void Navigated(string url) =>
Cdp.Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } });
/// Time spent in the host's pauses (the virtual clock moves only there).
public TimeSpan Elapsed => Clock.Now - _start;
public async ValueTask DisposeAsync()
{
await Host.ShutdownAsync();
_log.Dispose();
}
}
/// A running browser on one page, as the remote view host sees it.
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 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;
}
}