Files
Febe/tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs
T
Alby96andClaude Opus 5.5 f48b6abac4 Prove: l'errore di chi ascolta la ripartenza si prova sulla CI per Linux
La prova che un gestore di Reconnected che lancia non disfa l'Attach di
WebView2CdpSession usa solo un finto WebView2, ma stava in
tests/Febe.Tests.Windows, che la CI non esegue mai (rilievo R4 della
revisione). Ora sta in tests/Febe.Tests/Desktop/WebView2CdpSessionTests.cs,
accanto alle altre prove della sessione, e gira a ogni push. Controllata con
il vecchio Reconnected?.Invoke rimesso a mano: rossa; con il codice vero: verde.

La guida di Windows ora dice dove sta quella prova e cita, fra le prove per
Windows, «Esci» mentre l'avvio non si completa.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 11:29:48 +02:00

350 lines
18 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 async Task AFailingReconnectionHandlerDoesNotUndoTheAttach()
{
// Attach runs inside the start of the new WebView: an error of whoever listens must not turn a start that worked
// into a failed one, retried with the same outcome for ever.
var log = new RecordingBrowserLog();
await using var session = new WebView2CdpSession(log);
var later = 0;
session.Reconnected += (_, _) => throw new InvalidOperationException("guasto di chi ascolta");
session.Reconnected += (_, _) => later++;
session.Attach(new FakeDevTools());
session.Attach(new FakeDevTools());
Assert.IsTrue(session.IsAttached, "the new WebView stays attached");
Assert.AreEqual(1, later, "the other handlers still hear of it");
Assert.IsTrue(log.Lines.Any(l => l.StartsWith("Warning ", StringComparison.Ordinal) && l.Contains("InvalidOperationException", StringComparison.Ordinal)), log.All);
Assert.AreEqual("{}", (await session.SendAsync("Page.enable", ct: TestContext.CancellationToken)).GetRawText());
}
[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()!));
}
}