How to use QuerySelectorAsync method of PuppeteerSharp.Frame class

1using System;
2using System.Linq;
3using System.Threading.Tasks;
4
5using FluentAssertions;
6
7using Microsoft.EntityFrameworkCore;
8using Microsoft.Extensions.DependencyInjection;
9
10using NUnit.Framework;
11
12using PuppeteerSharp;
13
14namespace Brighid.Identity.Auth
15{
16    [TestFixture]
17    [Category("Integration")]
18    public class AuthIntegrationTests
19    {
20        private const string Email = "[email protected]";
21        private const string Password = "Password123!";
22
23        [Test]
24        [Auto]
25        public async Task LoginRedirect(
26            AppFactory app,
27            Browser browser
28        )
29        {
30            var page = await browser.NewPageAsync();
31            await page.GoToAsync(app.RootUri.ToString());
32
33            // We should be redirected to login
34            new Uri(page.Url).AbsolutePath.Should().Be("/login");
35        }
36
37        [Test]
38        [Auto]
39        public async Task SignupThenLogin(
40            AppFactory app,
41            Browser browser
42        )
43        {
44            var page = await browser.NewPageAsync();
45            await page.GoToAsync($"{app.RootUri}signup");
46            {
47                var emailField = await page.MainFrame.QuerySelectorAsync("#Email");
48                await emailField.TypeAsync(Email);
49
50                var passwordField = await page.MainFrame.QuerySelectorAsync("#Password");
51                await passwordField.TypeAsync(Password);
52
53                var confirmPasswordField = await page.MainFrame.QuerySelectorAsync("#ConfirmPassword");
54                await confirmPasswordField.TypeAsync(Password);
55
56                var submitButton = await page.MainFrame.QuerySelectorAsync("input[type=submit]");
57                await submitButton.ClickAsync();
58
59                await page.MainFrame.WaitForNavigationAsync();
60            }
61
62            {
63                using var scope = app.Services.CreateScope();
64                var dbContext = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
65                var query = from user in dbContext.Users.AsQueryable() where user.Email == Email select user;
66                var exists = await query.AnyAsync();
67
68                exists.Should().Be(true);
69            }
70
71            {
72                var cookies = await page.GetCookiesAsync();
73                await page.DeleteCookieAsync(cookies);
74                await page.GoToAsync($"{app.RootUri}login", waitUntil: WaitUntilNavigation.DOMContentLoaded);
75            }
76
77            {
78                var emailField = await page.MainFrame.QuerySelectorAsync("#Email");
79                await emailField.TypeAsync(Email);
80
81                var passwordField = await page.MainFrame.QuerySelectorAsync("#Password");
82                await passwordField.TypeAsync(Password);
83
84                var submitButton = await page.MainFrame.QuerySelectorAsync("input[type=submit]");
85                await submitButton.ClickAsync();
86
87                await page.MainFrame.WaitForNavigationAsync();
88
89                var url = new Uri(page.Url);
90                url.AbsolutePath.Should().Be("/");
91            }
92        }
93    }
94}
95

Source: AuthIntegrationTests.cs

using System;
using System.Linq;
using System.Threading.Tasks;

using FluentAssertions;

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;

using NUnit.Framework;

using PuppeteerSharp;

namespace Brighid.Identity.Auth
{
    [TestFixture]
    [Category("Integration")]
    public class AuthIntegrationTests
    {
        private const string Email = "[email protected]";
        private const string Password = "Password123!";

        [Test]
        [Auto]
        public async Task LoginRedirect(
            AppFactory app,
            Browser browser
        )
        {
            var page = await browser.NewPageAsync();
            await page.GoToAsync(app.RootUri.ToString());

            // We should be redirected to login
            new Uri(page.Url).AbsolutePath.Should().Be("/login");
        }

