How to use ShouldRejectIfExecutablePathIsInvalid method of Microsoft.Playwright.Tests.BrowserTypeLaunchTests 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.Collections.Generic;
26using System.Threading.Tasks;
27using Microsoft.Playwright.NUnit;
28using NUnit.Framework;
29
30namespace Microsoft.Playwright.Tests
31{
32    ///<playwright-file>browsertype-launch.spec.ts</playwright-file>
33    public class BrowserTypeLaunchTests : PlaywrightTestEx
34    {
35        [PlaywrightTest("browsertype-launch.spec.ts", "should reject all promises when browser is closed")]
36        public async Task ShouldRejectAllPromisesWhenBrowserIsClosed()
37        {
38            await using var browser = await BrowserType.LaunchAsync();
39            var page = await (await browser.NewContextAsync()).NewPageAsync();
40            var neverResolves = page.EvaluateHandleAsync("() => new Promise(r => {})");
41            await browser.CloseAsync();
42            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => neverResolves);
43            // WebKit under task-set -c 1 is giving browser, rest are giving target.
44            StringAssert.Contains(" closed", exception.Message);
45
46        }
47
48        [PlaywrightTest("defaultbrowsercontext-2.spec.ts", "should throw if page argument is passed")]
49        [Skip(SkipAttribute.Targets.Firefox)]
50        public Task ShouldThrowIfPageArgumentIsPassed()
51        {
52            var args = new[] { Server.EmptyPage };
53            return PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => BrowserType.LaunchAsync(new() { Args = args }));
54        }
55
56        [PlaywrightTest("browsertype-launch.spec.ts", "should reject if launched browser fails immediately")]
57        public async Task ShouldRejectIfLaunchedBrowserFailsImmediately()
58        {
59            await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => BrowserType.LaunchAsync(new() { ExecutablePath = TestUtils.GetAsset("dummy_bad_browser_executable.js") }));
60        }
61
62        [PlaywrightTest("browsertype-launch.spec.ts", "should reject if executable path is invalid")]
63        public async Task ShouldRejectIfExecutablePathIsInvalid()
64        {
65            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => BrowserType.LaunchAsync(new() { ExecutablePath = "random-invalid-path" }));
66
67            StringAssert.Contains("Failed to launch", exception.Message);
68        }
69
70        [PlaywrightTest("browsertype-launch.spec.ts", "should fire close event for all contexts")]
71        public async Task ShouldFireCloseEventForAllContexts()
72        {
73            await using var browser = await BrowserType.LaunchAsync();
74            var context = await browser.NewContextAsync();
75            var closeTask = new TaskCompletionSource<bool>();
76
77            context.Close += (_, _) => closeTask.TrySetResult(true);
78
79            await TaskUtils.WhenAll(browser.CloseAsync(), closeTask.Task);
80        }
81
82        [PlaywrightTest("browsertype-launch.spec.ts", "should be callable twice")]
83        public async Task ShouldBeCallableTwice()
84        {
85            await using var browser = await BrowserType.LaunchAsync();
86            await TaskUtils.WhenAll(browser.CloseAsync(), browser.CloseAsync());
87            await browser.CloseAsync();
88        }
89
90        /// <summary>
91        /// PuppeteerSharp test. It's not in upstream
92        /// </summary>
93        public async Task ShouldWorkWithEnvironmentVariables()
94        {
95            var env = new Dictionary<string, string>
96            {
97                ["Foo"] = "Var"
98            };
99
100            await using var browser = await BrowserType.LaunchAsync(new() { Env = env });
101        }
102
103        /// <summary>
104        /// PuppeteerSharp test. It's not in upstream
105        /// </summary>
106        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
107        public async Task ShouldWorkWithIgnoreDefaultArgs()
108        {
109            string[] args = new[]
110            {
111                "--remote-debugging-pipe",
112                "--headless",
113                "--hide-scrollbars",
114                "--mute-audio",
115                "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4"
116            };
117
118            await using var browser = await BrowserType.LaunchAsync(new() { IgnoreAllDefaultArgs = true, Args = args });
119        }
120    }
121}
122

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

