How to use RouteFulfillOptions method of Microsoft.Playwright.RouteFulfillOptions class

1using Microsoft.Playwright;
2using System.Threading.Tasks;
3using System.Collections.Generic;  
4using System;  
5using System.IO;  
6using System.Text.Json;
7
8class Program
9{
10    public static async Task Main()
11    {
12        UsersContext context = new UsersContext();
13        using var playwright = await Playwright.CreateAsync();
14        await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions{
15            Headless = false, 
16            SlowMo = 2000
17        });
18        var page = await browser.NewPageAsync();
19        
20        var url  =  "http://localhost:4200/";
21        
22        string usersUrl  =  "https://jsonplaceholder.typicode.com/**";
23
24        await page.RouteAsync(usersUrl,async route => {
25            
26            if(route.Request.Method.ToUpperInvariant() == "GET"){
27                await route.FulfillAsync(new RouteFulfillOptions { 
28                    Status = 200
29                    , ContentType = "application/json"
30                    , Headers = new List<KeyValuePair<string, string>>{ 
31                            new KeyValuePair<string, string>("Access-Control-Allow-Credentials", "true" ),  
32                            new KeyValuePair<string, string>("Access-Control-Allow-Origin", "*" ),  
33                        }
34                    , Body = context.Data });
35            }
36            else if(route.Request.Method.ToUpperInvariant() == "PUT"){
37             
38                context.UpdateUser(route.Request.PostData);
39                
40                await route.FulfillAsync(new RouteFulfillOptions { 
41                    Status = 200
42                    , ContentType = "application/json"
43                    , Headers = new List<KeyValuePair<string, string>>{ 
44                            new KeyValuePair<string, string>("Access-Control-Allow-Credentials", "true" ),  
45                            new KeyValuePair<string, string>("Access-Control-Allow-Origin", "*" ),  
46                        }
47                    , Body = route.Request.PostData });
48            }
49            else{
50                await route.ContinueAsync();
51            }
52         });
53
54        await page.GotoAsync(url);
55        
56        await page.Locator("text=Leanne Graham").ClickAsync();;
57
58        var number = new Random().Next(0, 1000000).ToString("D6");
59
60        await page.FillAsync("input[aria-label=name]", $"Leanne Graham {number}");
61        await page.FillAsync("input[aria-label=username]", $"Bret {number}");
62        await page.FillAsync("input[aria-label=email]", $"Sincere{number}@april.biz");
63
64        await page.Locator("button[aria-label=btn-save]").ClickAsync();;
65
66        //This line is just to put wait on the browser
67        await page.Locator("button[aria-label=btn-none]").ClickAsync();;
68
69        await page.ScreenshotAsync(new PageScreenshotOptions { Path = "screenshot.png" });
70
71        await browser.CloseAsync();
72    }
73}
74
75

Source: Program.cs

using Microsoft.Playwright;
using System.Threading.Tasks;
using System.Collections.Generic;  
using System;  
using System.IO;  
using System.Text.Json;

class Program
{
    public static async Task Main()
    {
        UsersContext context = new UsersContext();
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions{
            Headless = false, 
            SlowMo = 2000
        });
        var page = await browser.NewPageAsync();
        
        var url  =  "http://localhost:4200/";
        
        string usersUrl  =  "https://jsonplaceholder.typicode.com/**";

        await page.RouteAsync(usersUrl,async route => {
            
            if(route.Request.Method.ToUpperInvariant() == "GET"){
                await route.FulfillAsync(new RouteFulfillOptions { 
                    Status = 200
                    , ContentType = "application/json"
                    , Headers = new List<KeyValuePair<string, string>>{ 
                            new KeyValuePair<string, string>("Access-Control-Allow-Credentials", "true" ),  
                            new KeyValuePair<string, string>("Access-Control-Allow-Origin", "*" ),  
                        }
                    , Body = context.Data });
            }
            else if(route.Request.Method.ToUpperInvariant() == "PUT"){
             
                context.UpdateUser(route.Request.PostData);
                
                await route.FulfillAsync(new RouteFulfillOptions { 
                    Status = 200
                    , ContentType = "application/json"
                    , Headers = new List<KeyValuePair<string, string>>{ 
                            new KeyValuePair<string, string>("Access-Control-Allow-Credentials", "true" ),  
                            new KeyValuePair<string, string>("Access-Control-Allow-Origin", "*" ),  
                        }
                    , Body = route.Request.PostData });
            }
            else{
                await route.ContinueAsync();
            }
         });

        await page.GotoAsync(url);
        
        await page.Locator("text=Leanne Graham").ClickAsync();;

        var number = new Random().Next(0, 1000000).ToString("D6");

        await page.FillAsync("input[aria-label=name]", $"Leanne Graham {number}");
        await page.FillAsync("input[aria-label=username]", $"Bret {number}");
        await page.FillAsync("input[aria-label=email]", $"Sincere{number}@april.biz");

        await page.Locator("button[aria-label=btn-save]").ClickAsync();;

