[webdriver-bidi] Add tests for browsingContext.locateNodes

tools/webdriver/webdriver/bidi/error.py

@@ -35,6 +35,10 @@ class InvalidArgumentException(BidiException):
     error_code = "invalid argument"
 
 
+class InvalidSelectorError(BidiException):
+    error_code = "invalid selector"
+
+
 class InvalidSessionIDError(BidiException):
     error_code = "invalid session id"
 

tools/webdriver/webdriver/bidi/modules/browsing_context.py

@@ -2,6 +2,7 @@
 from typing import Any, Dict, List, Mapping, MutableMapping, Optional, Union
 
 from ._module import BidiModule, command
+from .script import OwnershipModel, SerializationOptions
 
 
 class ElementOptions(Dict[str, Any]):
@@ -110,6 +111,38 @@ def handle_user_prompt(self,
         if user_text is not None:
             params["userText"] = user_text
         return params
+
+    @command
+    def locate_nodes(self,
+                     context: str,
+                     locator: Mapping[str, Any],
+                     max_node_count: Optional[int] = None,
+                     ownership: Optional[OwnershipModel] = None,
+                     sandbox: Optional[str] = None,
+                     serialization_options: Optional[SerializationOptions] = None,
+                     start_nodes: Optional[List[Mapping[str, Any]]] = None) -> Mapping[str, Any]:
+        params: MutableMapping[str, Any] = {"context": context, "locator": locator}
+        if max_node_count is not None:
+            params["maxNodeCount"] = max_node_count
+        if ownership is not None:
+            params["ownership"] = ownership
+        if sandbox is not None:
+            params["sandbox"] = sandbox
+        if serialization_options is not None:
+            params["serializationOptions"] = serialization_options
+        if start_nodes is not None:
+            params["startNodes"] = start_nodes
+        return params
+
+    @locate_nodes.result
+    def _locate_nodes(self, result: Mapping[str, Any]) -> Any:
+        assert result["context"] is not None
+        assert isinstance(result["context"], str)
+
+        assert result["nodes"] is not None
+        assert isinstance(result["nodes"], List)
+
+        return result
 
     @command
     def navigate(self,

webdriver/tests/bidi/browsing_context/locate_nodes/invalid.py

@@ -0,0 +1,162 @@
+import pytest
+import webdriver.bidi.error as error
+
+pytestmark = pytest.mark.asyncio
+
+
+MAX_INT = 9007199254740991
+
+
+async def navigate_to_page(bidi_session, inline, top_context):
+    url = inline("""<div>foo</div>""")
+    await bidi_session.browsing_context.navigate(
+        context=top_context["context"], url=url, wait="complete"
+    )
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_context_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=value, locator={"type": "css", "value": "div"}
+        )
+
+
+async def test_params_context_invalid_value(bidi_session, inline, top_context):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context="foo", locator={ "type": "css", "value": "div" }
+        )
+
+
+@pytest.mark.parametrize("value", [None, False, 42, {}, []])
+async def test_params_locator_type_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"], locator={ "type": value, "value": "div" }
+        )
+
+
+@pytest.mark.parametrize("type", ["", "invalid"])
+async def test_params_locator_type_invalid_value(bidi_session, inline, top_context, type):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"], locator={ "type": type, "value": "div" }
+        )
+
+
+@pytest.mark.parametrize("type,value", [
+    ("css", "a*b"),
+    ("xpath", ""),
+    ("xpath", "invalid-xpath")
+    ("innerText", "")
+])
+async def test_params_locator_value_invalid_value(bidi_session, inline, top_context, type, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidSelectorException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"], locator={ "type": type, "value": value }
+        )
+
+
+@pytest.mark.parametrize("value", [False, "string", 1.5, {}, []])
+async def test_params_max_node_count_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "css", "value": "div" },
+            max_node_count=value
+        )
+
+
+@pytest.mark.parametrize("value", [0, MAX_INT + 1])
+async def test_params_max_node_count_invalid_value(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "invalid", "value": "div" },
+            max_node_count=value
+        )
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_ownership_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "css", "value": "div" },
+            ownership=value
+        )
+
+
+async def test_params_ownership_invalid_value(bidi_session, inline, top_context):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "css", "value": "div" },
+            ownership="foo"
+        )
+
+
+@pytest.mark.parametrize("value", [False, 42, {}, []])
+async def test_params_sandbox_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "css", "value": "div" },
+            sandbox=value
+        )
+
+
+@pytest.mark.parametrize("value", [False, 42, "foo", []])
+async def test_params_serialization_options_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "css", "value": "div" },
+            serialization_options=value
+        )
+
+
+@pytest.mark.parametrize("value", [False, "string", 42, {}])
+async def test_params_start_nodes_invalid_type(bidi_session, inline, top_context, value):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "css", "value": "div" },
+            start_nodes=value
+        )
+
+
+async def test_params_start_nodes_empty_list(bidi_session, inline, top_context):
+    await navigate_to_page(bidi_session, inline, top_context)
+
+    with pytest.raises(error.InvalidArgumentException):
+        await bidi_session.browsing_context.locate_nodes(
+            context=top_context["context"],
+            locator={ "type": "invalid", "value": "div" },
+            start_nodes=[]
+        )