Files
Febe/tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs
T

330 lines
17 KiB
C#

using System.Collections.Concurrent;
using System.Text.Json;
using System.Text.Json.Nodes;
using Febe.Browser.Cdp;
using Febe.Browser.WebView2;
using Febe.Tests.Desktop.Support;
namespace Febe.Tests.Desktop;
/// <summary>
/// The CDP adapter of WebView2 (spec §6.1, Windows) with a fake of the two WebView2 calls: the same allowlist and
/// refusals as the Chromium client, JSON in and out, events routed in order to their handlers, names only in the log.
/// </summary>
[TestClass]
public sealed class WebView2CdpSessionTests
{
private const string Secret = "segreto-che-non-deve-uscire";
public TestContext TestContext { get; set; } = null!;
[TestMethod]
public async Task AllowedCommandsReachWebView2AsJsonAndResultsComeBackAsElements()
{
var devTools = new FakeDevTools
{
Answer = (method, _) => Task.FromResult(method == "Page.getFrameTree"
? """{"frameTree":{"frame":{"id":"F1","url":"about:blank"}}}"""
: "{}"),
};
await using var session = new WebView2CdpSession();
session.Attach(devTools);
var tree = await session.SendAsync("Page.getFrameTree", ct: TestContext.CancellationToken);
Assert.AreEqual("F1", tree.GetProperty("frameTree").GetProperty("frame").GetProperty("id").GetString());
Assert.AreEqual("about:blank", await session.GetMainFrameUrlAsync(TestContext.CancellationToken));
await session.SendAsync("Page.navigate", new JsonObject { ["url"] = "http://127.0.0.1:8481/" }, TestContext.CancellationToken);
await session.SendAsync("Input.dispatchMouseEvent", new { type = "mouseWheel", x = 10, y = 20, deltaX = 0, deltaY = 120 }, TestContext.CancellationToken);
await session.SendAsync("Page.enable", ct: TestContext.CancellationToken);
var calls = devTools.Calls.ToArray();
Assert.AreEqual("Page.navigate", calls[2].Method);
Assert.AreEqual("http://127.0.0.1:8481/", JsonNode.Parse(calls[2].Json)!["url"]!.GetValue<string>());
var mouse = JsonNode.Parse(calls[3].Json)!;
Assert.AreEqual("mouseWheel", mouse["type"]!.GetValue<string>());
Assert.AreEqual(120, mouse["deltaY"]!.GetValue<int>());
Assert.AreEqual("{}", calls[4].Json, "no parameters: an empty object, as WebView2 wants");
}
[TestMethod]
public async Task EveryCommandOutsideTheAllowlistIsRefusedBeforeWebView2()
{
var devTools = new FakeDevTools();
await using var session = new WebView2CdpSession();
session.Attach(devTools);
foreach (var method in new[]
{
"Network.setUserAgentOverride", "Network.setExtraHTTPHeaders", "Page.addScriptToEvaluateOnNewDocument",
"Emulation.setTimezoneOverride", "Emulation.setUserAgentOverride", "Fetch.enable", "Fetch.continueRequest",
"Target.createTarget", "Page.reload", "Runtime.callFunctionOn", "Network.setCookie", "Storage.getCookies",
"DOM.setAttributeValue", "Browser.close",
})
{
var error = await Assert.ThrowsAsync<CdpCommandNotAllowedException>(() => session.SendAsync(method, new { value = Secret }, TestContext.CancellationToken));
Assert.AreEqual(method, error.Method);
Assert.DoesNotContain(Secret, error.Message);
}
Assert.IsEmpty(devTools.Calls, "nothing refused ever reaches WebView2");
// Every command of the allowlist passes (Runtime.evaluate only read-only).
foreach (var method in CdpCommandPolicy.Allowed.Where(m => m != "Runtime.evaluate"))
{
await session.SendAsync(method, ct: TestContext.CancellationToken);
}
Assert.HasCount(CdpCommandPolicy.Allowed.Count - 1, devTools.Calls);
}
[TestMethod]
public async Task RuntimeEvaluateOnlyReadsThePage()
{
var devTools = new FakeDevTools { Answer = (_, _) => Task.FromResult("""{"result":{"type":"string","value":"complete"}}""") };
await using var session = new WebView2CdpSession();
session.Attach(devTools);
var value = await session.EvaluateAsync("document.readyState", TestContext.CancellationToken);
Assert.AreEqual("complete", value.GetString());
foreach (var expression in new[] { "document.querySelector('a').click()", "window.scrollBy(0, 400)", "document.cookie", "fetch('/api')", "location = 'https://example.org'" })
{
await Assert.ThrowsAsync<CdpCommandNotAllowedException>(() => session.SendAsync("Runtime.evaluate", new JsonObject { ["expression"] = expression }, TestContext.CancellationToken));
}
Assert.HasCount(1, devTools.Calls, "only the read-only expression was sent");
}
[TestMethod]
public async Task EventsReachTheirHandlersInOrderOffTheCallersThreadAndStopWhenUnsubscribed()
{
var devTools = new FakeDevTools();
await using var session = new WebView2CdpSession();
session.Attach(devTools);
var received = new ConcurrentQueue<(string Handler, int N)>();
var handlerThreads = new ConcurrentBag<int>();
using var first = session.On("Network.responseReceived", e =>
{
handlerThreads.Add(Environment.CurrentManagedThreadId);
received.Enqueue(("a", e.GetProperty("n").GetInt32()));
});
var second = session.On("Network.responseReceived", e => received.Enqueue(("b", e.GetProperty("n").GetInt32())));
using var other = session.On("Page.frameNavigated", e => received.Enqueue(("nav", 0)));
Assert.AreEqual(1, devTools.Subscribed("Network.responseReceived"), "one WebView2 receiver per event name");
// WebView2 raises events on its UI thread: here a thread of its own, which no handler may run on.
var raisingThread = 0;
var ui = new Thread(() =>
{
raisingThread = Environment.CurrentManagedThreadId;
for (var i = 1; i <= 50; i++)
{
devTools.Raise("Network.responseReceived", $$"""{"n":{{i}}}""");
}
devTools.Raise("Page.frameNavigated", """{"frame":{"id":"F1"}}""");
devTools.Raise("Network.loadingFinished", """{"requestId":"1"}"""); // nobody listens
});
ui.Start();
ui.Join();
await session.DrainAsync();
var a = received.Where(r => r.Handler == "a").Select(r => r.N).ToArray();
CollectionAssert.AreEqual(Enumerable.Range(1, 50).ToArray(), a, "in order");
Assert.AreEqual(50, received.Count(r => r.Handler == "b"));
Assert.AreEqual(1, received.Count(r => r.Handler == "nav"));
Assert.IsFalse(handlerThreads.Contains(raisingThread), "handlers never run on WebView2's (UI) thread");
second.Dispose();
devTools.Raise("Network.responseReceived", """{"n":51}""");
await session.DrainAsync();
Assert.AreEqual(50, received.Count(r => r.Handler == "b"), "an unsubscribed handler gets nothing");
Assert.AreEqual(51, received.Count(r => r.Handler == "a"));
first.Dispose();
Assert.AreEqual(0, devTools.Subscribed("Network.responseReceived"), "the last handler removes the WebView2 receiver");
}
[TestMethod]
public async Task AHandlerThatThrowsOrSendsACommandDoesNotStopTheOthers()
{
var devTools = new FakeDevTools { Answer = (_, _) => Task.FromResult("""{"body":"x","base64Encoded":false}""") };
var log = new RecordingBrowserLog();
await using var session = new WebView2CdpSession(log);
session.Attach(devTools);
var bodies = new ConcurrentQueue<string>();
using var bad = session.On("Network.loadingFinished", _ => throw new InvalidOperationException(Secret));
// The pattern of ResponseTap: the handler queues the command, it never blocks.
using var good = session.On("Network.loadingFinished", e => _ = Task.Run(async () =>
{
var body = await session.SendAsync("Network.getResponseBody", new JsonObject { ["requestId"] = e.GetProperty("requestId").GetString() });
bodies.Enqueue(body.GetProperty("body").GetString()!);
}));
devTools.Raise("Network.loadingFinished", """{"requestId":"7"}""");
await session.DrainAsync();
for (var i = 0; i < 50 && bodies.IsEmpty; i++)
{
await Task.Delay(20, TestContext.CancellationToken);
}
Assert.AreEqual("x", bodies.Single());
StringAssert.Contains(log.All, "Network.loadingFinished");
}
[TestMethod]
public async Task TheLogHasCommandAndEventNamesOnlyNeverParametersResultsOrErrorsText()
{
var log = new RecordingBrowserLog();
var devTools = new FakeDevTools
{
Answer = (method, json) => method switch
{
"Network.getCookies" => Task.FromResult($$"""{"cookies":[{"name":"sessionid","value":"{{Secret}}"}]}"""),
// WebView2 reports a protocol error as an exception whose message carries the error object (and here
// also the parameters, which must not get anywhere).
"Network.getResponseBody" => Task.FromException<string>(new InvalidOperationException(
$$"""Errore 0x80004005 per {{json}}: {"code":-32000,"message":"No resource with given identifier found","data":"{{Secret}}"}""")),
_ => Task.FromResult("{}"),
},
};
await using var session = new WebView2CdpSession(log);
session.Attach(devTools);
await session.SendAsync("Input.dispatchKeyEvent", new { type = "char", text = Secret }, TestContext.CancellationToken);
var cookies = await session.SendAsync("Network.getCookies", new { urls = new[] { "https://www.instagram.com/?x=" + Secret } }, TestContext.CancellationToken);
Assert.AreEqual("sessionid", cookies.GetProperty("cookies")[0].GetProperty("name").GetString());
var error = await Assert.ThrowsAsync<CdpCommandException>(() => session.SendAsync("Network.getResponseBody", new { requestId = Secret }, TestContext.CancellationToken));
Assert.AreEqual(-32000, error.Code);
Assert.AreEqual("No resource with given identifier found", error.BrowserMessage);
Assert.DoesNotContain(Secret, error.Message, "only the code and the message of the protocol error");
using (session.On("Network.responseReceived", _ => throw new InvalidOperationException("gestore")))
{
devTools.Raise("Network.responseReceived", $$$"""{"response":{"url":"https://cdn/{{{Secret}}}"}}""");
await session.DrainAsync();
}
var all = log.All;
StringAssert.Contains(all, "Input.dispatchKeyEvent");
StringAssert.Contains(all, "Network.getCookies");
StringAssert.Contains(all, "Network.getResponseBody");
StringAssert.Contains(all, "Network.responseReceived");
Assert.DoesNotContain(Secret, all, "never parameters, results, events or error text in the log");
Assert.DoesNotContain("instagram.com", all);
}
[TestMethod]
public async Task AFailureWithoutAProtocolErrorKeepsOnlyItsCode()
{
var devTools = new FakeDevTools { Answer = (_, _) => Task.FromException<string>(new InvalidOperationException("c:\\Users\\alberto " + Secret) { HResult = unchecked((int)0x8007139F) }) };
await using var session = new WebView2CdpSession();
session.Attach(devTools);
var error = await Assert.ThrowsAsync<CdpCommandException>(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken));
Assert.AreEqual(unchecked((int)0x8007139F), error.Code);
Assert.DoesNotContain(Secret, error.Message);
}
[TestMethod]
public async Task WithoutAWebViewCommandsFailFastAndAClosingWebViewIsADisconnection()
{
await using var session = new WebView2CdpSession();
await Assert.ThrowsAsync<BrowserUnavailableException>(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken));
// Policy first: a forbidden command is reported as such even without a WebView.
await Assert.ThrowsAsync<CdpCommandNotAllowedException>(() => session.SendAsync("Emulation.setLocaleOverride", ct: TestContext.CancellationToken));
var devTools = new FakeDevTools { Answer = (_, _) => Task.FromException<string>(new CdpDisconnectedException("chiuso")) };
session.Attach(devTools);
await Assert.ThrowsAsync<CdpDisconnectedException>(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken));
session.Detach();
Assert.IsFalse(session.IsAttached);
await Assert.ThrowsAsync<BrowserUnavailableException>(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken));
}
[TestMethod]
public async Task ACommandWithoutAnswerTimesOutAndCancellationIsHonoured()
{
var never = new TaskCompletionSource<string>();
var devTools = new FakeDevTools { Answer = (_, _) => never.Task };
await using var session = new WebView2CdpSession(options: new WebView2CdpOptions(TimeSpan.FromMilliseconds(200)));
session.Attach(devTools);
var timeout = await Assert.ThrowsAsync<TimeoutException>(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken));
StringAssert.Contains(timeout.Message, "Page.enable");
using var cancel = new CancellationTokenSource(TimeSpan.FromMilliseconds(50));
await Assert.ThrowsAsync<TaskCanceledException>(() => session.SendAsync("Page.enable", ct: cancel.Token));
}
[TestMethod]
public async Task ANewWebViewKeepsTheSubscriptionsAndSaysItReconnected()
{
await using var session = new WebView2CdpSession();
var reconnected = 0;
session.Reconnected += (_, _) => reconnected++;
var received = new ConcurrentQueue<string>();
using var subscription = session.On("Page.screencastFrame", e => received.Enqueue(e.GetProperty("data").GetString()!));
var first = new FakeDevTools();
session.Attach(first);
Assert.AreEqual(0, reconnected, "the first WebView is not a reconnection");
first.Raise("Page.screencastFrame", """{"data":"uno","sessionId":1}""");
await session.DrainAsync();
// The browser process restarted («Scollega», crash): a new WebView, the same session object.
session.Detach();
Assert.AreEqual(0, first.Subscribed("Page.screencastFrame"), "the old WebView's receivers are removed");
var second = new FakeDevTools();
session.Attach(second);
Assert.AreEqual(1, reconnected);
Assert.AreEqual(1, second.Subscribed("Page.screencastFrame"), "subscriptions survive");
first.Raise("Page.screencastFrame", """{"data":"vecchio"}""");
second.Raise("Page.screencastFrame", """{"data":"due","sessionId":2}""");
await session.DrainAsync();
CollectionAssert.AreEqual(new[] { "uno", "due" }, received.ToArray());
}
[TestMethod]
public void ProtocolErrorsAreReadFromTheMessageOfWebView2()
{
var error = WebView2CdpSession.ProtocolError("IO.read", new InvalidOperationException("""{"code":-32602,"message":"Invalid parameters","data":"handle: string value expected"}"""));
Assert.AreEqual(-32602, error.Code);
Assert.AreEqual("Invalid parameters", error.BrowserMessage);
Assert.AreEqual("IO.read", error.Method);
var garbled = WebView2CdpSession.ProtocolError("IO.read", new InvalidOperationException("{ non è json }"));
Assert.AreEqual("errore di WebView2", garbled.BrowserMessage);
}
[TestMethod]
public async Task UnreadableEventsAreSkippedAndLoggedByNameOnly()
{
var log = new RecordingBrowserLog();
var devTools = new FakeDevTools();
await using var session = new WebView2CdpSession(log);
session.Attach(devTools);
var good = 0;
using var subscription = session.On("Page.loadEventFired", _ => good++);
devTools.Raise("Page.loadEventFired", "{non json " + Secret);
devTools.Raise("Page.loadEventFired", """{"timestamp":1}""");
await session.DrainAsync();
Assert.AreEqual(1, good);
StringAssert.Contains(log.All, "Page.loadEventFired");
Assert.DoesNotContain(Secret, log.All);
}
[TestMethod]
public async Task ResultsAreSelfContainedElements()
{
var devTools = new FakeDevTools { Answer = (_, _) => Task.FromResult("""{"data":"AAEC","base64Encoded":true,"eof":true}""") };
await using var session = new WebView2CdpSession();
session.Attach(devTools);
var chunk = await session.SendAsync("IO.read", new { handle = "h" }, TestContext.CancellationToken);
GC.Collect();
Assert.AreEqual(JsonValueKind.True, chunk.GetProperty("eof").ValueKind);
CollectionAssert.AreEqual(new byte[] { 0, 1, 2 }, Convert.FromBase64String(chunk.GetProperty("data").GetString()!));
}
}