How to use ShouldFailPrimitiveValuesAsPrototypes method of PuppeteerSharp.Tests.PageTests.QueryObjectsTests class

1using System.Threading.Tasks;
2using PuppeteerSharp.Tests.Attributes;
3using PuppeteerSharp.Xunit;
4using Xunit;
5using Xunit.Abstractions;
6
7namespace PuppeteerSharp.Tests.PageTests
8{
9    [Collection(TestConstants.TestFixtureCollectionName)]
10    public class QueryObjectsTests : PuppeteerPageBaseTest
11    {
12        public QueryObjectsTests(ITestOutputHelper output) : base(output)
13        {
14        }
15
16        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should work")]
17        [SkipBrowserFact(skipFirefox: true)]
18        public async Task ShouldWork()
19        {
20            // Instantiate an object
21            await Page.EvaluateExpressionAsync("window.set = new Set(['hello', 'world'])");
22            var prototypeHandle = await Page.EvaluateExpressionHandleAsync("Set.prototype");
23            var objectsHandle = await Page.QueryObjectsAsync(prototypeHandle);
24            var count = await Page.EvaluateFunctionAsync<int>("objects => objects.length", objectsHandle);
25            Assert.Equal(1, count);
26            var values = await Page.EvaluateFunctionAsync<string[]>("objects => Array.from(objects[0].values())", objectsHandle);
27            Assert.Equal(new[] { "hello", "world" }, values);
28        }
29
30        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should work for non-blank page")]
31        [SkipBrowserFact(skipFirefox: true)]
32        public async Task ShouldWorkForNonBlankPage()
33        {
34            // Instantiate an object
35            await Page.GoToAsync(TestConstants.EmptyPage);
36            await Page.EvaluateFunctionAsync("() => window.set = new Set(['hello', 'world'])");
37            var prototypeHandle = await Page.EvaluateFunctionHandleAsync("() => Set.prototype");
38            var objectsHandle = await Page.QueryObjectsAsync(prototypeHandle);
39            var count = await Page.EvaluateFunctionAsync<int>("objects => objects.length", objectsHandle);
40            Assert.Equal(1, count);
41        }
42
43        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should fail for disposed handles")]
44        [PuppeteerFact]
45        public async Task ShouldFailForDisposedHandles()
46        {
47            var prototypeHandle = await Page.EvaluateExpressionHandleAsync("HTMLBodyElement.prototype");
48            await prototypeHandle.DisposeAsync();
49            var exception = await Assert.ThrowsAsync<PuppeteerException>(()
50                => Page.QueryObjectsAsync(prototypeHandle));
51            Assert.Equal("Prototype JSHandle is disposed!", exception.Message);
52        }
53
54        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should fail primitive values as prototypes")]
55        [PuppeteerFact]
56        public async Task ShouldFailPrimitiveValuesAsPrototypes()
57        {
58            var prototypeHandle = await Page.EvaluateExpressionHandleAsync("42");
59            var exception = await Assert.ThrowsAsync<PuppeteerException>(()
60                => Page.QueryObjectsAsync(prototypeHandle));
61            Assert.Equal("Prototype JSHandle must not be referencing primitive value", exception.Message);
62        }
63    }
64}
65

Source: QueryObjectsTests.cs

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

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

        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should work")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldWork()
        {
            // Instantiate an object
            await Page.EvaluateExpressionAsync("window.set = new Set(['hello', 'world'])");
            var prototypeHandle = await Page.EvaluateExpressionHandleAsync("Set.prototype");
            var objectsHandle = await Page.QueryObjectsAsync(prototypeHandle);
            var count = await Page.EvaluateFunctionAsync<int>("objects => objects.length", objectsHandle);
            Assert.Equal(1, count);
            var values = await Page.EvaluateFunctionAsync<string[]>("objects => Array.from(objects[0].values())", objectsHandle);
            Assert.Equal(new[] { "hello", "world" }, values);
        }

        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should work for non-blank page")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ShouldWorkForNonBlankPage()
        {
            // Instantiate an object
            await Page.GoToAsync(TestConstants.EmptyPage);
            await Page.EvaluateFunctionAsync("() => window.set = new Set(['hello', 'world'])");
            var prototypeHandle = await Page.EvaluateFunctionHandleAsync("() => Set.prototype");
            var objectsHandle = await Page.QueryObjectsAsync(prototypeHandle);
            var count = await Page.EvaluateFunctionAsync<int>("objects => objects.length", objectsHandle);
            Assert.Equal(1, count);
        }

        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should fail for disposed handles")]
        [PuppeteerFact]
        public async Task ShouldFailForDisposedHandles()
        {
            var prototypeHandle = await Page.EvaluateExpressionHandleAsync("HTMLBodyElement.prototype");
            await prototypeHandle.DisposeAsync();
            var exception = await Assert.ThrowsAsync<PuppeteerException>(()
                => Page.QueryObjectsAsync(prototypeHandle));
            Assert.Equal("Prototype JSHandle is disposed!", exception.Message);
        }

        [PuppeteerTest("page.spec.ts", "ExecutionContext.queryObjects", "should fail primitive values as prototypes")]
        [PuppeteerFact]
        public async Task ShouldFailPrimitiveValuesAsPrototypes()
        {
            var prototypeHandle = await Page.EvaluateExpressionHandleAsync("42");
            var exception = await Assert.ThrowsAsync<PuppeteerException>(()
                => Page.QueryObjectsAsync(prototypeHandle));
            Assert.Equal("Prototype JSHandle must not be referencing primitive value", exception.Message);
        }
    }
}