Implement Page.waitFor (#147)

Author: Meir017

README.md

@@ -71,6 +71,28 @@ using (var page = await Browser.NewPageAsync())
 }
 ```
 
+## Wait For Selector
+
+```cs
+using (var page = await Browser.NewPageAsync())
+{
+    await page.GoToAsync("http://www.spapage.com");
+    await page.WaitForSelectorAsync("div.main-content")
+    await page.PdfAsync(outputFile));
+}
+```
+
+## Wait For Function
+```cs
+using (var page = await Browser.NewPageAsync())
+{
+    await page.GoToAsync("http://www.spapage.com");
+    var watchDog = page.WaitForFunctionAsync("window.innerWidth < 100");
+    await Page.SetViewport(new ViewPortOptions { Width = 50, Height = 50 });
+    await watchDog;
+}
+```
+
 # Monthly reports
  * [April 2018](http://www.hardkoded.com/blogs/puppeteer-sharp-monthly-april-2018)
  * [March 2018](http://www.hardkoded.com/blogs/puppeteer-sharp-monthly-march-2018)

lib/PuppeteerSharp.Tests/Page/WaitForTests.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.Page
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class WaitForTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWaitForSelector()
+        {
+            var found = false;
+            var waitFor = Page.WaitForSelectorAsync("div").ContinueWith(_ => found = true);
+            await Page.GoToAsync(TestConstants.EmptyPage);
+
+            Assert.False(found);
+
+            await Page.GoToAsync(TestConstants.ServerUrl + "/grid.html");
+            await waitFor;
+            Assert.True(found);
+        }
+
+        [Fact]
+        public async Task ShouldTimeout()
+        {
+            var startTime = DateTime.Now;
+            var timeout = 42;
+            await Page.WaitForTimeoutAsync(timeout);
+            Assert.True((DateTime.Now - startTime).TotalMilliseconds > timeout / 2);
+        }
+
+        [Fact]
+        public async Task ShouldWaitForPredicate()
+        {
+            var watchdog = Page.WaitForFunctionAsync("() => window.innerWidth < 100");
+            Page.SetViewport(new ViewPortOptions { Width = 10, Height = 10 });
+            await watchdog;
+        }
+
+        [Fact]
+        public async Task ShouldWaitForPredicateWithArguments()
+        {
+            await Page.WaitForFunctionAsync("(arg1, arg2) => arg1 !== arg2", new WaitForFunctionOptions(), 1, 2);
+        }
+    }
+}

lib/PuppeteerSharp.Tests/Puppeteer/PuppeteerLaunchTests.cs

@@ -50,7 +50,7 @@ public async Task ShouldWorkInRealLifeWithOptions()
                     "https://www.google.com",
                     new NavigationOptions()
                     {
-                        Timeout = 5000,
+                        Timeout = 10000,
                         WaitUntil = new[] { WaitUntilNavigation.Networkidle0 }
                     });
                 Assert.Equal(response.Status, HttpStatusCode.OK);

lib/PuppeteerSharp/Frame.cs

@@ -13,10 +13,11 @@ public class Frame
         private string _defaultContextId = "<not-initialized>";
         private object _context = null;
         private string _url = string.Empty;
-        private List<WaitTask> _waitTasks;
         private bool _detached;
         private TaskCompletionSource<ElementHandle> _documentCompletionSource;
 
+        internal List<WaitTask> WaitTasks { get; }
+
         public Frame(Session client, Page page, Frame parentFrame, string frameId)
         {
             _client = client;
@@ -31,7 +32,7 @@ public Frame(Session client, Page page, Frame parentFrame, string frameId)
 
             SetDefaultContext(null);
 
-            _waitTasks = new List<WaitTask>();
+            WaitTasks = new List<WaitTask>();
             LifecycleEvents = new List<string>();
         }
 
@@ -163,7 +164,7 @@ internal void SetDefaultContext(ExecutionContext context)
             {
                 ContextResolveTaskWrapper.SetResult(context);
 
-                foreach (var waitTask in _waitTasks)
+                foreach (var waitTask in WaitTasks)
                 {
                     waitTask.Rerun();
                 }
@@ -176,7 +177,7 @@ internal void SetDefaultContext(ExecutionContext context)
 
         internal void Detach()
         {
-            foreach (var waitTask in _waitTasks)
+            foreach (var waitTask in WaitTasks)
             {
                 waitTask.Termiante(new Exception("waitForSelector failed: frame got detached."));
             }
@@ -188,10 +189,43 @@ internal void Detach()
             _parentFrame = null;
         }
 
+        internal Task WaitForTimeoutAsync(int milliseconds) => Task.Delay(milliseconds);
+
+        internal Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options, params object[] args)
+            => new WaitTask(this, script, options.Polling, options.Timeout, args).Task;
+
+        internal async Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options)
+        {
+            const string predicate = @"
+              function predicate(selector, waitForVisible, waitForHidden) {
+              const node = document.querySelector(selector);
+              if (!node)
+                return waitForHidden;
+              if (!waitForVisible && !waitForHidden)
+                return node;
+              const style = window.getComputedStyle(node);
+              const isVisible = style && style.visibility !== 'hidden' && hasVisibleBoundingBox();
+              const success = (waitForVisible === isVisible || waitForHidden === !isVisible);
+              return success ? node : null;
+
+              function hasVisibleBoundingBox() {
+                const rect = node.getBoundingClientRect();
+                return !!(rect.top || rect.bottom || rect.width || rect.height);
+              }
+            }";
+            var polling = options.Visible || options.Hidden ? WaitForFunctionPollingOption.Raf : WaitForFunctionPollingOption.Mutation;
+            var handle = await WaitForFunctionAsync(predicate, new WaitForFunctionOptions
+            {
+                Timeout = options.Timeout,
+                Polling = polling
+            }, selector, options.Visible, options.Hidden);
+            return handle.AsElement();
+        }
+
         #endregion
 
         #region Private Methods
-        
+
         private async Task<ElementHandle> GetDocument()
         {
             if (_documentCompletionSource == null)

lib/PuppeteerSharp/Page.cs

@@ -541,6 +541,41 @@ await Task.WhenAll(
             return navigationTask.Result;
         }
 
+        /// <summary>
+        /// Waits for a timeout
+        /// </summary>
+        /// <param name="milliseconds"></param>
+        /// <returns>A task that resolves when after the timeout</returns>
+        public Task WaitForTimeoutAsync(int milliseconds)
+            => MainFrame.WaitForTimeoutAsync(milliseconds);
+
+        /// <summary>
+        /// Waits for a script to be evaluated to a truthy value
+        /// </summary>
+        /// <param name="script">Function to be evaluated in browser context</param>
+        /// <param name="options">Optional waiting parameters</param>
+        /// <param name="args">Arguments to pass to <c>script</c></param>
+        /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>
+        public Task<JSHandle> WaitForFunctionAsync(string script, WaitForFunctionOptions options = null, params object[] args)
+            => MainFrame.WaitForFunctionAsync(script, options ?? new WaitForFunctionOptions(), args);
+
+        /// <summary>
+        /// Waits for a script to be evaluated to a truthy value
+        /// </summary>
+        /// <param name="script">Function to be evaluated in browser context</param>
+        /// <param name="args">Arguments to pass to <c>script</c></param>
+        /// <returns>A task that resolves when the <c>script</c> returns a truthy value</returns>
+        public Task<JSHandle> WaitForFunctionAsync(string script, params object[] args) => WaitForFunctionAsync(script, null, args);
+
+        /// <summary>
+        /// Waits for a selector to be added to the DOM
+        /// </summary>
+        /// <param name="selector">A selector of an element to wait for</param>
+        /// <param name="options">Optional waiting parameters</param>
+        /// <returns>A task that resolves when element specified by selector string is added to DOM</returns>
+        public Task<ElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)
+            => MainFrame.WaitForSelectorAsync(selector, options ?? new WaitForSelectorOptions());
+
         #endregion
 
         #region Private Method

lib/PuppeteerSharp/WaitForFunctionOptions.cs

@@ -0,0 +1,20 @@
+namespace PuppeteerSharp
+{
+    /// <summary>
+    /// Optional waiting parameters.
+    /// </summary>
+    /// <seealso cref="Page.WaitForFunctionAsync(string, WaitForFunctionOptions, object[])"/>
+    /// <seealso cref="Frame.WaitForFunctionAsync(string, WaitForFunctionOptions, object[])"/>
+    public class WaitForFunctionOptions
+    {
+        /// <summary>
+        /// Maximum time to wait for in milliseconds. Defaults to 30000 (30 seconds).
+        /// </summary>
+        public int Timeout { get; set; } = 30_000;
+
+        /// <summary>
+        /// An interval at which the <c>pageFunction</c> is executed. defaults to <see cref="WaitForFunctionPollingOption.Raf"/>
+        /// </summary>
+        public WaitForFunctionPollingOption Polling { get; set; } = WaitForFunctionPollingOption.Raf;
+    }
+}

lib/PuppeteerSharp/WaitForFunctionPollingOption.cs

@@ -0,0 +1,22 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace PuppeteerSharp
+{
+    /// <summary>
+    /// An interval at which the <c>pageFunction</c> is executed.
+    /// </summary>
+    [JsonConverter(typeof(StringEnumConverter), true)]
+    public enum WaitForFunctionPollingOption
+    {
+        /// <summary>
+        /// To constantly execute <c>pageFunction</c> in <c>requestAnimationFrame</c> callback.
+        /// This is the tightest polling mode which is suitable to observe styling changes.
+        /// </summary>
+        Raf,
+        /// <summary>
+        /// To execute <c>pageFunction</c> on every DOM mutation.
+        /// </summary>
+        Mutation
+    }
+}

lib/PuppeteerSharp/WaitForSelectorOptions.cs

@@ -0,0 +1,25 @@
+namespace PuppeteerSharp
+{
+    /// <summary>
+    /// Optional waiting parameters.
+    /// </summary>
+    /// <seealso cref="Page.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>
+    /// <seealso cref="Frame.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>
+    public class WaitForSelectorOptions
+    {
+        /// <summary>
+        /// Maximum time to wait for in milliseconds. Defaults to 30000 (30 seconds).
+        /// </summary>
+        public int Timeout { get; set; } = 30_000;
+
+        /// <summary>
+        /// Wait for selector to become visible.
+        /// </summary>
+        public bool Visible { get; set; }
+
+        /// <summary>
+        /// Wait for selector to become hidden.
+        /// </summary>
+        public bool Hidden { get; set; }
+    }
+}