Browser.waitForTarget (#762)

Author: bdurrani

lib/PuppeteerSharp.Tests/BrowserContextTests/BrowserContextTests.cs

@@ -149,5 +149,27 @@ public async Task ShouldWorkAcrossSessions()
             remoteBrowser.Disconnect();
             await context.CloseAsync();
         }
+
+        [Fact]
+        public async Task ShouldWaitForTarget()
+        {
+            var context = await Browser.CreateIncognitoBrowserContextAsync();
+            var targetPromise = context.WaitForTargetAsync((target) => target.Url == TestConstants.EmptyPage);
+            var page = await context.NewPageAsync();
+            await page.GoToAsync(TestConstants.EmptyPage);
+            var promiseTarget = await targetPromise;
+            var targetPage = await promiseTarget.PageAsync();
+            Assert.Equal(targetPage, page);
+            await context.CloseAsync();
+        }
+
+        [Fact]
+        public async Task ShouldTimeoutWaitingForNonExistantTarget()
+        {
+            var context = await Browser.CreateIncognitoBrowserContextAsync();
+            var exception = await Assert.ThrowsAsync<TimeoutException>(()
+                => context.WaitForTargetAsync((target) => target.Url == TestConstants.EmptyPage, new WaitForOptions { Timeout = 1 }));
+            await context.CloseAsync(); 
+        }
     }
 }

lib/PuppeteerSharp.Tests/TargetTests/TargetTests.cs

@@ -181,7 +181,7 @@ await Task.WhenAll(
               Server.WaitForRequest("/one-style.css")
             );
             // Connect to the opened page.
-            var target = Browser.Targets().First(t => t.Url.Contains("one-style.html"));
+            var target = await Context.WaitForTargetAsync(t => t.Url.Contains("one-style.html"));
             var newPage = await target.PageAsync();
             // Issue a redirect.
             serverResponse.Redirect("/injectedstyle.css");

lib/PuppeteerSharp/Browser.cs

@@ -149,6 +149,11 @@ public Browser(
         internal Connection Connection { get; }
         internal ViewPortOptions DefaultViewport { get; }
 
+        /// <summary>
+        /// Dafault wait time in milliseconds. Defaults to 30 seconds.
+        /// </summary>
+        public int DefaultWaitForTimeout { get; set; } = 30000; 
+
         #endregion
 
         #region Public Methods
@@ -258,6 +263,63 @@ public async Task<string> GetUserAgentAsync()
         /// <returns>Task</returns>
         public Task CloseAsync() => _closeTask ?? (_closeTask = CloseCoreAsync());
 
+        /// <summary>
+        /// This searches for a target in this specific browser context.
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// await page.EvaluateAsync("() => window.open('https://www.example.com/')");
+        /// var newWindowTarget = await browserContext.WaitForTargetAsync((target) => target.Url == "https://www.example.com/");
+        /// ]]>
+        /// </code>
+        /// </example>
+        /// </summary>
+        /// <param name="predicate">A function to be run for every target</param>
+        /// <param name="options">options</param>
+        /// <returns>Resolves to the first target found that matches the predicate function.</returns>
+        public async Task<Target> WaitForTargetAsync(Func<Target, bool> predicate, WaitForOptions options = null)
+        {
+            var timeout = options?.Timeout ?? DefaultWaitForTimeout;
+            var existingTarget = Targets().FirstOrDefault(predicate);
+            if (existingTarget != null)
+            {
+                return existingTarget;
+            }
+
+            var targetCompletionSource = new TaskCompletionSource<Target>();
+
+            void TargetHandler(object sender, TargetChangedArgs e)
+            {
+                if (predicate(e.Target))
+                {
+                    targetCompletionSource.TrySetResult(e.Target);
+                }
+            }
+
+            try
+            {
+                TargetCreated += TargetHandler;
+                TargetChanged += TargetHandler;
+
+                var task = await Task.WhenAny(new[]
+                {
+                    TaskHelper.CreateTimeoutTask(timeout),
+                    targetCompletionSource.Task
+                }).ConfigureAwait(false);
+
+                // if this was the timeout task, this will throw a timeout exception
+                // othewise this is the targetCompletionSource task which has already
+                // completed
+                await task;
+                return await targetCompletionSource.Task;
+            }
+            finally
+            {
+                TargetCreated -= TargetHandler;
+                TargetChanged -= TargetHandler;
+            }
+        }
+
         private async Task CloseCoreAsync()
         {
             try

lib/PuppeteerSharp/BrowserContext.cs

@@ -55,6 +55,23 @@ internal BrowserContext(IConnection connection, Browser browser, string contextI
         /// </summary>
         /// <returns>An array of all active targets inside the browser context</returns>
         public Target[] Targets() => Array.FindAll(Browser.Targets(), target => target.BrowserContext == this);
+ 
+        /// <summary>
+        /// This searches for a target in this specific browser context.
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// await page.EvaluateAsync("() => window.open('https://www.example.com/')");
+        /// var newWindowTarget = await browserContext.WaitForTargetAsync((target) => target.Url == "https://www.example.com/");
+        /// ]]>
+        /// </code>
+        /// </example>
+        /// </summary>
+        /// <param name="predicate">A function to be run for every target</param>
+        /// <param name="options">options</param>
+        /// <returns>Resolves to the first target found that matches the predicate function.</returns>
+        public Task<Target> WaitForTargetAsync(Func<Target, bool> predicate, WaitForOptions options = null) 
+            => Browser.WaitForTargetAsync((target) => target.BrowserContext == this && predicate(target), options);
 
         /// <summary>
         /// An array of all pages inside the browser context.