From 8769f58049565689cb0ac1362eb1695d216e07fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 18:40:28 -0300 Subject: [PATCH 1/8] Port Playwright's check, wait-for-url, locator-list and selectors-text tests (Refs #1060) The testbed gets the /content route and Playwright's test assets (with its LICENSE and NOTICE), and the first four of upstream's Playwright page test files run against them. Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- COMPATIBILITY.md | 1 + tests/E2E.Agent.Tests/PlaywrightRoutes.cs | 72 +++++++ tests/E2E.Agent.Tests/Testbed.cs | 2 +- tests/E2E.NUnit.Tests/Check/PageCheckTests.cs | 160 ++++++++++++++ tests/E2E.NUnit.Tests/E2E.NUnit.Tests.csproj | 2 + tests/E2E.NUnit.Tests/Helpers/Helpers.cs | 69 ++++++ .../LocatorList/LocatorListTests.cs | 27 +++ .../SelectorsText/SelectorsTextTests.cs | 62 ++++++ .../Testbed/playwright/LICENSE | 202 ++++++++++++++++++ .../E2E.NUnit.Tests/Testbed/playwright/NOTICE | 5 + .../Testbed/playwright/assets/empty.html | 0 .../Testbed/playwright/assets/grid.html | 66 ++++++ .../WaitForUrl/PageWaitForUrlTests.cs | 127 +++++++++++ 13 files changed, 794 insertions(+), 1 deletion(-) create mode 100644 tests/E2E.Agent.Tests/PlaywrightRoutes.cs create mode 100644 tests/E2E.NUnit.Tests/Check/PageCheckTests.cs create mode 100644 tests/E2E.NUnit.Tests/Helpers/Helpers.cs create mode 100644 tests/E2E.NUnit.Tests/LocatorList/LocatorListTests.cs create mode 100644 tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/LICENSE create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/NOTICE create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/assets/empty.html create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/assets/grid.html create mode 100644 tests/E2E.NUnit.Tests/WaitForUrl/PageWaitForUrlTests.cs diff --git a/COMPATIBILITY.md b/COMPATIBILITY.md index 7f77ebc47..1bdd8a6c4 100644 --- a/COMPATIBILITY.md +++ b/COMPATIBILITY.md @@ -162,6 +162,7 @@ Differences: - Upstream's docs site pages that have no counterpart in the port: the page objects page (`docs/page-objects.mdx`, moved to `/page-object-model` in `d30114a`), `e2e feedback` and the `docs/reference/cli.mdx` text about its opt-out variables (`4c1e2e8`), and `examples/` with its registry (`b3ae3a4`, `38b802d`, `a29edcb`, `b54646f`). The migration guides (`docs/migrate/*.mdx`, `8537abc`) are ported: see [Migration guides](#migration-guides). The docs site has .NET-only guides for upstream's five example apps of `caf51eb` (tester-army/e2e#1497: i18n, file upload, location, biometrics, deep links), under [Examples](docs-site/src/content/docs/examples/index.mdx). They are not ports: that commit only adds registry entries that link to separate repositories, so there was no guide text. Each page writes C# tests for the upstream app. The self-healing deep dive (`6fa99ea`) is ported as the [Self-healing tests](README.md#self-healing-tests) section of the guide, since the port has no docs pages for the cache, the trace page, or executors to link to. Known gap: only `e2e explore` prints a run summary, since it is the one command that feeds a run to `ListReporter` (see [List reporter](#list-reporter)): the `Cache 4 replayed · 1 handed off · 1 missed` row is `Format.CacheText` over `Format.StepsCacheTally` (`E2E.Cli`, upstream's `cacheText` and `stepsCacheTally` of `report/format.ts`), which an exploration, with its cache off, never fills, and a test run does not print ([#799](https://github.com/hardkoded/e2e-dotnet/issues/799)) - Parallel workers and serial suites - `test.fail` and the `fail` test option (tester-army/e2e#1539, `732ea8a`): a test expected to fail, whose product failure passes and whose pass fails with `UNEXPECTED_PASS`. It lives in upstream's test registry, scheduler, retry, and reporters (`settleExpectedFailure` runs on a finished attempt), and the port has none of them. NUnit and xUnit v3 own the verdict and the retries, and neither has an expected-failure outcome, so a port would need a new public API of its own +- Playwright's page tests in the testbed suite (tester-army/e2e#1505, `bdf769b`) are ported in slices (hardkoded/e2e-dotnet#1060), as the `playwright` category of `tests/E2E.NUnit.Tests`, against the playground's `/content` route and Playwright's test assets (Apache-2.0, `Testbed/playwright/`, with Playwright's `LICENSE` and `NOTICE`). A test upstream marks `{ fail: 'reason' }` keeps its assertions inside the test-only `Helpers.ExpectedToFailAsync`, which passes while the body fails and fails once it passes. Ported so far: `check`, `wait-for-url`, `locator-list`, and `selectors-text` (one test is such a known difference, hardkoded/e2e-dotnet#1062). - Serial groups (upstream tester-army/e2e#1056, #1470): serial runs, group retries, and skipping the rest of a group after a failure belong to the test runner, which is NUnit or xUnit here, so the port keeps no serial groups. The schema has `serialAttempt.cutRetry` and the serial verdict is read from it, but nothing in the port writes a serial attempt: see [Report document](#report-document) - The out-of-process engine protocol (upstream tester-army/e2e#1232, [#873](https://github.com/hardkoded/e2e-dotnet/issues/873)): the port has no runner and no worker pool, so there is no engine process to talk to. An engine is written in .NET against `IEngine` - Diff-only observations for a custom executor's own model turns. The built-in agent has them (#1022): `#id` lines on the opening screen and on `observe`, and a diff after each action (see [MCP server](#mcp-server) for the presenter). `ExecutorObservation.Text`, which an executor reads from `Observe`, keeps the full `[ref=…]` snapshot, cut at the observation byte budget (see [Agents](#agents)), and a node is addressed by its ref there (`new ExecutorTarget("e12")`), so a custom executor has no presenter of its own. Upstream gives every executor the `#id` view. diff --git a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs new file mode 100644 index 000000000..c27600fb8 --- /dev/null +++ b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs @@ -0,0 +1,72 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Net; +using System.Text; + +namespace E2E.Playground; + +/// +/// The routes of the tests ported from Playwright, a port of upstream's apps/testbed/app/playwright/routes.mjs: +/// its test assets (copied from microsoft/playwright tests/assets at v1.64.1, Apache-2.0, under +/// Testbed/playwright/assets next to the test assembly) and the dynamic routes its test server sets per test. +/// The playground serves them for any path it has no page for. This port has /content and the assets so far. +/// +internal static class PlaywrightRoutes +{ + private static readonly string Root = Path.Combine(AppContext.BaseDirectory, "Testbed", "playwright", "assets"); + + private static readonly Dictionary Types = new(StringComparer.Ordinal) + { + [".html"] = "text/html", + [".js"] = "text/javascript", + [".css"] = "text/css", + [".json"] = "application/json", + [".png"] = "image/png", + [".pdf"] = "application/pdf", + [".svg"] = "image/svg+xml", + [".txt"] = "text/plain", + }; + + /// Serves one request: a dynamic route, else an asset, else a 404. + public static async Task HandleAsync(HttpListenerContext context) + { + var response = context.Response; + var path = context.Request.Url!.AbsolutePath; + if (path == "/content") + { + var html = context.Request.QueryString["html"] ?? ""; + response.ContentType = "text/html; charset=utf-8"; + await WriteAsync(response, FromBase64Url(html)).ConfigureAwait(false); + return; + } + + var file = Path.GetFullPath(Path.Combine(Root, Uri.UnescapeDataString(path).TrimStart('/'))); + if (!file.StartsWith(Root + Path.DirectorySeparatorChar, StringComparison.Ordinal) || !File.Exists(file)) + { + response.StatusCode = 404; + response.ContentType = "text/plain"; + await WriteAsync(response, Encoding.UTF8.GetBytes("Not found")).ConfigureAwait(false); + return; + } + + response.ContentType = Types.GetValueOrDefault(Path.GetExtension(file), "application/octet-stream"); + response.AddHeader("Cache-Control", "no-store"); + await WriteAsync(response, await File.ReadAllBytesAsync(file).ConfigureAwait(false)).ConfigureAwait(false); + } + + private static byte[] FromBase64Url(string value) + { + var padded = value.Replace('-', '+').Replace('_', '/'); + padded = padded.PadRight(padded.Length + ((4 - (padded.Length % 4)) % 4), '='); + var bytes = new byte[padded.Length]; + return Convert.TryFromBase64String(padded, bytes, out var written) ? bytes[..written] : []; + } + + private static async Task WriteAsync(HttpListenerResponse response, byte[] bytes) + { + response.ContentLength64 = bytes.Length; + await response.OutputStream.WriteAsync(bytes).ConfigureAwait(false); + } +} diff --git a/tests/E2E.Agent.Tests/Testbed.cs b/tests/E2E.Agent.Tests/Testbed.cs index acdb010f7..d2a2336cf 100644 --- a/tests/E2E.Agent.Tests/Testbed.cs +++ b/tests/E2E.Agent.Tests/Testbed.cs @@ -1014,7 +1014,7 @@ await WriteHtmlAsync(response, "Dashboard", """ } else { - response.StatusCode = 404; + await PlaywrightRoutes.HandleAsync(context).ConfigureAwait(false); } response.Close(); diff --git a/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs b/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs new file mode 100644 index 000000000..174b0c70e --- /dev/null +++ b/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs @@ -0,0 +1,160 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.Check; + +/// +/// test.describe('page check') of upstream's apps/testbed/tests/check.e2e.ts (Playwright's page-check.spec.ts). +/// Not ported, as upstream: should check the label with position (no position), trial run should not check and trial run +/// should not uncheck (no trial), should check the box using setChecked (no setChecked). +/// +public sealed class PageCheckTests : PlaywrightTest +{ + private static readonly string[] AriaRoles = ["checkbox", "menuitemcheckbox", "option", "radio", "switch", "menuitemradio", "treeitem"]; + + [Test] + public async Task Should_check_the_box() + { + await Browser.GotoAsync(Content("")); + await Browser.Locator("input").CheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.checkbox.checked"), Is.True); + } + + [Test] + public async Task Should_not_check_the_checked_box() + { + await Browser.GotoAsync(Content("")); + await Browser.Locator("input").CheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.checkbox.checked"), Is.True); + } + + [Test] + public async Task Should_uncheck_the_box() + { + await Browser.GotoAsync(Content("")); + await Browser.Locator("input").UncheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.checkbox.checked"), Is.False); + } + + [Test] + public async Task Should_not_uncheck_the_unchecked_box() + { + await Browser.GotoAsync(Content("")); + await Browser.Locator("input").UncheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.checkbox.checked"), Is.False); + } + + [Test] + public async Task Should_check_radio() + { + await Browser.GotoAsync(Content(""" + one + two + three + """)); + await Browser.Locator("#two").CheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.two.checked"), Is.True); + } + + [Test] + public async Task Should_check_radio_by_aria_role() + { + await Browser.GotoAsync(Content(""" + + + """)); + await Browser.Locator("div").CheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.checkbox.getAttribute('aria-checked')"), Is.EqualTo("true")); + } + + // Upstream: { fail: '`uncheck` refuses a `role=radio`, where Playwright clicks it and refuses only a native radio' }. + [Test] + public async Task Should_uncheck_radio_by_aria_role() + { + await ExpectedToFailAsync(async () => + { + await Browser.GotoAsync(Content(""" + + + """)); + await Browser.Locator("div").UncheckAsync(); + Equal("false", await Browser.EvaluateAsync("() => window.checkbox.getAttribute('aria-checked')")); + }); + } + + [Test] + public async Task Should_check_the_box_by_aria_role() + { + foreach (var role in AriaRoles) + { + await Browser.GotoAsync(Content($$""" +
CHECKBOX
+ + """)); + await Browser.Locator("div").CheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => window.checkbox.getAttribute('aria-checked')"), Is.EqualTo("true")); + } + } + + // Upstream: { fail: '`uncheck` refuses a `role=radio`, where Playwright clicks it and refuses only a native radio' }. + [Test] + public async Task Should_uncheck_the_box_by_aria_role() + { + await ExpectedToFailAsync(async () => + { + foreach (var role in AriaRoles) + { + await Browser.GotoAsync(Content($$""" +
CHECKBOX
+ + """)); + await Browser.Locator("div").UncheckAsync(); + Equal("false", await Browser.EvaluateAsync("() => window.checkbox.getAttribute('aria-checked')")); + } + }); + } + + [Test] + public async Task Should_throw_when_not_a_checkbox() + { + await Browser.GotoAsync(Content("
Check me
")); + var error = await Assert.CatchAsync(() => Browser.Locator("div").CheckAsync()); + Assert.That(error!.Message, Does.Contain("Not a checkbox or radio button")); + } + + [Test] + public async Task Should_throw_when_not_a_checkbox_2() + { + await Browser.GotoAsync(Content("
Check me
")); + var error = await Assert.CatchAsync(() => Browser.Locator("div").CheckAsync()); + Assert.That(error!.Message, Does.Contain("Not a checkbox or radio button")); + } + + [Test] + public async Task Should_check_the_box_inside_a_button() + { + await Browser.GotoAsync(Content("
")); + await Browser.Locator("input").CheckAsync(); + Assert.That(await Browser.EvaluateAsync("() => document.querySelector('input').checked"), Is.True); + Assert.That(await Browser.Locator("input").IsCheckedAsync(), Is.True); + } + + [Test] + public async Task Should_throw_when_trying_to_uncheck_radio_button() + { + await Browser.GotoAsync(Content("")); + var error = await Assert.CatchAsync(() => Browser.Locator("#radio").UncheckAsync()); + Assert.That(error!.Message, Does.Contain("uncheck cannot clear a radio button")); + } +} diff --git a/tests/E2E.NUnit.Tests/E2E.NUnit.Tests.csproj b/tests/E2E.NUnit.Tests/E2E.NUnit.Tests.csproj index ae5cb97ad..b71222b73 100644 --- a/tests/E2E.NUnit.Tests/E2E.NUnit.Tests.csproj +++ b/tests/E2E.NUnit.Tests/E2E.NUnit.Tests.csproj @@ -16,7 +16,9 @@ + + diff --git a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs new file mode 100644 index 000000000..994ac1351 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs @@ -0,0 +1,69 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Text; + +namespace E2E.NUnit.Tests; + +/// +/// The helpers of the tests ported from Playwright, upstream's apps/testbed/tests/helpers.ts: +/// content and PREFIX. is .NET-only (see its summary). +/// +internal static class Helpers +{ + /// The app's origin, Playwright's server.PREFIX in the tests ported from it. + public static string PREFIX => E2E.Playground.Testbed.Url; + + /// A path that serves as a page, for Playwright's page.setContent(html). + public static string Content(string html) => + "/content?html=" + Convert.ToBase64String(Encoding.UTF8.GetBytes(html)).TrimEnd('=').Replace('+', '-').Replace('/', '_'); + + /// + /// An equality check for a body run by . It throws: an NUnit assertion inside a test body is + /// recorded as a failure of the test even when the body catches it. + /// + public static void Equal(T expected, T actual) + { + if (!EqualityComparer.Default.Equals(expected, actual)) + { + throw new InvalidOperationException($"Expected {expected}, but was {actual}."); + } + } + + /// + /// Runs the body of a test upstream marks { fail: 'reason' }, a known difference from Playwright: the test passes while + /// still fails, and fails once it passes, so the marker is removed. The port has no fail test option + /// (see COMPATIBILITY.md), and NUnit has no expected-failure outcome. + /// + public static async Task ExpectedToFailAsync(Func body) + { + try + { + await body().ConfigureAwait(false); + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + return; + } + + Assert.Fail("UNEXPECTED_PASS: the test is marked as a known difference from Playwright, and it passed. Remove the marker."); + } +} + +/// +/// The base of the classes ported from Playwright's page tests: the playground as the base URL, the cache off, and the playwright +/// category (upstream's tags: ['playwright']). +/// +[Category("playwright")] +public abstract class PlaywrightTest : E2ETest +{ + private static readonly E2EConfig FixtureConfig = E2EConfig.Parse( + """{ "cache": { "mode": "off" } }""", + AppContext.BaseDirectory, + _ => null); + + protected override E2EConfig Config => FixtureConfig; + + protected override string? BaseUrl => E2E.Playground.Testbed.Url; +} diff --git a/tests/E2E.NUnit.Tests/LocatorList/LocatorListTests.cs b/tests/E2E.NUnit.Tests/LocatorList/LocatorListTests.cs new file mode 100644 index 000000000..9d25b0898 --- /dev/null +++ b/tests/E2E.NUnit.Tests/LocatorList/LocatorListTests.cs @@ -0,0 +1,27 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.LocatorList; + +/// +/// test.describe('locator list') of upstream's apps/testbed/tests/locator-list.e2e.ts (Playwright's +/// locator-list.spec.ts). div >> p is the CSS div p. +/// +public sealed class LocatorListTests : PlaywrightTest +{ + [Test] + public async Task Locator_all_should_work() + { + await Browser.GotoAsync(Content("

A

B

C

")); + var texts = new List(); + foreach (var p in await Browser.Locator("div p").AllAsync()) + { + texts.Add(await p.TextContentAsync()); + } + + Assert.That(texts, Is.EqualTo(new[] { "A", "B", "C" })); + } +} diff --git a/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs b/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs new file mode 100644 index 000000000..30eb20b81 --- /dev/null +++ b/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs @@ -0,0 +1,62 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Text.RegularExpressions; +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.SelectorsText; + +/// +/// test.describe('selectors text') of upstream's apps/testbed/tests/selectors-text.e2e.ts (Playwright's +/// selectors-text.spec.ts). locator(css, { hasText }) is a locator Filter(hasText). The 20 other tests are not +/// ported, as upstream: they need Playwright's text= selectors, :text pseudo-classes, >> chains, or element handles. +/// +public sealed partial class SelectorsTextTests : PlaywrightTest +{ + [Test] + public async Task Text_is_should_ignore_comments() + { + await Browser.GotoAsync(Content(""" +
hello + + world
+ """)); + Assert.That(await Browser.Locator("div").Filter(hasText: "hello world").GetAttributeAsync("id"), Is.EqualTo("me")); + Assert.That(await Screen.GetByText("hello world").GetAttributeAsync("id"), Is.EqualTo("me")); + } + + // Known difference, hardkoded/e2e-dotnet#1062: the first getByText('hello') match has no `id`. + [Test] + public async Task HasText_and_internal_text_should_match_full_node_text_in_strict_mode() + { + await ExpectedToFailAsync(async () => + { + await Browser.GotoAsync(Content(""" +
helloworld
+
hello
+ """)); + await Expect.That(Screen.GetByText("helloworld")).ToHaveAttributeAsync("id", "div1"); + await Expect.That(Screen.GetByText("hello")).ToHaveAttributeAsync("id", "div2"); + await Expect.That(Browser.Locator("div").Filter(hasText: HelloWorld())).ToHaveAttributeAsync("id", "div1"); + await Expect.That(Browser.Locator("div").Filter(hasText: Hello())).ToHaveAttributeAsync("id", "div2"); + + await Browser.GotoAsync(Content(""" +
helloworld
+
hello
+ """)); + await Expect.That(Screen.GetByText("helloworld")).ToHaveAttributeAsync("id", "div1"); + Equal("span1", await Screen.GetByText("hello").Nth(0).GetAttributeAsync("id")); + Equal("span2", await Screen.GetByText("hello").Nth(1).GetAttributeAsync("id")); + await Expect.That(Screen.GetByText("hello")).ToHaveCountAsync(2); + await Expect.That(Browser.Locator("div").Filter(hasText: HelloWorld())).ToHaveAttributeAsync("id", "div1"); + await Expect.That(Browser.Locator("div").Filter(hasText: Hello())).ToHaveAttributeAsync("id", "div2"); + }); + } + + [GeneratedRegex(@"^helloworld$")] + private static partial Regex HelloWorld(); + + [GeneratedRegex(@"^hello$")] + private static partial Regex Hello(); +} diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/LICENSE b/tests/E2E.NUnit.Tests/Testbed/playwright/LICENSE new file mode 100644 index 000000000..4ace03ddb --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/LICENSE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Portions Copyright (c) Microsoft Corporation. + Portions Copyright 2017 Google Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/NOTICE b/tests/E2E.NUnit.Tests/Testbed/playwright/NOTICE new file mode 100644 index 000000000..814ec1696 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/NOTICE @@ -0,0 +1,5 @@ +Playwright +Copyright (c) Microsoft Corporation + +This software contains code derived from the Puppeteer project (https://github.com/puppeteer/puppeteer), +available under the Apache 2.0 license (https://github.com/puppeteer/puppeteer/blob/master/LICENSE). diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/empty.html b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/empty.html new file mode 100644 index 000000000..e69de29bb diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/grid.html b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/grid.html new file mode 100644 index 000000000..8345f429b --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/grid.html @@ -0,0 +1,66 @@ + + + diff --git a/tests/E2E.NUnit.Tests/WaitForUrl/PageWaitForUrlTests.cs b/tests/E2E.NUnit.Tests/WaitForUrl/PageWaitForUrlTests.cs new file mode 100644 index 000000000..29bb79f45 --- /dev/null +++ b/tests/E2E.NUnit.Tests/WaitForUrl/PageWaitForUrlTests.cs @@ -0,0 +1,127 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Text.RegularExpressions; +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.WaitForUrl; + +/// +/// test.describe('page wait for url') of upstream's apps/testbed/tests/wait-for-url.e2e.ts (Playwright's +/// page-wait-for-url.spec.ts). Not ported, as upstream: should work with both domcontentloaded and load, should work with +/// commit, should work with commit and about:blank (no waitUntil), should work on frame (no frame.waitForURL). +/// +public sealed partial class PageWaitForUrlTests : PlaywrightTest +{ + private static string EmptyPage => $"{PREFIX}/empty.html"; + + [Test] + public async Task Should_work() + { + await Browser.GotoAsync(EmptyPage); + await Browser.EvaluateAsync("(url) => { window.location.href = url; }", $"{PREFIX}/grid.html"); + await Browser.WaitForURLAsync("/grid.html"); + } + + [Test] + public async Task Should_respect_timeout() + { + // e2e opens no page before the first goto, where Playwright starts on about:blank. + await Browser.GotoAsync(EmptyPage); + var promise = Assert.CatchAsync(() => Browser.WaitForURLAsync("/frame.html", TimeSpan.FromMilliseconds(2500))); + await Browser.GotoAsync(EmptyPage); + var error = await promise; + Assert.That(error!.Message, Does.Contain("frame.html")); + } + + [Test] + public async Task Should_work_with_clicking_on_anchor_links() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content("foobar")); + await Browser.Locator("a").TapAsync(); + await Browser.WaitForURLAsync(FoobarSuffix()); + } + + [Test] + public async Task Should_work_with_history_pushState() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content(""" + SPA + + """)); + await Browser.Locator("a").TapAsync(); + await Browser.WaitForURLAsync("/wow.html"); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/wow.html")); + } + + [Test] + public async Task Should_work_with_history_replaceState() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content(""" + SPA + + """)); + await Browser.Locator("a").TapAsync(); + await Browser.WaitForURLAsync("/replaced.html"); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/replaced.html")); + } + + [Test] + public async Task Should_work_with_DOM_history_back_history_forward() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content(""" + back + forward + + """)); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/second.html")); + + await Browser.Locator("a#back").TapAsync(); + await Browser.WaitForURLAsync("/first.html"); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/first.html")); + + await Browser.Locator("a#forward").TapAsync(); + await Browser.WaitForURLAsync("/second.html"); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/second.html")); + } + + [Test] + public async Task Should_work_with_url_match_for_same_document_navigations() + { + await Browser.GotoAsync(EmptyPage); + var resolved = false; + var waitPromise = Task.Run(async () => + { + await Browser.WaitForURLAsync(ThirdHtml()); + resolved = true; + }); + Assert.That(resolved, Is.False); + await Browser.EvaluateAsync("() => { history.pushState({}, '', '/first.html'); }"); + Assert.That(resolved, Is.False); + await Browser.EvaluateAsync("() => { history.pushState({}, '', '/second.html'); }"); + Assert.That(resolved, Is.False); + await Browser.EvaluateAsync("() => { history.pushState({}, '', '/third.html'); }"); + await waitPromise; + Assert.That(resolved, Is.True); + } + + [GeneratedRegex(@"#foobar$")] + private static partial Regex FoobarSuffix(); + + [GeneratedRegex(@"third\.html")] + private static partial Regex ThirdHtml(); +} From b9f92cf450fe125e214362320fa98dd8fbc18cba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 18:43:21 -0300 Subject: [PATCH 2/8] Link the routes into the xUnit test project and pin the known difference of expected failures (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.NUnit.Tests/Check/PageCheckTests.cs | 4 ++-- tests/E2E.NUnit.Tests/Helpers/Helpers.cs | 5 +++-- tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs | 2 +- tests/E2E.XUnit.V3.Tests/E2E.XUnit.V3.Tests.csproj | 1 + 4 files changed, 7 insertions(+), 5 deletions(-) diff --git a/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs b/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs index 174b0c70e..0895e69e9 100644 --- a/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs +++ b/tests/E2E.NUnit.Tests/Check/PageCheckTests.cs @@ -76,7 +76,7 @@ await Browser.GotoAsync(Content(""" [Test] public async Task Should_uncheck_radio_by_aria_role() { - await ExpectedToFailAsync(async () => + await ExpectedToFailAsync("uncheck", async () => { await Browser.GotoAsync(Content(""" @@ -109,7 +109,7 @@ await Browser.GotoAsync(Content($$""" [Test] public async Task Should_uncheck_the_box_by_aria_role() { - await ExpectedToFailAsync(async () => + await ExpectedToFailAsync("uncheck", async () => { foreach (var role in AriaRoles) { diff --git a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs index 994ac1351..da38a9b5c 100644 --- a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs +++ b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs @@ -33,10 +33,10 @@ public static void Equal(T expected, T actual) /// /// Runs the body of a test upstream marks { fail: 'reason' }, a known difference from Playwright: the test passes while - /// still fails, and fails once it passes, so the marker is removed. The port has no fail test option + /// still fails with a message that contains , and fails once it passes, so the marker is removed. The port has no fail test option /// (see COMPATIBILITY.md), and NUnit has no expected-failure outcome. /// - public static async Task ExpectedToFailAsync(Func body) + public static async Task ExpectedToFailAsync(string failure, Func body) { try { @@ -44,6 +44,7 @@ public static async Task ExpectedToFailAsync(Func body) } catch (Exception ex) when (ex is not OperationCanceledException) { + Assert.That(ex.Message, Does.Contain(failure), "the body failed, but not with the known difference"); return; } diff --git a/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs b/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs index 30eb20b81..c14218e4a 100644 --- a/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs +++ b/tests/E2E.NUnit.Tests/SelectorsText/SelectorsTextTests.cs @@ -30,7 +30,7 @@ await Browser.GotoAsync(Content(""" [Test] public async Task HasText_and_internal_text_should_match_full_node_text_in_strict_mode() { - await ExpectedToFailAsync(async () => + await ExpectedToFailAsync("Expected span1", async () => { await Browser.GotoAsync(Content("""
helloworld
diff --git a/tests/E2E.XUnit.V3.Tests/E2E.XUnit.V3.Tests.csproj b/tests/E2E.XUnit.V3.Tests/E2E.XUnit.V3.Tests.csproj index 9d764e906..43d87e126 100644 --- a/tests/E2E.XUnit.V3.Tests/E2E.XUnit.V3.Tests.csproj +++ b/tests/E2E.XUnit.V3.Tests/E2E.XUnit.V3.Tests.csproj @@ -19,6 +19,7 @@ + From c7461dd68ab65fce30b81231c2de20ed320020a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 19:06:19 -0300 Subject: [PATCH 3/8] Port Playwright's dialog and download tests (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.Agent.Tests/PlaywrightRoutes.cs | 46 ++++- .../E2E.NUnit.Tests/Dialog/PageDialogTests.cs | 166 ++++++++++++++++ .../Download/DownloadEventTests.cs | 187 ++++++++++++++++++ .../E2E.NUnit.Tests/Download/DownloadTests.cs | 117 +++++++++++ tests/E2E.NUnit.Tests/Helpers/Helpers.cs | 3 + .../playwright/assets/chromium-linux.zip | Bin 0 -> 325 bytes .../playwright/assets/download-blob.html | 29 +++ .../Testbed/playwright/assets/empty.pdf | Bin 0 -> 857 bytes 8 files changed, 547 insertions(+), 1 deletion(-) create mode 100644 tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs create mode 100644 tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs create mode 100644 tests/E2E.NUnit.Tests/Download/DownloadTests.cs create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/assets/chromium-linux.zip create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/assets/download-blob.html create mode 100644 tests/E2E.NUnit.Tests/Testbed/playwright/assets/empty.pdf diff --git a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs index c27600fb8..1ca3ad676 100644 --- a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs +++ b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs @@ -11,7 +11,7 @@ namespace E2E.Playground; /// The routes of the tests ported from Playwright, a port of upstream's apps/testbed/app/playwright/routes.mjs: /// its test assets (copied from microsoft/playwright tests/assets at v1.64.1, Apache-2.0, under /// Testbed/playwright/assets next to the test assembly) and the dynamic routes its test server sets per test. -/// The playground serves them for any path it has no page for. This port has /content and the assets so far. +/// The playground serves them for any path it has no page for. This port has /content, /download, /respond, /binary and the assets so far. /// internal static class PlaywrightRoutes { @@ -42,6 +42,50 @@ public static async Task HandleAsync(HttpListenerContext context) return; } + // Download routes (group: dialog and download). + var query = context.Request.QueryString; + if (path == "/download") + { + response.ContentType = "application/octet-stream"; + response.AddHeader("Content-Disposition", "attachment" + (query["name"] is { } name ? "; filename=" + name : "")); + await WriteAsync(response, Encoding.UTF8.GetBytes(query["body"] ?? "Hello world")).ConfigureAwait(false); + return; + } + + if (path == "/respond") + { + response.StatusCode = int.TryParse(query["status"], out var status) ? status : 200; + var headers = System.Text.Json.JsonSerializer.Deserialize>(query["headers"] ?? "{}") ?? []; + foreach (var (header, value) in headers) + { + if (header.Equals("content-type", StringComparison.OrdinalIgnoreCase)) + { + response.ContentType = value; + } + else + { + response.AddHeader(header, value); + } + } + + await WriteAsync(response, Encoding.UTF8.GetBytes(query["body"] ?? "")).ConfigureAwait(false); + return; + } + + if (path == "/binary") + { + var length = Math.Clamp(int.TryParse(query["bytes"], out var bytes) ? bytes : 1 << 20, 0, 16 << 20); + var data = new byte[length]; + for (var i = 0; i < data.Length; i++) + { + data[i] = (byte)(((uint)(i + 1) * 2654435761u) >> 24); + } + + response.ContentType = "application/zip"; + await WriteAsync(response, data).ConfigureAwait(false); + return; + } + var file = Path.GetFullPath(Path.Combine(Root, Uri.UnescapeDataString(path).TrimStart('/'))); if (!file.StartsWith(Root + Path.DirectorySeparatorChar, StringComparison.Ordinal) || !File.Exists(file)) { diff --git a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs new file mode 100644 index 000000000..ded978b55 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs @@ -0,0 +1,166 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using E2E.Engine; +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.Dialog; + +/// +/// test.describe('page dialog') of upstream's apps/testbed/tests/dialog.e2e.ts (Playwright's +/// page-dialog.spec.ts). page.on('dialog') is Browser.OnDialogAsync. A dialog no handler answers is dismissed as +/// in Playwright, and e2e also fails the next step for it. Not ported, as upstream: should fire dialogclosed when dialog is accepted, +/// should fire dialogclosed when dialog is dismissed, should fire dialogclosed for auto-dismissed dialogs (no dialogclosed event), +/// should be able to close context with open alert (e2e answers every dialog). The defaultValue() assertions are dropped: +/// e2e dialogs have no default value. +/// +public sealed class PageDialogTests : PlaywrightTest +{ + [Test] + public async Task Should_fire() + { + await Browser.GotoAsync("/empty.html"); + await Browser.OnDialogAsync(async dialog => + { + Assert.That(dialog.Type, Is.EqualTo(DialogType.Alert)); + Assert.That(dialog.Message, Is.EqualTo("yo")); + await dialog.AcceptAsync(); + }); + await Browser.EvaluateAsync("() => alert('yo')"); + } + + [Test] + public async Task Should_allow_accepting_prompts() + { + await Browser.GotoAsync("/empty.html"); + await Browser.OnDialogAsync(async dialog => + { + Assert.That(dialog.Type, Is.EqualTo(DialogType.Prompt)); + Assert.That(dialog.Message, Is.EqualTo("question?")); + await dialog.AcceptAsync("answer!"); + }); + var result = await Browser.EvaluateAsync("() => prompt('question?', 'yes.')"); + Assert.That(result, Is.EqualTo("answer!")); + } + + [Test] + public async Task Should_dismiss_the_prompt() + { + await Browser.GotoAsync("/empty.html"); + await Browser.OnDialogAsync(dialog => dialog.DismissAsync()); + var result = await Browser.EvaluateAsync("() => prompt('question?')"); + Assert.That(result, Is.Null); + } + + [Test] + public async Task Should_accept_the_confirm_prompt() + { + await Browser.GotoAsync("/empty.html"); + await Browser.OnDialogAsync(async dialog => + { + await dialog.AcceptAsync(); + }); + var result = await Browser.EvaluateAsync("() => confirm('boolean?')"); + Assert.That(result, Is.True); + } + + [Test] + public async Task Should_dismiss_the_confirm_prompt() + { + await Browser.GotoAsync("/empty.html"); + await Browser.OnDialogAsync(async dialog => + { + await dialog.DismissAsync(); + }); + var result = await Browser.EvaluateAsync("() => confirm('boolean?')"); + Assert.That(result, Is.False); + } + + [Test] + public async Task Should_handle_multiple_alerts() + { + await Browser.OnDialogAsync(async dialog => + { + try + { + await dialog.AcceptAsync(); + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + // Upstream: `.catch(() => {})`. + } + }); + await Browser.GotoAsync(Content(""" +

Hello World

+ + """)); + Assert.That(await Browser.Locator("p").TextContentAsync(), Is.EqualTo("Hello World")); + } + + [Test] + public async Task Should_handle_multiple_confirms() + { + await Browser.OnDialogAsync(async dialog => + { + try + { + await dialog.AcceptAsync(); + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + // Upstream: `.catch(() => {})`. + } + }); + await Browser.GotoAsync(Content(""" +

Hello World

+ + """)); + Assert.That(await Browser.Locator("p").TextContentAsync(), Is.EqualTo("Hello World")); + } + + [Test] + public async Task Should_auto_dismiss_the_prompt_without_listeners() + { + await Browser.GotoAsync("/empty.html"); + var result = await Browser.EvaluateAsync("() => prompt('question?')"); + Assert.That(result, Is.Null); + var error = await Failure(() => Browser.TitleAsync()); + Assert.That(error?.Message, Does.Contain("unhandled prompt dialog: question?")); + } + + [Test] + public async Task Should_auto_dismiss_the_alert_without_listeners() + { + await Browser.GotoAsync(Content("""
Click me
""")); + var error = await Failure(async () => + { + await Browser.Locator("div").TapAsync(); + await Browser.TitleAsync(); + }); + Assert.That(error?.Message, Does.Contain("unhandled alert dialog: 123")); + Assert.That(await Browser.EvaluateAsync("window._clicked"), Is.True); + } + + /// What threw, or null when it did not throw (upstream's failure). + private static async Task Failure(Func act) + { + try + { + await act(); + return null; + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + return ex; + } + } +} diff --git a/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs new file mode 100644 index 000000000..bbe34127d --- /dev/null +++ b/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs @@ -0,0 +1,187 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Text; +using System.Text.Json; +using E2E.Engine; +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.Download; + +/// +/// test.describe('download event') of upstream's apps/testbed/tests/download.e2e.ts (Playwright's +/// download.spec.ts). page.waitForEvent('download') is Browser.WaitForDownloadAsync(trigger), which saves the +/// file, and download.path() is the saved file's AbsolutePath. e2e has no download.url(), so its assertions are +/// dropped. Not ported, as upstream: should report downloads with acceptDownloads: false, should report proper download url when +/// download is from download attribute, should save to user-specified path without updating original path, should save to two +/// different paths with multiple saveAs calls, should save to overwritten filepath, should create subdirectories when saving to +/// non-existent user-specified path, should error when saving with downloads disabled, should error when saving after deletion, +/// should delete file, should expose stream, should delete downloads on context destruction, should delete downloads on browser +/// gone, should save downloads to artifactsDir, should close the context without awaiting the failed download, should close the +/// context without awaiting the download, should throw if browser dies, should be able to cancel pending downloads, should not fail +/// explicitly to cancel a download even if that is already finished, should save to user-specified path (no +/// download.saveAs, delete, createReadStream, cancel, failure, acceptDownloads, context or +/// browser control from the test). +/// +public sealed class DownloadEventTests : PlaywrightTest +{ + [Test] + public async Task Should_report_download_when_navigation_turns_into_download_smoke() + { + // e2e opens no page before the first goto, where Playwright starts on about:blank. + await Browser.GotoAsync("/empty.html"); + Exception? responseOrError = null; + var download = await Browser.WaitForDownloadAsync(async () => + { + responseOrError = await Record(() => Browser.GotoAsync($"{PREFIX}/download")); + }); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + Assert.That(responseOrError, Is.Not.Null); + Assert.That(responseOrError!.Message, Does.Contain("Download is starting")); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/empty.html")); + } + + [Test] + public async Task Should_work_with_Cross_Origin_Opener_Policy() + { + // e2e opens no page before the first goto, where Playwright starts on about:blank. + await Browser.GotoAsync("/empty.html"); + Exception? responseOrError = null; + var url = Respond(new Dictionary + { + ["content-type"] = "application/octet-stream", + ["content-disposition"] = "attachment", + ["cross-origin-opener-policy"] = "same-origin", + }); + var download = await Browser.WaitForDownloadAsync(async () => + { + responseOrError = await Record(() => Browser.GotoAsync(url)); + }); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + Assert.That(responseOrError, Is.Not.Null); + Assert.That(responseOrError!.Message, Does.Contain("Download is starting")); + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/empty.html")); + } + + [Test] + public async Task Should_report_downloads_with_acceptDownloads_true() + { + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + [Test] + public async Task Should_report_downloads_for_download_attribute() + { + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(download.SuggestedFilename, Is.EqualTo("foo.zip")); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + } + + [Test] + public async Task Should_report_non_navigation_downloads() + { + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(download.SuggestedFilename, Is.EqualTo("file.txt")); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + [Test] + public async Task Should_report_download_path_within_page_on_download_handler_for_Files() + { + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + [Test] + public async Task Should_report_download_path_within_page_on_download_handler_for_Blobs() + { + await Browser.GotoAsync("/download-blob.html"); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + [Test] + public async Task Should_report_alt_click_downloads() + { + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync(new ClickOptions { Modifiers = [KeyModifier.Alt] })); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + [Test] + public async Task Should_report_new_window_downloads() + { + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + } + + [Test] + public async Task Should_download_large_binary_zip() + { + var fileContent = new byte[1 << 20]; + for (var i = 0; i < fileContent.Length; i++) + { + fileContent[i] = (byte)(((uint)(i + 1) * 2654435761u) >> 24); + } + + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + var downloaded = await File.ReadAllBytesAsync(download.AbsolutePath); + Assert.That(downloaded, Has.Length.EqualTo(fileContent.Length)); + Assert.That(downloaded.AsSpan().SequenceEqual(fileContent), Is.True); + } + + [Test] + public async Task Should_report_downloads_with_interception() + { + await Browser.RouteAsync(new System.Text.RegularExpressions.Regex(".*"), route => route.ContinueAsync()); + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + [Test] + public async Task Should_emit_download_event_from_nested_iframes() + { + var third = Content($""" download"""); + var second = Content($""""""); + await Browser.GotoAsync(Content($"""""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.FrameLocator("iframe").FrameLocator("iframe").Locator("a").TapAsync()); + Assert.That(File.Exists(download.AbsolutePath), Is.True); + Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); + } + + /// /respond answering with and . + internal static string Respond(Dictionary headers, string body = "Hello world") => + $"/respond?headers={Uri.EscapeDataString(JsonSerializer.Serialize(headers))}&body={Uri.EscapeDataString(body)}"; + + private static async Task Record(Func act) + { + try + { + await act(); + return null; + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + return ex; + } + } +} diff --git a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs new file mode 100644 index 000000000..8c97d63d9 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs @@ -0,0 +1,117 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Text.RegularExpressions; +using E2E.Engine; +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.Download; + +/// +/// test.describe('download') of upstream's apps/testbed/tests/download.e2e.ts (Playwright's +/// download.spec.ts); see for how downloads are read. +/// +public sealed class DownloadTests : PlaywrightTest +{ + [Test] + public async Task Should_be_able_to_download_a_PDF_file() + { + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content("""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + await AssertDownloadToPdf(download, Asset("empty.pdf")); + } + + // Upstream marks this test `fail`: `route.fulfill` bodies are strings, so binary bytes do not survive the round trip. + [Test] + public async Task Should_be_able_to_download_a_inline_PDF_file_via_response_interception() + { + await ExpectedToFailAsync("Expected True", async () => + { + await Browser.GotoAsync("/empty.html"); + await Browser.RouteAsync("**/empty.pdf", async route => + { + var response = await route.FetchAsync(); + var headers = new Dictionary(response.Headers) { ["Content-Disposition"] = "attachment" }; + await route.FulfillAsync(new RouteFulfillResponse { Status = response.Status, Headers = headers, Body = await response.TextAsync() }); + }); + await Browser.GotoAsync(Content("""open""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + await AssertDownloadToPdf(download, Asset("empty.pdf"), thrown: true); + }); + } + + [Test] + public async Task Should_be_able_to_download_a_inline_PDF_file_via_navigation() + { + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content("""open""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + await AssertDownloadToPdf(download, Asset("empty.pdf")); + } + + [Test] + public async Task Should_download_even_if_there_is_no_attachment_value() + { + await Browser.GotoAsync(Content($"""download""")); + await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + } + + [Test] + public async Task Should_convert_navigation_to_a_resource_with_unsupported_mime_type_into_download() + { + // e2e opens no page before the first goto, where Playwright starts on about:blank. + await Browser.GotoAsync("/empty.html"); + await Browser.WaitForDownloadAsync(async () => + { + try + { + await Browser.GotoAsync(DownloadEventTests.Respond(new Dictionary { ["content-type"] = "application/octet-stream" })); + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + // Upstream: `.catch(() => undefined)`. + } + }); + } + + [Test] + public async Task Should_download_links_with_data_url() + { + await Browser.GotoAsync(Content("""Download!""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(download.SuggestedFilename, Is.EqualTo("SomeFile.txt")); + } + + [Test] + public async Task Should_download_successfully_when_routing() + { + await Browser.RouteAsync("**/*", route => route.ContinueAsync()); + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content($"""download""")); + var download = await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); + Assert.That(download.SuggestedFilename, Is.EqualTo("foo.zip")); + } + + /// + /// Checks a saved download is the file at byte for byte, PDF magic first, Playwright's + /// assertDownloadToPDF. With it throws instead of asserting (for a body run by ). + /// + private static async Task AssertDownloadToPdf(BrowserDownload download, string filePath, bool thrown = false) + { + var data = await File.ReadAllBytesAsync(download.AbsolutePath); + var expected = await File.ReadAllBytesAsync(filePath); + var magic = "%PDF"u8.ToArray(); + var ok = download.SuggestedFilename == Path.GetFileName(filePath) && data.AsSpan().StartsWith(magic) && data.AsSpan().SequenceEqual(expected); + if (thrown) + { + Equal(true, ok); + return; + } + + Assert.That(download.SuggestedFilename, Is.EqualTo(Path.GetFileName(filePath))); + Assert.That(data.AsSpan().StartsWith(magic), Is.True); + Assert.That(data.AsSpan().SequenceEqual(expected), Is.True); + } +} diff --git a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs index da38a9b5c..ccbc2f2ea 100644 --- a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs +++ b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs @@ -15,6 +15,9 @@ internal static class Helpers /// The app's origin, Playwright's server.PREFIX in the tests ported from it. public static string PREFIX => E2E.Playground.Testbed.Url; + /// The absolute path of one of Playwright's test assets, upstream's asset. + public static string Asset(string name) => Path.Combine(AppContext.BaseDirectory, "Testbed", "playwright", "assets", name); + /// A path that serves as a page, for Playwright's page.setContent(html). public static string Content(string html) => "/content?html=" + Convert.ToBase64String(Encoding.UTF8.GetBytes(html)).TrimEnd('=').Replace('+', '-').Replace('/', '_'); diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/chromium-linux.zip b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/chromium-linux.zip new file mode 100644 index 0000000000000000000000000000000000000000..9c00ec080d0e9ef688dca5442a75f1095c02f0e3 GIT binary patch literal 325 zcmWIWW@h1H0D;A=Za!cJl;C9$U`Wm=%Fj*J&B@FwtZxSQYgUh!>sg5Doxp z6=C22LUgUd=vpD>fDCwqWWeW-U$}b%3O;=)=IMIE#1P=k&SB2ywUr;}0A3&t@MdHZ zWya+=9++Dl-a3MqXinvTI~8IK!lB4k2s0pzS<+~YZVb%X9B^j`c(byBY-0k#DL{HQ Hh{FH?_oYdx literal 0 HcmV?d00001 diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/download-blob.html b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/download-blob.html new file mode 100644 index 000000000..3c4a3d813 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/download-blob.html @@ -0,0 +1,29 @@ + + + + Blob Download Example + + + + Download + + diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/empty.pdf b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/empty.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ed845a63727e0a03b754a73e0f050e49d4e0f0a2 GIT binary patch literal 857 zcmaJ=L2DC17?sva8IoHR_4Ek_TdU4)Hk)>(gpy5Cf{BJrZ?VvIcapAVcXW0Fu^=dd z2dRHR^dN};K%rN`+=1MML!QK`;4Eo_Bp-sX4zQ+)3-3wfbwGdhb{4gR1JSw}A!9w|Z zPRr?$eWUBVlA4etM+QY;b{`AUM3Nby|I2`x2%-sB>5dkHC@kg7pXqB2_T zp@uT^xX%c!v#2Y#!7__Qh$T7-$>7z2k^69Rc5W6vf3Xi=w$CqK{3cF|C;o1|k-qPCH%F*p#KZfM!(^h;XwVz3)>-%fN zw-4rKE}VFM`P^?Mf4tJzNG{R1@$fza+H|`p&0#U`3y;NsVPmjfi%DpYGNl`AAc59G zB$mdrJ)UcugjNP}y(LxDSh{Y2ipnYCz<`+_xFtS-wuWFq&%v^l!xEcEl0`BGm6$_l zONzcHo30pv8n$-y2j5Nm~ljWwtBb9`CAU zy6AXnm4RR#qQNrJCIbqlX_(M~38rI_8W2q|!#s}ZCOVwr=@#zmDa_1cYSWmtl3-G} rL5~S_6k5R!Lv_^QT!Qk30oI}p2X$O9coIuj$dQXe-Xz&< Date: Wed, 4 Nov 2026 19:08:18 -0300 Subject: [PATCH 4/8] Assert the dialog handler ran and quote the download filename (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.Agent.Tests/PlaywrightRoutes.cs | 2 +- tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs index 1ca3ad676..0d77259b1 100644 --- a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs +++ b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs @@ -47,7 +47,7 @@ public static async Task HandleAsync(HttpListenerContext context) if (path == "/download") { response.ContentType = "application/octet-stream"; - response.AddHeader("Content-Disposition", "attachment" + (query["name"] is { } name ? "; filename=" + name : "")); + response.AddHeader("Content-Disposition", "attachment" + (query["name"] is { } name ? "; filename=\"" + name + "\"" : "")); await WriteAsync(response, Encoding.UTF8.GetBytes(query["body"] ?? "Hello world")).ConfigureAwait(false); return; } diff --git a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs index ded978b55..f5a2f623f 100644 --- a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs +++ b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs @@ -21,13 +21,16 @@ public sealed class PageDialogTests : PlaywrightTest public async Task Should_fire() { await Browser.GotoAsync("/empty.html"); + var fired = false; await Browser.OnDialogAsync(async dialog => { Assert.That(dialog.Type, Is.EqualTo(DialogType.Alert)); Assert.That(dialog.Message, Is.EqualTo("yo")); + fired = true; await dialog.AcceptAsync(); }); await Browser.EvaluateAsync("() => alert('yo')"); + Assert.That(fired, Is.True); } [Test] From 14da6fe74ffdbf0540068910e66b9b9e5f01b4cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 19:10:52 -0300 Subject: [PATCH 5/8] Share the failure and respond helpers and answer bad /respond input with 400 (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.Agent.Tests/PlaywrightRoutes.cs | 26 +++++++++++++------ .../E2E.NUnit.Tests/Dialog/PageDialogTests.cs | 14 ---------- .../Download/DownloadEventTests.cs | 22 ++-------------- .../E2E.NUnit.Tests/Download/DownloadTests.cs | 4 +-- tests/E2E.NUnit.Tests/Helpers/Helpers.cs | 18 +++++++++++++ 5 files changed, 40 insertions(+), 44 deletions(-) diff --git a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs index 0d77259b1..ecf0e121e 100644 --- a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs +++ b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs @@ -55,18 +55,28 @@ public static async Task HandleAsync(HttpListenerContext context) if (path == "/respond") { response.StatusCode = int.TryParse(query["status"], out var status) ? status : 200; - var headers = System.Text.Json.JsonSerializer.Deserialize>(query["headers"] ?? "{}") ?? []; - foreach (var (header, value) in headers) + try { - if (header.Equals("content-type", StringComparison.OrdinalIgnoreCase)) + var headers = System.Text.Json.JsonSerializer.Deserialize>(query["headers"] ?? "{}") ?? []; + foreach (var (header, value) in headers) { - response.ContentType = value; - } - else - { - response.AddHeader(header, value); + if (header.Equals("content-type", StringComparison.OrdinalIgnoreCase)) + { + response.ContentType = value; + } + else + { + response.AddHeader(header, value); + } } } + catch (Exception ex) when (ex is System.Text.Json.JsonException or ArgumentException) + { + response.StatusCode = 400; + response.ContentType = "text/plain"; + await WriteAsync(response, Encoding.UTF8.GetBytes("Bad headers: " + ex.Message)).ConfigureAwait(false); + return; + } await WriteAsync(response, Encoding.UTF8.GetBytes(query["body"] ?? "")).ConfigureAwait(false); return; diff --git a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs index f5a2f623f..ccff1ff62 100644 --- a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs +++ b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs @@ -152,18 +152,4 @@ public async Task Should_auto_dismiss_the_alert_without_listeners() Assert.That(error?.Message, Does.Contain("unhandled alert dialog: 123")); Assert.That(await Browser.EvaluateAsync("window._clicked"), Is.True); } - - /// What threw, or null when it did not throw (upstream's failure). - private static async Task Failure(Func act) - { - try - { - await act(); - return null; - } - catch (Exception ex) when (ex is not OperationCanceledException) - { - return ex; - } - } } diff --git a/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs index bbe34127d..acff725c9 100644 --- a/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs +++ b/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs @@ -3,7 +3,6 @@ // SPDX-License-Identifier: Apache-2.0 using System.Text; -using System.Text.Json; using E2E.Engine; using static E2E.NUnit.Tests.Helpers; @@ -34,7 +33,7 @@ public async Task Should_report_download_when_navigation_turns_into_download_smo Exception? responseOrError = null; var download = await Browser.WaitForDownloadAsync(async () => { - responseOrError = await Record(() => Browser.GotoAsync($"{PREFIX}/download")); + responseOrError = await Failure(() => Browser.GotoAsync($"{PREFIX}/download")); }); Assert.That(File.Exists(download.AbsolutePath), Is.True); Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); @@ -57,7 +56,7 @@ public async Task Should_work_with_Cross_Origin_Opener_Policy() }); var download = await Browser.WaitForDownloadAsync(async () => { - responseOrError = await Record(() => Browser.GotoAsync(url)); + responseOrError = await Failure(() => Browser.GotoAsync(url)); }); Assert.That(File.Exists(download.AbsolutePath), Is.True); Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); @@ -167,21 +166,4 @@ public async Task Should_emit_download_event_from_nested_iframes() Assert.That(File.Exists(download.AbsolutePath), Is.True); Assert.That(await File.ReadAllTextAsync(download.AbsolutePath), Is.EqualTo("Hello world")); } - - /// /respond answering with and . - internal static string Respond(Dictionary headers, string body = "Hello world") => - $"/respond?headers={Uri.EscapeDataString(JsonSerializer.Serialize(headers))}&body={Uri.EscapeDataString(body)}"; - - private static async Task Record(Func act) - { - try - { - await act(); - return null; - } - catch (Exception ex) when (ex is not OperationCanceledException) - { - return ex; - } - } } diff --git a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs index 8c97d63d9..7f867513d 100644 --- a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs +++ b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs @@ -54,7 +54,7 @@ public async Task Should_be_able_to_download_a_inline_PDF_file_via_navigation() [Test] public async Task Should_download_even_if_there_is_no_attachment_value() { - await Browser.GotoAsync(Content($"""download""")); + await Browser.GotoAsync(Content($"""download""")); await Browser.WaitForDownloadAsync(() => Browser.Locator("a").TapAsync()); } @@ -67,7 +67,7 @@ await Browser.WaitForDownloadAsync(async () => { try { - await Browser.GotoAsync(DownloadEventTests.Respond(new Dictionary { ["content-type"] = "application/octet-stream" })); + await Browser.GotoAsync(Respond(new Dictionary { ["content-type"] = "application/octet-stream" })); } catch (Exception ex) when (ex is not OperationCanceledException) { diff --git a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs index ccbc2f2ea..11ad7e661 100644 --- a/tests/E2E.NUnit.Tests/Helpers/Helpers.cs +++ b/tests/E2E.NUnit.Tests/Helpers/Helpers.cs @@ -18,6 +18,24 @@ internal static class Helpers /// The absolute path of one of Playwright's test assets, upstream's asset. public static string Asset(string name) => Path.Combine(AppContext.BaseDirectory, "Testbed", "playwright", "assets", name); + /// What threw, or null when it did not throw (upstream's failure). + public static async Task Failure(Func act) + { + try + { + await act().ConfigureAwait(false); + return null; + } + catch (Exception ex) when (ex is not OperationCanceledException) + { + return ex; + } + } + + /// A path of /respond answering with and (upstream's respond). + public static string Respond(Dictionary headers, string body = "Hello world") => + $"/respond?headers={Uri.EscapeDataString(System.Text.Json.JsonSerializer.Serialize(headers))}&body={Uri.EscapeDataString(body)}"; + /// A path that serves as a page, for Playwright's page.setContent(html). public static string Content(string html) => "/content?html=" + Convert.ToBase64String(Encoding.UTF8.GetBytes(html)).TrimEnd('=').Replace('+', '-').Replace('/', '_'); From 1085e06c90706c82eba29e82fd85f294caa65e1e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 19:13:54 -0300 Subject: [PATCH 6/8] Answer a bad /respond status with 400 and clean the /download filename (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.Agent.Tests/PlaywrightRoutes.cs | 6 +++--- tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs | 1 - tests/E2E.NUnit.Tests/Download/DownloadTests.cs | 1 - 3 files changed, 3 insertions(+), 5 deletions(-) diff --git a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs index ecf0e121e..5ce0fdfea 100644 --- a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs +++ b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs @@ -47,16 +47,16 @@ public static async Task HandleAsync(HttpListenerContext context) if (path == "/download") { response.ContentType = "application/octet-stream"; - response.AddHeader("Content-Disposition", "attachment" + (query["name"] is { } name ? "; filename=\"" + name + "\"" : "")); + response.AddHeader("Content-Disposition", "attachment" + (query["name"] is { } name ? "; filename=\"" + name.Replace("\"", "", StringComparison.Ordinal).ReplaceLineEndings("") + "\"" : "")); await WriteAsync(response, Encoding.UTF8.GetBytes(query["body"] ?? "Hello world")).ConfigureAwait(false); return; } if (path == "/respond") { - response.StatusCode = int.TryParse(query["status"], out var status) ? status : 200; try { + response.StatusCode = int.TryParse(query["status"], out var status) ? status : 200; var headers = System.Text.Json.JsonSerializer.Deserialize>(query["headers"] ?? "{}") ?? []; foreach (var (header, value) in headers) { @@ -70,7 +70,7 @@ public static async Task HandleAsync(HttpListenerContext context) } } } - catch (Exception ex) when (ex is System.Text.Json.JsonException or ArgumentException) + catch (Exception ex) when (ex is System.Text.Json.JsonException or ArgumentException or System.Net.ProtocolViolationException) { response.StatusCode = 400; response.ContentType = "text/plain"; diff --git a/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs index acff725c9..2ea79d7e8 100644 --- a/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs +++ b/tests/E2E.NUnit.Tests/Download/DownloadEventTests.cs @@ -2,7 +2,6 @@ // Modified by Dario Kondratiuk. // SPDX-License-Identifier: Apache-2.0 -using System.Text; using E2E.Engine; using static E2E.NUnit.Tests.Helpers; diff --git a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs index 7f867513d..cecb718bd 100644 --- a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs +++ b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs @@ -2,7 +2,6 @@ // Modified by Dario Kondratiuk. // SPDX-License-Identifier: Apache-2.0 -using System.Text.RegularExpressions; using E2E.Engine; using static E2E.NUnit.Tests.Helpers; From cc7d647e3be38cf8ae816b398a642046429777c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 19:39:54 -0300 Subject: [PATCH 7/8] Pin the known PDF difference to the bytes and assert dialogs after the call (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs | 14 ++++++++++++-- tests/E2E.NUnit.Tests/Download/DownloadTests.cs | 11 ++++++++--- 2 files changed, 20 insertions(+), 5 deletions(-) diff --git a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs index ccff1ff62..ff42ebf98 100644 --- a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs +++ b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs @@ -37,13 +37,17 @@ await Browser.OnDialogAsync(async dialog => public async Task Should_allow_accepting_prompts() { await Browser.GotoAsync("/empty.html"); + DialogType? type = null; + string? message = null; await Browser.OnDialogAsync(async dialog => { - Assert.That(dialog.Type, Is.EqualTo(DialogType.Prompt)); - Assert.That(dialog.Message, Is.EqualTo("question?")); + type = dialog.Type; + message = dialog.Message; await dialog.AcceptAsync("answer!"); }); var result = await Browser.EvaluateAsync("() => prompt('question?', 'yes.')"); + Assert.That(type, Is.EqualTo(DialogType.Prompt)); + Assert.That(message, Is.EqualTo("question?")); Assert.That(result, Is.EqualTo("answer!")); } @@ -83,8 +87,10 @@ await Browser.OnDialogAsync(async dialog => [Test] public async Task Should_handle_multiple_alerts() { + var seen = 0; await Browser.OnDialogAsync(async dialog => { + Interlocked.Increment(ref seen); try { await dialog.AcceptAsync(); @@ -103,13 +109,16 @@ await Browser.GotoAsync(Content(""" """)); Assert.That(await Browser.Locator("p").TextContentAsync(), Is.EqualTo("Hello World")); + Assert.That(Volatile.Read(ref seen), Is.EqualTo(3)); } [Test] public async Task Should_handle_multiple_confirms() { + var seen = 0; await Browser.OnDialogAsync(async dialog => { + Interlocked.Increment(ref seen); try { await dialog.AcceptAsync(); @@ -128,6 +137,7 @@ await Browser.GotoAsync(Content(""" """)); Assert.That(await Browser.Locator("p").TextContentAsync(), Is.EqualTo("Hello World")); + Assert.That(Volatile.Read(ref seen), Is.EqualTo(3)); } [Test] diff --git a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs index cecb718bd..08461b659 100644 --- a/tests/E2E.NUnit.Tests/Download/DownloadTests.cs +++ b/tests/E2E.NUnit.Tests/Download/DownloadTests.cs @@ -26,7 +26,7 @@ public async Task Should_be_able_to_download_a_PDF_file() [Test] public async Task Should_be_able_to_download_a_inline_PDF_file_via_response_interception() { - await ExpectedToFailAsync("Expected True", async () => + await ExpectedToFailAsync("the downloaded bytes differ from the asset", async () => { await Browser.GotoAsync("/empty.html"); await Browser.RouteAsync("**/empty.pdf", async route => @@ -102,10 +102,15 @@ private static async Task AssertDownloadToPdf(BrowserDownload download, string f var data = await File.ReadAllBytesAsync(download.AbsolutePath); var expected = await File.ReadAllBytesAsync(filePath); var magic = "%PDF"u8.ToArray(); - var ok = download.SuggestedFilename == Path.GetFileName(filePath) && data.AsSpan().StartsWith(magic) && data.AsSpan().SequenceEqual(expected); if (thrown) { - Equal(true, ok); + // The known difference is the bytes only: the name is right and the file is a different size or has other content. + Equal(Path.GetFileName(filePath), download.SuggestedFilename); + if (!data.AsSpan().StartsWith(magic) || !data.AsSpan().SequenceEqual(expected)) + { + throw new InvalidOperationException($"the downloaded bytes differ from the asset ({data.Length} bytes, expected {expected.Length})"); + } + return; } From 488a87ab3f4897f49d0dcc9270b42d6fb77145d2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dar=C3=ADo=20Kondratiuk?= Date: Wed, 4 Nov 2026 19:42:00 -0300 Subject: [PATCH 8/8] Assert the alert dialog after the call and catch every bad /respond input (Refs #1060) Co-Authored-By: Claude Sonnet 5.5 Claude-Session: https://claude.ai/code/session_01Ls2e1yaZFgZ3FEJkYScfkK --- tests/E2E.Agent.Tests/PlaywrightRoutes.cs | 2 +- tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs | 11 ++++++----- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs index 5ce0fdfea..3ae239421 100644 --- a/tests/E2E.Agent.Tests/PlaywrightRoutes.cs +++ b/tests/E2E.Agent.Tests/PlaywrightRoutes.cs @@ -70,7 +70,7 @@ public static async Task HandleAsync(HttpListenerContext context) } } } - catch (Exception ex) when (ex is System.Text.Json.JsonException or ArgumentException or System.Net.ProtocolViolationException) + catch (Exception ex) when (ex is System.Text.Json.JsonException or ArgumentException or InvalidOperationException or System.Net.ProtocolViolationException) { response.StatusCode = 400; response.ContentType = "text/plain"; diff --git a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs index ff42ebf98..c3da0206d 100644 --- a/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs +++ b/tests/E2E.NUnit.Tests/Dialog/PageDialogTests.cs @@ -21,16 +21,17 @@ public sealed class PageDialogTests : PlaywrightTest public async Task Should_fire() { await Browser.GotoAsync("/empty.html"); - var fired = false; + DialogType? type = null; + string? message = null; await Browser.OnDialogAsync(async dialog => { - Assert.That(dialog.Type, Is.EqualTo(DialogType.Alert)); - Assert.That(dialog.Message, Is.EqualTo("yo")); - fired = true; + type = dialog.Type; + message = dialog.Message; await dialog.AcceptAsync(); }); await Browser.EvaluateAsync("() => alert('yo')"); - Assert.That(fired, Is.True); + Assert.That(type, Is.EqualTo(DialogType.Alert)); + Assert.That(message, Is.EqualTo("yo")); } [Test]