diff --git a/tests/E2E.NUnit.Tests/NetworkIdle/PageNetworkIdleTests.cs b/tests/E2E.NUnit.Tests/NetworkIdle/PageNetworkIdleTests.cs new file mode 100644 index 000000000..b60dffb07 --- /dev/null +++ b/tests/E2E.NUnit.Tests/NetworkIdle/PageNetworkIdleTests.cs @@ -0,0 +1,182 @@ +// 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.NetworkIdle; + +/// +/// test.describe('page network idle') of upstream's apps/testbed/tests/network-idle.e2e.ts (Playwright's +/// page-network-idle.spec.ts), where page.setContent(html, { waitUntil }) is Browser.GotoAsync(Content(html), ...) +/// and a request the server holds is one a route holds. Not ported, as upstream: should wait for networkidle in waitForNavigation +/// (no waitForNavigation), should wait for networkidle when navigating iframe (no frame.goto), should wait for networkidle +/// from the popup (no popup event and waitForLoadState). +/// +public sealed class PageNetworkIdleTests : PlaywrightTest +{ + private static readonly GotoOptions NetworkIdle = new() { WaitUntil = GotoWaitUntil.NetworkIdle }; + + private static string EmptyPage => $"{PREFIX}/empty.html"; + + /// + /// Playwright's networkIdleTest: holds fetch-request-a.js and fetch-request-b.js + /// until the test answers them, and checks settles only 500ms after the last. + /// + private async Task NetworkIdleTestAsync(Func action) + { + var aRequested = Deferred(); + var aAnswer = Deferred(); + var bRequested = Deferred(); + var bAnswer = Deferred(); + foreach (var (suffix, requested, answer) in new[] { ("/fetch-request-a.js", aRequested, aAnswer), ("/fetch-request-b.js", bRequested, bAnswer) }) + { + await Browser.RouteAsync($"**{suffix}", async route => + { + requested.TrySetResult(); + await answer.Task; + await route.FulfillAsync(new RouteFulfillResponse { Status = 404, Body = "File not found" }); + }); + } + + var actionPromise = action(); + var actionFinished = false; + _ = actionPromise.ContinueWith(_ => actionFinished = true, TaskScheduler.Default); + + await aRequested.Task; + Assert.That(actionFinished, Is.False); + + await Browser.EvaluateAsync("() => window['fetchSecond']()"); + aAnswer.TrySetResult(); + + await bRequested.Task; + Assert.That(actionFinished, Is.False); + + var timer = Task.Delay(500); + bAnswer.TrySetResult(); + + await actionPromise; + Assert.That(timer.IsCompletedSuccessfully, Is.True); + } + + [Test] + public async Task Should_navigate_to_empty_page_with_networkidle() + { + var response = await AllAsync(Browser.WaitForResponseAsync("**/empty.html"), Browser.GotoAsync(EmptyPage, NetworkIdle)); + Assert.That(response.Status, Is.EqualTo(200)); + } + + [Test] + public async Task Should_wait_for_networkidle_to_succeed_navigation() + { + await NetworkIdleTestAsync(() => Browser.GotoAsync("/networkidle.html", NetworkIdle)); + } + + [Test] + public async Task Should_wait_for_networkidle_to_succeed_navigation_with_request_from_previous_navigation() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content("")); + await NetworkIdleTestAsync(() => Browser.GotoAsync("/networkidle.html", NetworkIdle)); + } + + [Test] + public async Task Should_wait_for_networkidle_in_setContent() + { + await Browser.GotoAsync(EmptyPage); + await NetworkIdleTestAsync(() => Browser.GotoAsync(Content(""), NetworkIdle)); + } + + [Test] + public async Task Should_wait_for_networkidle_in_setContent_with_request_from_previous_navigation() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content("")); + await NetworkIdleTestAsync(() => Browser.GotoAsync(Content(""), NetworkIdle)); + } + + [Test] + public async Task Should_wait_for_networkidle_in_setContent_from_the_child_frame() + { + await Browser.GotoAsync(EmptyPage); + await NetworkIdleTestAsync(() => Browser.GotoAsync(Content(""), NetworkIdle)); + } + + [Test] + public async Task Should_wait_for_networkidle_from_the_child_frame() + { + await NetworkIdleTestAsync(() => Browser.GotoAsync("/networkidle-frame.html", NetworkIdle)); + } + + [Test] + public async Task Should_wait_for_networkidle_when_iframe_attaches_and_detaches() + { + var done = false; + var promise = Task.Run(async () => + { + await Browser.GotoAsync(Content($$""" + + + + """), NetworkIdle); + done = true; + }); + await Task.Delay(600); + Assert.That(done, Is.False); + await Browser.EvaluateAsync("() => { document.querySelector('iframe').remove(); }"); + await promise; + Assert.That(done, Is.True); + } + + [Test] + public async Task Should_work_after_repeated_navigations_in_the_same_page() + { + var requestCount = 0; + await Browser.RouteAsync("**/empty.html", route => route.FulfillAsync(new RouteFulfillResponse + { + ContentType = "text/html", + Body = """ + + """, + })); + await Browser.RouteAsync("**/sample", async route => + { + Interlocked.Increment(ref requestCount); + await route.FulfillAsync(new RouteFulfillResponse { ContentType = "application/json", Body = """{"content":"sample"}""" }); + }); + await Browser.GotoAsync(EmptyPage, NetworkIdle); + Assert.That(requestCount, Is.EqualTo(1)); + await Browser.GotoAsync(EmptyPage, NetworkIdle); + Assert.That(requestCount, Is.EqualTo(2)); + } + + [Test] + public async Task Should_not_wait_for_an_open_EventSource_connection() + { + var page = Content(""); + var response = await AllAsync(Browser.WaitForResponseAsync("**/content?**"), Browser.GotoAsync(page, NetworkIdle)); + Assert.That(response.Status, Is.EqualTo(200)); + } + + [Test] + public async Task Should_not_wait_for_an_open_EventSource_connection_in_setContent() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content(""" + + """), NetworkIdle); + await Browser.EvaluateAsync("() => window['__sseOpened'].then(() => null)"); + } +} diff --git a/tests/E2E.NUnit.Tests/RequestContinue/PageRequestContinuePostDataTests.cs b/tests/E2E.NUnit.Tests/RequestContinue/PageRequestContinuePostDataTests.cs new file mode 100644 index 000000000..cad9e9969 --- /dev/null +++ b/tests/E2E.NUnit.Tests/RequestContinue/PageRequestContinuePostDataTests.cs @@ -0,0 +1,85 @@ +// 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.RequestContinue; + +/// +/// The nested test.describe('post data') of page request continue in upstream's apps/testbed/tests/request-continue.e2e.ts +/// (Playwright's page-request-continue.spec.ts). +/// +public sealed class PageRequestContinuePostDataTests : PlaywrightTest +{ + private static string EmptyPage => $"{PREFIX}/empty.html"; + + private async Task FetchedAsync(string url, string init) => + Served.Parse((await Browser.EvaluateAsync($"(url) => fetch(url, {init}).then((response) => response.text())", url))!); + + [Test] + public async Task Should_amend_post_data() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { PostData = "doggo" })); + var serverRequest = await FetchedAsync("/cors-echo", "{ method: 'POST', body: 'birdy' }"); + Assert.That(serverRequest.Body, Is.EqualTo("doggo")); + } + + [Test] + public async Task Should_compute_content_length_from_post_data() + { + await Browser.GotoAsync(EmptyPage); + var data = new string('a', 7500); + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides + { + PostData = data, + Headers = WithHeaders(route.Request.Headers, ("content-type", "application/json")), + })); + var serverRequest = await FetchedAsync("/cors-echo", "{ method: 'PATCH', body: 'birdy' }"); + Assert.That(serverRequest.Body, Is.EqualTo(data)); + Assert.That(serverRequest.Header("content-length"), Is.EqualTo(data.Length.ToString(System.Globalization.CultureInfo.InvariantCulture))); + Assert.That(serverRequest.Header("content-type"), Is.EqualTo("application/json")); + } + + [Test] + public async Task Should_amend_method_and_post_data() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { Method = "POST", PostData = "doggo" })); + var serverRequest = await FetchedAsync("/cors-echo", "{ method: 'GET' }"); + Assert.That(serverRequest.Method, Is.EqualTo("POST")); + Assert.That(serverRequest.Body, Is.EqualTo("doggo")); + } + + [Test] + public async Task Should_amend_utf8_post_data() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { PostData = "пушкин" })); + var serverRequest = await FetchedAsync("/cors-echo", "{ method: 'POST', body: 'birdy' }"); + Assert.That(serverRequest.Method, Is.EqualTo("POST")); + Assert.That(serverRequest.Body, Is.EqualTo("пушкин")); + } + + [Test] + public async Task Should_amend_longer_post_data() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { PostData = "doggo-is-longer-than-birdy" })); + var serverRequest = await FetchedAsync("/cors-echo", "{ method: 'POST', body: 'birdy' }"); + Assert.That(serverRequest.Method, Is.EqualTo("POST")); + Assert.That(serverRequest.Body, Is.EqualTo("doggo-is-longer-than-birdy")); + } + + [Test] + public async Task Should_use_content_type_from_original_request() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync($"{PREFIX}/cors-echo", route => route.ContinueAsync(new RouteContinueOverrides { PostData = """{"b":2}""" })); + var request = await FetchedAsync($"{PREFIX}/cors-echo", """{ method: 'POST', body: '{"a":1}', headers: { 'content-type': 'application/json' } }"""); + Assert.That(request.Header("content-type"), Is.EqualTo("application/json")); + Assert.That(request.Body, Is.EqualTo("""{"b":2}""")); + } +} diff --git a/tests/E2E.NUnit.Tests/RequestContinue/PageRequestContinueTests.cs b/tests/E2E.NUnit.Tests/RequestContinue/PageRequestContinueTests.cs new file mode 100644 index 000000000..7515f5eec --- /dev/null +++ b/tests/E2E.NUnit.Tests/RequestContinue/PageRequestContinueTests.cs @@ -0,0 +1,463 @@ +// Copyright 2026 TesterArmy. +// Modified by Dario Kondratiuk. +// SPDX-License-Identifier: Apache-2.0 + +using System.Text.Json; +using System.Text.RegularExpressions; +using E2E.Engine; +using static E2E.NUnit.Tests.Helpers; + +namespace E2E.NUnit.Tests.RequestContinue; + +/// +/// test.describe('page request continue') of upstream's apps/testbed/tests/request-continue.e2e.ts (Playwright's +/// page-request-continue.spec.ts); its post data tests are in . +/// Not ported, as upstream: should amend binary post data (a string postData only), should work with Cross-Origin-Opener-Policy +/// (no request and response events), redirected requests should report overridden headers (no fallback({ headers }), no +/// response.request()), postData should return empty string when overriding body with empty string (no waitForRequest). +/// +public sealed class PageRequestContinueTests : PlaywrightTest +{ + private static string EmptyPage => $"{PREFIX}/empty.html"; + + /// The request the server received for the page now open, which /cors-echo printed as its text. + private async Task ServedAsync() => Served.Parse((await Browser.EvaluateAsync("document.body.textContent"))!); + + /// The request the server received for a page fetch to with , which /cors-echo answered with. + private async Task FetchedAsync(string url, string init = "{}") => + Served.Parse((await Browser.EvaluateAsync($"(url) => fetch(url, {init}).then((response) => response.text())", url))!); + + /// + /// Continues the requests of with foo: undefined among the headers, upstream's way to delete one, then fetches. + /// A header value is a string here, and continue refuses : the refusal is thrown once the fetch is over. + /// + private async Task FetchedWithDeletedHeaderAsync(string pattern, string url, string init) + { + Exception? refused = null; + await Browser.RouteAsync(pattern, async route => + { + try + { + await route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("foo", null!)) }); + } + catch (Exception ex) + { + refused = ex; + await route.AbortAsync(); + } + }); + try + { + return await FetchedAsync(url, init); + } + catch when (refused is not null) + { + throw refused; + } + } + + [Test] + public async Task Should_work() + { + await Browser.RouteAsync("**/*", route => route.ContinueAsync()); + await Browser.GotoAsync(EmptyPage); + } + + [Test] + public async Task Should_amend_HTTP_headers() + { + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("FOO", "bar")) })); + await Browser.GotoAsync(EmptyPage); + var request = await FetchedAsync("/cors-echo"); + Assert.That(request.Header("foo"), Is.EqualTo("bar")); + } + + [Test] + public async Task Should_not_allow_to_override_unsafe_HTTP_headers() + { + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("host", "bar"), ("trailer", "baz")) })); + await Browser.GotoAsync("/cors-echo"); + var serverRequest = await ServedAsync(); + Assert.That(serverRequest.Header("trailer"), Is.Null); + Assert.That(serverRequest.Header("host"), Is.EqualTo(new Uri(EmptyPage).Authority)); + } + + [Test] + public async Task Should_delete_header_with_undefined_value() + { + // Known difference: a header value is a string, so null cannot delete a header; `route.continue` refuses the null value. + await ExpectedToFailAsync("must be a string", async () => + { + await Browser.GotoAsync("/empty.html"); + var serverRequest = await FetchedWithDeletedHeaderAsync($"{PREFIX}/cors-echo", $"{PREFIX}/cors-echo", "{ headers: { foo: 'a', bar: 'b' } }"); + Equal("GET", serverRequest.Method); + Equal(null, serverRequest.Header("foo")); + Equal("b", serverRequest.Header("bar")); + }); + } + + [Test] + public async Task Should_amend_method() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { Method = "POST" })); + var request = await FetchedAsync("/cors-echo"); + Assert.That(request.Method, Is.EqualTo("POST")); + } + + [Test] + public async Task Should_override_request_url() + { + await Browser.RouteAsync("**/foo", route => route.ContinueAsync(new RouteContinueOverrides { Url = $"{PREFIX}/global-var.html" })); + var response = await AllAsync(Browser.WaitForResponseAsync(new Regex(@"/(foo|global-var\.html)$")), Browser.GotoAsync($"{PREFIX}/foo")); + Assert.That(response.Url, Is.EqualTo($"{PREFIX}/global-var.html")); + Assert.That(await Browser.EvaluateAsync("() => window['globalVar']"), Is.EqualTo(123)); + } + + [Test] + public async Task Should_not_allow_changing_protocol_when_overriding_url() + { + var failed = Deferred(); + await Browser.RouteAsync("**/*", async route => + { + try + { + await route.ContinueAsync(new RouteContinueOverrides { Url = "file:///tmp/foo" }); + failed.TrySetResult(null); + } + catch (Exception caught) + { + failed.TrySetResult(caught); + await route.AbortAsync(); + } + }); + var navigation = Browser.GotoAsync(EmptyPage).ContinueWith(_ => { }, TaskScheduler.Default); + var error = await failed.Task; + Assert.That(error, Is.Not.Null); + Assert.That(error!.Message, Does.Match("scheme")); + await navigation; + } + + [Test] + public async Task Should_not_throw_if_request_was_cancelled_by_the_page() + { + var routed = Deferred(); + var release = Deferred(); + await Browser.RouteAsync("**/data.json", async route => + { + routed.TrySetResult(); + await release.Task; + await route.ContinueAsync(); + }); + await Browser.GotoAsync(EmptyPage); + await Browser.EvaluateAsync(""" + (url) => { + globalThis.controller = new AbortController(); + globalThis.failure = fetch(url, { signal: globalThis.controller.signal }).then(() => 'loaded', (error) => error.name); + } + """, $"{PREFIX}/data.json"); + await routed.Task; + Assert.That(await Browser.EvaluateAsync("() => { globalThis.controller.abort(); return globalThis.failure; }"), Is.EqualTo("AbortError")); + release.TrySetResult(); + await Browser.EvaluateAsync("() => new Promise((resolve) => setTimeout(resolve, 100))"); + } + + [Test] + public async Task Should_override_method_along_with_url() + { + await Browser.RouteAsync("**/foo", route => route.ContinueAsync(new RouteContinueOverrides { Url = $"{PREFIX}/cors-echo", Method = "POST" })); + await Browser.GotoAsync($"{PREFIX}/foo"); + Assert.That((await ServedAsync()).Method, Is.EqualTo("POST")); + } + + [Test] + public async Task Should_amend_method_on_main_request() + { + await Browser.RouteAsync("**/*", route => route.ContinueAsync(new RouteContinueOverrides { Method = "POST" })); + await Browser.GotoAsync("/cors-echo"); + Assert.That((await ServedAsync()).Method, Is.EqualTo("POST")); + } + + [Test] + public async Task Should_not_delete_the_origin_header() + { + await Browser.GotoAsync("/empty.html"); + string? interceptedOrigin = null; + await Browser.RouteAsync($"{CROSS}/cors-echo", async route => + { + var headers = WithHeaders(route.Request.Headers); + interceptedOrigin = headers.GetValueOrDefault("origin"); + headers.Remove("origin"); + await route.ContinueAsync(new RouteContinueOverrides { Headers = headers }); + }); + var serverRequest = await FetchedAsync($"{CROSS}/cors-echo"); + Assert.That(serverRequest.Method, Is.EqualTo("GET")); + Assert.That(interceptedOrigin, Is.EqualTo(PREFIX)); + Assert.That(serverRequest.Header("origin"), Is.EqualTo(PREFIX)); + } + + [Test] + public async Task Should_continue_preload_link_requests() + { + var intercepted = false; + await Browser.RouteAsync("**/one-style.css", async route => + { + intercepted = true; + await route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("custom", "value")) }); + }); + await Browser.GotoAsync("/preload.html"); + await Browser.EvaluateAsync("() => new Promise((resolve) => { const check = () => window.preloadedStyles ? resolve(true) : setTimeout(check, 20); check(); })"); + Assert.That(intercepted, Is.True); + // preload.html sets the flag before switching the link to a stylesheet, which applies a task later. + await Expect.Poll(() => Browser.EvaluateAsync("() => window.getComputedStyle(document.body).backgroundColor")).ToMatchAsync(Is.EqualTo("rgb(255, 192, 203)")); + } + + [Test] + public async Task Should_respect_set_cookie_in_redirect_response() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/bounce?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers) })); + await Browser.GotoAsync($"/bounce?cookie={Uri.EscapeDataString("foo=bar; max-age=36000")}&to=/cors-echo"); + Assert.That((await ServedAsync()).Header("cookie"), Is.EqualTo("foo=bar")); + Assert.That(await Browser.EvaluateAsync("() => document.cookie"), Is.EqualTo("foo=bar")); + } + + [Test] + public async Task Continue_should_not_propagate_cookie_override_to_redirects() + { + await Browser.GotoAsync("/set-cookie?cookie=foo=bar;"); + Assert.That(await Browser.EvaluateAsync("() => document.cookie"), Is.EqualTo("foo=bar")); + await Browser.RouteAsync("**/redirect?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("cookie", "override")) })); + await Browser.GotoAsync($"/redirect?to={Uri.EscapeDataString($"{PREFIX}/cors-echo")}"); + Assert.That((await ServedAsync()).Header("cookie"), Is.EqualTo("foo=bar")); + } + + [Test] + public async Task Continue_should_not_override_cookie() + { + await Browser.GotoAsync("/set-cookie?cookie=foo=bar;"); + Assert.That(await Browser.EvaluateAsync("() => document.cookie"), Is.EqualTo("foo=bar")); + await Browser.RouteAsync("**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("cookie", "override"), ("custom", "value")) })); + await Browser.GotoAsync("/cors-echo"); + var serverRequest = await ServedAsync(); + Assert.That(serverRequest.Header("cookie"), Is.EqualTo("foo=bar")); + Assert.That(serverRequest.Header("custom"), Is.EqualTo("value")); + } + + [Test] + public async Task Continue_with_headers_should_send_fresh_cookie_from_the_browser_cookie_store() + { + await Browser.GotoAsync("/set-cookie?cookie=foo=v1;"); + Assert.That(await Browser.EvaluateAsync("() => document.cookie"), Is.EqualTo("foo=v1")); + await Browser.RouteAsync("**/cors-echo", async route => + { + await Browser.SetCookiesAsync([new BrowserCookie { Name = "foo", Value = "v2", Url = PREFIX }]); + await route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers) }); + }); + await Browser.GotoAsync("/cors-echo"); + Assert.That((await ServedAsync()).Header("cookie"), Is.EqualTo("foo=v2")); + } + + [Test] + public async Task Continue_with_headers_should_send_fresh_cookie_after_a_redirect() + { + await Browser.GotoAsync("/set-cookie?cookie=foo=v1;"); + Assert.That(await Browser.EvaluateAsync("() => document.cookie"), Is.EqualTo("foo=v1")); + await Browser.RouteAsync("**/bounce?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers) })); + await Browser.GotoAsync($"/bounce?cookie={Uri.EscapeDataString("foo=v2;")}&to={Uri.EscapeDataString($"{PREFIX}/cors-echo")}"); + Assert.That((await ServedAsync()).Header("cookie"), Is.EqualTo("foo=v2")); + } + + [Test] + public async Task Redirect_after_continue_should_be_able_to_delete_cookie() + { + await Browser.GotoAsync("/set-cookie?cookie=foo=bar;"); + Assert.That(await Browser.EvaluateAsync("() => document.cookie"), Is.EqualTo("foo=bar")); + await Browser.RouteAsync("**/redirect?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers) })); + await Browser.GotoAsync($"/redirect?to={Uri.EscapeDataString($"/set-cookie?cookie={Uri.EscapeDataString("foo=bar; expires=Thu, 01 Jan 1970 00:00:00 GMT")}")}"); + await Browser.GotoAsync("/cors-echo"); + Assert.That((await ServedAsync()).Header("cookie"), Is.Null.Or.Empty); + } + + [Test] + public async Task Continue_should_propagate_headers_to_redirects() + { + await Browser.RouteAsync("**/redirect?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("custom", "value")) })); + await Browser.GotoAsync("/redirect?to=/cors-echo"); + Assert.That((await ServedAsync()).Header("custom"), Is.EqualTo("value")); + } + + [Test] + public async Task Continue_should_drop_content_length_on_redirects() + { + await Browser.GotoAsync(EmptyPage); + await Browser.RouteAsync("**/redirect?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("custom", "value")) })); + var serverRequest = await FetchedAsync($"{PREFIX}/redirect?to=/cors-echo", "{ method: 'POST', body: 'foo' }"); + Assert.That(serverRequest.Method, Is.EqualTo("GET")); + Assert.That(serverRequest.Header("content-length"), Is.Null); + Assert.That(serverRequest.Header("content-type"), Is.Null); + Assert.That(serverRequest.Header("custom"), Is.EqualTo("value")); + } + + [Test] + public async Task Continue_should_delete_headers_on_redirects() + { + // Known difference: a header value is a string, so null cannot delete a header; `route.continue` refuses the null value. + await ExpectedToFailAsync("must be a string", async () => + { + await Browser.GotoAsync("/empty.html"); + var serverRequest = await FetchedWithDeletedHeaderAsync("**/redirect?**", $"{PREFIX}/redirect?to=/cors-echo", "{ headers: { foo: 'a' } }"); + Equal("GET", serverRequest.Method); + Equal(null, serverRequest.Header("foo")); + }); + } + + [Test] + public async Task Propagate_headers_same_origin_redirect() + { + await Browser.GotoAsync("/empty.html"); + await Browser.EvaluateAsync("() => { document.cookie = 'a=b'; }"); + var serverRequest = await FetchedAsync( + $"{PREFIX}/redirect?to={Uri.EscapeDataString("/cors-echo?preflight")}", + "{ headers: { authorization: 'credentials', custom: 'foo' }, credentials: 'include' }"); + Assert.That(serverRequest.Header("authorization"), Is.EqualTo("credentials")); + Assert.That(serverRequest.Header("cookie"), Is.EqualTo("a=b")); + Assert.That(serverRequest.Header("custom"), Is.EqualTo("foo")); + } + + [Test] + public async Task Propagate_headers_cross_origin() + { + await Browser.GotoAsync("/empty.html"); + var serverRequest = await FetchedAsync( + $"{CROSS}/cors-echo?preflight", + "{ headers: { authorization: 'credentials', custom: 'foo' }, credentials: 'include' }"); + Assert.That(serverRequest.Header("authorization"), Is.EqualTo("credentials")); + Assert.That(serverRequest.Header("custom"), Is.EqualTo("foo")); + } + + [Test] + public async Task Propagate_headers_cross_origin_redirect() + { + await Browser.GotoAsync("/empty.html"); + await Browser.EvaluateAsync("() => { document.cookie = 'a=b'; }"); + var serverRequest = await FetchedAsync( + $"{PREFIX}/bounce?status=301&to={Uri.EscapeDataString($"{CROSS}/cors-echo?preflight")}", + "{ headers: { authorization: 'credentials', custom: 'foo' }, credentials: 'include' }"); + Assert.That(serverRequest.Header("authorization"), Is.Null.Or.Empty); + Assert.That(serverRequest.Header("cookie"), Is.Null.Or.Empty); + Assert.That(serverRequest.Header("custom"), Is.EqualTo("foo")); + } + + [Test] + public async Task Propagate_headers_cross_origin_redirect_after_interception() + { + await Browser.GotoAsync("/empty.html"); + await Browser.EvaluateAsync("() => { document.cookie = 'a=b'; }"); + await Browser.RouteAsync("**/bounce?**", route => route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(route.Request.Headers, ("authorization", "credentials"), ("custom", "foo")) })); + var serverRequest = await FetchedAsync( + $"{PREFIX}/bounce?status=301&to={Uri.EscapeDataString($"{CROSS}/cors-echo?preflight")}", + "{ headers: { authorization: 'none' }, credentials: 'include' }"); + Assert.That(serverRequest.Header("authorization"), Is.EqualTo("credentials")); + Assert.That(serverRequest.Header("cookie"), Is.Null.Or.Empty); + Assert.That(serverRequest.Header("custom"), Is.EqualTo("foo")); + } + + [Test] + public async Task Continue_should_pass_on_307_cross_origin_redirect() + { + var final = $"{PREFIX}{Content("final

