Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
330 lines
17 KiB
C#
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()!));
|
|
}
|
|
}
|