How to use ShouldIntercept method of Microsoft.Playwright.Tests.BrowserContextRouteTests 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.Collections.Generic;
27using System.Net;
28using System.Net.Http;
29using System.Threading.Tasks;
30using Microsoft.Playwright.NUnit;
31using NUnit.Framework;
32
33namespace Microsoft.Playwright.Tests
34{
35    public class BrowserContextRouteTests : BrowserTestEx
36    {
37        [PlaywrightTest("browsercontext-route.spec.ts", "should intercept")]
38        public async Task ShouldIntercept()
39        {
40            bool intercepted = false;
41
42            await using var context = await Browser.NewContextAsync();
43            IPage page = null;
44
45            await context.RouteAsync("**/empty.html", (route) =>
46            {
47                intercepted = true;
48
49                StringAssert.Contains("empty.html", route.Request.Url);
50#pragma warning disable 0612
51                Assert.False(string.IsNullOrEmpty(route.Request.Headers["user-agent"]));
52#pragma warning restore 0612
53                Assert.AreEqual(HttpMethod.Get.Method, route.Request.Method);
54                Assert.Null(route.Request.PostData);
55                Assert.True(route.Request.IsNavigationRequest);
56                Assert.AreEqual("document", route.Request.ResourceType);
57                Assert.AreEqual(page.MainFrame, route.Request.Frame);
58                Assert.AreEqual("about:blank", page.MainFrame.Url);
59
60                route.ContinueAsync();
61            });
62
63            page = await context.NewPageAsync();
64            var response = await page.GotoAsync(Server.EmptyPage);
65            Assert.True(response.Ok);
66            Assert.True(intercepted);
67        }
68
69        [PlaywrightTest("browsercontext-route.spec.ts", "should unroute")]
70        public async Task ShouldUnroute()
71        {
72            await using var context = await Browser.NewContextAsync();
73            var page = await context.NewPageAsync();
74            var intercepted = new List<int>();
75
76
77            await context.RouteAsync("**/*", route =>
78            {
79                intercepted.Add(1);
80                route.ContinueAsync();
81            });
82
83            await context.RouteAsync("**/empty.html", (route) =>
84            {
85                intercepted.Add(2);
86                route.ContinueAsync();
87            });
88
89            await context.RouteAsync("**/empty.html", (route) =>
90            {
91                intercepted.Add(3);
92                route.ContinueAsync();
93            });
94
95            Action<IRoute> handler4 = (route) =>
96            {
97                intercepted.Add(4);
98                route.ContinueAsync();
99            };
100            await context.RouteAsync("**/empty.html", handler4);
101
102            await page.GotoAsync(Server.EmptyPage);
103            Assert.AreEqual(new List<int>() { 4 }, intercepted);
104
105            intercepted.Clear();
106            await context.UnrouteAsync("**/empty.html", handler4);
107            await page.GotoAsync(Server.EmptyPage);
108            Assert.AreEqual(new List<int>() { 3 }, intercepted);
109
110            intercepted.Clear();
111            await context.UnrouteAsync("**/empty.html");
112            await page.GotoAsync(Server.EmptyPage);
113            Assert.AreEqual(new List<int>() { 1 }, intercepted);
114        }
115
116        [PlaywrightTest]
117        public async Task ShouldUnroutePageWithBaseUrl()
118        {
119            var options = new BrowserNewContextOptions();
120            options.BaseURL = Server.Prefix;
121
122            await using var context = await Browser.NewContextAsync(options);
123            var page = await context.NewPageAsync();
124            var intercepted = new List<int>();
125
126            await page.RouteAsync("/empty.html", (route) =>
127            {
128                intercepted.Add(1);
129                route.ContinueAsync();
130            });
131
132            Action<IRoute> handler2 = (route) =>
133            {
134                intercepted.Add(2);
135                route.ContinueAsync();
136            };
137            await page.RouteAsync("/empty.html", handler2);
138
139            await page.GotoAsync(Server.EmptyPage);
140            Assert.AreEqual(new List<int>() { 2 }, intercepted);
141
142            intercepted.Clear();
143            await page.UnrouteAsync("/empty.html", handler2);
144            await page.GotoAsync(Server.EmptyPage);
145            Assert.AreEqual(new List<int>() { 1 }, intercepted);
146        }
147
148        [PlaywrightTest("browsercontext-route.spec.ts", "should yield to page.route")]
149        public async Task ShouldYieldToPageRoute()
150        {
151            await using var context = await Browser.NewContextAsync();
152            await context.RouteAsync("**/empty.html", (route) =>
153            {
154                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "context" });
155            });
156
157            var page = await context.NewPageAsync();
158            await page.RouteAsync("**/empty.html", (route) =>
159            {
160                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "page" });
161            });
162
163            var response = await page.GotoAsync(Server.EmptyPage);
164            Assert.AreEqual("page", await response.TextAsync());
165        }
166
167        [PlaywrightTest("browsercontext-route.spec.ts", "should fall back to context.route")]
168        public async Task ShouldFallBackToContextRoute()
169        {
170            await using var context = await Browser.NewContextAsync();
171            await context.RouteAsync("**/empty.html", (route) =>
172            {
173                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "context" });
174            });
175
176            var page = await context.NewPageAsync();
177            await page.RouteAsync("**/non-empty.html", (route) =>
178            {
179                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "page" });
180            });
181
182            var response = await page.GotoAsync(Server.EmptyPage);
183            Assert.AreEqual("context", await response.TextAsync());
184        }
185
186        [PlaywrightTest]
187        public async Task ShouldThrowOnInvalidRouteUrl()
188        {
189            await using var context = await Browser.NewContextAsync();
190
191#if NETCOREAPP3_1
192            var regexParseExceptionType = typeof(System.Text.RegularExpressions.Regex).Assembly
193                .GetType("System.Text.RegularExpressions.RegexParseException", throwOnError: true);
194#else
195            var regexParseExceptionType = typeof(System.Text.RegularExpressions.RegexParseException);
196#endif
197
198            Assert.Throws(regexParseExceptionType, () =>
199                context.RouteAsync("[", route =>
200                {
201                    route.ContinueAsync();
202                })
203            );
204        }
205
206        [PlaywrightTest("browsercontext-route.spec.ts", "should support the times parameter with route matching")]
207        public async Task ShouldSupportTheTimesParameterWithRouteMatching()
208        {
209            await using var context = await Browser.NewContextAsync();
210            var page = await context.NewPageAsync();
211            List<int> intercepted = new();
212            await context.RouteAsync("**/empty.html", (route) =>
213            {
214                intercepted.Add(1);
215                route.ContinueAsync();
216            }, new() { Times = 1 });
217
218            await page.GotoAsync(Server.EmptyPage);
219            await page.GotoAsync(Server.EmptyPage);
220            await page.GotoAsync(Server.EmptyPage);
221            Assert.AreEqual(1, intercepted.Count);
222        }
223    }
224}
225

