How to use ShouldRespectDefaultTimeout method of Microsoft.Playwright.Tests.PageWaitForRequestTests class

1/*
2 * MIT License
3 *
4 * Copyright (c) Microsoft Corporation.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25using System;
26using System.Text.RegularExpressions;
27using System.Threading.Tasks;
28using Microsoft.Playwright.NUnit;
29using NUnit.Framework;
30
31namespace Microsoft.Playwright.Tests
32{
33    public class PageWaitForRequestTests : PageTestEx
34    {
35        [PlaywrightTest("page-wait-for-request.spec.ts", "should work")]
36        public async Task ShouldWork()
37        {
38            await Page.GotoAsync(Server.EmptyPage);
39            var task = Page.WaitForRequestAsync(Server.Prefix + "/digits/2.png");
40            var (request, _) = await TaskUtils.WhenAll(
41                task,
42                Page.EvaluateAsync(@"() => {
43                  fetch('/digits/1.png');
44                  fetch('/digits/2.png');
45                  fetch('/digits/3.png');
46                }")
47            );
48            Assert.AreEqual(Server.Prefix + "/digits/2.png", request.Url);
49        }
50
51        [PlaywrightTest("page-wait-for-request.spec.ts", "should work with predicate")]
52        public async Task ShouldWorkWithPredicate()
53        {
54            await Page.GotoAsync(Server.EmptyPage);
55            var task = Page.WaitForRequestAsync(e => e.Url == Server.Prefix + "/digits/2.png");
56            var (requestEvent, _) = await TaskUtils.WhenAll(
57                task,
58                Page.EvaluateAsync<string>(@"() => {
59                    fetch('/digits/1.png');
60                    fetch('/digits/2.png');
61                    fetch('/digits/3.png');
62                }")
63            );
64            Assert.AreEqual(Server.Prefix + "/digits/2.png", requestEvent.Url);
65        }
66
67        [PlaywrightTest("page-wait-for-request.spec.ts", "should respect timeout")]
68        public Task ShouldRespectTimeout()
69        {
70            return PlaywrightAssert.ThrowsAsync<TimeoutException>(
71                () => Page.WaitForRequestAsync(_ => false, new() { Timeout = 1 }));
72        }
73
74        [PlaywrightTest("page-wait-for-request.spec.ts", "should respect default timeout")]
75        public async Task ShouldRespectDefaultTimeout()
76        {
77            Page.SetDefaultTimeout(1);
78            var exception = await PlaywrightAssert.ThrowsAsync<TimeoutException>(
79                () => Page.WaitForRequestAsync(_ => false));
80            StringAssert.Contains(exception.Message, "Timeout 1ms exceeded while waiting for event \"Request\"");
81        }
82
83        [PlaywrightTest("page-wait-for-request.spec.ts", "should work with no timeout")]
84        public async Task ShouldWorkWithNoTimeout()
85        {
86            await Page.GotoAsync(Server.EmptyPage);
87            var task = Page.WaitForRequestAsync(Server.Prefix + "/digits/2.png", new() { Timeout = 0 });
88            var (request, _) = await TaskUtils.WhenAll(
89                task,
90                Page.EvaluateAsync(@"() => setTimeout(() => {
91                    fetch('/digits/1.png');
92                    fetch('/digits/2.png');
93                    fetch('/digits/3.png');
94                }, 50)")
95            );
96            Assert.AreEqual(Server.Prefix + "/digits/2.png", request.Url);
97        }
98
99        [PlaywrightTest("page-wait-for-request.spec.ts", "should work with url match")]
100        public async Task ShouldWorkWithUrlMatch()
101        {
102            await Page.GotoAsync(Server.EmptyPage);
103            var task = Page.WaitForRequestAsync(new Regex(@"/digits/\d.png"));
104            var (request, _) = await TaskUtils.WhenAll(
105                task,
106                Page.EvaluateAsync<string>(@"() => {
107                    fetch('/digits/1.png');
108                }")
109            );
110            Assert.AreEqual(Server.Prefix + "/digits/1.png", request.Url);
111        }
112    }
113}
114

Source: PageWaitForRequestTests.cs

/*
 * MIT License
 *
 * Copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

using System;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    public class PageWaitForRequestTests : PageTestEx
    {
        [PlaywrightTest("page-wait-for-request.spec.ts", "should work")]
        public async Task ShouldWork()
        {
            await Page.GotoAsync(Server.EmptyPage);
            var task = Page.WaitForRequestAsync(Server.Prefix + "/digits/2.png");
            var (request, _) = await TaskUtils.WhenAll(
                task,
                Page.EvaluateAsync(@"() => {
                  fetch('/digits/1.png');
                  fetch('/digits/2.png');
                  fetch('/digits/3.png');
                }")
            );
            Assert.AreEqual(Server.Prefix + "/digits/2.png", request.Url);
        }

        [PlaywrightTest("page-wait-for-request.spec.ts", "should work with predicate")]
        public async Task ShouldWorkWithPredicate()
        {
            await Page.GotoAsync(Server.EmptyPage);
            var task = Page.WaitForRequestAsync(e => e.Url == Server.Prefix + "/digits/2.png");
            var (requestEvent, _) = await TaskUtils.WhenAll(
                task,
                Page.EvaluateAsync<string>(@"() => {
                    fetch('/digits/1.png');
                    fetch('/digits/2.png');
                    fetch('/digits/3.png');
                }")
            );
            Assert.AreEqual(Server.Prefix + "/digits/2.png", requestEvent.Url);
        }

        [PlaywrightTest("page-wait-for-request.spec.ts", "should respect timeout")]
        public Task ShouldRespectTimeout()
        {
            return PlaywrightAssert.ThrowsAsync<TimeoutException>(
                () => Page.WaitForRequestAsync(_ => false, new() { Timeout = 1 }));
        }

        [PlaywrightTest("page-wait-for-request.spec.ts", "should respect default timeout")]
        public async Task ShouldRespectDefaultTimeout()
        {
            Page.SetDefaultTimeout(1);
            var exception = await PlaywrightAssert.ThrowsAsync<TimeoutException>(
                () => Page.WaitForRequestAsync(_ => false));
            StringAssert.Contains(exception.Message, "Timeout 1ms exceeded while waiting for event \"Request\"");
        }

        [PlaywrightTest("page-wait-for-request.spec.ts", "should work with no timeout")]
        public async Task ShouldWorkWithNoTimeout()
        {
            await Page.GotoAsync(Server.EmptyPage);
            var task = Page.WaitForRequestAsync(Server.Prefix + "/digits/2.png", new() { Timeout = 0 });
            var (request, _) = await TaskUtils.WhenAll(
                task,
                Page.EvaluateAsync(@"() => setTimeout(() => {
                    fetch('/digits/1.png');
                    fetch('/digits/2.png');
                    fetch('/digits/3.png');
                }, 50)")
            );
            Assert.AreEqual(Server.Prefix + "/digits/2.png", request.Url);
        }

        [PlaywrightTest("page-wait-for-request.spec.ts", "should work with url match")]
        public async Task ShouldWorkWithUrlMatch()
        {
            await Page.GotoAsync(Server.EmptyPage);
            var task = Page.WaitForRequestAsync(new Regex(@"/digits/\d.png"));
            var (request, _) = await TaskUtils.WhenAll(
                task,
                Page.EvaluateAsync<string>(@"() => {
                    fetch('/digits/1.png');
                }")
            );
            Assert.AreEqual(Server.Prefix + "/digits/1.png", request.Url);
        }
    }
}