        //This line is just to put wait on the browser
        await page.Locator("button[aria-label=btn-none]").ClickAsync();;

        await page.ScreenshotAsync(new PageScreenshotOptions { Path = "screenshot.png" });

        await browser.CloseAsync();
    }
}

1using System;
2using System.Collections.Generic;
3using System.Threading.Tasks;
4using Microsoft.Playwright;
5using NUnit.Framework;
6using Newtonsoft.Json;
7
8namespace PlaywrightTests;
9
10public class Tests
11{
12    public IBrowser _Browser { get; set;}
13    public IPlaywright _Playwright { get; set;}
14    public IBrowserContext _Context { get; set; }
15
16    public IPage _Page { get; set; }
17
18    [OneTimeSetUp]
19    public async Task SetupAsync()
20    {
21        var playwright = await Playwright.CreateAsync();
22        _Playwright = playwright;
23
24        var browserLaunchOptions = new BrowserTypeLaunchOptions { 
25                Headless = false
26        };
27        var browser = await playwright.Chromium.LaunchAsync(browserLaunchOptions);
28        _Browser = browser;
29
30        _Context = await _Browser.NewContextAsync();
31
32        _Page = await _Context.NewPageAsync();
33    }
34
35    [TearDown]
36    public async Task TearDownAsync(){
37        Console.WriteLine(await _Page.TitleAsync());
38        await _Page.PauseAsync();
39    }
40
41    [OneTimeTearDown]
42    public async Task OneTimeTearDownAsync(){
43        await _Context.CloseAsync();
44        await _Browser.CloseAsync();
45        _Playwright.Dispose();
46    }
47
48    [Test]
49    public async Task InterceptContent()
50    {
51        await _Page.RouteAsync("**/*", async route =>{
52            if(route.Request.ResourceType == "stylesheet" ){
53                await route.AbortAsync();
54            }
55            else {
56                await route.ContinueAsync();
57            }
58        });
59        await _Page.GotoAsync("https://danube-webshop.herokuapp.com/");
60    }
61    [Test]
62    public async Task InterceptResponses()
63    { 
64        Object[] mockResponseObject = {new {
65            id =  1,
66            title = "How to Mock a Response",
67            author = "A. Friend",
68            genre = "business",
69            price = "0.00",
70            rating = "★★★★★",
71            stock = 65535
72        }};
73        var list = new List<object>(){mockResponseObject};
74        await _Page.RouteAsync("https://danube-webshop.herokuapp.com/api/books", async route =>{
75            await route.FulfillAsync(new RouteFulfillOptions {
76                ContentType = "application/json",
77                Body = JsonConvert.SerializeObject(mockResponseObject)
78            });
79        });
80        await _Page.GotoAsync("https://danube-webshop.herokuapp.com/");
81    }
82}

Source: UnitTest1.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Playwright;
using NUnit.Framework;
using Newtonsoft.Json;

namespace PlaywrightTests;

public class Tests
{
    public IBrowser _Browser { get; set;}
    public IPlaywright _Playwright { get; set;}
    public IBrowserContext _Context { get; set; }

    public IPage _Page { get; set; }

    [OneTimeSetUp]
    public async Task SetupAsync()
    {
        var playwright = await Playwright.CreateAsync();
        _Playwright = playwright;

        var browserLaunchOptions = new BrowserTypeLaunchOptions { 
                Headless = false
        };
        var browser = await playwright.Chromium.LaunchAsync(browserLaunchOptions);
        _Browser = browser;

        _Context = await _Browser.NewContextAsync();

        _Page = await _Context.NewPageAsync();
    }

    [TearDown]
    public async Task TearDownAsync(){
        Console.WriteLine(await _Page.TitleAsync());
        await _Page.PauseAsync();
    }

    [OneTimeTearDown]
    public async Task OneTimeTearDownAsync(){
        await _Context.CloseAsync();
        await _Browser.CloseAsync();
        _Playwright.Dispose();
    }

    [Test]
    public async Task InterceptContent()
    {
        await _Page.RouteAsync("**/*", async route =>{
            if(route.Request.ResourceType == "stylesheet" ){
                await route.AbortAsync();
            }
            else {
                await route.ContinueAsync();
            }
        });
        await _Page.GotoAsync("https://danube-webshop.herokuapp.com/");
    }
    [Test]
    public async Task InterceptResponses()
    { 
        Object[] mockResponseObject = {new {
            id =  1,
            title = "How to Mock a Response",
            author = "A. Friend",
            genre = "business",
            price = "0.00",
            rating = "★★★★★",
            stock = 65535
        }};
        var list = new List<object>(){mockResponseObject};
        await _Page.RouteAsync("https://danube-webshop.herokuapp.com/api/books", async route =>{
            await route.FulfillAsync(new RouteFulfillOptions {
                ContentType = "application/json",
                Body = JsonConvert.SerializeObject(mockResponseObject)
            });
        });
        await _Page.GotoAsync("https://danube-webshop.herokuapp.com/");
    }
}