Source: BrowserContextRouteTests.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.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;

namespace Microsoft.Playwright.Tests
{
    public class BrowserContextRouteTests : BrowserTestEx
    {
        [PlaywrightTest("browsercontext-route.spec.ts", "should intercept")]
        public async Task ShouldIntercept()
        {
            bool intercepted = false;

            await using var context = await Browser.NewContextAsync();
            IPage page = null;

            await context.RouteAsync("**/empty.html", (route) =>
            {
                intercepted = true;

                StringAssert.Contains("empty.html", route.Request.Url);
#pragma warning disable 0612
                Assert.False(string.IsNullOrEmpty(route.Request.Headers["user-agent"]));
#pragma warning restore 0612
                Assert.AreEqual(HttpMethod.Get.Method, route.Request.Method);
                Assert.Null(route.Request.PostData);
                Assert.True(route.Request.IsNavigationRequest);
                Assert.AreEqual("document", route.Request.ResourceType);
                Assert.AreEqual(page.MainFrame, route.Request.Frame);
                Assert.AreEqual("about:blank", page.MainFrame.Url);

                route.ContinueAsync();
            });

            page = await context.NewPageAsync();
            var response = await page.GotoAsync(Server.EmptyPage);
            Assert.True(response.Ok);
            Assert.True(intercepted);
        }

