Use xpath query handler (#2230)

* Use xpath query handler

* Disable obsolete errors

* Match test

Author: kblok

lib/PuppeteerSharp.Tests/ElementHandleTests/CustomQueriesTests.cs

@@ -21,7 +21,7 @@ public override Task DisposeAsync()
             return base.DisposeAsync();
         }
 
-        [PuppeteerTest("elementhandle.spec.ts", "Custom queries", "should reguster and unregister")]
+        [PuppeteerTest("elementhandle.spec.ts", "Custom queries", "should register and unregister")]
         [PuppeteerFact]
         public async Task ShouldRegisterAndUnregister()
         {
@@ -49,7 +49,7 @@ public async Task ShouldRegisterAndUnregister()
             }
             catch (Exception ex)
             {
-                Assert.Equal($"Query set to use \"getById\", but no query handler of that name was found", ex.Message);
+                Assert.DoesNotContain($"Custom query handler name not set - throw expected", ex.Message);
             }
 
             var handlerNamesAfterUnregistering = ((Browser)Browser).GetCustomQueryHandlerNames();

lib/PuppeteerSharp.Tests/QuerySelectorTests/ElementHandleXPathTests.cs

@@ -1,3 +1,4 @@
+#pragma warning disable CS0618 // XPathAsync is obsolete but we test the funcionatlity anyway
 using System.Threading.Tasks;
 using PuppeteerSharp.Tests.Attributes;
 using PuppeteerSharp.Xunit;
@@ -37,3 +38,4 @@ public async Task ShouldReturnNullForNonExistingElement()
         }
     }
 }
+#pragma warning restore CS0618

lib/PuppeteerSharp.Tests/QuerySelectorTests/PageXPathTests.cs

@@ -1,3 +1,4 @@
+#pragma warning disable CS0618 // WaitForXPathAsync is obsolete but we test the funcionatlity anyway
 using System.Threading.Tasks;
 using PuppeteerSharp.Tests.Attributes;
 using PuppeteerSharp.Xunit;
@@ -13,7 +14,7 @@ public PageXPathTests(ITestOutputHelper output) : base(output)
         {
         }
 
-        [PuppeteerTest("queryselector.spec.ts", "Path.$x", "should query existing element")]
+        [PuppeteerTest("queryselector.spec.ts", "Page.$x", "should query existing element")]
         [PuppeteerFact]
         public async Task ShouldQueryExistingElement()
         {
@@ -23,15 +24,15 @@ public async Task ShouldQueryExistingElement()
             Assert.Single(elements);
         }
 
-        [PuppeteerTest("queryselector.spec.ts", "Path.$x", "should return empty array for non-existing element")]
+        [PuppeteerTest("queryselector.spec.ts", "Page.$x", "should return empty array for non-existing element")]
         [PuppeteerFact]
         public async Task ShouldReturnEmptyArrayForNonExistingElement()
         {
             var elements = await Page.XPathAsync("/html/body/non-existing-element");
             Assert.Empty(elements);
         }
 
-        [PuppeteerTest("queryselector.spec.ts", "Path.$x", "should return multiple elements")]
+        [PuppeteerTest("queryselector.spec.ts", "Page.$x", "should return multiple elements")]
         [PuppeteerFact]
         public async Task ShouldReturnMultipleElements()
         {
@@ -41,3 +42,4 @@ public async Task ShouldReturnMultipleElements()
         }
     }
 }
+#pragma warning restore CS0618

lib/PuppeteerSharp.Tests/WaitTaskTests/FrameWaitForXPathTests.cs

@@ -1,3 +1,4 @@
+#pragma warning disable CS0618 // WaitForXPathAsync is obsolete but we test the funcionatlity anyway
 using System;
 using System.Linq;
 using System.Threading.Tasks;
@@ -108,4 +109,5 @@ public async Task ShouldRespectTimeout()
             Assert.Contains($"Waiting failed: {timeout}ms exceeded", exception.Message);
         }
     }