ok

")}"; + await Browser.GotoAsync("/empty.html"); + await Browser.GotoAsync(Content($""" +
+ +
+ """)); + await Browser.RouteAsync("**/*", route => route.ContinueAsync()); + var navigation = Browser.WaitForURLAsync(final); + await Browser.Locator("input").TapAsync(); + await navigation; + await Expect.That(Browser.Locator("p")).ToHaveTextAsync("ok"); + } + + [Test] + public async Task Should_intercept_css_variable_with_background_url() + { + var intercepted = Deferred(); + var interceptedRequests = 0; + await Browser.RouteAsync($"{PREFIX}/pptr.png", async route => + { + Interlocked.Increment(ref interceptedRequests); + intercepted.TrySetResult(); + await route.ContinueAsync(); + }); + await Browser.GotoAsync(Content(""" + +
Yo!
+ """)); + Assert.That(await Browser.Locator("div").TextContentAsync(), Is.EqualTo("Yo!")); + await intercepted.Task; + await Task.Delay(1000); + Assert.That(interceptedRequests, Is.EqualTo(1)); + } + + [Test] + public async Task Continue_should_not_change_multipart_form_data_body() + { + await Browser.GotoAsync(EmptyPage); + + async Task SendFormData() + { + var result = await Browser.EvaluateAsync(""" + async () => { + const newFile = new File(['file content'], 'file.txt'); + const formData = new FormData(); + formData.append('file', newFile); + const response = await fetch('/cors-echo', { method: 'POST', credentials: 'include', body: formData }); + return [response.status, (await response.json()).body]; + } + """); + Assert.That(result[0].GetInt32(), Is.EqualTo(200)); + return result[1].GetString()!; + } + + var reqBefore = await SendFormData(); + await Browser.RouteAsync("**/*", route => route.ContinueAsync()); + var reqAfter = await SendFormData(); + var fileContent = string.Join( + "\r\n", + "Content-Disposition: form-data; name=\"file\"; filename=\"file.txt\"", + "Content-Type: application/octet-stream", + "", + "file content", + "------"); + Assert.That(reqBefore, Does.Contain(fileContent)); + Assert.That(reqAfter, Does.Contain(fileContent)); + } + + [Test] + public async Task Should_not_forward_Host_header_on_cross_origin_redirect() + { + await Browser.RouteAsync("**/*", async route => + { + var headers = route.Request.Headers; + Assert.That(headers.ContainsKey("host"), Is.False); + await route.ContinueAsync(new RouteContinueOverrides { Headers = WithHeaders(headers) }); + }); + var response = await AllAsync( + Browser.WaitForResponseAsync("**/cors-echo"), + Browser.GotoAsync($"{PREFIX}/bounce?to={Uri.EscapeDataString($"{CROSS}/cors-echo")}")); + Assert.That(response.Status, Is.EqualTo(200)); + Assert.That((await ServedAsync()).Header("host"), Is.EqualTo(new Uri(CROSS).Authority)); + } +} diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle-frame.html b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle-frame.html new file mode 100644 index 000000000..3bf7ad4fe --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle-frame.html @@ -0,0 +1 @@ + diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle.html b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle.html new file mode 100644 index 000000000..ab10c9796 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle.html @@ -0,0 +1 @@ + diff --git a/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle.js b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle.js new file mode 100644 index 000000000..9d8998458 --- /dev/null +++ b/tests/E2E.NUnit.Tests/Testbed/playwright/assets/networkidle.js @@ -0,0 +1,12 @@ +async function main() { + window.ws = new WebSocket('ws://localhost:' + window.location.port + '/ws'); + window.ws.addEventListener('message', message => {}); + + fetch('fetch-request-a.js'); + window.top.fetchSecond = () => { + // Do not return the promise here. + fetch('fetch-request-b.js'); + }; +} + +main(); diff --git a/tests/E2E.NUnit.Tests/WaitForNavigation/PageWaitForNavigationTests.cs b/tests/E2E.NUnit.Tests/WaitForNavigation/PageWaitForNavigationTests.cs new file mode 100644 index 000000000..f89d597bc --- /dev/null +++ b/tests/E2E.NUnit.Tests/WaitForNavigation/PageWaitForNavigationTests.cs @@ -0,0 +1,193 @@ +// 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.WaitForNavigation; + +/// +/// test.describe('page wait for navigation') of upstream's apps/testbed/tests/wait-for-navigation.e2e.ts (Playwright's +/// page-wait-for-navigation.spec.ts), where page.waitForNavigation() is Browser.WaitForURLAsync with the URL the +/// navigation lands on. Not ported, as upstream: should work with both domcontentloaded and load, should work with commit +/// (no waitForNavigation({ waitUntil })), should work with clicking on links which do not commit navigation (no HTTPS server +/// with a bad certificate), should work when subframe issues window.stop() (no frameattached and framenavigated +/// events), should work on frame, should fail when frame detaches (no frame.waitForNavigation). +/// +public sealed class PageWaitForNavigationTests : PlaywrightTest +{ + private static string EmptyPage => $"{PREFIX}/empty.html"; + + [Test] + public async Task Should_work() + { + await Browser.GotoAsync(EmptyPage); + var navigation = Browser.WaitForURLAsync("/grid.html"); + await Browser.EvaluateAsync("(url) => { window.location.href = url; }", $"{PREFIX}/grid.html"); + await navigation; + Assert.That(await Browser.UrlAsync(), Does.Contain("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("/one-style.html"); + var promise = Assert.CatchAsync(() => Browser.WaitForURLAsync("/frame.html", TimeSpan.FromMilliseconds(5000))); + await Browser.GotoAsync(EmptyPage); + var error = await promise; + Assert.That(error!.Message, Does.Contain("/frame.html")); + Assert.That(error.Message, Does.Contain(EmptyPage)); + } + + [Test] + public async Task Should_work_with_clicking_on_anchor_links() + { + await Browser.GotoAsync(EmptyPage); + var page = Content("foobar"); + await Browser.GotoAsync(page); + var navigation = Browser.WaitForURLAsync($"{page}#foobar"); + await Browser.Locator("a").TapAsync(); + await navigation; + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}{page}#foobar")); + } + + [Test] + public async Task Should_work_with_history_pushState() + { + await Browser.GotoAsync(EmptyPage); + await Browser.GotoAsync(Content(""" + SPA + + """)); + var navigation = Browser.WaitForURLAsync("/wow.html"); + await Browser.Locator("a").TapAsync(); + await navigation; + 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 + + """)); + var navigation = Browser.WaitForURLAsync("/replaced.html"); + await Browser.Locator("a").TapAsync(); + await navigation; + 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")); + var back = Browser.WaitForURLAsync("/first.html"); + await Browser.Locator("a#back").TapAsync(); + await back; + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/first.html")); + var forward = Browser.WaitForURLAsync("/second.html"); + await Browser.Locator("a#forward").TapAsync(); + await forward; + Assert.That(await Browser.UrlAsync(), Is.EqualTo($"{PREFIX}/second.html")); + } + + [Test] + public async Task Should_work_with_url_match() + { + // e2e opens no page before the first goto, where Playwright starts on about:blank. + await Browser.GotoAsync(Content("

blank

")); + var response1 = false; + var response1Promise = Task.Run(async () => + { + await Browser.WaitForURLAsync(new Regex(@"one-style\.html")); + response1 = true; + }); + var response2 = false; + var response2Promise = Task.Run(async () => + { + await Browser.WaitForURLAsync(new Regex(@"/frame.html")); + response2 = true; + }); + var response3 = false; + var response3Promise = Task.Run(async () => + { + await Browser.WaitForURLAsync(new Regex(@"[?&]foo=bar")); + response3 = true; + }); + Assert.That(response1, Is.False); + Assert.That(response2, Is.False); + Assert.That(response3, Is.False); + await Browser.GotoAsync(EmptyPage); + Assert.That(response1, Is.False); + Assert.That(response2, Is.False); + Assert.That(response3, Is.False); + await Browser.GotoAsync("/frame.html"); + Assert.That(response1, Is.False); + await response2Promise; + Assert.That(response2, Is.True); + Assert.That(response3, Is.False); + await Browser.GotoAsync("/one-style.html"); + await response1Promise; + Assert.That(response1, Is.True); + Assert.That(response2, Is.True); + Assert.That(response3, Is.False); + await Browser.GotoAsync("/frame.html?foo=bar"); + await response3Promise; + Assert.That(response1, Is.True); + Assert.That(response2, Is.True); + Assert.That(response3, Is.True); + await Browser.GotoAsync("/empty.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(new Regex(@"third\.html")); + 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); + } + + [Test] + public async Task Should_work_for_cross_process_navigations() + { + await Browser.GotoAsync(EmptyPage); + var url = $"{CROSS}/empty.html"; + var waitPromise = Browser.WaitForURLAsync(url); + var gotoPromise = Browser.GotoAsync(url, new GotoOptions { WaitUntil = GotoWaitUntil.DomContentLoaded }); + await waitPromise; + Assert.That(await Browser.UrlAsync(), Is.EqualTo(url)); + Assert.That(await Browser.EvaluateAsync("document.location.href"), Is.EqualTo(url)); + await gotoPromise; + } +} diff --git a/tests/E2E.NUnit.Tests/WaitForResponse/PageWaitForResponseTests.cs b/tests/E2E.NUnit.Tests/WaitForResponse/PageWaitForResponseTests.cs new file mode 100644 index 000000000..19b8c2b10 --- /dev/null +++ b/tests/E2E.NUnit.Tests/WaitForResponse/PageWaitForResponseTests.cs @@ -0,0 +1,68 @@ +// 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.WaitForResponse; + +/// +/// test.describe('page wait for response') of upstream's apps/testbed/tests/wait-for-response.e2e.ts (Playwright's +/// page-wait-for-response.spec.ts). Not ported, as upstream: should respect timeout (no waitForEvent('response')), +/// should respect default timeout (no setDefaultTimeout, no predicate), should work with predicate, should work with async +/// predicate, sync predicate should be only called once (no response predicates). The /digits/*.png assets are not copied: the tests +/// match the URL of the response, which a 404 has too, and grid.html lays out one pixel lower once its digit images load +/// (LocatorMisc2Tests.Should_return_bounding_box expects y 50). +/// +public sealed class PageWaitForResponseTests : PlaywrightTest +{ + private static string EmptyPage => $"{PREFIX}/empty.html"; + + [Test] + public async Task Should_work() + { + await Browser.GotoAsync(EmptyPage); + var waiting = Browser.WaitForResponseAsync($"{PREFIX}/digits/2.png"); + await Browser.EvaluateAsync(""" + () => { + void fetch('/digits/1.png'); + void fetch('/digits/2.png'); + void fetch('/digits/3.png'); + } + """); + var response = await waiting; + Assert.That(response.Url, Is.EqualTo($"{PREFIX}/digits/2.png")); + } + + [Test] + public async Task Should_log_the_url() + { + // Known difference (hardkoded/e2e-dotnet#1068): the timeout message does not name the pattern yet. + await ExpectedToFailAsync("Timeout 1000ms exceeded", async () => + { + await Browser.GotoAsync(EmptyPage); + var error1 = await Assert.CatchAsync(() => Browser.WaitForResponseAsync("foo.css", TimeSpan.FromMilliseconds(1000))); + Contain("\"foo.css\"", error1!.Message); + var error2 = await Assert.CatchAsync(() => Browser.WaitForResponseAsync(new Regex("foo.css", RegexOptions.IgnoreCase), TimeSpan.FromMilliseconds(1000))); + Contain("/foo.css/i", error2!.Message); + }); + } + + [Test] + [Ignore("a timeout must be positive, so there is no `timeout: 0` for no timeout (refused as INVALID_ARGUMENT, which `fail` does not cover)")] + public async Task Should_work_with_no_timeout() + { + await Browser.GotoAsync(EmptyPage); + var waiting = Browser.WaitForResponseAsync($"{PREFIX}/digits/2.png", TimeSpan.Zero); + await Browser.EvaluateAsync(""" + () => setTimeout(() => { + void fetch('/digits/1.png'); + void fetch('/digits/2.png'); + void fetch('/digits/3.png'); + }, 50) && null + """); + var response = await waiting; + Assert.That(response.Url, Is.EqualTo($"{PREFIX}/digits/2.png")); + } +}