How to use PuppeteerTest method of PuppeteerSharp.Tests.ChromiumSpecificTests.BrowserUrlOptionTests class

1using System.Threading.Tasks;
2using PuppeteerSharp.Tests.Attributes;
3using PuppeteerSharp.Xunit;
4using Xunit;
5using Xunit.Abstractions;
6
7namespace PuppeteerSharp.Tests.ChromiumSpecificTests
8{
9    [Collection(TestConstants.TestFixtureCollectionName)]
10    public class BrowserUrlOptionTests : PuppeteerPageBaseTest
11    {
12        public BrowserUrlOptionTests(ITestOutputHelper output) : base(output)
13        {
14        }
15
16        [PuppeteerTest("chromiumonly.spec.ts", "Puppeteer.launch |browserURL| option", "should be able to connect using browserUrl, with and without trailing slash")]
17        [SkipBrowserFact(skipFirefox: true)]
18        public async Task ShouldBeAbleToConnectUsingBrowserURLWithAndWithoutTrailingSlash()
19        {
20            var options = TestConstants.DefaultBrowserOptions();
21            options.Args = new string[] { "--remote-debugging-port=21222" };
22            var originalBrowser = await Puppeteer.LaunchAsync(options);
23            var browserURL = "http://127.0.0.1:21222";
24
25            var browser1 = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserURL = browserURL });
26            var page1 = await browser1.NewPageAsync();
27            Assert.Equal(56, await page1.EvaluateExpressionAsync<int>("7 * 8"));
28            browser1.Disconnect();
29
30            var browser2 = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserURL = browserURL + "/" });
31            var page2 = await browser2.NewPageAsync();
32            Assert.Equal(56, await page2.EvaluateExpressionAsync<int>("7 * 8"));
33            browser2.Disconnect();
34            await originalBrowser.CloseAsync();
35        }
36
37        [PuppeteerTest("chromiumonly.spec.ts", "Puppeteer.launch |browserURL| option", "should throw when using both browserWSEndpoint and browserURL")]
38        [SkipBrowserFact(skipFirefox: true)]
39        public async Task ShouldThrowWhenUsingBothBrowserWSEndpointAndBrowserURL()
40        {
41            var options = TestConstants.DefaultBrowserOptions();
42            options.Args = new string[] { "--remote-debugging-port=21222" };
43            var originalBrowser = await Puppeteer.LaunchAsync(options);
44            var browserURL = "http://127.0.0.1:21222";
45
46            await Assert.ThrowsAsync<PuppeteerException>(() => Puppeteer.ConnectAsync(new ConnectOptions
47            {
48                BrowserURL = browserURL,
49                BrowserWSEndpoint = originalBrowser.WebSocketEndpoint
50            }));
51
52            await originalBrowser.CloseAsync();
53        }
54
55        [PuppeteerTest("chromiumonly.spec.ts", "Puppeteer.launch |browserURL| option", "should throw when trying to connect to non-existing browser")]
56        [SkipBrowserFact(skipFirefox: true)]
57        public async Task ShouldThrowWhenTryingToConnectToNonExistingBrowser()
58        {
59            var options = TestConstants.DefaultBrowserOptions();
60            options.Args = new string[] { "--remote-debugging-port=21222" };
61            var originalBrowser = await Puppeteer.LaunchAsync(options);
62            var browserURL = "http://127.0.0.1:2122";
63
64            await Assert.ThrowsAsync<ProcessException>(() => Puppeteer.ConnectAsync(new ConnectOptions
65            {
66                BrowserURL = browserURL
67            }));
68
69            await originalBrowser.CloseAsync();
70        }
71    }
72}
73

Source: BrowserUrlOptionTests.cs

using System.Threading.Tasks;
using PuppeteerSharp.Tests.Attributes;
using PuppeteerSharp.Xunit;
using Xunit;
using Xunit.Abstractions;

namespace PuppeteerSharp.Tests.ChromiumSpecificTests
{
    [Collection(TestConstants.TestFixtureCollectionName)]
    public class BrowserUrlOptionTests : PuppeteerPageBaseTest
    {
        public BrowserUrlOptionTests(ITestOutputHelper output) : base(output)
        {
        }

        [PuppeteerTest("chromiumonly.spec.ts", "Puppeteer.launch |browserURL| option", "should be able to connect using browserUrl, with and without trailing slash")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldBeAbleToConnectUsingBrowserURLWithAndWithoutTrailingSlash()
        {
            var options = TestConstants.DefaultBrowserOptions();
            options.Args = new string[] { "--remote-debugging-port=21222" };
            var originalBrowser = await Puppeteer.LaunchAsync(options);
            var browserURL = "http://127.0.0.1:21222";

            var browser1 = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserURL = browserURL });
            var page1 = await browser1.NewPageAsync();
            Assert.Equal(56, await page1.EvaluateExpressionAsync<int>("7 * 8"));
            browser1.Disconnect();

            var browser2 = await Puppeteer.ConnectAsync(new ConnectOptions { BrowserURL = browserURL + "/" });
            var page2 = await browser2.NewPageAsync();
            Assert.Equal(56, await page2.EvaluateExpressionAsync<int>("7 * 8"));
            browser2.Disconnect();
            await originalBrowser.CloseAsync();
        }

        [PuppeteerTest("chromiumonly.spec.ts", "Puppeteer.launch |browserURL| option", "should throw when using both browserWSEndpoint and browserURL")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldThrowWhenUsingBothBrowserWSEndpointAndBrowserURL()
        {
            var options = TestConstants.DefaultBrowserOptions();
            options.Args = new string[] { "--remote-debugging-port=21222" };
            var originalBrowser = await Puppeteer.LaunchAsync(options);
            var browserURL = "http://127.0.0.1:21222";

            await Assert.ThrowsAsync<PuppeteerException>(() => Puppeteer.ConnectAsync(new ConnectOptions
            {
                BrowserURL = browserURL,
                BrowserWSEndpoint = originalBrowser.WebSocketEndpoint
            }));

            await originalBrowser.CloseAsync();
        }

        [PuppeteerTest("chromiumonly.spec.ts", "Puppeteer.launch |browserURL| option", "should throw when trying to connect to non-existing browser")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldThrowWhenTryingToConnectToNonExistingBrowser()
        {
            var options = TestConstants.DefaultBrowserOptions();
            options.Args = new string[] { "--remote-debugging-port=21222" };
            var originalBrowser = await Puppeteer.LaunchAsync(options);
            var browserURL = "http://127.0.0.1:2122";

            await Assert.ThrowsAsync<ProcessException>(() => Puppeteer.ConnectAsync(new ConnectOptions
            {
                BrowserURL = browserURL
            }));

            await originalBrowser.CloseAsync();
        }
    }
}