-}
+}
+#pragma warning restore CS0618

lib/PuppeteerSharp.Tests/WaitTaskTests/PageWaitForTests.cs

@@ -1,3 +1,4 @@
+#pragma warning disable CS0618 // WaitForXPathAsync is obsolete but we test the funcionatlity anyway
 using System;
 using System.Threading.Tasks;
 using PuppeteerSharp.Tests.Attributes;
@@ -85,3 +86,4 @@ public async Task ShouldWaitForPredicateWithArguments()
             => await Page.WaitForFunctionAsync("(arg1, arg2) => arg1 !== arg2", new WaitForFunctionOptions(), 1, 2);
     }
 }
+#pragma warning restore CS0618

lib/PuppeteerSharp/CustomQueriesManager.cs

@@ -10,6 +10,8 @@ namespace PuppeteerSharp
 {
     internal class CustomQueriesManager
     {
+        private static readonly string[] CustomQuerySeparators = new[] { "=", "/" };
+        private readonly Dictionary<string, PuppeteerQueryHandler> _internalQueryHandlers;
         private readonly Dictionary<string, PuppeteerQueryHandler> _queryHandlers = new();
         private readonly PuppeteerQueryHandler _pierceHandler = CreatePuppeteerQueryHandler(new CustomQueryHandler
         {
@@ -62,9 +64,7 @@ internal class CustomQueriesManager
         });
 
         private readonly PuppeteerQueryHandler _ariaHandler = AriaQueryHandlerFactory.Create();
-        private readonly Dictionary<string, PuppeteerQueryHandler> _builtInHandlers;
         private readonly Regex _customQueryHandlerNameRegex = new("[a-zA-Z]+$", RegexOptions.Compiled);
-        private readonly Regex _customQueryHandlerParserRegex = new("(?<query>^[a-zA-Z]+)\\/(?<selector>.*)", RegexOptions.Compiled);
         private readonly PuppeteerQueryHandler _defaultHandler = CreatePuppeteerQueryHandler(new CustomQueryHandler
         {
             QueryOne = "(element, selector) => element.querySelector(selector)",
@@ -124,19 +124,54 @@ internal class CustomQueriesManager
               }",
         });
 
+        private readonly PuppeteerQueryHandler _xpathHandler = CreatePuppeteerQueryHandler(new CustomQueryHandler
+        {
+            QueryOne = @"(element, selector) => {
+              const doc = element.ownerDocument || document;
+              const result = doc.evaluate(
+                selector,
+                element,
+                null,
+                XPathResult.FIRST_ORDERED_NODE_TYPE
+              );
+              return result.singleNodeValue;
+            }",
+            QueryAll = @"(element, selector) => {
+              const doc = element.ownerDocument || document;
+              const iterator = doc.evaluate(
+                selector,
+                element,
+                null,
+                XPathResult.ORDERED_NODE_ITERATOR_TYPE
+              );
+              const array = [];
+              let item;
+              while ((item = iterator.iterateNext())) {
+                array.push(item);
+              }
+              return array;
+            },
+          })",
+        });
+
         public CustomQueriesManager()
         {
-            _builtInHandlers = new()
+            _internalQueryHandlers = new()
             {
                 ["aria"] = _ariaHandler,
                 ["pierce"] = _pierceHandler,
                 ["text"] = _textQueryHandler,
+                ["xpath"] = _xpathHandler,
             };
-            _queryHandlers = _builtInHandlers.Clone();
         }
 
         internal void RegisterCustomQueryHandler(string name, CustomQueryHandler queryHandler)
         {
+            if (_internalQueryHandlers.ContainsKey(name))
+            {
+                throw new PuppeteerException($"A query handler named \"{name}\" already exists");
+            }
+
             if (_queryHandlers.ContainsKey(name))
             {
                 throw new PuppeteerException($"A custom query handler named \"{name}\" already exists");
@@ -155,21 +190,23 @@ internal void RegisterCustomQueryHandler(string name, CustomQueryHandler queryHa
 
         internal (string UpdatedSelector, PuppeteerQueryHandler QueryHandler) GetQueryHandlerAndSelector(string selector)
         {
-            var customQueryHandlerMatch = _customQueryHandlerParserRegex.Match(selector);
-            if (!customQueryHandlerMatch.Success)
-            {
-                return (selector, _defaultHandler);
-            }
-
-            var name = customQueryHandlerMatch.Groups["query"].Value;
-            var updatedSelector = customQueryHandlerMatch.Groups["selector"].Value;
+            var handlers = _internalQueryHandlers.Concat(_queryHandlers);
 
-            if (!_queryHandlers.TryGetValue(name, out var queryHandler))
+            foreach (var kv in handlers)
             {
-                throw new PuppeteerException($"Query set to use \"{name}\", but no query handler of that name was found");
+              foreach (var separator in CustomQuerySeparators)
+              {
+                var prefix = $"{kv.Key}{separator}";
+
+                if (selector.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                {
+                  selector = selector.Substring(prefix.Length);
+                  return (selector, kv.Value);
+                }
+              }
             }
 
-            return (updatedSelector, queryHandler);
+            return (selector, _defaultHandler);
         }
 
         internal IEnumerable<string> GetCustomQueryHandlerNames()
@@ -267,7 +304,6 @@ await handle.ExecutionContext.World.GetPuppeteerUtilAsync().ConfigureAwait(false
             return internalHandler;
         }
 
-        private IEnumerable<string> CustomQueryHandlerNames()
-            => _queryHandlers.Keys.ToArray().Where(k => !_builtInHandlers.ContainsKey(k));
+        private IEnumerable<string> CustomQueryHandlerNames() => _queryHandlers.Keys.ToArray();
     }
 }

lib/PuppeteerSharp/ElementHandle.cs

@@ -81,6 +81,11 @@ public async Task<Stream> ScreenshotStreamAsync(ScreenshotOptions options)
         /// <inheritdoc/>
         public async Task<IElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)
         {
+            if (string.IsNullOrEmpty(selector))
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             var customQueriesManager = ((Browser)Frame.FrameManager.Page.Browser).CustomQueriesManager;
             var (updatedSelector, queryHandler) = customQueriesManager.GetQueryHandlerAndSelector(selector);
             return await queryHandler.WaitFor(null, this, updatedSelector, options).ConfigureAwait(false);
@@ -242,20 +247,35 @@ public async Task PressAsync(string key, PressOptions options = null)
         /// <inheritdoc/>
         public Task<IElementHandle> QuerySelectorAsync(string selector)
         {
+            if (string.IsNullOrEmpty(selector))
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             var (updatedSelector, queryHandler) = CustomQueriesManager.GetQueryHandlerAndSelector(selector);
             return queryHandler.QueryOne(this, updatedSelector);
         }
 
         /// <inheritdoc/>
         public Task<IElementHandle[]> QuerySelectorAllAsync(string selector)
         {
+            if (string.IsNullOrEmpty(selector))
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             var (updatedSelector, queryHandler) = CustomQueriesManager.GetQueryHandlerAndSelector(selector);
             return queryHandler.QueryAll(this, updatedSelector);
         }
 
         /// <inheritdoc/>
         public async Task<IJSHandle> QuerySelectorAllHandleAsync(string selector)
         {
+            if (string.IsNullOrEmpty(selector))
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             var (updatedSelector, queryHandler) = CustomQueriesManager.GetQueryHandlerAndSelector(selector);
             var handles = await queryHandler.QueryAll(this, updatedSelector).ConfigureAwait(false);
 

lib/PuppeteerSharp/Frame.cs

@@ -94,24 +94,30 @@ public async Task<IExecutionContext> GetExecutionContextAsync()
         /// <inheritdoc/>
         public async Task<IElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null)
         {
+            if (string.IsNullOrEmpty(selector))
+            {
+                throw new ArgumentNullException(nameof(selector));
+            }
+
             var customQueriesManager = ((Browser)FrameManager.Page.Browser).CustomQueriesManager;
             var (updatedSelector, queryHandler) = customQueriesManager.GetQueryHandlerAndSelector(selector);
             return await queryHandler.WaitFor(this, null, updatedSelector, options).ConfigureAwait(false);
         }
 
         /// <inheritdoc/>
-        public async Task<IElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)
+        public Task<IElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null)
         {
-            var handle = await PuppeteerWorld.WaitForXPathAsync(xpath, options).ConfigureAwait(false);
-            if (handle == null)
+            if (string.IsNullOrEmpty(xpath))
+            {
+                throw new ArgumentNullException(nameof(xpath));
+            }
+
+            if (xpath.StartsWith("//", StringComparison.OrdinalIgnoreCase))
             {
-                return null;
+                xpath = $".{xpath}";
             }
 
-            var mainExecutionContext = await MainWorld.GetExecutionContextAsync().ConfigureAwait(false);
-            var result = await mainExecutionContext.AdoptElementHandleAsync(handle).ConfigureAwait(false);
-            await handle.DisposeAsync().ConfigureAwait(false);
-            return result;
+            return WaitForSelectorAsync($"xpath/{xpath}", options);
         }
 
         /// <inheritdoc/>

