Waittask refactor (#2190)

* Waittask refactor * remove typescript code * Fix some javascript calls * Some improvements * cr * Fix some tests * passing tests * WaitTask Refactor - Fix Evaluation failed: TypeError: fun is not a function (#2192) * Fix Evaluation failed: TypeError: fun is not a function - The whitespace is causing the new Function() call to fail. * Alternate fix * Fix ShouldRespectTimeout test * Fix failing test --------- Co-authored-by: Alex Maitland <amaitland@users.noreply.github.com>
hardkoded · Apr 26, 2023 · f24c854 · f24c854
1 parent 28f0354
commit f24c854
Show file tree

Hide file tree

Showing 13 changed files with 580 additions and 252 deletions.
diff --git a/lib/PuppeteerSharp.Tests/TestConstants.cs b/lib/PuppeteerSharp.Tests/TestConstants.cs
@@ -40,10 +40,12 @@ public static class TestConstants
             "    http://localhost:<PORT>/frames/frame.html (aframe)"
         };
 
-        public static LaunchOptions DefaultBrowserOptions() => new LaunchOptions
+        public static LaunchOptions DefaultBrowserOptions() => new()
         {
             SlowMo = Convert.ToInt32(Environment.GetEnvironmentVariable("SLOW_MO")),
-            Headless = Convert.ToBoolean(Environment.GetEnvironmentVariable("HEADLESS") ?? "true"),
+            Headless = Convert.ToBoolean(
+                Environment.GetEnvironmentVariable("HEADLESS") ??
+                (System.Diagnostics.Debugger.IsAttached ? "false" : "true")),
             Product = IsChrome ? Product.Chrome : Product.Firefox,
             EnqueueAsyncMessages = Convert.ToBoolean(Environment.GetEnvironmentVariable("ENQUEUE_ASYNC_MESSAGES") ?? "false"),
             Timeout = 0,
@@ -55,7 +57,7 @@ public static class TestConstants
 #endif
         };
 
-        public static LaunchOptions BrowserWithExtensionOptions() => new LaunchOptions
+        public static LaunchOptions BrowserWithExtensionOptions() => new()
         {
             Headless = false,
             Args = new[]

diff --git a/lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForFunctionTests.cs b/lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForFunctionTests.cs
@@ -31,30 +31,29 @@ public async Task ShouldWorkWhenResolvedRightBeforeExecutionContextDisposal()
         [PuppeteerFact]
         public async Task ShouldPollOnInterval()
         {
-            var success = false;
             var startTime = DateTime.UtcNow;
             var polling = 100;
-            var watchdog = Page.WaitForFunctionAsync("() => window.__FOO === 'hit'", new WaitForFunctionOptions { PollingInterval = polling })
-                .ContinueWith(_ => success = true);
-            await Page.EvaluateExpressionAsync("window.__FOO = 'hit'");
-            Assert.False(success);
+            var watchdog = Page.WaitForFunctionAsync("() => window.__FOO === 'hit'", new WaitForFunctionOptions { PollingInterval = polling });
+            // Wait for function will release the execution faster than in node.
+            // We add some CDP action to wait for the task to start the polling
             await Page.EvaluateExpressionAsync("document.body.appendChild(document.createElement('div'))");
+            await Page.EvaluateFunctionAsync("() => setTimeout(window.__FOO = 'hit', 50)");
             await watchdog;
+
             Assert.True((DateTime.UtcNow - startTime).TotalMilliseconds > polling / 2);
         }
 
         [PuppeteerTest("waittask.spec.ts", "Frame.waitForFunction", "should poll on interval async")]
         [PuppeteerFact]
         public async Task ShouldPollOnIntervalAsync()
         {
-            var success = false;
             var startTime = DateTime.UtcNow;
-            var polling = 100;
-            var watchdog = Page.WaitForFunctionAsync("async () => window.__FOO === 'hit'", new WaitForFunctionOptions { PollingInterval = polling })
-                .ContinueWith(_ => success = true);
-            await Page.EvaluateFunctionAsync("async () => window.__FOO = 'hit'");
-            Assert.False(success);
+            var polling = 1000;
+            var watchdog = Page.WaitForFunctionAsync("async () => window.__FOO === 'hit'", new WaitForFunctionOptions { PollingInterval = polling });
+            // Wait for function will release the execution faster than in node.
+            // We add some CDP action to wait for the task to start the polling
             await Page.EvaluateExpressionAsync("document.body.appendChild(document.createElement('div'))");
+            await Page.EvaluateFunctionAsync("async () => setTimeout(window.__FOO = 'hit', 50)");
             await watchdog;
             Assert.True((DateTime.UtcNow - startTime).TotalMilliseconds > polling / 2);
         }
@@ -162,7 +161,7 @@ public async Task ShouldRespectTimeout()
             var exception = await Assert.ThrowsAsync<WaitTaskTimeoutException>(()
                 => Page.WaitForExpressionAsync("false", new WaitForFunctionOptions { Timeout = 10 }));
 
-            Assert.Contains("waiting for function failed: timeout", exception.Message);
+            Assert.Contains("Waiting failed: 10ms exceeded", exception.Message);
         }
 
         [PuppeteerTest("waittask.spec.ts", "Frame.waitForFunction", "should respect default timeout")]
@@ -173,7 +172,7 @@ public async Task ShouldRespectDefaultTimeout()
             var exception = await Assert.ThrowsAsync<WaitTaskTimeoutException>(()
                 => Page.WaitForExpressionAsync("false"));
 
-            Assert.Contains("waiting for function failed: timeout", exception.Message);
+            Assert.Contains("Waiting failed: 1ms exceeded", exception.Message);
         }
 
         [PuppeteerTest("waittask.spec.ts", "Frame.waitForFunction", "should disable timeout when its set to 0")]

