fix: re-add nodriver evaluate serialization options (#190)

dbrun3 · nathanfallet · web-flow · commit ce464f985038 · 2025-08-28T21:27:06.000-04:00
* fix: readd nodriver evaluate serialization options

* chore: update changelog

* added tests to validate bug has been fixed, complex_object.html for testing complex evaluate cases, formatting

* more tests

* fix value_modes test

* fix linting and typing

---------

Co-authored-by: Nathan Fallet &lt;contact@nathanfallet.me&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Re-add nodriver evaluate serialization options for improved JavaScript evaluation @dbrun3
+
 ### Added
 
 - Fix: allow reset expect and intercept @nathanfallet
diff --git a/tests/core/test_tab.py b/tests/core/test_tab.py
@@ -289,3 +289,67 @@ async def test_intercept_with_reload(browser: zd.Browser) -> None:
         assert body is not None
         # original_response = loads(body)
         # assert original_response["name"] == "Zendriver"
+
+
+async def test_evaluate_complex_object_no_error(browser: zd.Browser) -> None:
+    tab = await browser.get(sample_file("complex_object.html"))
+    await tab.wait_for_ready_state("complete")
+
+    result = await tab.evaluate("document.querySelector('body:not(.no-js)')")
+    assert result is not None
+
+    # This is similar to the original failing case but more likely to trigger the error
+    body_with_complex_refs = await tab.evaluate("document.body")
+    assert body_with_complex_refs is not None
+
+
+async def test_evaluate_return_by_value_modes(browser: zd.Browser) -> None:
+    tab = await browser.get(sample_file("complex_object.html"))
+    await tab.wait_for_ready_state("complete")
+
+    expression = "document.querySelector('body:not(.no-js)')"
+
+    result_by_value = await tab.evaluate(expression, return_by_value=True)
+    assert result_by_value is not None
+
+    result_false = await tab.evaluate(expression, return_by_value=False)
+    assert (
+        result_false is not None
+    )  # Should return the deep serialized value, not a tuple
+
+
+async def test_evaluate_stress_test_complex_objects(browser: zd.Browser) -> None:
+    tab = await browser.get(sample_file("complex_object.html"))
+    await tab.wait_for_ready_state("complete")
+
+    # Test various DOM queries that could trigger reference chain issues
+    # Each test case is a tuple of (expression, expected_type_or_validator)
+    test_cases = [
+        ("document.querySelector('body:not(.no-js)')", lambda x: x is not None),
+        ("document.documentElement", lambda x: x is not None),
+        ("document.querySelector('*')", lambda x: x is not None),
+        ("document.body.parentElement", lambda x: x is not None),
+        ("document.getElementById('content')", lambda x: x is not None),
+        (
+            "document.body.complexStructure ? 'has complex structure' : 'no structure'",
+            str,
+        ),
+        ("document.readyState", str),
+        ("navigator.userAgent", str),
+        ("window.location.href", str),
+        ("document.title", str),
+    ]
+
+    for expression, validator in test_cases:
+        result = await tab.evaluate(expression)
+        # Verify the result is usable and matches expected type/validation
+        if callable(validator):
+            assert validator(
+                result
+            ), f"Result validation failed for '{expression}': {result}"
+        elif isinstance(validator, type):
+            assert isinstance(
+                result, validator
+            ), f"Expected {validator} for '{expression}', got {type(result)}: {result}"
+        else:
+            raise ValueError("Validator must be a type or callable")
diff --git a/tests/sample_data/complex_object.html b/tests/sample_data/complex_object.html
@@ -0,0 +1,87 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Complex Object Test</title>
+</head>
+
+<body class="no-js">
+  <div id="content">
+    <h1>Complex Object Chain Test</h1>
+    <p>This page creates a complex object structure that may cause "Object reference chain is too long" errors.</p>
+  </div>
+
+  <script>
+    // Remove no-js class immediately
+    document.body.classList.remove('no-js');
+
+    // The key insight is that DOM elements themselves can have properties added
+    // that create circular references when Chrome tries to serialize them
+
+    // Add complex circular references directly to DOM elements
+    document.body.complexRef = document;
+    document.body.windowRef = window;
+    document.body.self = document.body;
+
+    // Create a complex object and attach it to DOM elements
+    const createComplexStructure = () => {
+      const structure = {};
+      structure.self = structure;
+      structure.body = document.body;
+      structure.document = document;
+      structure.window = window;
+
+      // Create deep nesting with DOM references
+      let current = structure;
+      for (let i = 0; i < 100; i++) {
+        current.next = {
+          level: i,
+          parent: current,
+          body: document.body,
+          document: document,
+          window: window,
+          elements: Array.from(document.querySelectorAll('*'))
+        };
+        current = current.next;
+      }
+      current.back_to_start = structure;
+
+      return structure;
+    };
+
+    const complexStructure = createComplexStructure();
+
+    // Attach the complex structure to DOM elements
+    document.body.complexStructure = complexStructure;
+    document.documentElement.complexStructure = complexStructure;
+
+    // Add references to all elements
+    Array.from(document.querySelectorAll('*')).forEach((el, i) => {
+      el.complexRef = complexStructure;
+      el.index = i;
+      el.bodyRef = document.body;
+      el.documentRef = document;
+      el.windowRef = window;
+    });
+
+    // Create circular references between elements
+    const allElements = Array.from(document.querySelectorAll('*'));
+    allElements.forEach((el, i) => {
+      el.nextElement = allElements[(i + 1) % allElements.length];
+      el.prevElement = allElements[(i - 1 + allElements.length) % allElements.length];
+      el.allElements = allElements;
+    });
+
+    // Add properties to the body element that create deep circular references
+    document.body.deepRef = {
+      level1: { level2: { level3: { level4: { level5: { body: document.body } } } } }
+    };
+    document.body.deepRef.level1.level2.level3.level4.level5.back = document.body.deepRef;
+
+    console.log('Complex DOM structure with circular references created');
+  </script>
+</body>
+
+</html>
diff --git a/zendriver/core/tab.py b/zendriver/core/tab.py
@@ -718,13 +718,20 @@ async def evaluate(
         | None
         | typing.Tuple[cdp.runtime.RemoteObject, cdp.runtime.ExceptionDetails | None]
     ):
+        ser = cdp.runtime.SerializationOptions(
+            serialization="deep",
+            max_depth=10,
+            additional_parameters={"maxNodeDepth": 10, "includeShadowTree": "all"},
+        )
+
         remote_object, errors = await self.send(
             cdp.runtime.evaluate(
                 expression=expression,
                 user_gesture=True,
                 await_promise=await_promise,
                 return_by_value=return_by_value,
                 allow_unsafe_eval_blocked_by_csp=True,
+                serialization_options=ser,
             )
         )
         if errors:
@@ -734,6 +741,9 @@ async def evaluate(
             if return_by_value:
                 if remote_object.value:
                     return remote_object.value
+            else:
+                if remote_object.deep_serialized_value:
+                    return remote_object.deep_serialized_value.value
 
         return remote_object, errors
 