        [Test]
        [Auto]
        public async Task SignupThenLogin(
            AppFactory app,
            Browser browser
        )
        {
            var page = await browser.NewPageAsync();
            await page.GoToAsync($"{app.RootUri}signup");
            {
                var emailField = await page.MainFrame.QuerySelectorAsync("#Email");
                await emailField.TypeAsync(Email);

                var passwordField = await page.MainFrame.QuerySelectorAsync("#Password");
                await passwordField.TypeAsync(Password);

                var confirmPasswordField = await page.MainFrame.QuerySelectorAsync("#ConfirmPassword");
                await confirmPasswordField.TypeAsync(Password);

                var submitButton = await page.MainFrame.QuerySelectorAsync("input[type=submit]");
                await submitButton.ClickAsync();

                await page.MainFrame.WaitForNavigationAsync();
            }

            {
                using var scope = app.Services.CreateScope();
                var dbContext = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
                var query = from user in dbContext.Users.AsQueryable() where user.Email == Email select user;
                var exists = await query.AnyAsync();

                exists.Should().Be(true);
            }

            {
                var cookies = await page.GetCookiesAsync();
                await page.DeleteCookieAsync(cookies);
                await page.GoToAsync($"{app.RootUri}login", waitUntil: WaitUntilNavigation.DOMContentLoaded);
            }

            {
                var emailField = await page.MainFrame.QuerySelectorAsync("#Email");
                await emailField.TypeAsync(Email);

                var passwordField = await page.MainFrame.QuerySelectorAsync("#Password");
                await passwordField.TypeAsync(Password);

                var submitButton = await page.MainFrame.QuerySelectorAsync("input[type=submit]");
                await submitButton.ClickAsync();

                await page.MainFrame.WaitForNavigationAsync();

                var url = new Uri(page.Url);
                url.AbsolutePath.Should().Be("/");
            }
        }
    }
}

1using System;
2using System.Collections.Generic;
3using System.Text;
4using System.Threading.Tasks;
5using PuppeteerSharp;
6
7namespace SpotifyBot.PuppeteerPrelude
8{
9    public static class PuppeteerExtensions
10    {
11        public static async Task UseProxyAuth(this Page page, string credentials)
12        {
13            var authStr = $"Basic {Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials))}";
14            await page.SetExtraHttpHeadersAsync(new Dictionary<string, string>
15            {
16                ["Proxy-Authorization"] = authStr
17            });
18        }
19
20        public static async Task TypeAsync(this Frame frame, string selector, string text)
21        {
22            await (await frame.QuerySelectorAsync(selector)).TypeAsync(text);
23        }
24
25        public static async Task ClickAsync(this Frame frame, string selector)
26        {
27            await (await frame.QuerySelectorAsync(selector)).ClickAsync();
28        }
29
30        public static async Task WaitForTruth(this Page page, string script, WaitForFunctionOptions opts = null)
31        {
32            var jsHandle = await page.WaitForExpressionAsync(script, opts);
33            await jsHandle.DisposeAsync();
34        }
35
36        public static async Task WaitForDocumentInteractiveState(this Page page, int? timeout = null)
37        {
38            await page.WaitForTruth("document.readyState === 'interactive' || document.readyState === 'complete'", new WaitForFunctionOptions { Timeout = timeout ?? page.Browser.DefaultWaitForTimeout });
39        }
40    }
41}
42

Source: PuppeteerExtensions.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using PuppeteerSharp;

namespace SpotifyBot.PuppeteerPrelude
{
    public static class PuppeteerExtensions
    {
        public static async Task UseProxyAuth(this Page page, string credentials)
        {
            var authStr = $"Basic {Convert.ToBase64String(Encoding.UTF8.GetBytes(credentials))}";
            await page.SetExtraHttpHeadersAsync(new Dictionary<string, string>
            {
                ["Proxy-Authorization"] = authStr
            });
        }

        public static async Task TypeAsync(this Frame frame, string selector, string text)
        {
            await (await frame.QuerySelectorAsync(selector)).TypeAsync(text);
        }

        public static async Task ClickAsync(this Frame frame, string selector)
        {
            await (await frame.QuerySelectorAsync(selector)).ClickAsync();
        }

        public static async Task WaitForTruth(this Page page, string script, WaitForFunctionOptions opts = null)
        {
            var jsHandle = await page.WaitForExpressionAsync(script, opts);
            await jsHandle.DisposeAsync();
        }

        public static async Task WaitForDocumentInteractiveState(this Page page, int? timeout = null)
        {
            await page.WaitForTruth("document.readyState === 'interactive' || document.readyState === 'complete'", new WaitForFunctionOptions { Timeout = timeout ?? page.Browser.DefaultWaitForTimeout });
        }
    }
}