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; /// /// 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. /// [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()); var mouse = JsonNode.Parse(calls[3].Json)!; Assert.AreEqual("mouseWheel", mouse["type"]!.GetValue()); Assert.AreEqual(120, mouse["deltaY"]!.GetValue()); 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(() => 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(() => 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(); 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(); 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(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(() => 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(new InvalidOperationException("c:\\Users\\alberto " + Secret) { HResult = unchecked((int)0x8007139F) }) }; await using var session = new WebView2CdpSession(); session.Attach(devTools); var error = await Assert.ThrowsAsync(() => 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(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken)); // Policy first: a forbidden command is reported as such even without a WebView. await Assert.ThrowsAsync(() => session.SendAsync("Emulation.setLocaleOverride", ct: TestContext.CancellationToken)); var devTools = new FakeDevTools { Answer = (_, _) => Task.FromException(new CdpDisconnectedException("chiuso")) }; session.Attach(devTools); await Assert.ThrowsAsync(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken)); session.Detach(); Assert.IsFalse(session.IsAttached); await Assert.ThrowsAsync(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken)); } [TestMethod] public async Task ACommandWithoutAnswerTimesOutAndCancellationIsHonoured() { var never = new TaskCompletionSource(); 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(() => session.SendAsync("Page.enable", ct: TestContext.CancellationToken)); StringAssert.Contains(timeout.Message, "Page.enable"); using var cancel = new CancellationTokenSource(TimeSpan.FromMilliseconds(50)); await Assert.ThrowsAsync(() => 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(); 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()!)); } }