diff --git a/lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForSelectorTests.cs b/lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForSelectorTests.cs
@@ -105,7 +105,7 @@ public async Task ShouldThrowWhenFrameIsDetached()
             var frame = Page.FirstChildFrame();
             var waitTask = frame.WaitForSelectorAsync(".box");
             await FrameUtils.DetachFrameAsync(Page, "frame1");
-            var waitException = await Assert.ThrowsAsync<Exception>(() => waitTask);
+            var waitException = await Assert.ThrowsAsync<WaitTaskTimeoutException>(() => waitTask);
 
             Assert.NotNull(waitException);
             Assert.Contains("waitForFunction failed: frame got detached.", waitException.Message);
@@ -206,7 +206,7 @@ public async Task ShouldRespectTimeout()
             var exception = await Assert.ThrowsAsync<WaitTaskTimeoutException>(async ()
                 => await Page.WaitForSelectorAsync("div", new WaitForSelectorOptions { Timeout = 10 }));
 
-            Assert.Contains("waiting for selector 'div' failed: timeout", exception.Message);
+            Assert.Contains("Waiting for selector `div` failed: Waiting failed: 10ms exceeded", exception.Message);
         }
 
         [PuppeteerTest("waittask.spec.ts", "Frame.waitForSelector", "should have an error message specifically for awaiting an element to be hidden")]
@@ -217,7 +217,7 @@ public async Task ShouldHaveAnErrorMessageSpecificallyForAwaitingAnElementToBeHi
             var exception = await Assert.ThrowsAsync<WaitTaskTimeoutException>(async ()
                 => await Page.WaitForSelectorAsync("div", new WaitForSelectorOptions { Hidden = true, Timeout = 10 }));
 
-            Assert.Contains("waiting for selector 'div' to be hidden failed: timeout", exception.Message);
+            Assert.Contains("Waiting for selector `div` failed: Waiting failed: 10ms exceeded", exception.Message);
         }
 
         [PuppeteerTest("waittask.spec.ts", "Frame.waitForSelector", "should respond to node attribute mutation")]

diff --git a/lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForXPathTests.cs b/lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForXPathTests.cs
@@ -100,10 +100,12 @@ public async Task ShouldAllowYouToSelectAnElementWithSingleSlash()
         [PuppeteerFact]
         public async Task ShouldRespectTimeout()
         {
+            const int timeout = 10;
+
             var exception = await Assert.ThrowsAsync<WaitTaskTimeoutException>(()
-                    => Page.WaitForXPathAsync("//div", new WaitForSelectorOptions { Timeout = 10 }));
+                    => Page.WaitForXPathAsync("//div", new WaitForSelectorOptions { Timeout = timeout }));
 
-            Assert.Contains("waiting for XPath '//div' failed: timeout", exception.Message);
+            Assert.Contains($"Waiting failed: {timeout}ms exceeded", exception.Message);
         }
     }
 }
diff --git a/lib/PuppeteerSharp.Tests/WaitTaskTests/PageWaitForTests.cs b/lib/PuppeteerSharp.Tests/WaitTaskTests/PageWaitForTests.cs
@@ -47,7 +47,7 @@ public async Task ShouldWaitForAnXpath()
         public async Task ShouldNotAllowYouToSelectAnElementWithSingleSlashXpath()
         {
             await Page.SetContentAsync("<div>some text</div>");
-            var exception = await Assert.ThrowsAsync<EvaluationFailedException>(() =>
+            var exception = await Assert.ThrowsAsync<WaitTaskTimeoutException>(() =>
                 Page.WaitForSelectorAsync("/html/body/div"));
             Assert.NotNull(exception);
         }

diff --git a/lib/PuppeteerSharp/AriaQueryHandlerFactory.cs b/lib/PuppeteerSharp/AriaQueryHandlerFactory.cs
@@ -52,6 +52,7 @@ async Task<IElementHandle> WaitFor(IElementHandle root, string selector, WaitFor
 
                 return await frame.PuppeteerWorld.WaitForSelectorInPageAsync(
                     @"(_, selector) => globalThis.ariaQuerySelector(selector)",
+                    element,
                     selector,
                     options,
                     new[] { binding }).ConfigureAwait(false);

diff --git a/lib/PuppeteerSharp/CustomQueriesManager.cs b/lib/PuppeteerSharp/CustomQueriesManager.cs
@@ -154,9 +154,9 @@ private static InternalQueryHandler MakeQueryHandler(CustomQueryHandler handler)
                 internalHandler.WaitFor = async (IElementHandle root, string selector, WaitForSelectorOptions options) =>
                 {
                     var frame = (root as ElementHandle).Frame;
-                    var element = await frame.PuppeteerWorld.AdoptHandleAsync(root).ConfigureAwait(false);
+                    var element = await frame.PuppeteerWorld.AdoptHandleAsync(root).ConfigureAwait(false) as IElementHandle;
 
-                    return await frame.PuppeteerWorld.WaitForSelectorInPageAsync(handler.QueryOne, selector, options).ConfigureAwait(false);
+                    return await frame.PuppeteerWorld.WaitForSelectorInPageAsync(handler.QueryOne, element, selector, options).ConfigureAwait(false);
                 };
             }