namespace Microsoft.Playwright.Tests
{
    ///<playwright-file>browsertype-launch.spec.ts</playwright-file>
    public class BrowserTypeLaunchTests : PlaywrightTestEx
    {
        [PlaywrightTest("browsertype-launch.spec.ts", "should reject all promises when browser is closed")]
        public async Task ShouldRejectAllPromisesWhenBrowserIsClosed()
        {
            await using var browser = await BrowserType.LaunchAsync();
            var page = await (await browser.NewContextAsync()).NewPageAsync();
            var neverResolves = page.EvaluateHandleAsync("() => new Promise(r => {})");
            await browser.CloseAsync();
            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => neverResolves);
            // WebKit under task-set -c 1 is giving browser, rest are giving target.
            StringAssert.Contains(" closed", exception.Message);

        }

        [PlaywrightTest("defaultbrowsercontext-2.spec.ts", "should throw if page argument is passed")]
        [Skip(SkipAttribute.Targets.Firefox)]
        public Task ShouldThrowIfPageArgumentIsPassed()
        {
            var args = new[] { Server.EmptyPage };
            return PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => BrowserType.LaunchAsync(new() { Args = args }));
        }

        [PlaywrightTest("browsertype-launch.spec.ts", "should reject if launched browser fails immediately")]
        public async Task ShouldRejectIfLaunchedBrowserFailsImmediately()
        {
            await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => BrowserType.LaunchAsync(new() { ExecutablePath = TestUtils.GetAsset("dummy_bad_browser_executable.js") }));
        }

        [PlaywrightTest("browsertype-launch.spec.ts", "should reject if executable path is invalid")]
        public async Task ShouldRejectIfExecutablePathIsInvalid()
        {
            var exception = await PlaywrightAssert.ThrowsAsync<PlaywrightException>(() => BrowserType.LaunchAsync(new() { ExecutablePath = "random-invalid-path" }));

            StringAssert.Contains("Failed to launch", exception.Message);
        }

        [PlaywrightTest("browsertype-launch.spec.ts", "should fire close event for all contexts")]
        public async Task ShouldFireCloseEventForAllContexts()
        {
            await using var browser = await BrowserType.LaunchAsync();
            var context = await browser.NewContextAsync();
            var closeTask = new TaskCompletionSource<bool>();

            context.Close += (_, _) => closeTask.TrySetResult(true);

            await TaskUtils.WhenAll(browser.CloseAsync(), closeTask.Task);
        }

        [PlaywrightTest("browsertype-launch.spec.ts", "should be callable twice")]
        public async Task ShouldBeCallableTwice()
        {
            await using var browser = await BrowserType.LaunchAsync();
            await TaskUtils.WhenAll(browser.CloseAsync(), browser.CloseAsync());
            await browser.CloseAsync();
        }

        /// <summary>
        /// PuppeteerSharp test. It's not in upstream
        /// </summary>
        public async Task ShouldWorkWithEnvironmentVariables()
        {
            var env = new Dictionary<string, string>
            {
                ["Foo"] = "Var"
            };

            await using var browser = await BrowserType.LaunchAsync(new() { Env = env });
        }

        /// <summary>
        /// PuppeteerSharp test. It's not in upstream
        /// </summary>
        [Skip(SkipAttribute.Targets.Firefox, SkipAttribute.Targets.Webkit)]
        public async Task ShouldWorkWithIgnoreDefaultArgs()
        {
            string[] args = new[]
            {
                "--remote-debugging-pipe",
                "--headless",
                "--hide-scrollbars",
                "--mute-audio",
                "--blink-settings=primaryHoverType=2,availableHoverTypes=2,primaryPointerType=4,availablePointerTypes=4"
            };

            await using var browser = await BrowserType.LaunchAsync(new() { IgnoreAllDefaultArgs = true, Args = args });
        }
    }
}