add bidi script tests

Author: navin772

py/test/selenium/webdriver/common/bidi_script_tests.py

@@ -15,7 +15,10 @@
 # specific language governing permissions and limitations
 # under the License.
 
+import pytest
+
 from selenium.webdriver.common.bidi.log import LogLevel
+from selenium.webdriver.common.bidi.script import RealmType, ResultOwnership
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support.ui import WebDriverWait
 
@@ -127,3 +130,335 @@ def test_removes_javascript_message_handler(driver, pages):
 
     WebDriverWait(driver, 5).until(lambda _: len(log_entries2) == 2)
     assert len(log_entries1) == 1
+
+
+def test_add_preload_script(driver, pages):
+    """Test adding a preload script."""
+    function_declaration = "() => { window.preloadExecuted = true; }"
+
+    script_id = driver.script.add_preload_script(function_declaration)
+    assert script_id is not None
+    assert isinstance(script_id, str)
+
+    # Navigate to a page to trigger the preload script
+    pages.load("blank.html")
+
+    # Check if the preload script was executed
+    result = driver.script.evaluate(
+        "window.preloadExecuted", {"context": driver.current_window_handle}, await_promise=False
+    )
+    assert result.result["value"] is True
+
+
+def test_add_preload_script_with_arguments(driver, pages):
+    """Test adding a preload script with channel arguments."""
+    function_declaration = "(channelFunc) => { channelFunc('test_value'); window.preloadValue = 'received'; }"
+
+    arguments = [{"type": "channel", "value": {"channel": "test-channel", "ownership": "root"}}]
+
+    script_id = driver.script.add_preload_script(function_declaration, arguments=arguments)
+    assert script_id is not None
+
+    pages.load("blank.html")
+
+    result = driver.script.evaluate(
+        "window.preloadValue", {"context": driver.current_window_handle}, await_promise=False
+    )
+    assert result.result["value"] == "received"
+
+
+def test_add_preload_script_with_contexts(driver, pages):
+    """Test adding a preload script with specific contexts."""
+    function_declaration = "() => { window.contextSpecific = true; }"
+    contexts = [driver.current_window_handle]
+
+    script_id = driver.script.add_preload_script(function_declaration, contexts=contexts)
+    assert script_id is not None
+
+    pages.load("blank.html")
+
+    result = driver.script.evaluate(
+        "window.contextSpecific", {"context": driver.current_window_handle}, await_promise=False
+    )
+    assert result.result["value"] is True
+
+
+def test_add_preload_script_invalid_arguments(driver):
+    """Test that providing both contexts and user_contexts raises an error."""
+    function_declaration = "() => {}"
+
+    with pytest.raises(ValueError, match="Cannot specify both contexts and user_contexts"):
+        driver.script.add_preload_script(function_declaration, contexts=["context1"], user_contexts=["user1"])
+
+
+def test_remove_preload_script(driver, pages):
+    """Test removing a preload script."""
+    function_declaration = "() => { window.removableScript = true; }"
+
+    script_id = driver.script.add_preload_script(function_declaration)
+    driver.script.remove_preload_script(script_id=script_id)
+
+    # Navigate to a page after removing the script
+    pages.load("blank.html")
+
+    # The script should not have executed
+    result = driver.script.evaluate(
+        "typeof window.removableScript", {"context": driver.current_window_handle}, await_promise=False
+    )
+    assert result.result["value"] == "undefined"
+
+
+def test_evaluate_expression(driver, pages):
+    """Test evaluating a simple expression."""
+    pages.load("blank.html")
+
+    result = driver.script.evaluate("1 + 2", {"context": driver.current_window_handle}, await_promise=False)
+
+    assert result.realm is not None
+    assert result.result["type"] == "number"
+    assert result.result["value"] == 3
+    assert result.exception_details is None
+
+
+def test_evaluate_with_await_promise(driver, pages):
+    """Test evaluating an expression that returns a promise."""
+    pages.load("blank.html")
+
+    result = driver.script.evaluate(
+        "Promise.resolve(42)", {"context": driver.current_window_handle}, await_promise=True
+    )
+
+    assert result.result["type"] == "number"
+    assert result.result["value"] == 42
+
+
+def test_evaluate_with_exception(driver, pages):
+    """Test evaluating an expression that throws an exception."""
+    pages.load("blank.html")
+
+    result = driver.script.evaluate(
+        "throw new Error('Test error')", {"context": driver.current_window_handle}, await_promise=False
+    )
+
+    assert result.exception_details is not None
+    assert "Test error" in str(result.exception_details)
+
+
+def test_call_function(driver, pages):
+    """Test calling a function."""
+    pages.load("blank.html")
+
+    result = driver.script.call_function(
+        "(a, b) => a + b",
+        await_promise=False,
+        target={"context": driver.current_window_handle},
+        arguments=[{"type": "number", "value": 5}, {"type": "number", "value": 3}],
+    )
+
+    assert result.result["type"] == "number"
+    assert result.result["value"] == 8
+
+
+def test_call_function_with_this(driver, pages):
+    """Test calling a function with a specific 'this' value."""
+    pages.load("blank.html")
+
+    # First set up an object
+    driver.script.evaluate(
+        "window.testObj = { value: 10 }", {"context": driver.current_window_handle}, await_promise=False
+    )
+
+    result = driver.script.call_function(
+        "function() { return this.value; }",
+        await_promise=False,
+        target={"context": driver.current_window_handle},
+        this={"type": "object", "value": [["value", {"type": "number", "value": 20}]]},
+    )
+
+    assert result.result["type"] == "number"
+    assert result.result["value"] == 20
+
+
+def test_call_function_with_user_activation(driver, pages):
+    """Test calling a function with user activation."""
+    pages.load("blank.html")
+
+    result = driver.script.call_function(
+        "() => navigator.userActivation ? navigator.userActivation.isActive : false",
+        await_promise=False,
+        target={"context": driver.current_window_handle},
+        user_activation=True,
+    )
+
+    # Note: The actual behavior depends on browser implementation
+    assert result.result is not None
+
+
+def test_get_realms(driver, pages):
+    """Test getting all realms."""
+    pages.load("blank.html")
+
+    realms = driver.script.get_realms()
+
+    assert len(realms) > 0
+    assert all(hasattr(realm, "realm") for realm in realms)
+    assert all(hasattr(realm, "origin") for realm in realms)
+    assert all(hasattr(realm, "type") for realm in realms)
+
+
+def test_get_realms_filtered_by_context(driver, pages):
+    """Test getting realms filtered by context."""
+    pages.load("blank.html")
+
+    realms = driver.script.get_realms(context=driver.current_window_handle)
+
+    assert len(realms) > 0
+    # All realms should be associated with the specified context
+    for realm in realms:
+        if realm.context is not None:
+            assert realm.context == driver.current_window_handle
+
+
+def test_get_realms_filtered_by_type(driver, pages):
+    """Test getting realms filtered by type."""
+    pages.load("blank.html")
+
+    realms = driver.script.get_realms(type=RealmType.WINDOW)
+
+    assert len(realms) > 0
+    # All realms should be of the specified type
+    for realm in realms:
+        assert realm.type == RealmType.WINDOW
+
+
+def test_disown_handles(driver, pages):
+    """Test disowning handles."""
+    pages.load("blank.html")
+
+    # First create some handles by evaluating an object
+    result = driver.script.evaluate(
+        "({ test: 'value' })",
+        {"context": driver.current_window_handle},
+        await_promise=False,
+        result_ownership=ResultOwnership.ROOT,
+    )
+
+    # Extract handle from result (this would be implementation specific)
+    if "handle" in result.result:
+        handle = result.result["handle"]
+
+        # Disown the handle
+        driver.script.disown(handles=[handle], target={"context": driver.current_window_handle})
+
+        # The disown operation should complete without error
+        # Note: We can't easily test the actual garbage collection behavior, try something
+
+
+def test_evaluate_with_result_ownership(driver, pages):
+    """Test evaluating with different result ownership settings."""
+    pages.load("blank.html")
+
+    # Test with ROOT ownership
+    result = driver.script.evaluate(
+        "({ test: 'value' })",
+        {"context": driver.current_window_handle},
+        await_promise=False,
+        result_ownership=ResultOwnership.ROOT,
+    )
+
+    assert result.result is not None
+
+    # Test with NONE ownership
+    result = driver.script.evaluate(
+        "({ test: 'value' })",
+        {"context": driver.current_window_handle},
+        await_promise=False,
+        result_ownership=ResultOwnership.NONE,
+    )
+
+    assert result.result is not None
+
+
+def test_evaluate_with_serialization_options(driver, pages):
+    """Test evaluating with serialization options."""
+    pages.load("blank.html")
+
+    serialization_options = {"maxDomDepth": 1, "maxObjectDepth": 1}
+
+    result = driver.script.evaluate(
+        "document.body",
+        {"context": driver.current_window_handle},
+        await_promise=False,
+        serialization_options=serialization_options,
+    )
+
+    assert result.result is not None
+
+
+def test_call_function_with_serialization_options(driver, pages):
+    """Test calling a function with serialization options."""
+    pages.load("blank.html")
+
+    serialization_options = {"maxDomDepth": 1, "maxObjectDepth": 1}
+
+    result = driver.script.call_function(
+        "() => document.body",
+        await_promise=False,
+        target={"context": driver.current_window_handle},
+        serialization_options=serialization_options,
+    )
+
+    assert result.result is not None
+
+
+def test_add_preload_script_with_sandbox(driver, pages):
+    """Test adding a preload script with sandbox."""
+    function_declaration = "() => { window.sandboxScript = true; }"
+
+    script_id = driver.script.add_preload_script(function_declaration, sandbox="test-sandbox")
+    assert script_id is not None
+
+    pages.load("blank.html")
+
+    # The script should execute in the sandbox, have a check to verify this
+
+
+def test_evaluate_with_user_activation(driver, pages):
+    """Test evaluating with user activation."""
+    pages.load("blank.html")
+
+    result = driver.script.evaluate(
+        "navigator.userActivation ? navigator.userActivation.isActive : false",
+        {"context": driver.current_window_handle},
+        await_promise=False,
+        user_activation=True,
+    )
+
+    assert result.result is not None
+    # try to verify user_activation
+
+
+def test_call_function_with_exception(driver, pages):
+    """Test calling a function that throws an exception."""
+    pages.load("blank.html")
+
+    result = driver.script.call_function(
+        "() => { throw new Error('Function error'); }",
+        await_promise=False,
+        target={"context": driver.current_window_handle},
+    )
+
+    assert result.exception_details is not None
+    assert "Function error" in str(result.exception_details)
+
+
+def test_call_function_with_await_promise(driver, pages):
+    """Test calling a function that returns a promise."""
+    pages.load("blank.html")
+
+    result = driver.script.call_function(
+        "() => Promise.resolve('async result')", await_promise=True, target={"context": driver.current_window_handle}
+    )
+
+    assert result.result["type"] == "string"
+    assert result.result["value"] == "async result"