        [PlaywrightTest("browsercontext-route.spec.ts", "should unroute")]
        public async Task ShouldUnroute()
        {
            await using var context = await Browser.NewContextAsync();
            var page = await context.NewPageAsync();
            var intercepted = new List<int>();


            await context.RouteAsync("**/*", route =>
            {
                intercepted.Add(1);
                route.ContinueAsync();
            });

            await context.RouteAsync("**/empty.html", (route) =>
            {
                intercepted.Add(2);
                route.ContinueAsync();
            });

            await context.RouteAsync("**/empty.html", (route) =>
            {
                intercepted.Add(3);
                route.ContinueAsync();
            });

            Action<IRoute> handler4 = (route) =>
            {
                intercepted.Add(4);
                route.ContinueAsync();
            };
            await context.RouteAsync("**/empty.html", handler4);

            await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual(new List<int>() { 4 }, intercepted);

            intercepted.Clear();
            await context.UnrouteAsync("**/empty.html", handler4);
            await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual(new List<int>() { 3 }, intercepted);

            intercepted.Clear();
            await context.UnrouteAsync("**/empty.html");
            await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual(new List<int>() { 1 }, intercepted);
        }

        [PlaywrightTest]
        public async Task ShouldUnroutePageWithBaseUrl()
        {
            var options = new BrowserNewContextOptions();
            options.BaseURL = Server.Prefix;

            await using var context = await Browser.NewContextAsync(options);
            var page = await context.NewPageAsync();
            var intercepted = new List<int>();

            await page.RouteAsync("/empty.html", (route) =>
            {
                intercepted.Add(1);
                route.ContinueAsync();
            });

            Action<IRoute> handler2 = (route) =>
            {
                intercepted.Add(2);
                route.ContinueAsync();
            };
            await page.RouteAsync("/empty.html", handler2);

            await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual(new List<int>() { 2 }, intercepted);

            intercepted.Clear();
            await page.UnrouteAsync("/empty.html", handler2);
            await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual(new List<int>() { 1 }, intercepted);
        }

        [PlaywrightTest("browsercontext-route.spec.ts", "should yield to page.route")]
        public async Task ShouldYieldToPageRoute()
        {
            await using var context = await Browser.NewContextAsync();
            await context.RouteAsync("**/empty.html", (route) =>
            {
                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "context" });
            });

            var page = await context.NewPageAsync();
            await page.RouteAsync("**/empty.html", (route) =>
            {
                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "page" });
            });

            var response = await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual("page", await response.TextAsync());
        }

        [PlaywrightTest("browsercontext-route.spec.ts", "should fall back to context.route")]
        public async Task ShouldFallBackToContextRoute()
        {
            await using var context = await Browser.NewContextAsync();
            await context.RouteAsync("**/empty.html", (route) =>
            {
                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "context" });
            });

            var page = await context.NewPageAsync();
            await page.RouteAsync("**/non-empty.html", (route) =>
            {
                route.FulfillAsync(new() { Status = (int)HttpStatusCode.OK, Body = "page" });
            });

            var response = await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual("context", await response.TextAsync());
        }

        [PlaywrightTest]
        public async Task ShouldThrowOnInvalidRouteUrl()
        {
            await using var context = await Browser.NewContextAsync();

#if NETCOREAPP3_1
            var regexParseExceptionType = typeof(System.Text.RegularExpressions.Regex).Assembly
                .GetType("System.Text.RegularExpressions.RegexParseException", throwOnError: true);
#else
            var regexParseExceptionType = typeof(System.Text.RegularExpressions.RegexParseException);
#endif

            Assert.Throws(regexParseExceptionType, () =>
                context.RouteAsync("[", route =>
                {
                    route.ContinueAsync();
                })
            );
        }

        [PlaywrightTest("browsercontext-route.spec.ts", "should support the times parameter with route matching")]
        public async Task ShouldSupportTheTimesParameterWithRouteMatching()
        {
            await using var context = await Browser.NewContextAsync();
            var page = await context.NewPageAsync();
            List<int> intercepted = new();
            await context.RouteAsync("**/empty.html", (route) =>
            {
                intercepted.Add(1);
                route.ContinueAsync();
            }, new() { Times = 1 });

            await page.GotoAsync(Server.EmptyPage);
            await page.GotoAsync(Server.EmptyPage);
            await page.GotoAsync(Server.EmptyPage);
            Assert.AreEqual(1, intercepted.Count);
        }
    }
}