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

1using Microsoft.Playwright;
2using Microsoft.Playwright.NUnit;
3using NUnit.Framework;
4using System.Threading.Tasks;
5using WebullApi;
6
7namespace tests
8{
9
10    public class Test1 : ContextTest
11    {
12
13        private TradingPage _tradingPage;
14       
15   
16        [SetUp]
17        public async Task Setup()
18        {
19                  
20            string email = "[email protected]";
21
22            string password = "Asmallamountofmilk13";
23
24            var page = await Context.NewPageAsync();
25            
26            var loginPage = await new HomePage(page)
27                .ClickLoginAsync();
28
29            var centerPage = await loginPage.LoginViaEmailAsync(email, password);
30
31            _tradingPage = await centerPage.ClickTrade();
32
33        }
34
35
36
37
38        [Test] 
39
40        public async Task Test()
41        {
42            await _tradingPage.Trade();
43        }
44
45   
46    }
47
48
49    
50
51
52    //private async Task LoginAsync()û
53    //{
54    //    playwright = await Playwright.CreateAsync();
55    //    browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
56    //    { Headless = false, SlowMo = 50, });
57    //    Context = await browser.NewContextAsync();
58    //    await Context.StorageStateAsync(new BrowserContextStorageStateOptions
59    //    {
60    //        Path = "state.json"
61    //    });
62    //    page = await Context.NewPageAsync();
63    //    await page.GotoAsync(HttpsWwwDemoblazeComCartHtml);
64    //    await page.ClickAsync("a:has-text('Log In')");
65    //    await Helpers.Login("[email protected]@gmail.com", "12345678", page);
66    //}
67}
68

Source: UnitTest1.cs

using Microsoft.Playwright;
using Microsoft.Playwright.NUnit;
using NUnit.Framework;
using System.Threading.Tasks;
using WebullApi;

namespace tests
{

    public class Test1 : ContextTest
    {

        private TradingPage _tradingPage;
       
   
        [SetUp]
        public async Task Setup()
        {
                  
            string email = "[email protected]";

            string password = "Asmallamountofmilk13";

            var page = await Context.NewPageAsync();
            
            var loginPage = await new HomePage(page)
                .ClickLoginAsync();

            var centerPage = await loginPage.LoginViaEmailAsync(email, password);

            _tradingPage = await centerPage.ClickTrade();

        }




        [Test] 

        public async Task Test()
        {
            await _tradingPage.Trade();
        }

   
    }


    


    //private async Task LoginAsync()û
    //{
    //    playwright = await Playwright.CreateAsync();
    //    browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
    //    { Headless = false, SlowMo = 50, });
    //    Context = await browser.NewContextAsync();
    //    await Context.StorageStateAsync(new BrowserContextStorageStateOptions
    //    {
    //        Path = "state.json"
    //    });
    //    page = await Context.NewPageAsync();
    //    await page.GotoAsync(HttpsWwwDemoblazeComCartHtml);
    //    await page.ClickAsync("a:has-text('Log In')");
    //    await Helpers.Login("[email protected]@gmail.com", "12345678", page);
    //}
}

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.ComponentModel.DataAnnotations;
28using System.Drawing;
29using System.Globalization;
30using System.IO;
31using System.Runtime.Serialization;
32using System.Text.Json;
33using System.Text.Json.Serialization;
34using System.Text.RegularExpressions;
35using System.Threading;
36using System.Threading.Tasks;
37
38#nullable enable
39
40namespace Microsoft.Playwright
41{
42    public class BrowserContextStorageStateOptions
43    {
44        public BrowserContextStorageStateOptions() { }
45
46        public BrowserContextStorageStateOptions(BrowserContextStorageStateOptions clone)
47        {
48            if (clone == null)
49            {
50                return;
51            }
52
53            Path = clone.Path;
54        }
55
56        /// <summary>
57        /// <para>
58        /// The file path to save the storage state to. If <paramref name="path"/> is a relative
59        /// path, then it is resolved relative to current working directory. If no path is provided,
60        /// storage state is still returned, but won't be saved to the disk.
61        /// </para>
62        /// </summary>
63        [JsonPropertyName("path")]
64        public string? Path { get; set; }
65    }
66}
67
68#nullable disable
69