lib/PuppeteerSharp/IElementHandle.cs

@@ -274,6 +274,7 @@ public interface IElementHandle : IJSHandle
         /// </summary>
         /// <param name="expression">Expression to evaluate <see href="https://developer.mozilla.org/en-US/docs/Web/API/Document/evaluate"/>.</param>
         /// <returns>Task which resolves to an array of <see cref="IElementHandle"/>.</returns>
+        [Obsolete("Use " + nameof(QuerySelectorAsync) + " instead")]
         Task<IElementHandle[]> XPathAsync(string expression);
     }
 }

lib/PuppeteerSharp/IFrame.cs

@@ -381,7 +381,6 @@ public interface IFrame
         /// <param name="options">Optional waiting parameters.</param>
         /// <returns>A task that resolves when element specified by selector string is added to DOM.
         /// Resolves to `null` if waiting for `hidden: true` and selector is not found in DOM.</returns>
-        /// <seealso cref="WaitForXPathAsync(string, WaitForSelectorOptions)"/>
         /// <seealso cref="IPage.WaitForSelectorAsync(string, WaitForSelectorOptions)"/>
         /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>
         Task<IElementHandle> WaitForSelectorAsync(string selector, WaitForSelectorOptions options = null);
@@ -421,16 +420,16 @@ public interface IFrame
         /// </code>
         /// </example>
         /// <seealso cref="WaitForSelectorAsync(string, WaitForSelectorOptions)"/>
-        /// <seealso cref="IPage.WaitForXPathAsync(string, WaitForSelectorOptions)"/>
         /// <exception cref="WaitTaskTimeoutException">If timeout occurred.</exception>
+        [Obsolete("Use " + nameof(WaitForSelectorAsync) + " instead")]
         Task<IElementHandle> WaitForXPathAsync(string xpath, WaitForSelectorOptions options = null);
 
         /// <summary>
         /// Evaluates the XPath expression.
         /// </summary>
         /// <param name="expression">Expression to evaluate <see href="https://developer.mozilla.org/en-US/docs/Web/API/Document/evaluate"/>.</param>
         /// <returns>Task which resolves to an array of <see cref="IElementHandle"/>.</returns>
-        /// <seealso cref="IPage.XPathAsync(string)"/>
+        [Obsolete("Use " + nameof(QuerySelectorAsync) + " instead")]
         Task<IElementHandle[]> XPathAsync(string expression);
     }
 }