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 <[email protected]>

Author: kblok

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[]

lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForFunctionTests.cs

@@ -31,30 +31,29 @@ await Page.WaitForFunctionAsync(@"() =>
         [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")]

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")]

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);
         }
     }
 }

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);
         }

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);

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);
                 };
             }