Source: BrowserContextStorageStateOptions.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.ComponentModel.DataAnnotations;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

#nullable enable

namespace Microsoft.Playwright
{
    public class BrowserContextStorageStateOptions
    {
        public BrowserContextStorageStateOptions() { }

        public BrowserContextStorageStateOptions(BrowserContextStorageStateOptions clone)
        {
            if (clone == null)
            {
                return;
            }

            Path = clone.Path;
        }

        /// <summary>
        /// <para>
        /// The file path to save the storage state to. If <paramref name="path"/> is a relative
        /// path, then it is resolved relative to current working directory. If no path is provided,
        /// storage state is still returned, but won't be saved to the disk.
        /// </para>
        /// </summary>
        [JsonPropertyName("path")]
        public string? Path { get; set; }
    }
}

#nullable disable

1using Microsoft.Playwright;
2using System.Threading.Tasks;
3
4namespace manaTest.Helpers
5{
6    public static class IPageExtensions
7    {
8        private static volatile TaskCompletionSource<IPage> loginPageTask;
9
10        public static async Task<IPage> DoLogin(this Task<IPage> targetPage)
11        {
12            if (null == loginPageTask)
13            {
14                loginPageTask ??= new TaskCompletionSource<IPage>();
15                var loginPage = await handleLoginStep();
16                loginPageTask.TrySetResult(loginPage);
17                return loginPage;
18            }
19            await loginPageTask.Task;
20            return await targetPage;
21
22            async Task<IPage> handleLoginStep()
23            {
24                var loginPage = await targetPage;
25                await loginPage.GotoAsync("https://localhost:44364");
26                await loginPage.WaitForTimeoutAsync(15000);
27                //const string LoginButtonSelector = "text=Login";
28                //await loginPage.ClickAsync(LoginButtonSelector);
29
30                //await loginPage.WaitForTimeoutAsync(10000);
31                //var options = new PageWaitForNavigationOptions { UrlString = "https://localhost:44364" };
32                //await loginPage.WaitForNavigationAsync(options);
33                //await loginPage.WaitForLoadStateAsync(LoadState.NetworkIdle);
34                var contextStateOptions = new BrowserContextStorageStateOptions
35                {
36                    Path = PageFactory.StorageStatePath,
37                };
38                await loginPage.Context.StorageStateAsync(contextStateOptions);
39                return loginPage;
40            }
41        }
42    }
43}
44

Source: IPageExtensions.cs

using Microsoft.Playwright;
using System.Threading.Tasks;

namespace manaTest.Helpers
{
    public static class IPageExtensions
    {
        private static volatile TaskCompletionSource<IPage> loginPageTask;

        public static async Task<IPage> DoLogin(this Task<IPage> targetPage)
        {
            if (null == loginPageTask)
            {
                loginPageTask ??= new TaskCompletionSource<IPage>();
                var loginPage = await handleLoginStep();
                loginPageTask.TrySetResult(loginPage);
                return loginPage;
            }
            await loginPageTask.Task;
            return await targetPage;

            async Task<IPage> handleLoginStep()
            {
                var loginPage = await targetPage;
                await loginPage.GotoAsync("https://localhost:44364");
                await loginPage.WaitForTimeoutAsync(15000);
                //const string LoginButtonSelector = "text=Login";
                //await loginPage.ClickAsync(LoginButtonSelector);

                //await loginPage.WaitForTimeoutAsync(10000);
                //var options = new PageWaitForNavigationOptions { UrlString = "https://localhost:44364" };
                //await loginPage.WaitForNavigationAsync(options);
                //await loginPage.WaitForLoadStateAsync(LoadState.NetworkIdle);
                var contextStateOptions = new BrowserContextStorageStateOptions
                {
                    Path = PageFactory.StorageStatePath,
                };
                await loginPage.Context.StorageStateAsync(contextStateOptions);
                return loginPage;
            }
        }
    }
}