How to use IdleOverrideTests method of PuppeteerSharp.Tests.IdleOverrideTests.IdleOverrideTests class

1using System.Collections.Generic;
2using System.Linq;
3using System.Threading.Tasks;
4using PuppeteerSharp.Tests.Attributes;
5using PuppeteerSharp.Xunit;
6using Xunit;
7using Xunit.Abstractions;
8
9namespace PuppeteerSharp.Tests.IdleOverrideTests
10{
11    [Collection(TestConstants.TestFixtureCollectionName)]
12    public class IdleOverrideTests : PuppeteerPageBaseTest
13    {
14        public IdleOverrideTests(ITestOutputHelper output) : base(output)
15        {
16        }
17
18        private async Task<string> GetIdleStateAsync()
19        {
20            var stateElement = await Page.QuerySelectorAsync("#state");
21            return await Page.EvaluateFunctionAsync<string>(
22                @"(element) => {
23                    return element.innerText;
24                }",
25                stateElement);
26        }
27
28        private async Task VerifyStateAsync(string expectedState)
29        {
30            var actualState = await GetIdleStateAsync();
31            Assert.Equal(expectedState, actualState);
32        }
33
34        [PuppeteerTest("idle_override.spec.ts", "Emulate idle state", "changing idle state emulation causes change of the IdleDetector state")]
35        [SkipBrowserFact(skipFirefox: true)]
36        public async Task ChangingIdleStateEmulationCausesChangeOfTheIdleDetectorState()
37        {
38            await Context.OverridePermissionsAsync(
39                TestConstants.ServerUrl + "/idle-detector.html",
40                new[]
41                {
42                    OverridePermission.IdleDetection,
43                });
44
45            await Page.GoToAsync(TestConstants.ServerUrl+ "/idle-detector.html");
46
47            // Store initial state, as soon as it is not guaranteed to be `active, unlocked`.
48            var initialState = await GetIdleStateAsync();
49
50            // Emulate Idle states and verify IdleDetector updates state accordingly.
51            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
52                IsUserActive = false,
53                IsScreenUnlocked =  false,
54            });
55
56            await VerifyStateAsync("Idle state: idle, locked.");
57
58            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
59                IsUserActive = true,
60                IsScreenUnlocked = false,
61            });
62            await VerifyStateAsync("Idle state: active, locked.");
63
64            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
65                IsUserActive = true,
66                IsScreenUnlocked = true,
67            });
68            await VerifyStateAsync("Idle state: active, unlocked.");
69
70            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
71                IsUserActive = false,
72                IsScreenUnlocked = true,
73            });
74            await VerifyStateAsync("Idle state: idle, unlocked.");
75
76            // Remove Idle emulation and verify IdleDetector is in initial state.
77            await Page.EmulateIdleStateAsync();
78            await VerifyStateAsync(initialState);
79
80            // Emulate idle state again after removing emulation.
81            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
82                IsUserActive = false,
83                IsScreenUnlocked = false,
84            });
85            await VerifyStateAsync("Idle state: idle, locked.");
86
87            // Remove emulation second time.
88            await Page.EmulateIdleStateAsync();
89            await VerifyStateAsync(initialState);
90        }
91    }
92}
93

Source: IdleOverrideTests.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using PuppeteerSharp.Tests.Attributes;
using PuppeteerSharp.Xunit;
using Xunit;
using Xunit.Abstractions;

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

        private async Task<string> GetIdleStateAsync()
        {
            var stateElement = await Page.QuerySelectorAsync("#state");
            return await Page.EvaluateFunctionAsync<string>(
                @"(element) => {
                    return element.innerText;
                }",
                stateElement);
        }

        private async Task VerifyStateAsync(string expectedState)
        {
            var actualState = await GetIdleStateAsync();
            Assert.Equal(expectedState, actualState);
        }

        [PuppeteerTest("idle_override.spec.ts", "Emulate idle state", "changing idle state emulation causes change of the IdleDetector state")]
        [SkipBrowserFact(skipFirefox: true)]
        public async Task ChangingIdleStateEmulationCausesChangeOfTheIdleDetectorState()
        {
            await Context.OverridePermissionsAsync(
                TestConstants.ServerUrl + "/idle-detector.html",
                new[]
                {
                    OverridePermission.IdleDetection,
                });

            await Page.GoToAsync(TestConstants.ServerUrl+ "/idle-detector.html");

            // Store initial state, as soon as it is not guaranteed to be `active, unlocked`.
            var initialState = await GetIdleStateAsync();

            // Emulate Idle states and verify IdleDetector updates state accordingly.
            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
                IsUserActive = false,
                IsScreenUnlocked =  false,
            });

            await VerifyStateAsync("Idle state: idle, locked.");

            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
                IsUserActive = true,
                IsScreenUnlocked = false,
            });
            await VerifyStateAsync("Idle state: active, locked.");

            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
                IsUserActive = true,
                IsScreenUnlocked = true,
            });
            await VerifyStateAsync("Idle state: active, unlocked.");

            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
                IsUserActive = false,
                IsScreenUnlocked = true,
            });
            await VerifyStateAsync("Idle state: idle, unlocked.");

            // Remove Idle emulation and verify IdleDetector is in initial state.
            await Page.EmulateIdleStateAsync();
            await VerifyStateAsync(initialState);

            // Emulate idle state again after removing emulation.
            await Page.EmulateIdleStateAsync(new EmulateIdleOverrides {
                IsUserActive = false,
                IsScreenUnlocked = false,
            });
            await VerifyStateAsync("Idle state: idle, locked.");

            // Remove emulation second time.
            await Page.EmulateIdleStateAsync();
            await VerifyStateAsync(initialState);
        }
    }
}