How to use ShouldNotBeVisibleInBrowserPages method of PuppeteerSharp.Tests.PageTests.CloseTests class

1using System.Threading.Tasks;
2using Xunit;
3using Xunit.Abstractions;
4
5namespace PuppeteerSharp.Tests.PageTests
6{
7    [Collection("PuppeteerLoaderFixture collection")]
8    public class CloseTests : PuppeteerPageBaseTest
9    {
10        public CloseTests(ITestOutputHelper output) : base(output) { }
11
12        [Fact]
13        public async Task ShouldRejectAllPromisesWhenPageIsClosed()
14        {
15            var exceptionTask = Assert.ThrowsAsync<TargetClosedException>(() => Page.EvaluateFunctionAsync("() => new Promise(r => {})"));
16
17            await Task.WhenAll(
18                exceptionTask,
19                Page.CloseAsync()
20            );
21
22            var exception = await exceptionTask;
23            Assert.Contains("Protocol error", exception.Message);
24            Assert.Equal("Target.detachedFromTarget", exception.CloseReason);
25        }
26
27        [Fact]
28        public async Task ShouldNotBeVisibleInBrowserPages()
29        {
30            Assert.Contains(Page, await Browser.PagesAsync());
31            await Page.CloseAsync();
32            Assert.DoesNotContain(Page, await Browser.PagesAsync());
33        }
34
35        [Fact]
36        public async Task ShouldRunBeforeunloadIfAskedFor()
37        {
38            await Page.GoToAsync(TestConstants.ServerUrl + "/beforeunload.html");
39
40            var dialogTask = new TaskCompletionSource<bool>();
41            Page.Dialog += async (sender, e) =>
42            {
43                Assert.Equal(DialogType.BeforeUnload, e.Dialog.DialogType);
44                Assert.Equal(string.Empty, e.Dialog.Message);
45                Assert.Equal(string.Empty, e.Dialog.DefaultValue);
46
47                await e.Dialog.Accept();
48                dialogTask.TrySetResult(true);
49            };
50
51            var closeTask = new TaskCompletionSource<bool>();
52            Page.Close += (sender, e) => closeTask.TrySetResult(true);
53
54            // We have to interact with a page so that 'beforeunload' handlers
55            // fire.
56            await Page.ClickAsync("body");
57            await Page.CloseAsync(new PageCloseOptions { RunBeforeUnload = true });
58
59            await Task.WhenAll(
60                dialogTask.Task,
61                closeTask.Task
62            );
63        }
64
65        [Fact]
66        public async Task ShouldNotRunBeforeunloadByDefault()
67        {
68            await Page.GoToAsync(TestConstants.ServerUrl + "/beforeunload.html");
69            await Page.ClickAsync("body");
70            await Page.CloseAsync();
71        }
72
73        [Fact]
74        public async Task ShouldSetThePageCloseState()
75        {
76            Assert.False(Page.IsClosed);
77            await Page.CloseAsync();
78            Assert.True(Page.IsClosed);
79        }
80
81        [Fact(Timeout = 10000)]
82        public async Task ShouldCloseWhenConnectionBreaksPrematurely()
83        {
84            Browser.Connection.Dispose();
85            await Page.CloseAsync();
86        }
87    }
88}

Source: CloseTests.cs

using System.Threading.Tasks;
using Xunit;
using Xunit.Abstractions;

namespace PuppeteerSharp.Tests.PageTests
{
    [Collection("PuppeteerLoaderFixture collection")]
    public class CloseTests : PuppeteerPageBaseTest
    {
        public CloseTests(ITestOutputHelper output) : base(output) { }

        [Fact]
        public async Task ShouldRejectAllPromisesWhenPageIsClosed()
        {
            var exceptionTask = Assert.ThrowsAsync<TargetClosedException>(() => Page.EvaluateFunctionAsync("() => new Promise(r => {})"));

            await Task.WhenAll(
                exceptionTask,
                Page.CloseAsync()
            );

            var exception = await exceptionTask;
            Assert.Contains("Protocol error", exception.Message);
            Assert.Equal("Target.detachedFromTarget", exception.CloseReason);
        }

        [Fact]
        public async Task ShouldNotBeVisibleInBrowserPages()
        {
            Assert.Contains(Page, await Browser.PagesAsync());
            await Page.CloseAsync();
            Assert.DoesNotContain(Page, await Browser.PagesAsync());
        }

        [Fact]
        public async Task ShouldRunBeforeunloadIfAskedFor()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/beforeunload.html");

            var dialogTask = new TaskCompletionSource<bool>();
            Page.Dialog += async (sender, e) =>
            {
                Assert.Equal(DialogType.BeforeUnload, e.Dialog.DialogType);
                Assert.Equal(string.Empty, e.Dialog.Message);
                Assert.Equal(string.Empty, e.Dialog.DefaultValue);

                await e.Dialog.Accept();
                dialogTask.TrySetResult(true);
            };

            var closeTask = new TaskCompletionSource<bool>();
            Page.Close += (sender, e) => closeTask.TrySetResult(true);

            // We have to interact with a page so that 'beforeunload' handlers
            // fire.
            await Page.ClickAsync("body");
            await Page.CloseAsync(new PageCloseOptions { RunBeforeUnload = true });

            await Task.WhenAll(
                dialogTask.Task,
                closeTask.Task
            );
        }

        [Fact]
        public async Task ShouldNotRunBeforeunloadByDefault()
        {
            await Page.GoToAsync(TestConstants.ServerUrl + "/beforeunload.html");
            await Page.ClickAsync("body");
            await Page.CloseAsync();
        }

        [Fact]
        public async Task ShouldSetThePageCloseState()
        {
            Assert.False(Page.IsClosed);
            await Page.CloseAsync();
            Assert.True(Page.IsClosed);
        }

        [Fact(Timeout = 10000)]
        public async Task ShouldCloseWhenConnectionBreaksPrematurely()
        {
            Browser.Connection.Dispose();
            await Page.CloseAsync();
        }
    }
}