diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fd6b21a8b93..1cbc03f4df5 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -438,6 +438,15 @@ jobs:
export MOLI_BIN="$PWD/target/ci-bin/moli-release-head/moli"
uv run --project moli-cdp-smoke --no-sync moli-cdp-smoke \
--browser moli --strict-full-suite --repeat 2 --jobs 4 --output-dir target/smoke/cdp-ci
+ - uses: actions/setup-go@40f1582b2485089dde7abd97c1529aa768e1baff # v5.6.0
+ with:
+ go-version-file: moli-cdp-smoke/chromedp/go.mod
+ cache-dependency-path: moli-cdp-smoke/chromedp/go.sum
+ - name: Run chromedp DOM search regression
+ working-directory: moli-cdp-smoke/chromedp
+ env:
+ MOLI_BIN: ${{ github.workspace }}/target/ci-bin/moli-release-head/moli
+ run: go test -mod=readonly -count=1 ./...
- name: Require full Chromium smoke
if: ${{ always() }}
env:
diff --git a/moli-cdp-smoke/chromedp/dom_search_test.go b/moli-cdp-smoke/chromedp/dom_search_test.go
new file mode 100644
index 00000000000..f8ab1259641
--- /dev/null
+++ b/moli-cdp-smoke/chromedp/dom_search_test.go
@@ -0,0 +1,221 @@
+package chromedp_smoke
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "net"
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "os/exec"
+ "path/filepath"
+ "testing"
+ "time"
+
+ "github.com/chromedp/cdproto/cdp"
+ "github.com/chromedp/cdproto/dom"
+ "github.com/chromedp/cdproto/runtime"
+ "github.com/chromedp/chromedp"
+)
+
+func startMoli(t *testing.T, ctx context.Context) string {
+ t.Helper()
+ binary := os.Getenv("MOLI_BIN")
+ if binary == "" {
+ binary = "../../target/debug/moli"
+ }
+ binary, err := filepath.Abs(binary)
+ if err != nil {
+ t.Fatal(err)
+ }
+ listener, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ address := listener.Addr().(*net.TCPAddr)
+ if err := listener.Close(); err != nil {
+ t.Fatal(err)
+ }
+ var logs bytes.Buffer
+ cmd := exec.Command(binary, "serve", "--host", "127.0.0.1", "--port", fmt.Sprint(address.Port))
+ cmd.Stdout, cmd.Stderr = &logs, &logs
+ cmd.Env = append(os.Environ(), "HTTP_PROXY=", "HTTPS_PROXY=", "ALL_PROXY=", "http_proxy=", "https_proxy=", "all_proxy=")
+ if err := cmd.Start(); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() {
+ _ = cmd.Process.Kill()
+ _ = cmd.Wait()
+ if t.Failed() {
+ t.Logf("Moli output:\n%s", logs.String())
+ }
+ })
+ client := &http.Client{Transport: &http.Transport{Proxy: nil}, Timeout: time.Second}
+ t.Cleanup(client.CloseIdleConnections)
+ ticker := time.NewTicker(25 * time.Millisecond)
+ defer ticker.Stop()
+ for {
+ request, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://"+address.String()+"/json/version", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ response, err := client.Do(request)
+ if err == nil {
+ var version struct {
+ WebSocketURL string `json:"webSocketDebuggerUrl"`
+ }
+ err = json.NewDecoder(response.Body).Decode(&version)
+ response.Body.Close()
+ if err == nil && version.WebSocketURL != "" {
+ return version.WebSocketURL
+ }
+ }
+ select {
+ case <-ctx.Done():
+ t.Fatalf("Moli discovery: %v", ctx.Err())
+ case <-ticker.C:
+ }
+ }
+}
+
+func TestDOMSearchPublishesNodePaths(t *testing.T) {
+ ctx, cancel := context.WithTimeout(t.Context(), 30*time.Second)
+ defer cancel()
+ endpoint := startMoli(t, ctx)
+ fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ fmt.Fprint(w, "
")
+ if r.URL.Path == "/static" {
+ for i := range 12 {
+ fmt.Fprintf(w, "- link %d
", i, i)
+ }
+ }
+ fmt.Fprint(w, "
")
+ if r.URL.Path == "/trees" {
+ fmt.Fprint(w, `
+
+`)
+ }
+ if r.URL.Path == "/script" {
+ fmt.Fprint(w, ``)
+ }
+ fmt.Fprint(w, "")
+ }))
+ defer fixture.Close()
+ allocator, cancelAllocator := chromedp.NewRemoteAllocator(ctx, endpoint, chromedp.NoModifyURL)
+ defer cancelAllocator()
+ browser, cancelBrowser := chromedp.NewContext(allocator, chromedp.WithDebugf(t.Logf))
+ defer cancelBrowser()
+ var links []string
+ for i := range 12 {
+ links = append(links, fmt.Sprintf("/next/%d", i))
+ }
+ for _, fixtureCase := range []struct {
+ path string
+ hrefs []string
+ }{
+ {"/static", links},
+ {"/script", links},
+ {"/trees", []string{"/light", "/shadow", "/frame"}},
+ } {
+ t.Run(fixtureCase.path, func(t *testing.T) {
+ if err := chromedp.Run(browser, chromedp.Navigate(fixture.URL+fixtureCase.path)); err != nil {
+ t.Fatal(err)
+ }
+ for range 2 {
+ var nodes []*cdp.Node
+ // The default BySearch / NodeReady path uses the frontend node cache.
+ // Do not replace this with ByJSPath or Runtime.evaluate.
+ if err := chromedp.Run(browser, chromedp.Nodes("a[href]", &nodes, chromedp.AtLeast(1))); err != nil {
+ t.Fatalf("get links: %v", err)
+ }
+ if len(nodes) != len(fixtureCase.hrefs) {
+ t.Fatalf("got %d links, want %d", len(nodes), len(fixtureCase.hrefs))
+ }
+ for i, node := range nodes {
+ if got, want := node.AttributeValue("href"), fixtureCase.hrefs[i]; got != want {
+ t.Fatalf("link %d: href=%q, want %q", i, got, want)
+ }
+ }
+ }
+ })
+ }
+}
+
+func TestDOMSearchPublicationAcrossCommandsAndDynamicTrees(t *testing.T) {
+ ctx, cancel := context.WithTimeout(t.Context(), 60*time.Second)
+ defer cancel()
+ endpoint := startMoli(t, ctx)
+ fixture := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ fmt.Fprint(w, `
+
+
+`)
+ }))
+ defer fixture.Close()
+ allocator, cancelAllocator := chromedp.NewRemoteAllocator(ctx, endpoint, chromedp.NoModifyURL)
+ defer cancelAllocator()
+ for _, test := range []struct {
+ name, expression, selector, command string
+ }{
+ {"describe-target", `document.getElementById('target')`, "#target", "describe"},
+ {"describe-ancestor", `document.querySelector('section')`, "#target", "describe"},
+ {"request-target", `document.getElementById('target')`, "#target", "request"},
+ {"request-ancestor", `document.querySelector('section')`, "#target", "request"},
+ {"new-shadow-root", `document.getElementById('host').attachShadow({mode:'closed'}).innerHTML=''`, "#shadow-hit", "evaluate"},
+ {"replacement-frame-document", `new Promise(resolve => {const f=document.getElementById('frame');f.onload=()=>resolve(true);f.srcdoc='replacement';})`, "#frame-hit", "evaluate"},
+ } {
+ t.Run(test.name, func(t *testing.T) {
+ browser, cancelBrowser := chromedp.NewContext(allocator, chromedp.WithDebugf(t.Logf))
+ defer cancelBrowser()
+ query, cancelQuery := context.WithTimeout(browser, 10*time.Second)
+ defer cancelQuery()
+ var owners []*cdp.Node
+ if err := chromedp.Run(query,
+ chromedp.Navigate(fixture.URL),
+ // Publish the owners before changing their associated trees.
+ chromedp.Nodes("#host, #frame", &owners, chromedp.ByQueryAll, chromedp.AtLeast(2)),
+ chromedp.ActionFunc(func(ctx context.Context) error {
+ object, exception, err := runtime.Evaluate(test.expression).WithAwaitPromise(true).Do(ctx)
+ if err != nil {
+ return err
+ }
+ if exception != nil {
+ return fmt.Errorf("evaluate: %v", exception)
+ }
+ switch test.command {
+ case "describe":
+ _, err = dom.DescribeNode().WithObjectID(object.ObjectID).Do(ctx)
+ case "request":
+ _, err = dom.RequestNode(object.ObjectID).Do(ctx)
+ }
+ return err
+ }),
+ ); err != nil {
+ t.Fatal(err)
+ }
+ for range 2 {
+ var nodes []*cdp.Node
+ if err := chromedp.Run(query, chromedp.Nodes(test.selector, &nodes)); err != nil {
+ t.Fatalf("BySearch / NodeReady: %v", err)
+ }
+ if len(nodes) != 1 || nodes[0].AttributeValue("href") == "" {
+ t.Fatalf("expected one usable link in the frontend cache, got %v", nodes)
+ }
+ }
+ })
+ }
+}
diff --git a/moli-cdp-smoke/chromedp/go.mod b/moli-cdp-smoke/chromedp/go.mod
new file mode 100644
index 00000000000..33902f6be58
--- /dev/null
+++ b/moli-cdp-smoke/chromedp/go.mod
@@ -0,0 +1,17 @@
+module github.com/lexmount/moli/moli-cdp-smoke/chromedp
+
+go 1.26
+
+require (
+ github.com/chromedp/cdproto v0.0.0-20260427013145-5737772c319b
+ github.com/chromedp/chromedp v0.15.1
+)
+
+require (
+ github.com/chromedp/sysutil v1.1.0 // indirect
+ github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+ github.com/gobwas/httphead v0.1.0 // indirect
+ github.com/gobwas/pool v0.2.1 // indirect
+ github.com/gobwas/ws v1.4.0 // indirect
+ golang.org/x/sys v0.42.0 // indirect
+)
diff --git a/moli-cdp-smoke/chromedp/go.sum b/moli-cdp-smoke/chromedp/go.sum
new file mode 100644
index 00000000000..b050dc1256c
--- /dev/null
+++ b/moli-cdp-smoke/chromedp/go.sum
@@ -0,0 +1,21 @@
+github.com/chromedp/cdproto v0.0.0-20260427013145-5737772c319b h1:fpvdcCAe2z3H8OvVY00iKOp3Wapbs/Gy375Fn6l/XM4=
+github.com/chromedp/cdproto v0.0.0-20260427013145-5737772c319b/go.mod h1:cbyjALe67vDvlvdiG9369P8w5U2w6IshwtyD2f2Tvag=
+github.com/chromedp/chromedp v0.15.1 h1:EJWiPm7BNqDqjYy6U0lTSL5wNH+iNt9GjC3a4gfjNyQ=
+github.com/chromedp/chromedp v0.15.1/go.mod h1:CdTHtUqD/dqaFw/cvFWtTydoEQS44wLBuwbMR9EkOY4=
+github.com/chromedp/sysutil v1.1.0 h1:PUFNv5EcprjqXZD9nJb9b/c9ibAbxiYo4exNWZyipwM=
+github.com/chromedp/sysutil v1.1.0/go.mod h1:WiThHUdltqCNKGc4gaU50XgYjwjYIhKWoHGPTUfWTJ8=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
+github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
+github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
+github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
+github.com/gobwas/ws v1.4.0 h1:CTaoG1tojrh4ucGPcoJFiAQUAsEWekEWvLy7GsVNqGs=
+github.com/gobwas/ws v1.4.0/go.mod h1:G3gNqMNtPppf5XUz7O4shetPpcZ1VJ7zt18dlUeakrc=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80 h1:6Yzfa6GP0rIo/kULo2bwGEkFvCePZ3qHDDTC3/J9Swo=
+github.com/ledongthuc/pdf v0.0.0-20220302134840-0c2507a12d80/go.mod h1:imJHygn/1yfhB7XSJJKlFZKl/J+dCPAknuiaGOshXAs=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde h1:x0TT0RDC7UhAVbbWWBzr41ElhJx5tXPWkIHA2HWPRuw=
+github.com/orisano/pixelmatch v0.0.0-20220722002657-fb0b55479cde/go.mod h1:nZgzbfBr3hhjoZnS66nKrHmduYNpc34ny7RK4z5/HM0=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
diff --git a/moli-cdp-smoke/moli_cdp_smoke/groups/dom_publication.py b/moli-cdp-smoke/moli_cdp_smoke/groups/dom_publication.py
new file mode 100644
index 00000000000..a20235b5ea6
--- /dev/null
+++ b/moli-cdp-smoke/moli_cdp_smoke/groups/dom_publication.py
@@ -0,0 +1,619 @@
+"""Validate the client's DOM mirror in WebSocket order, before each reply."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import sys
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..assertions import SmokeError, assert_equal, record
+from ..navigation import command, navigate, receive_response
+from ..raw_cdp import RawCdpClient, connect_raw_cdp
+
+
+def _descendants(node: dict[str, Any]):
+ for relation in ("children", "shadowRoots", "pseudoElements"):
+ for child in node.get(relation, []):
+ yield relation, child
+ for relation in ("contentDocument", "templateContent"):
+ if isinstance(node.get(relation), dict):
+ yield relation, node[relation]
+
+
+@dataclass
+class _DomMirror:
+ nodes: dict[int, dict[str, Any]] = field(default_factory=dict)
+ parents: dict[int, int] = field(default_factory=dict)
+ relations: dict[int, str] = field(default_factory=dict)
+
+ def require(self, node_id: int, label: str, *, allow_zero: bool = False) -> None:
+ if allow_zero and node_id == 0:
+ return
+ if not node_id or node_id not in self.nodes:
+ raise SmokeError(f"{label} references unpublished nodeId={node_id}")
+
+ def clear(self) -> None:
+ self.nodes.clear()
+ self.parents.clear()
+ self.relations.clear()
+
+ def forget(self, node_id: int) -> None:
+ for child in [child for child, parent in self.parents.items() if parent == node_id]:
+ self.forget(child)
+ self.nodes.pop(node_id, None)
+ self.parents.pop(node_id, None)
+ self.relations.pop(node_id, None)
+
+ def remember(self, node: dict[str, Any], parent: int = 0, relation: str = "children") -> None:
+ node_id = node["nodeId"]
+ if not node_id:
+ raise SmokeError(f"DOM tree snapshot contains nodeId 0: {node!r}")
+ self.require(parent, "snapshot parent", allow_zero=True)
+ self.require(node.get("parentId", 0), "snapshot parentId", allow_zero=True)
+ # A replacement snapshot retires its old descendants, including frame
+ # documents and shadow roots. Merely remembering IDs would miss this.
+ self.forget(node_id)
+ self.nodes[node_id] = node
+ self.parents[node_id] = parent
+ self.relations[node_id] = relation
+ for child_relation, child in _descendants(node):
+ self.remember(child, node_id, child_relation)
+
+ def describe(self, node: dict[str, Any]) -> None:
+ for field_name in ("nodeId", "parentId"):
+ self.require(node.get(field_name, 0), f"describeNode {field_name}", allow_zero=True)
+ for _, child in _descendants(node):
+ self.describe(child)
+
+ def observe(self, message: dict[str, Any]) -> None:
+ method, params = message.get("method"), message.get("params", {})
+ if method == "DOM.documentUpdated":
+ self.clear()
+ elif method == "DOM.setChildNodes":
+ parent = params["parentId"]
+ self.require(parent, method, allow_zero=True)
+ if parent:
+ for child in [child for child, owner in self.parents.items()
+ if owner == parent and self.relations[child] == "children"]:
+ self.forget(child)
+ for node in params["nodes"]:
+ self.remember(node, parent)
+ elif method == "DOM.childNodeInserted":
+ parent, previous = params["parentNodeId"], params["previousNodeId"]
+ self.require(parent, method)
+ self.require(previous, "previousNodeId", allow_zero=True)
+ if previous:
+ assert_equal(self.parents[previous], parent, "previous sibling parent")
+ self.remember(params["node"], parent)
+ elif method == "DOM.childNodeRemoved":
+ self.require(params["parentNodeId"], method)
+ self.require(params["nodeId"], method)
+ assert_equal(self.parents[params["nodeId"]], params["parentNodeId"], "removed node parent")
+ self.forget(params["nodeId"])
+ elif method in ("DOM.attributeModified", "DOM.attributeRemoved",
+ "DOM.characterDataModified", "DOM.childNodeCountUpdated"):
+ self.require(params["nodeId"], method)
+ elif method == "DOM.shadowRootPushed":
+ self.require(params["hostId"], method)
+ self.remember(params["root"], params["hostId"], "shadowRoots")
+ elif method == "DOM.shadowRootPopped":
+ self.require(params["hostId"], method)
+ self.require(params["rootId"], method)
+ self.forget(params["rootId"])
+
+
+@dataclass
+class _Probe:
+ client: RawCdpClient
+ mirrors: dict[str, _DomMirror] = field(default_factory=dict)
+ messages: list[dict[str, Any]] = field(default_factory=list)
+
+ def observe(self, message: dict[str, Any]) -> None:
+ self.messages.append(message)
+ if mirror := self.mirrors.get(message.get("sessionId", "")):
+ mirror.observe(message)
+
+ async def call(self, method: str, params: dict[str, Any] | None = None,
+ session: str | None = None) -> dict[str, Any]:
+ result, _, _ = await command(self.client, method, params, session_id=session,
+ on_message=self.observe)
+ if result.get("exceptionDetails"):
+ raise SmokeError(f"{method} threw: {result!r}")
+ if mirror := self.mirrors.get(session or ""):
+ if method == "DOM.getDocument":
+ mirror.clear()
+ mirror.remember(result["root"])
+ elif method == "DOM.describeNode":
+ mirror.describe(result["node"])
+ elif method in ("DOM.getSearchResults", "DOM.pushNodesByBackendIdsToFrontend"):
+ for node_id in result["nodeIds"]:
+ mirror.require(node_id, f"{method} response",
+ allow_zero=method == "DOM.pushNodesByBackendIdsToFrontend")
+ elif method == "DOM.requestNode":
+ mirror.require(result["nodeId"], "requestNode response")
+ elif method in ("DOM.getFrameOwner", "DOM.getNodeForLocation") and "nodeId" in result:
+ mirror.require(result["nodeId"], f"{method} response")
+ return result
+
+ async def attach(self, target: str) -> str:
+ session = (await self.call("Target.attachToTarget", {
+ "targetId": target, "flatten": True,
+ }))["sessionId"]
+ self.mirrors[session] = _DomMirror()
+ return session
+
+ async def evaluate(self, session: str, expression: str) -> dict[str, Any]:
+ return (await self.call("Runtime.evaluate", {
+ "expression": expression, "awaitPromise": True,
+ }, session))["result"]
+
+ async def document(self, session: str, depth: int = 1) -> None:
+ await self.call("DOM.getDocument", {"depth": depth, "pierce": False}, session)
+
+ async def search(self, session: str, query: str, count: int, *, ua: bool = False) -> list[int]:
+ search = await self.call("DOM.performSearch", {
+ "query": query, "includeUserAgentShadowDOM": ua,
+ }, session)
+ assert_equal(search["resultCount"], count, f"{query} result count")
+ result = await self.call("DOM.getSearchResults", {
+ "searchId": search["searchId"], "fromIndex": 0, "toIndex": count,
+ }, session)
+ await self.call("DOM.discardSearchResults", {"searchId": search["searchId"]}, session)
+ return result["nodeIds"]
+
+
+_HTML = """retained
+"""
+
+
+async def _install(probe: _Probe, session: str) -> None:
+ await probe.evaluate(session, "(async () => {document.body.innerHTML = " + json.dumps(_HTML) + ";"
+ "const frame=document.createElement('iframe');frame.id='frame';"
+ "const loaded=new Promise(resolve=>frame.onload=resolve);"
+ "frame.srcdoc='frame';"
+ "document.body.append(frame);await loaded;return true;})()")
+
+
+async def _describe_search(probe: _Probe, session: str, ancestor: bool, backend: bool) -> None:
+ selector = "#branch" if ancestor else "#target"
+ obj = await probe.evaluate(session, f"document.querySelector({json.dumps(selector)})")
+ described = await probe.call("DOM.describeNode", {"objectId": obj["objectId"], "depth": 2}, session)
+ assert_equal(described["node"]["nodeId"], 0, "cold describeNode ID")
+ if backend:
+ again = await probe.call("DOM.describeNode", {
+ "backendNodeId": described["node"]["backendNodeId"], "depth": 2,
+ }, session)
+ assert_equal(again["node"]["nodeId"], 0, "cold backend describeNode ID")
+ ids = await probe.search(session, "#target", 1)
+ described = await probe.call("DOM.describeNode", {"nodeId": ids[0]}, session)
+ assert_equal(described["node"]["nodeId"], ids[0], "published describeNode ID")
+ assert_equal(await probe.search(session, "#target", 1), ids, "repeat search identity")
+
+
+async def _request_search(probe: _Probe, session: str, ancestor: bool) -> None:
+ selector = "#branch" if ancestor else "#target"
+ obj = await probe.evaluate(session, f"document.querySelector({json.dumps(selector)})")
+ requested = await probe.call("DOM.requestNode", {"objectId": obj["objectId"]}, session)
+ assert_equal(await probe.call("DOM.requestNode", {"objectId": obj["objectId"]}, session),
+ requested, "repeat requestNode identity")
+ await probe.search(session, "#target", 1)
+
+
+async def _ranges(probe: _Probe, session: str) -> None:
+ search = await probe.call("DOM.performSearch", {"query": ".light-hit"}, session)
+ assert_equal(search["resultCount"], 3, "range result count")
+ params = {"searchId": search["searchId"], "fromIndex": 1, "toIndex": 2}
+ result = await probe.call("DOM.getSearchResults", params, session)
+ attrs = (await probe.call("DOM.getAttributes", {"nodeId": result["nodeIds"][0]}, session))["attributes"]
+ assert_equal(dict(zip(attrs[::2], attrs[1::2]))["id"], "second", "requested result range")
+ before = len(probe.messages)
+ assert_equal(await probe.call("DOM.getSearchResults", params, session), result, "repeat range")
+ assert_equal([m for m in probe.messages[before:] if m.get("method") == "DOM.setChildNodes"], [],
+ "already published range needs no repeated path")
+ await probe.call("DOM.getSearchResults", {**params, "fromIndex": 0, "toIndex": 3}, session)
+
+
+async def _mixed(probe: _Probe, session: str) -> None:
+ await probe.evaluate(session, "document.getElementById('host').attachShadow({mode:'closed'})"
+ ".innerHTML=''")
+ await probe.search(session, ".hit", 5)
+
+
+async def _ua(probe: _Probe, session: str) -> None:
+ hidden = await probe.call("DOM.performSearch", {"query": "#editing-view-port"}, session)
+ assert_equal(hidden["resultCount"], 0, "UA nodes excluded by default")
+ await probe.search(session, "#editing-view-port", 1, ua=True)
+
+
+async def _detached(probe: _Probe, session: str) -> None:
+ search = await probe.call("DOM.performSearch", {"query": "#target"}, session)
+ assert_equal(search["resultCount"], 1, "retained search result")
+ await probe.evaluate(session, "window.retained=document.getElementById('target');retained.remove()")
+ result = await probe.call("DOM.getSearchResults", {
+ "searchId": search["searchId"], "fromIndex": 0, "toIndex": 1,
+ }, session)
+ assert_equal(probe.mirrors[session].nodes[result["nodeIds"][0]]["localName"], "a", "detached node")
+
+
+async def _associated(probe: _Probe, session: str, frame: bool, depth: int) -> None:
+ await probe.document(session, depth)
+ owner = "frame" if frame else "host"
+ root = next(node_id for node_id, node in probe.mirrors[session].nodes.items()
+ if node["nodeType"] == 9 and probe.mirrors[session].parents[node_id] == 0)
+ await probe.call("DOM.querySelector", {"nodeId": root, "selector": f"#{owner}"}, session)
+ if frame:
+ await probe.evaluate(session, "new Promise(resolve => {const f=document.getElementById('frame');"
+ "f.onload=()=>resolve(true);f.srcdoc='';})")
+ query = "#replacement"
+ else:
+ await probe.evaluate(session, "document.getElementById('host').attachShadow({mode:'closed'})"
+ ".innerHTML=''")
+ query = "#replacement"
+ await probe.search(session, query, 1)
+ # Previously published light children remain usable after the owner gains
+ # an associated tree; searching it must repair any replacement snapshot.
+ if not frame and depth == -1:
+ await probe.search(session, "#retained", 1)
+
+
+async def _parent_refresh(probe: _Probe, session: str, whitespace: bool) -> None:
+ await probe.call("DOM.enable", {"includeWhitespace": "all" if whitespace else "none"}, session)
+ await probe.evaluate(session, "document.getElementById('host').attachShadow({mode:'closed'})"
+ ".innerHTML=''")
+ await probe.call("DOM.getDocument", {"depth": -1, "pierce": True}, session)
+ await probe.search(session, "#frame-hit", 1)
+ await probe.search(session, "#shadow-hit", 1)
+ await probe.search(session, "#editing-view-port", 1, ua=True)
+ mirror = probe.mirrors[session]
+ body = next(node_id for node_id, node in mirror.nodes.items() if node["nodeName"] == "BODY")
+ retained = set(mirror.nodes)
+ for _ in range(2):
+ # The same complete child-snapshot publisher services mutation resyncs.
+ # A shallow replacement must retain every still-live published ID,
+ # including frame documents and generated/author shadow descendants.
+ await probe.call("DOM.requestChildNodes", {"nodeId": body, "depth": 1}, session)
+ missing = retained - mirror.nodes.keys()
+ if missing:
+ raise SmokeError(f"parent replacement retired live published nodes: {sorted(missing)}")
+ await probe.search(session, "#frame-hit", 1)
+ await probe.search(session, "#shadow-hit", 1)
+ await probe.search(session, "#editing-view-port", 1, ua=True)
+ await probe.evaluate(session, "document.getElementById('frame').contentDocument"
+ ".getElementById('frame-hit').setAttribute('data-resync','retained')")
+ await probe.search(session, "#frame-hit", 1)
+
+
+async def _template_refresh(probe: _Probe, session: str, owner_refresh: bool) -> None:
+ await probe.evaluate(session, "document.body.innerHTML=''")
+ await probe.document(session, -1)
+ mirror = probe.mirrors[session]
+ template = next(node for node in mirror.nodes.values() if node["nodeName"] == "TEMPLATE")
+ fragment = template["templateContent"]
+ assert_equal(fragment.get("children"), None, "template content stays shallow")
+ await probe.call("DOM.requestChildNodes", {"nodeId": fragment["nodeId"], "depth": -1}, session)
+ article = next(node for node in mirror.nodes.values() if node["nodeName"] == "ARTICLE")
+ retained = set(mirror.nodes)
+ body = next(node_id for node_id, node in mirror.nodes.items() if node["nodeName"] == "BODY")
+ if owner_refresh:
+ await probe.evaluate(session, "document.getElementById('template-host').attachShadow({mode:'closed'})"
+ ".innerHTML='shadow'")
+ await probe.search(session, "#template-shadow", 1)
+ else:
+ await probe.call("DOM.requestChildNodes", {"nodeId": body, "depth": 1}, session)
+ missing = retained - mirror.nodes.keys()
+ if missing:
+ raise SmokeError(f"template parent request retired published nodes: {sorted(missing)}")
+ result = await probe.call("DOM.pushNodesByBackendIdsToFrontend", {
+ "backendNodeIds": [article["backendNodeId"]],
+ }, session)
+ # Chromium returns 0 for backend IDs owned by the inert template Document.
+ # A nonzero result must still refer to the retained frontend node.
+ if result["nodeIds"][0] not in (0, article["nodeId"]):
+ raise SmokeError(f"template descendant changed identity: {result!r}")
+ await probe.call("DOM.getAttributes", {"nodeId": article["nodeId"]}, session)
+
+
+async def _deep_owner_refresh(probe: _Probe, session: str) -> None:
+ await probe.evaluate(session, "(() => {document.body.innerHTML='';"
+ "let cursor=document.getElementById('deep-host');"
+ "for(let i=0;i<1100;++i){const child=document.createElement('div');"
+ "child.id='deep-'+i;cursor.appendChild(child);cursor=child;}})()")
+ await probe.document(session, 4)
+ mirror = probe.mirrors[session]
+ for index in range(0, 1100, 50):
+ node = next(n for n in mirror.nodes.values()
+ if n.get("attributes") == ["id", f"deep-{index}"])
+ await probe.call("DOM.requestChildNodes", {"nodeId": node["nodeId"], "depth": 50}, session)
+ leaf = next(n for n in mirror.nodes.values() if n.get("attributes") == ["id", "deep-1099"])
+ retained = set(mirror.nodes)
+ await probe.evaluate(session, "document.getElementById('deep-host').attachShadow({mode:'closed'})"
+ ".innerHTML='shadow'")
+ await probe.search(session, "#deep-shadow", 1)
+ missing = retained - mirror.nodes.keys()
+ if missing:
+ raise SmokeError(f"1100-level owner refresh retired published nodes: {sorted(missing)}")
+ result = await probe.call("DOM.pushNodesByBackendIdsToFrontend", {
+ "backendNodeIds": [leaf["backendNodeId"]],
+ }, session)
+ assert_equal(result["nodeIds"], [leaf["nodeId"]], "deep descendant keeps its frontend identity")
+ await probe.evaluate(session, "document.getElementById('deep-1099').setAttribute('data-state','retained')")
+
+
+async def _request_depth(probe: _Probe, session: str) -> None:
+ await probe.document(session, 3)
+ mirror = probe.mirrors[session]
+ body = next(node_id for node_id, node in mirror.nodes.items() if node["nodeName"] == "BODY")
+ for depth in (2, 3):
+ start = len(probe.messages)
+ await probe.call("DOM.requestChildNodes", {"nodeId": body, "depth": depth}, session)
+ events = [m["params"] for m in probe.messages[start:] if m.get("method") == "DOM.setChildNodes"]
+ if any(event["parentId"] == body for event in events):
+ raise SmokeError("deeper request replaced an already expanded parent")
+ start = len(probe.messages)
+ await probe.call("DOM.requestChildNodes", {"nodeId": body, "depth": depth}, session)
+ assert_equal([m for m in probe.messages[start:] if m.get("method") == "DOM.setChildNodes"], [],
+ "repeated child expansion is idempotent")
+ for selector in ("#target", "#retained"):
+ obj = await probe.evaluate(session, f"document.querySelector({json.dumps(selector)})")
+ node = (await probe.call("DOM.describeNode", {"objectId": obj["objectId"]}, session))["node"]
+ mirror.require(node["nodeId"], "deeper request published all branches")
+
+
+async def _frontend_inputs(probe: _Probe, target: str) -> None:
+ peer = await probe.attach(target)
+ await probe.document(peer, -1)
+ obj = await probe.evaluate(peer, "document.getElementById('branch')")
+ peer_node = (await probe.call("DOM.describeNode", {"objectId": obj["objectId"]}, peer))["node"]
+ session = await probe.attach(target)
+ guessed = peer_node["nodeId"]
+
+ async def assert_ignored_child_request(node_id: int) -> None:
+ start = len(probe.messages)
+ result = await probe.call("DOM.requestChildNodes", {"nodeId": node_id, "depth": 1}, session)
+ assert_equal(result, {}, "missing child request succeeds")
+ assert_equal([m for m in probe.messages[start:] if m.get("method", "").startswith("DOM.")], [],
+ "missing child request must not publish nodes")
+
+ await assert_ignored_child_request(guessed)
+ await probe.document(session)
+ if guessed in probe.mirrors[session].nodes:
+ raise SmokeError("fixture ID must be unknown to the shallow session")
+ commands = [("DOM.requestChildNodes", {"depth": 1}),
+ ("DOM.querySelector", {"selector": "#target"}),
+ ("DOM.querySelectorAll", {"selector": "#target"}),
+ ("DOM.getAttributes", {}), ("DOM.getOuterHTML", {}),
+ ("DOM.describeNode", {}), ("DOM.resolveNode", {})]
+ for method, params in commands:
+ start = len(probe.messages)
+ rid = await probe.client.send(method, {"nodeId": guessed, **params}, session_id=session)
+ reply, _ = await receive_response(probe.client, rid, on_message=probe.observe)
+ if method == "DOM.requestChildNodes":
+ assert_equal(reply.get("result"), {}, "unknown child request is a no-op")
+ else:
+ assert_equal(reply.get("error", {}).get("code"), -32000, "unknown frontend input")
+ assert_equal([m for m in probe.messages[start:] if m.get("method", "").startswith("DOM.")], [],
+ "unknown input must not publish nodes")
+ obj = await probe.evaluate(session, "document.getElementById('branch')")
+ node_id = (await probe.call("DOM.requestNode", {"objectId": obj["objectId"]}, session))["nodeId"]
+ for method, params in commands:
+ await probe.call(method, {"nodeId": node_id, **params}, session)
+ await probe.call("DOM.disable", session=session)
+ await assert_ignored_child_request(node_id)
+
+
+async def _id_exit(probe: _Probe, target: str, kind: str, state: int) -> None:
+ session = await probe.attach(target)
+ await probe.evaluate(session, "document.getElementById('target').style.cssText="
+ "'position:fixed;left:20px;top:20px;width:40px;height:40px;display:block;z-index:10000'")
+ if state:
+ await probe.document(session, 1 if state == 1 else -1)
+ selector = "#frame" if kind == "frame_owner" else "#target"
+ obj = await probe.evaluate(session, f"document.querySelector({json.dumps(selector)})")
+ described = (await probe.call("DOM.describeNode", {"objectId": obj["objectId"]}, session))["node"]
+ backend = described["backendNodeId"]
+ assert_equal(bool(described["nodeId"]), state == 2, "initial frontend publication state")
+ if kind == "push":
+ params = {"backendNodeIds": [backend, 0, backend]}
+ if not state:
+ rid = await probe.client.send("DOM.pushNodesByBackendIdsToFrontend", params, session_id=session)
+ reply, _ = await receive_response(probe.client, rid, on_message=probe.observe)
+ if "Document needs to be requested first" not in reply.get("error", {}).get("message", ""):
+ raise SmokeError(f"cold pushNodes must require a requested document: {reply!r}")
+ return
+ result = await probe.call("DOM.pushNodesByBackendIdsToFrontend", params, session)
+ node_id = result["nodeIds"][0]
+ assert_equal(result["nodeIds"], [node_id, 0, node_id], "batch positions and duplicate identities")
+ elif kind == "frame_owner":
+ tree = (await probe.call("Page.getFrameTree", session=session))["frameTree"]
+ result = await probe.call("DOM.getFrameOwner", {
+ "frameId": tree["childFrames"][0]["frame"]["id"],
+ }, session)
+ assert_equal(result["backendNodeId"], backend, "frame owner backend identity")
+ node_id = result.get("nodeId")
+ else:
+ result = await probe.call("DOM.getNodeForLocation", {"x": 25, "y": 25}, session)
+ assert_equal(result["backendNodeId"], backend, "hit-test backend identity")
+ node_id = result.get("nodeId")
+ if not state:
+ assert_equal(node_id, None, "cold document exposes backend identity only")
+ assert_equal(probe.mirrors[session].nodes, {}, "cold lookup does not publish a DOM tree")
+ return
+ probe.mirrors[session].require(node_id, "node ID outlet")
+ if state == 2:
+ assert_equal(node_id, described["nodeId"], "previously published identity stays stable")
+ await probe.call("DOM.getAttributes", {"nodeId": node_id}, session)
+ assert_equal(await probe.search(session, selector, 1), [node_id], "subsequent search reuses publication")
+
+
+async def _push_inspector_trees(probe: _Probe, target: str) -> None:
+ session = await probe.attach(target)
+ await probe.evaluate(session, "window.pushShadow=document.getElementById('host').attachShadow({mode:'closed'});"
+ "pushShadow.innerHTML='shadow';"
+ "window.pushDetached=document.createElement('a');pushDetached.textContent='detached';"
+ "document.body.insertAdjacentHTML('beforeend','marker');"
+ "document.getElementById('push-marker').getBoundingClientRect()")
+ await probe.document(session)
+ backend_ids = []
+ for expression in ("document.getElementById('target')", "pushShadow.firstChild",
+ "document.getElementById('frame').contentDocument.getElementById('frame-hit')",
+ "pushDetached"):
+ obj = await probe.evaluate(session, expression)
+ node = (await probe.call("DOM.describeNode", {"objectId":obj["objectId"]}, session))["node"]
+ backend_ids.append(node["backendNodeId"])
+ for selector, field, wanted in (("#control", "shadowRoots", "editing-view-port"),
+ ("#push-marker", "pseudoElements", None)):
+ obj = await probe.evaluate(session, f"document.querySelector({json.dumps(selector)})")
+ node = (await probe.call("DOM.describeNode", {
+ "objectId":obj["objectId"], "depth":-1, "pierce":True,
+ }, session))["node"]
+ pending = list(node.get(field, []))
+ match = None
+ while pending:
+ candidate = pending.pop()
+ attributes = candidate.get("attributes", [])
+ if wanted is None or dict(zip(attributes[::2],attributes[1::2])).get("id") == wanted:
+ match = candidate
+ break
+ pending.extend(child for _, child in _descendants(candidate))
+ if match is None:
+ raise SmokeError(f"missing generated Inspector node for {selector}: {node!r}")
+ backend_ids.append(match["backendNodeId"])
+ result = await probe.call("DOM.pushNodesByBackendIdsToFrontend", {"backendNodeIds":backend_ids}, session)
+ for backend, node_id in zip(backend_ids, result["nodeIds"], strict=True):
+ probe.mirrors[session].require(node_id, "mixed Inspector push response")
+ node = (await probe.call("DOM.describeNode", {"nodeId":node_id}, session))["node"]
+ assert_equal(node["backendNodeId"], backend, "published backend identity")
+ # Chromium can assign a fresh frontend ID when pushing a detached root
+ # again. Connected Inspector nodes retain their published identities.
+ connected = [index for index in range(len(backend_ids)) if index != 3]
+ repeated = await probe.call("DOM.pushNodesByBackendIdsToFrontend", {
+ "backendNodeIds":[backend_ids[index] for index in connected],
+ }, session)
+ assert_equal(repeated["nodeIds"], [result["nodeIds"][index] for index in connected],
+ "repeat connected push identity")
+
+
+async def _sessions(probe: _Probe, session: str, target: str, mutations: bool) -> None:
+ other = await probe.attach(target)
+ await probe.document(other, -1 if mutations else 1)
+ if not mutations:
+ await probe.search(session, "#target", 1)
+ obj = await probe.evaluate(other, "document.getElementById('target')")
+ node = (await probe.call("DOM.describeNode", {"objectId": obj["objectId"]}, other))["node"]
+ assert_equal(node["nodeId"], 0, "another session's search does not publish here")
+ await probe.search(other, "#target", 1)
+ return
+ expression = """(() => {const n=document.getElementById('target');
+ n.setAttribute('data-state','ready');n.removeAttribute('data-state');
+ n.firstChild.data='changed';n.append(document.createElement('b'));n.lastChild.remove();
+ n.firstChild.data=' ';n.firstChild.data='restored';})()"""
+ for published in (False, True):
+ if published:
+ obj = await probe.evaluate(session, "document.getElementById('branch')")
+ branch = await probe.call("DOM.requestNode", {"objectId": obj["objectId"]}, session)
+ await probe.call("DOM.requestChildNodes", {"nodeId": branch["nodeId"], "depth": -1}, session)
+ start = len(probe.messages)
+ await probe.evaluate(session, expression)
+ await probe.evaluate(other, "void 0")
+ events = [m for m in probe.messages[start:] if m.get("method", "").startswith("DOM.")]
+ for receiver in (session, other):
+ methods = {m["method"] for m in events if m.get("sessionId") == receiver}
+ if receiver == session and not published:
+ assert_equal(methods, set(), "hidden nodes emit no mutation events")
+ else:
+ expected = {"DOM.attributeModified", "DOM.attributeRemoved", "DOM.characterDataModified",
+ "DOM.childNodeInserted", "DOM.childNodeRemoved"}
+ if not expected <= methods:
+ raise SmokeError(f"missing published mutations: {expected - methods!r}")
+
+
+async def _navigation(probe: _Probe, session: str, fixture: str) -> None:
+ await probe.search(session, "#target", 1)
+ search = await probe.call("DOM.performSearch", {"query": "#target"}, session)
+ await navigate(probe.client, session, {"url": f"{fixture}/plain?dom-publication-replacement"},
+ on_message=probe.observe)
+ assert_equal(probe.mirrors[session].nodes, {}, "documentUpdated retires the client mirror")
+ rid = await probe.client.send("DOM.getSearchResults", {
+ "searchId": search["searchId"], "fromIndex": 0, "toIndex": 1,
+ }, session_id=session)
+ response, _ = await receive_response(probe.client, rid, on_message=probe.observe)
+ if "error" not in response:
+ raise SmokeError(f"retired search survived navigation: {response!r}")
+ await _install(probe, session)
+ await probe.document(session)
+ await probe.search(session, "#target", 1)
+
+
+async def run_dom_publication_group(endpoint: str, fixture: str, results: list[dict[str, Any]]) -> None:
+ # This isolated worker receives 1000-level snapshots; its JSON decoder,
+ # DOM mirror, and persisted diagnostics must all be able to inspect them.
+ sys.setrecursionlimit(max(sys.getrecursionlimit(), 8000))
+ scenarios = [
+ (f"describe_{reference}_{node}", lambda p, s, t, a=ancestor, b=backend: _describe_search(p, s, a, b))
+ for node, ancestor in (("target", False), ("ancestor", True))
+ for reference, backend in (("object", False), ("backend", True))
+ ]
+ scenarios += [(f"request_{node}", lambda p, s, t, a=ancestor: _request_search(p, s, a))
+ for node, ancestor in (("target", False), ("ancestor", True))]
+ scenarios += [
+ ("range_and_repeat", lambda p, s, t: _ranges(p, s)),
+ ("mixed_light_shadow_frame", lambda p, s, t: _mixed(p, s)),
+ ("generated_ua", lambda p, s, t: _ua(p, s)),
+ ("retained_detached", lambda p, s, t: _detached(p, s)),
+ ("session_isolation", lambda p, s, t: _sessions(p, s, t, False)),
+ ("mutation_visibility", lambda p, s, t: _sessions(p, s, t, True)),
+ ("navigation_reset", lambda p, s, t: _navigation(p, s, fixture)),
+ ]
+ scenarios += [
+ (f"new_{kind}_{depth}", lambda p, s, t, f=frame, d=depth: _associated(p, s, f, d))
+ for kind, frame in (("shadow", False), ("frame_document", True)) for depth in (1, -1)
+ ]
+ scenarios += [
+ (f"parent_refresh_whitespace_{whitespace}", lambda p, s, t, w=whitespace: _parent_refresh(p, s, w))
+ for whitespace in (False, True)
+ ]
+ scenarios += [
+ (f"{kind}_publication_{state}", lambda p, s, t, k=kind, d=state: _id_exit(p, t, k, d))
+ for kind in ("push", "frame_owner", "hit_test") for state in range(3)
+ ]
+ scenarios.append(("push_inspector_trees", lambda p, s, t: _push_inspector_trees(p, t)))
+ scenarios.append(("frontend_input_visibility", lambda p, s, t: _frontend_inputs(p, t)))
+ scenarios += [
+ ("template_parent_refresh", lambda p, s, t: _template_refresh(p, s, False)),
+ ("template_owner_refresh", lambda p, s, t: _template_refresh(p, s, True)),
+ ("request_children_depth_and_repeat", lambda p, s, t: _request_depth(p, s)),
+ ("deep_owner_refresh", lambda p, s, t: _deep_owner_refresh(p, s)),
+ ]
+ failures = []
+ for name, scenario in scenarios:
+ client = await connect_raw_cdp(endpoint)
+ probe = _Probe(client)
+ target = None
+ try:
+ target = (await probe.call("Target.createTarget", {"url": "about:blank"}))["targetId"]
+ session = await probe.attach(target)
+ await probe.call("Page.enable", session=session)
+ await navigate(client, session, {"url": f"{fixture}/plain?dom-publication"},
+ on_message=probe.observe)
+ await _install(probe, session)
+ await probe.document(session)
+ await scenario(probe, session, target)
+ record(results, f"dom_publication_{name}", {"messages": len(probe.messages)})
+ except Exception as error:
+ failures.append(f"{name}: {error}")
+ results.append({"name": f"dom_publication_{name}", "ok": False,
+ "error": str(error), "wire": probe.messages})
+ finally:
+ if target:
+ with contextlib.suppress(Exception):
+ async with asyncio.timeout(3):
+ await probe.call("Target.closeTarget", {"targetId": target})
+ await client.websocket.close()
+ if failures:
+ raise SmokeError("DOM publication contracts failed: " + "; ".join(failures))
diff --git a/moli-cdp-smoke/moli_cdp_smoke/runner.py b/moli-cdp-smoke/moli_cdp_smoke/runner.py
index 9a92dc9619e..f4846ace606 100644
--- a/moli-cdp-smoke/moli_cdp_smoke/runner.py
+++ b/moli-cdp-smoke/moli_cdp_smoke/runner.py
@@ -33,6 +33,7 @@ from .groups.core import run_core_group
from .groups.dom_input import run_dom_input_group
from .groups.dom_hit_test import run_dom_hit_test_group
from .groups.dom_parser_mutations import run_dom_parser_mutations_group
+from .groups.dom_publication import run_dom_publication_group
from .groups.dom_shadow_outer_html import run_dom_shadow_outer_html_group
from .groups.dom_snapshot import run_dom_snapshot_group
from .groups.dom_whitespace import run_dom_whitespace_group
@@ -174,6 +175,12 @@ RAW_GROUPS: tuple[SmokeGroup, ...] = (
"raw",
run_agent_episode_group,
),
+ SmokeGroup(
+ "dom-publication",
+ "Raw DOM mirror publication, search/request/describe order, associated and detached trees, mutations, and session isolation.",
+ "raw",
+ run_dom_publication_group,
+ ),
SmokeGroup(
"dom-parser-mutations",
"Raw Chromium-calibrated parser-tail DOM mutation and DCL binding refresh order.",
diff --git a/moli-cdp-smoke/tests/test_dom_publication.py b/moli-cdp-smoke/tests/test_dom_publication.py
new file mode 100644
index 00000000000..ea5608c23fc
--- /dev/null
+++ b/moli-cdp-smoke/tests/test_dom_publication.py
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import unittest
+
+from moli_cdp_smoke.assertions import SmokeError
+from moli_cdp_smoke.groups.dom_publication import _DomMirror
+
+
+def node(node_id, **fields):
+ return {"nodeId": node_id, "nodeType": 1, **fields}
+
+
+class DomPublicationMirrorTests(unittest.TestCase):
+ def test_description_does_not_publish_a_node(self):
+ mirror = _DomMirror()
+ mirror.describe(node(0, backendNodeId=123))
+ with self.assertRaisesRegex(SmokeError, "unpublished"):
+ mirror.require(123, "getSearchResults response")
+
+ def test_result_must_be_known_before_a_later_notification(self):
+ mirror = _DomMirror()
+ mirror.remember(node(1))
+ with self.assertRaisesRegex(SmokeError, "unpublished"):
+ mirror.require(2, "getSearchResults response")
+ mirror.observe({"method": "DOM.setChildNodes", "params": {
+ "parentId": 1, "nodes": [node(2, parentId=1)],
+ }})
+ mirror.require(2, "getSearchResults response")
+
+ def test_unknown_event_targets_and_parents_fail(self):
+ for method, params in [
+ ("DOM.attributeModified", {"nodeId": 2}),
+ ("DOM.attributeRemoved", {"nodeId": 2}),
+ ("DOM.characterDataModified", {"nodeId": 2}),
+ ("DOM.childNodeCountUpdated", {"nodeId": 2}),
+ ("DOM.setChildNodes", {"parentId": 2, "nodes": []}),
+ ("DOM.childNodeInserted", {"parentNodeId": 1, "previousNodeId": 2, "node": node(3)}),
+ ]:
+ with self.subTest(method=method):
+ mirror = _DomMirror()
+ mirror.remember(node(1))
+ with self.assertRaisesRegex(SmokeError, "unpublished"):
+ mirror.observe({"method": method, "params": params})
+
+ def test_replacement_and_removal_retire_all_associated_descendants(self):
+ for update in [
+ {"method": "DOM.setChildNodes", "params": {"parentId": 1, "nodes": [node(2)]}},
+ {"method": "DOM.childNodeRemoved", "params": {"parentNodeId": 1, "nodeId": 2}},
+ {"method": "DOM.documentUpdated", "params": {}},
+ ]:
+ with self.subTest(update=update):
+ mirror = _DomMirror()
+ mirror.remember(node(1, children=[node(2, children=[node(3)],
+ shadowRoots=[node(4, children=[node(5)])],
+ contentDocument=node(6, children=[node(7)]),
+ templateContent=node(8), pseudoElements=[node(9)])]))
+ mirror.observe(update)
+ for node_id in range(3, 10):
+ with self.assertRaisesRegex(SmokeError, "unpublished"):
+ mirror.require(node_id, "retired descendant")
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/moli-cdp-smoke/tests/test_group_selection.py b/moli-cdp-smoke/tests/test_group_selection.py
index 1d3e10ac55b..9225b3bf3b6 100644
--- a/moli-cdp-smoke/tests/test_group_selection.py
+++ b/moli-cdp-smoke/tests/test_group_selection.py
@@ -31,6 +31,7 @@ class GroupSelectionTests(unittest.TestCase):
self.assertIn("file-chooser", DEFAULT_GROUP_NAMES)
self.assertIn("inspector-routing", DEFAULT_GROUP_NAMES)
self.assertIn("cdp-ordering", DEFAULT_GROUP_NAMES)
+ self.assertIn("dom-publication", DEFAULT_GROUP_NAMES)
self.assertIn("navigation-outcomes", DEFAULT_GROUP_NAMES)
self.assertIn("font-face", DEFAULT_GROUP_NAMES)
self.assertIn("media-error", DEFAULT_GROUP_NAMES)
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rs
index c1b6e49038d..8807ebc2e9f 100644
--- a/moli-core/src/page/command_dispatch.rs
+++ b/moli-core/src/page/command_dispatch.rs
@@ -297,6 +297,7 @@ impl Page {
RendererPageReply::OptionalExecutionContextId(_) => {
"an optional execution context reply"
}
+ RendererPageReply::DocumentNodeRequested { .. } => "a requested document node reply",
RendererPageReply::OptionalDocumentNodeObjectSnapshot(_) => {
"an optional document node object snapshot"
}
@@ -336,7 +337,7 @@ impl Page {
RendererPageReply::DocumentPerformSearch(_) => {
"a document perform search registration reply"
}
- RendererPageReply::DocumentSearchResults(_) => "a document search results reply",
+ RendererPageReply::DocumentSearchResults { .. } => "a document search results reply",
RendererPageReply::DocumentSearchResultsDiscarded => {
"a document search results discarded reply"
}
diff --git a/moli-core/src/page/renderer_command_support.rs b/moli-core/src/page/renderer_command_support.rs
index 9fb47a84cd1..3fe5b076265 100644
--- a/moli-core/src/page/renderer_command_support.rs
+++ b/moli-core/src/page/renderer_command_support.rs
@@ -849,6 +849,7 @@ impl Page {
object_id: &str,
depth: i32,
pierce: bool,
+ bind_frontend_nodes: bool,
) -> Result {
self.start_page_command(RendererPageCommand::document_node_snapshot_for_object_id(
inspector_session_id,
@@ -856,9 +857,37 @@ impl Page {
object_id.to_owned(),
depth,
pierce,
+ bind_frontend_nodes,
))
}
+ pub fn start_request_document_node_for_object_id(
+ &self,
+ inspector_session_id: Option,
+ include_whitespace: bool,
+ object_id: String,
+ ) -> Result {
+ self.start_page_command(RendererPageCommand::request_document_node_for_object_id(
+ inspector_session_id,
+ include_whitespace,
+ object_id,
+ ))
+ }
+
+ pub fn finish_request_document_node_for_object_id(
+ &mut self,
+ completion: CompletedPageCommand,
+ ) -> Result<(Option, Option)> {
+ let reply = self.finish_page_command(completion);
+ expect_page_reply!(
+ reply,
+ "request document node page command",
+ "a requested document node reply",
+ RendererPageReply::DocumentNodeRequested { node_id, child_node_snapshot_events } =>
+ Ok((node_id, child_node_snapshot_events)),
+ )
+ }
+
pub fn finish_document_node_snapshot_for_object_id(
&mut self,
completion: CompletedPageCommand,
@@ -1296,13 +1325,18 @@ impl Page {
pub fn finish_document_search_results(
&mut self,
completion: CompletedPageCommand,
- ) -> Result {
+ ) -> Result<(
+ RendererDomSearchResultsResolution,
+ Option,
+ )> {
let reply = self.finish_page_command(completion);
expect_page_reply!(
reply,
"document search results page command",
"a document search results resolution",
- RendererPageReply::DocumentSearchResults(result) => Ok(result),
+ RendererPageReply::DocumentSearchResults { resolution, child_node_snapshot_events } => {
+ Ok((resolution, child_node_snapshot_events))
+ },
)
}
@@ -1384,8 +1418,24 @@ impl Page {
frontend_node_id: u32,
) -> Result {
self.start_page_command(RendererPageCommand::DocumentFrontendNodeBinding {
- inspector_session_id,
- frontend_node_id,
+ reference: RendererDomNodeReference::FrontendNodeId {
+ inspector_session_id,
+ frontend_node_id,
+ },
+ })
+ }
+
+ /// Resolve an internal automation binding without treating it as a CDP input.
+ pub fn start_document_internal_frontend_node_binding(
+ &self,
+ inspector_session_id: Option,
+ frontend_node_id: u32,
+ ) -> Result {
+ self.start_page_command(RendererPageCommand::DocumentFrontendNodeBinding {
+ reference: RendererDomNodeReference::InternalFrontendNodeBinding {
+ inspector_session_id,
+ frontend_node_id,
+ },
})
}
diff --git a/moli-protocol/src/automation.rs b/moli-protocol/src/automation.rs
index c6502d616be..a49c652d7b1 100644
--- a/moli-protocol/src/automation.rs
+++ b/moli-protocol/src/automation.rs
@@ -941,6 +941,22 @@ pub enum DevToolsDomNodeReference {
}
impl DevToolsDomNodeReference {
+ pub(crate) fn into_renderer_reference_for_protocol(
+ self,
+ inspector_session_id: Option,
+ protocol: FrontendProtocol,
+ ) -> moli_core::page::RendererDomNodeReference {
+ if protocol != FrontendProtocol::Cdp
+ && let Self::FrontendNodeId(frontend_node_id) = self
+ {
+ return moli_core::page::RendererDomNodeReference::InternalFrontendNodeBinding {
+ inspector_session_id,
+ frontend_node_id,
+ };
+ }
+ self.into_renderer_reference(inspector_session_id)
+ }
+
pub(crate) fn into_renderer_reference(
self,
inspector_session_id: Option,
diff --git a/moli-protocol/src/conn/runtime_eval/inspector_routing.rs b/moli-protocol/src/conn/runtime_eval/inspector_routing.rs
index a460bb7ba3c..0671566add4 100644
--- a/moli-protocol/src/conn/runtime_eval/inspector_routing.rs
+++ b/moli-protocol/src/conn/runtime_eval/inspector_routing.rs
@@ -800,12 +800,15 @@ impl CdpConnection {
self.target_renderer_runtime_inspector_session_id_for_owner(owner);
let pending = {
let page = self.loaded_page_mut_for_protocol_access_for_owner(owner)?;
+ // LocateNodes and script node values need internal frontend handles.
+ // Allocating them does not publish a node in the CDP DOM mirror.
page.start_document_node_snapshot_for_object_id_in_inspector_session(
inspector_session_id,
include_whitespace,
object_id,
depth,
pierce,
+ true,
)
.map_err(|error| format!("resolve runtime node snapshot failed: {error}"))?
};
diff --git a/moli-protocol/src/domains/accessibility/tests.rs b/moli-protocol/src/domains/accessibility/tests.rs
index ec0072c951d..e65cba79a67 100644
--- a/moli-protocol/src/domains/accessibility/tests.rs
+++ b/moli-protocol/src/domains/accessibility/tests.rs
@@ -914,6 +914,11 @@ async fn child_frame_renderer_dom_node_ids_for_selector_async(
selector: &str,
base_id: u64,
) -> ChildFrameRendererDomNodeIds {
+ ctx.process_async(
+ json!({"id":base_id+3,"method":"DOM.getDocument","params":{"depth":-1,"pierce":true}}),
+ )
+ .await;
+ let _ = ctx.take_response_by_id(base_id + 3);
ctx.process_async(json!({
"id": base_id,
"method": "Page.createIsolatedWorld",
diff --git a/moli-protocol/src/domains/command_output.rs b/moli-protocol/src/domains/command_output.rs
index d7c0843044d..96d8da3960f 100644
--- a/moli-protocol/src/domains/command_output.rs
+++ b/moli-protocol/src/domains/command_output.rs
@@ -1769,10 +1769,13 @@ fn cdp_result_payload_from_devtools_result(result: AutomationResult) -> Value {
AutomationResult::DescribeNode(result) => json!({
"node": result.node,
}),
- AutomationResult::GetFrameOwner(result) => json!({
- "nodeId": result.node_id,
- "backendNodeId": result.backend_node_id,
- }),
+ AutomationResult::GetFrameOwner(result) => {
+ let mut value = json!({"backendNodeId": result.backend_node_id});
+ if result.node_id != 0 {
+ value["nodeId"] = json!(result.node_id);
+ }
+ value
+ }
AutomationResult::QuerySelector(result) => {
if result.multiple {
json!({ "nodeIds": result.node_ids })
diff --git a/moli-protocol/src/domains/dom.rs b/moli-protocol/src/domains/dom.rs
index d5db9ee9162..ec0f9de219a 100644
--- a/moli-protocol/src/domains/dom.rs
+++ b/moli-protocol/src/domains/dom.rs
@@ -34,11 +34,10 @@ pub(crate) use resolve::{
#[cfg(test)]
use node_payload::{
- backend_node_id_for_snapshot, node_snapshot_base_payload, node_snapshot_to_cdp_with_limit,
-};
-use node_payload::{
- collect_flattened_node_snapshot, frontend_node_id_for_snapshot, node_snapshot_to_cdp,
+ backend_node_id_for_snapshot, frontend_node_id_for_snapshot, node_snapshot_base_payload,
+ node_snapshot_to_cdp_with_limit,
};
+use node_payload::{collect_flattened_node_snapshot, node_snapshot_to_cdp};
pub(crate) enum DomCommandDispatchStep {
Pending(Box),
diff --git a/moli-protocol/src/domains/dom/child_frame.rs b/moli-protocol/src/domains/dom/child_frame.rs
index 70073e194c0..f9851f76ccc 100644
--- a/moli-protocol/src/domains/dom/child_frame.rs
+++ b/moli-protocol/src/domains/dom/child_frame.rs
@@ -15,6 +15,7 @@ use crate::automation::{
DevToolsGetAttributesResult, DevToolsGetOuterHtmlCommand, DevToolsGetOuterHtmlResult,
DevToolsGetPropertyResult, DevToolsGetTextResult, DevToolsQuerySelectorResult,
DevToolsResolveNodeCommand, DevToolsResolveNodeResult, DevToolsScrollIntoViewIfNeededCommand,
+ FrontendProtocol,
};
use crate::conn::{CdpConnection, CommandOwnerScope};
use moli_core::page::{
@@ -52,30 +53,48 @@ pub(super) async fn execute_devtools_dom_command(
command.root,
&command.selector,
command.multiple,
+ command.context.protocol,
)
.await?;
Ok(AutomationResult::QuerySelector(result))
}
AutomationCommand::GetAttributes(command) => {
- let result = attributes_command(conn, owner, command.reference).await?;
+ let result =
+ attributes_command(conn, owner, command.reference, command.context.protocol)
+ .await?;
Ok(AutomationResult::GetAttributes(result))
}
AutomationCommand::GetText(command) => {
- let result = text_command(conn, owner, command.reference).await?;
+ let result =
+ text_command(conn, owner, command.reference, command.context.protocol).await?;
Ok(AutomationResult::GetText(result))
}
AutomationCommand::GetProperty(command) => {
- let result = property_command(conn, owner, command.reference, &command.name).await?;
+ let result = property_command(
+ conn,
+ owner,
+ command.reference,
+ &command.name,
+ command.context.protocol,
+ )
+ .await?;
Ok(AutomationResult::GetProperty(result))
}
AutomationCommand::GetOuterHtml(command) => {
let DevToolsGetOuterHtmlCommand {
- context: _,
+ context,
reference,
include_shadow_dom,
} = command;
- let outer_html =
- outer_html_command(conn, owner, frame_id, reference, include_shadow_dom).await?;
+ let outer_html = outer_html_command(
+ conn,
+ owner,
+ frame_id,
+ reference,
+ include_shadow_dom,
+ context.protocol,
+ )
+ .await?;
Ok(AutomationResult::GetOuterHtml(DevToolsGetOuterHtmlResult {
outer_html,
}))
@@ -107,12 +126,14 @@ async fn query_selector_command(
root: Option,
selector: &str,
multiple: bool,
+ protocol: FrontendProtocol,
) -> Result {
let renderer_inspector_session_id =
conn.target_renderer_runtime_inspector_session_id_for_owner(owner);
let include_whitespace = dom_agent_includes_whitespace_for_owner(conn, owner);
let root = match root {
- Some(reference) => reference.into_renderer_reference(renderer_inspector_session_id.clone()),
+ Some(reference) => reference
+ .into_renderer_reference_for_protocol(renderer_inspector_session_id.clone(), protocol),
None => moli_core::page::RendererDomNodeReference::BackendNodeId(
child_frame_document_root_node_reference(conn, owner, frame_id)
.await?
@@ -145,6 +166,7 @@ async fn resolve_frontend_node_reference(
conn: &mut CdpConnection,
owner: &CommandOwnerScope,
reference: DevToolsDomNodeReference,
+ protocol: FrontendProtocol,
) -> Result {
let DevToolsDomNodeReference::FrontendNodeId(frontend_node_id) = reference else {
return Ok(reference);
@@ -152,9 +174,15 @@ async fn resolve_frontend_node_reference(
let renderer_inspector_session_id = renderer_inspector_session_id_for_owner(conn, owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
- let pending = page
- .start_document_frontend_node_binding(renderer_inspector_session_id, frontend_node_id)
- .map_err(PendingDomCommandStartError::renderer_error)?;
+ let pending = if protocol == FrontendProtocol::Cdp {
+ page.start_document_frontend_node_binding(renderer_inspector_session_id, frontend_node_id)
+ } else {
+ page.start_document_internal_frontend_node_binding(
+ renderer_inspector_session_id,
+ frontend_node_id,
+ )
+ }
+ .map_err(PendingDomCommandStartError::renderer_error)?;
let completion = pending
.wait()
.await
@@ -195,12 +223,15 @@ async fn attributes_command(
conn: &mut CdpConnection,
owner: &CommandOwnerScope,
reference: DevToolsDomNodeReference,
+ protocol: FrontendProtocol,
) -> Result {
let session = conn.target_renderer_runtime_inspector_session_id_for_owner(owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_document_node_attributes(reference.into_renderer_reference(session))
+ .start_document_node_attributes(
+ reference.into_renderer_reference_for_protocol(session, protocol),
+ )
.map_err(PendingDomCommandStartError::renderer_error)?;
let completion = pending
.wait()
@@ -215,12 +246,13 @@ async fn text_command(
conn: &mut CdpConnection,
owner: &CommandOwnerScope,
reference: DevToolsDomNodeReference,
+ protocol: FrontendProtocol,
) -> Result {
let session = conn.target_renderer_runtime_inspector_session_id_for_owner(owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_document_node_text(reference.into_renderer_reference(session))
+ .start_document_node_text(reference.into_renderer_reference_for_protocol(session, protocol))
.map_err(PendingDomCommandStartError::renderer_error)?;
let completion = pending
.wait()
@@ -236,12 +268,16 @@ async fn property_command(
owner: &CommandOwnerScope,
reference: DevToolsDomNodeReference,
name: &str,
+ protocol: FrontendProtocol,
) -> Result {
let session = conn.target_renderer_runtime_inspector_session_id_for_owner(owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_document_node_property(reference.into_renderer_reference(session), name)
+ .start_document_node_property(
+ reference.into_renderer_reference_for_protocol(session, protocol),
+ name,
+ )
.map_err(PendingDomCommandStartError::renderer_error)?;
let completion = pending
.wait()
@@ -258,6 +294,7 @@ async fn outer_html_command(
frame_id: &str,
reference: Option,
include_shadow_dom: bool,
+ protocol: FrontendProtocol,
) -> Result {
let reference = match reference {
Some(reference) => reference,
@@ -272,7 +309,7 @@ async fn outer_html_command(
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_outer_html_for_node(
- reference.into_renderer_reference(session),
+ reference.into_renderer_reference_for_protocol(session, protocol),
include_shadow_dom,
)
.map_err(PendingDomCommandStartError::renderer_error)?;
@@ -290,7 +327,9 @@ async fn resolve_node_command(
owner: &CommandOwnerScope,
command: DevToolsResolveNodeCommand,
) -> Result {
- let reference = resolve_frontend_node_reference(conn, owner, command.reference).await?;
+ let reference =
+ resolve_frontend_node_reference(conn, owner, command.reference, command.context.protocol)
+ .await?;
let object_group = command.object_group;
let renderer_inspector_session_id = renderer_inspector_session_id_for_owner(conn, owner);
let remote_object = {
@@ -353,14 +392,15 @@ async fn describe_node_command(
command: DevToolsDescribeNodeCommand,
) -> Result {
let DevToolsDescribeNodeCommand {
- context: _,
+ context,
reference,
depth,
pierce,
} = command;
let snapshot = match reference {
Some(reference) => {
- node_snapshot_for_reference(conn, owner, reference, depth, pierce).await?
+ node_snapshot_for_reference(conn, owner, reference, depth, pierce, context.protocol)
+ .await?
}
None => child_frame_root_node_snapshot(conn, owner, frame_id, depth, pierce).await?,
};
@@ -376,12 +416,14 @@ async fn node_snapshot_for_reference(
reference: DevToolsDomNodeReference,
depth: i32,
pierce: bool,
+ protocol: FrontendProtocol,
) -> Result {
let renderer_inspector_session_id = renderer_inspector_session_id_for_owner(conn, owner);
let include_whitespace = dom_agent_includes_whitespace_for_owner(conn, owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
- let reference = reference.into_renderer_reference(renderer_inspector_session_id.clone());
+ let reference = reference
+ .into_renderer_reference_for_protocol(renderer_inspector_session_id.clone(), protocol);
let pending = page
.start_document_node_snapshot_for_node_in_inspector_session(
renderer_inspector_session_id,
@@ -439,7 +481,9 @@ async fn dom_geometry_command(
owner: &CommandOwnerScope,
command: DevToolsDomGeometryCommand,
) -> Result {
- let geometry = document_geometry_for_reference(conn, owner, command.reference).await?;
+ let geometry =
+ document_geometry_for_reference(conn, owner, command.reference, command.context.protocol)
+ .await?;
devtools_dom_geometry_result_from_renderer(command.operation, geometry).map_err(|error| {
PendingDomCommandStartError {
code: -32000,
@@ -459,7 +503,7 @@ async fn scroll_into_view_if_needed_command(
// The lightweight headless renderer currently treats scrollIntoViewIfNeeded
// as a geometry-validating no-op. Match the top-level path for child-frame
// elements: prove the referenced node has geometry, then complete.
- match document_geometry_for_reference(conn, owner, reference).await? {
+ match document_geometry_for_reference(conn, owner, reference, command.context.protocol).await? {
RendererDocumentNodeGeometry::FoundElement { .. } => Ok(()),
RendererDocumentNodeGeometry::FoundNonElement { .. }
| RendererDocumentNodeGeometry::NoLayoutObject
@@ -474,12 +518,15 @@ async fn document_geometry_for_reference(
conn: &mut CdpConnection,
owner: &CommandOwnerScope,
reference: DevToolsDomNodeReference,
+ protocol: FrontendProtocol,
) -> Result {
let session = conn.target_renderer_runtime_inspector_session_id_for_owner(owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_document_geometry_for_node(reference.into_renderer_reference(session))
+ .start_document_geometry_for_node(
+ reference.into_renderer_reference_for_protocol(session, protocol),
+ )
.map_err(PendingDomCommandStartError::renderer_error)?;
let completion = pending
.wait()
diff --git a/moli-protocol/src/domains/dom/node_payload.rs b/moli-protocol/src/domains/dom/node_payload.rs
index 916d3e2755d..5b55f97e439 100644
--- a/moli-protocol/src/domains/dom/node_payload.rs
+++ b/moli-protocol/src/domains/dom/node_payload.rs
@@ -1,7 +1,6 @@
#[cfg(test)]
pub(super) use moli_protocol_cdp::{
- backend_node_id_for_snapshot, node_snapshot_base_payload, node_snapshot_to_cdp_with_limit,
-};
-pub(super) use moli_protocol_cdp::{
- collect_flattened_node_snapshot, frontend_node_id_for_snapshot, node_snapshot_to_cdp,
+ backend_node_id_for_snapshot, frontend_node_id_for_snapshot, node_snapshot_base_payload,
+ node_snapshot_to_cdp_with_limit,
};
+pub(super) use moli_protocol_cdp::{collect_flattened_node_snapshot, node_snapshot_to_cdp};
diff --git a/moli-protocol/src/domains/dom/patchright_shadow_tests.rs b/moli-protocol/src/domains/dom/patchright_shadow_tests.rs
index c7472525460..534ae1fea13 100644
--- a/moli-protocol/src/domains/dom/patchright_shadow_tests.rs
+++ b/moli-protocol/src/domains/dom/patchright_shadow_tests.rs
@@ -157,11 +157,13 @@ async fn describe_node_with_pierce_surfaces_closed_shadow_root_tree() {
ctx.process_async(json!({"id": 4, "method": "DOM.describeNode", "params": { "nodeId": host_id, "depth": -1 }})).await;
let without_pierce = take_response_by_id(&mut ctx, 4);
- assert!(
- without_pierce["result"]["node"]
- .get("shadowRoots")
- .is_none()
- );
+ let shallow_shadow_roots = without_pierce["result"]["node"]["shadowRoots"]
+ .as_array()
+ .expect("shallow shadow roots without piercing");
+ assert_eq!(shallow_shadow_roots.len(), 1);
+ assert_eq!(shallow_shadow_roots[0]["shadowRootType"], json!("closed"));
+ assert_eq!(shallow_shadow_roots[0]["childNodeCount"], json!(1));
+ assert!(shallow_shadow_roots[0].get("children").is_none());
ctx.process_async(json!({"id": 5, "method": "DOM.describeNode", "params": { "nodeId": host_id, "depth": -1, "pierce": true }})).await;
let with_pierce = take_response_by_id(&mut ctx, 5);
@@ -170,6 +172,10 @@ async fn describe_node_with_pierce_surfaces_closed_shadow_root_tree() {
.expect("shadow roots");
assert_eq!(shadow_roots.len(), 1);
assert_eq!(shadow_roots[0]["shadowRootType"], json!("closed"));
+ assert_eq!(
+ shadow_roots[0]["backendNodeId"],
+ shallow_shadow_roots[0]["backendNodeId"]
+ );
assert_eq!(
shadow_roots[0]["children"][0]["attributes"],
json!(["data-inside", "yes"])
diff --git a/moli-protocol/src/domains/dom/resolve.rs b/moli-protocol/src/domains/dom/resolve.rs
index 14a84a73b0a..6a74caf7907 100644
--- a/moli-protocol/src/domains/dom/resolve.rs
+++ b/moli-protocol/src/domains/dom/resolve.rs
@@ -44,6 +44,7 @@ use command_start::*;
mod pending_command;
use pending_command::*;
mod node_completion;
+pub(super) use node_completion::push_set_child_nodes_event_from_snapshots;
use node_completion::*;
mod protocol_dispatch;
pub(crate) use node_completion::complete_pending_dom_command_output_plan;
@@ -225,7 +226,9 @@ pub(super) enum PendingDomCommandKind {
GetAttributesLive,
GetTextLive,
GetPropertyLive,
- RequestNodeObjectReference,
+ RequestNodeObjectReference {
+ top_frame_id: Option,
+ },
GetOuterHtmlDocument,
GetOuterHtmlObjectReference,
GetOuterHtmlNodeReference,
@@ -256,7 +259,7 @@ pub(super) enum PendingDomCommandKind {
SetChildNodesSnapshotForBackendNode {
after: PendingSetChildNodesAfter,
top_frame_id: Option,
- missing_node_message: &'static str,
+ missing_node_message: Option<&'static str>,
},
QuerySelectorSetChildNodesLive {
multiple: bool,
diff --git a/moli-protocol/src/domains/dom/resolve/command_start.rs b/moli-protocol/src/domains/dom/resolve/command_start.rs
index db1f159c55f..ab6a64363ef 100644
--- a/moli-protocol/src/domains/dom/resolve/command_start.rs
+++ b/moli-protocol/src/domains/dom/resolve/command_start.rs
@@ -490,7 +490,11 @@ pub(super) fn start_devtools_remove_node_command(
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_remove_document_node(command.reference.into_renderer_reference(session))
+ .start_remove_document_node(
+ command
+ .reference
+ .into_renderer_reference_for_protocol(session, command.context.protocol),
+ )
.map_err(PendingDomCommandStartError::renderer_error)?;
Ok(Some(PendingDomCommandDispatch {
command_id,
@@ -535,7 +539,11 @@ pub(super) fn start_devtools_dom_geometry_command(
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_document_geometry_for_node(command.reference.into_renderer_reference(session))
+ .start_document_geometry_for_node(
+ command
+ .reference
+ .into_renderer_reference_for_protocol(session, command.context.protocol),
+ )
.map_err(PendingDomCommandStartError::renderer_error)?;
let kind = PendingDomCommandKind::RendererNodeGeometry {
operation: command.operation,
@@ -590,7 +598,10 @@ pub(super) fn start_devtools_describe_node_command(
let include_whitespace = dom_agent_includes_whitespace_for_owner(conn, owner);
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
- let reference = reference.into_renderer_reference(renderer_inspector_session_id.clone());
+ let reference = reference.into_renderer_reference_for_protocol(
+ renderer_inspector_session_id.clone(),
+ command.context.protocol,
+ );
let pending = page
.start_document_node_snapshot_for_node_in_inspector_session(
renderer_inspector_session_id,
@@ -659,17 +670,19 @@ pub(super) fn start_devtools_request_child_nodes_command(
} else {
command.depth
};
- let missing_node_message = if matches!(
- command.reference,
- DevToolsDomNodeReference::FrontendNodeId(_)
- ) {
- "Could not find node with given id"
- } else {
- "InvalidNode"
+ let missing_node_message = match (&command.reference, command.context.protocol) {
+ (DevToolsDomNodeReference::FrontendNodeId(_), crate::automation::FrontendProtocol::Cdp) => {
+ None
+ }
+ (DevToolsDomNodeReference::FrontendNodeId(_), _) => {
+ Some("Could not find node with given id")
+ }
+ (DevToolsDomNodeReference::BackendNodeId(_), _) => Some("InvalidNode"),
};
- let reference = command
- .reference
- .into_renderer_reference(renderer_inspector_session_id.clone());
+ let reference = command.reference.into_renderer_reference_for_protocol(
+ renderer_inspector_session_id.clone(),
+ command.context.protocol,
+ );
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
@@ -786,7 +799,10 @@ fn start_query_selector_command(
let publish_node_paths =
publish_node_paths && matches!(reference, DevToolsDomNodeReference::FrontendNodeId(_));
- let reference = reference.into_renderer_reference(renderer_inspector_session_id.clone());
+ let reference = reference.into_renderer_reference_for_protocol(
+ renderer_inspector_session_id.clone(),
+ command.context.protocol,
+ );
let page =
loaded_page_mut_for_owner(conn, owner).ok_or_else(|| PendingDomCommandStartError {
code: -32000,
@@ -1188,6 +1204,7 @@ pub(super) fn start_devtools_resolve_node_command(
command_id,
owner,
frontend_node_id,
+ command.context.protocol == crate::automation::FrontendProtocol::Cdp,
PendingDomCommandKind::ResolveFrontendNodeForResolveNode {
frontend_node_id,
requested_execution_context_id: command.execution_context_id,
@@ -1357,18 +1374,18 @@ pub(super) fn start_dom_object_reference_operation(
match operation {
PendingDomObjectReferenceOperation::RequestNode => {
let pending = page
- .start_document_node_snapshot_for_object_id_in_inspector_session(
+ .start_request_document_node_for_object_id(
renderer_inspector_session_id,
include_whitespace,
- &object_id,
- 0,
- false,
+ object_id,
)
.map_err(PendingDomCommandStartError::renderer_error)?;
Ok(Some(PendingDomCommandDispatch {
command_id,
owner_scope: owner.clone(),
- kind: PendingDomCommandKind::RequestNodeObjectReference,
+ kind: PendingDomCommandKind::RequestNodeObjectReference {
+ top_frame_id: top_frame_id_for_owner(conn, owner),
+ },
pending,
}))
}
@@ -1413,6 +1430,7 @@ pub(super) fn start_dom_object_reference_operation(
&object_id,
depth,
pierce,
+ false,
)
.map_err(PendingDomCommandStartError::renderer_error)?;
Ok(Some(PendingDomCommandDispatch {
@@ -1515,7 +1533,7 @@ pub(super) fn start_devtools_get_outer_html_command(
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
.start_outer_html_for_node(
- reference.into_renderer_reference(session),
+ reference.into_renderer_reference_for_protocol(session, command.context.protocol),
include_shadow_dom,
)
.map_err(PendingDomCommandStartError::renderer_error)?;
diff --git a/moli-protocol/src/domains/dom/resolve/native.rs b/moli-protocol/src/domains/dom/resolve/native.rs
index 8e154775da5..4d3f0342fc2 100644
--- a/moli-protocol/src/domains/dom/resolve/native.rs
+++ b/moli-protocol/src/domains/dom/resolve/native.rs
@@ -187,10 +187,6 @@ fn prepare(
} else {
params.depth
};
- let frontend = matches!(
- params.reference,
- DevToolsDomNodeReference::FrontendNodeId(_)
- );
Ok(Operation::new(
Command::DocumentChildNodeSnapshotEventsForNode {
reference: params.reference.into_renderer_reference(session.clone()),
@@ -200,19 +196,15 @@ fn prepare(
pierce: params.pierce,
},
move |reply| match reply {
- Ok(Reply::OptionalDocumentChildNodeSnapshotEvents(Some(mut snapshots))) => {
- snapshots.events.truncate(1);
+ Ok(Reply::OptionalDocumentChildNodeSnapshotEvents(Some(snapshots))) => {
let mut response = Response::success(json!({}));
response.notifications =
child_notifications(snapshots, top_frame.as_deref());
response
}
+ // Like Chromium, missing or unpublished targets are a no-op.
Ok(Reply::OptionalDocumentChildNodeSnapshotEvents(None)) => {
- if frontend {
- node_not_found()
- } else {
- Response::error(-32000, "InvalidNode")
- }
+ Response::success(json!({}))
}
Err(error) => Response::error(
-32000,
@@ -230,9 +222,11 @@ fn prepare(
inspector_session_id: session,
},
|reply| match reply {
- Ok(Reply::OptionalDocumentNodeReference(Some(node))) => Response::success(
- json!({"backendNodeId": node.backend_node_id, "nodeId": node.node_id}),
- ),
+ Ok(Reply::OptionalDocumentNodeReference(Some(node))) => {
+ Response::success(get_frame_owner_result_value(
+ &get_frame_owner_result_from_node_reference(node),
+ ))
+ }
Ok(Reply::OptionalDocumentNodeReference(None)) => Response::error(
-32000,
"Frame with the given id does not belong to the target.",
@@ -253,7 +247,7 @@ fn prepare(
.object_id
.as_deref()
.and_then(|id| cached_dom_remote_object_node_for_owner(conn, &owner, id));
- let project = move |reply| project_node_snapshot(reply, top_frame, cached, false);
+ let project = move |reply| project_node_snapshot(reply, top_frame, cached);
if let Some(object) = params.reference.object_id {
let object = dom_object_reference_id_for_owner(conn, &owner, &object.into());
Ok(Operation::new(
@@ -263,6 +257,7 @@ fn prepare(
object,
params.depth,
params.pierce,
+ false,
),
project,
))
@@ -291,7 +286,7 @@ fn prepare(
.flatten()
.ok_or_else(StartError::invalid_params)?;
Ok(Operation::new(
- Command::document_node_snapshot_for_object_id(
+ Command::request_document_node_for_object_id(
session,
whitespace,
dom_object_reference_id_for_owner(
@@ -299,10 +294,26 @@ fn prepare(
&owner,
¶ms.object_id.inner().to_owned().into(),
),
- 0,
- false,
),
- move |reply| project_node_snapshot(reply, top_frame, None, true),
+ move |reply| match reply {
+ Ok(Reply::DocumentNodeRequested {
+ node_id,
+ child_node_snapshot_events,
+ }) => {
+ let mut response = node_id
+ .map(|id| Response::success(json!({"nodeId": id})))
+ .unwrap_or_else(node_not_found);
+ if let Some(events) = child_node_snapshot_events {
+ response.notifications =
+ child_notifications(events, top_frame.as_deref());
+ }
+ response
+ }
+ Err(error) => {
+ Response::error(-32000, format!("Could not request node object: {error}"))
+ }
+ _ => unreachable!("DOM request node reply"),
+ },
))
}
DomAction::GetOuterHtml => {
@@ -442,17 +453,25 @@ fn prepare(
from_index: params.from_index,
to_index: params.to_index,
},
- |reply| match reply {
- Ok(Reply::DocumentSearchResults(
- RendererDomSearchResultsResolution::Found(nodes),
- )) => Response::success(
- json!({"nodeIds": nodes.into_iter().map(|node| node.frontend_node_id).collect::>()}),
- ),
- Ok(Reply::DocumentSearchResults(
- RendererDomSearchResultsResolution::SearchResultNotFound,
- )) => Response::error(-32000, "No search session with given id found"),
- Ok(Reply::DocumentSearchResults(_)) => {
- Response::error(-32000, "Invalid search result range")
+ move |reply| match reply {
+ Ok(Reply::DocumentSearchResults {
+ resolution,
+ child_node_snapshot_events,
+ }) => {
+ let mut response = match resolution {
+ RendererDomSearchResultsResolution::Found(nodes) => Response::success(
+ json!({"nodeIds": nodes.into_iter().map(|node| node.frontend_node_id).collect::>()}),
+ ),
+ RendererDomSearchResultsResolution::SearchResultNotFound => {
+ Response::error(-32000, "No search session with given id found")
+ }
+ _ => Response::error(-32000, "Invalid search result range"),
+ };
+ if let Some(snapshots) = child_node_snapshot_events {
+ response.notifications =
+ child_notifications(snapshots, top_frame.as_deref());
+ }
+ response
}
Err(error) => Response::error(
-32000,
@@ -493,13 +512,9 @@ fn project_node_snapshot(
reply: anyhow::Result,
top_frame: Option,
cached: Option,
- request: bool,
) -> Response {
match reply {
Ok(Reply::OptionalDocumentNodeObjectSnapshot(snapshot)) => match *snapshot {
- Some(snapshot) if request => frontend_node_id_for_snapshot(&snapshot.snapshot)
- .map(|id| Response::success(json!({"nodeId": id})))
- .unwrap_or_else(node_not_found),
Some(snapshot) => node_for_describe_node_object_snapshot(
&snapshot.snapshot,
snapshot.frame_id.as_deref(),
@@ -511,13 +526,7 @@ fn project_node_snapshot(
.map(|node| Response::success(json!({"node": node})))
.unwrap_or_else(node_not_found),
},
- Err(error) => Response::error(
- -32000,
- format!(
- "Could not {} node object: {error}",
- if request { "request" } else { "describe" }
- ),
- ),
+ Err(error) => Response::error(-32000, format!("Could not describe node object: {error}")),
_ => unreachable!("DOM node snapshot reply"),
}
}
diff --git a/moli-protocol/src/domains/dom/resolve/native/remote_object.rs b/moli-protocol/src/domains/dom/resolve/native/remote_object.rs
index 6790514b765..fab6e8e15a0 100644
--- a/moli-protocol/src/domains/dom/resolve/native/remote_object.rs
+++ b/moli-protocol/src/domains/dom/resolve/native/remote_object.rs
@@ -101,6 +101,7 @@ fn resolve(
id.clone(),
0,
false,
+ false,
),
move |reply| match reply {
Ok(Reply::OptionalDocumentNodeObjectSnapshot(snapshot)) => {
diff --git a/moli-protocol/src/domains/dom/resolve/node_completion.rs b/moli-protocol/src/domains/dom/resolve/node_completion.rs
index 23c2b44ef70..a8fa9cc5b6d 100644
--- a/moli-protocol/src/domains/dom/resolve/node_completion.rs
+++ b/moli-protocol/src/domains/dom/resolve/node_completion.rs
@@ -183,10 +183,13 @@ pub(super) fn complete_pending_dom_command_result(
};
match page.finish_document_child_node_snapshot_events(completion) {
Ok(Some(_)) => Ok(AutomationResult::Empty),
- Ok(None) => Err(DevToolsError::from(PendingDomCommandStartError {
- code: -32000,
- message: missing_node_message.to_owned(),
- })),
+ Ok(None) => match missing_node_message {
+ Some(message) => Err(DevToolsError::from(PendingDomCommandStartError {
+ code: -32000,
+ message: message.to_owned(),
+ })),
+ None => Ok(AutomationResult::Empty),
+ },
Err(error) => Err(DevToolsError::new(
DevToolsErrorKind::Internal,
format!("Could not capture child node snapshots: {error}"),
@@ -295,6 +298,7 @@ pub(super) fn complete_pending_dom_command_result(
&cache_object_id,
0,
false,
+ false,
) {
Ok(pending) => {
DevToolsDomCommandTaskStep::Pending(Box::new(PendingDomCommandDispatch {
@@ -561,10 +565,13 @@ pub(super) fn get_frame_owner_result_from_node_reference(
}
pub(super) fn get_frame_owner_result_value(result: &DevToolsGetFrameOwnerResult) -> Value {
- json!({
- "nodeId": result.node_id,
+ let mut value = json!({
"backendNodeId": result.backend_node_id,
- })
+ });
+ if result.node_id != 0 {
+ value["nodeId"] = json!(result.node_id);
+ }
+ value
}
pub(super) fn live_node_not_element_error() -> PendingDomCommandStartError {
@@ -1139,13 +1146,17 @@ pub(super) fn complete_set_child_nodes_snapshot_for_backend_node(
completion: CompletedPageCommand,
after: PendingSetChildNodesAfter,
top_frame_id: Option,
- missing_node_message: &'static str,
+ missing_node_message: Option<&'static str>,
out: &mut DomCommandOutput,
) -> DomCommandTaskStep {
let snapshot_events = match page.finish_document_child_node_snapshot_events(completion) {
Ok(Some(events)) => events,
Ok(None) => {
- out.push_error(-32000, missing_node_message);
+ if let Some(message) = missing_node_message {
+ out.push_error(-32000, message);
+ } else {
+ complete_set_child_nodes_after(after, out);
+ }
return DomCommandTaskStep::Complete;
}
Err(error) => {
@@ -1156,19 +1167,18 @@ pub(super) fn complete_set_child_nodes_snapshot_for_backend_node(
return DomCommandTaskStep::Complete;
}
};
- let Some(event) = snapshot_events.events.into_iter().next() else {
- complete_set_child_nodes_after(after, out);
- return DomCommandTaskStep::Complete;
- };
- complete_set_child_nodes_from_snapshots(
- session_id,
- after,
- event.parent_frontend_node_id,
- event.snapshots,
- snapshot_events.top_snapshot_node_id,
- top_frame_id,
- out,
- )
+ for event in snapshot_events.events {
+ push_set_child_nodes_event_from_snapshots(
+ session_id,
+ event.parent_frontend_node_id,
+ &event.snapshots,
+ snapshot_events.top_snapshot_node_id,
+ top_frame_id.as_deref(),
+ out,
+ );
+ }
+ complete_set_child_nodes_after(after, out);
+ DomCommandTaskStep::Complete
}
pub(super) fn complete_query_selector_set_child_nodes_live(
@@ -1212,27 +1222,6 @@ pub(super) fn complete_query_selector_set_child_nodes_live(
DomCommandTaskStep::Complete
}
-pub(super) fn complete_set_child_nodes_from_snapshots(
- session_id: Option<&str>,
- after: PendingSetChildNodesAfter,
- parent_frontend_node_id: u32,
- snapshots: Vec,
- top_snapshot_node_id: DocumentSnapshotNodeId,
- top_frame_id: Option,
- out: &mut DomCommandOutput,
-) -> DomCommandTaskStep {
- push_set_child_nodes_event_from_snapshots(
- session_id,
- parent_frontend_node_id,
- &snapshots,
- top_snapshot_node_id,
- top_frame_id.as_deref(),
- out,
- );
- complete_set_child_nodes_after(after, out);
- DomCommandTaskStep::Complete
-}
-
pub(super) fn complete_set_child_nodes_after(
after: PendingSetChildNodesAfter,
out: &mut DomCommandOutput,
@@ -1343,24 +1332,31 @@ pub(super) fn top_snapshot_node_id_for_live_object_snapshot(
}
pub(super) fn complete_request_node_object_reference(
- _session_id: Option<&str>,
+ session_id: Option<&str>,
page: &mut Page,
completion: CompletedPageCommand,
+ top_frame_id: Option,
out: &mut DomCommandOutput,
) -> DomCommandTaskStep {
- match page.finish_document_node_snapshot_for_object_id(completion) {
- Ok(Some(object_snapshot)) => {
- let Some(frontend_node_id) =
- super::frontend_node_id_for_snapshot(&object_snapshot.snapshot)
- else {
- out.push_error(-32000, "Could not find node with given id");
- return DomCommandTaskStep::Complete;
- };
+ match page.finish_request_document_node_for_object_id(completion) {
+ Ok((Some(frontend_node_id), snapshot_events)) => {
+ if let Some(snapshot_events) = snapshot_events {
+ for event in snapshot_events.events {
+ push_set_child_nodes_event_from_snapshots(
+ session_id,
+ event.parent_frontend_node_id,
+ &event.snapshots,
+ snapshot_events.top_snapshot_node_id,
+ top_frame_id.as_deref(),
+ out,
+ );
+ }
+ }
out.push_result(json!({
"nodeId": frontend_node_id
}));
}
- Ok(None) => out.push_error(-32000, "Could not find node with given id"),
+ Ok((None, _)) => out.push_error(-32000, "Could not find node with given id"),
Err(error) => {
out.push_error(-32000, format!("Could not request node object: {error}"));
}
diff --git a/moli-protocol/src/domains/dom/resolve/pending_command.rs b/moli-protocol/src/domains/dom/resolve/pending_command.rs
index 156bd40ff68..36c64c61bf6 100644
--- a/moli-protocol/src/domains/dom/resolve/pending_command.rs
+++ b/moli-protocol/src/domains/dom/resolve/pending_command.rs
@@ -281,8 +281,14 @@ pub(super) fn complete_pending_dom_command(
PendingDomCommandKind::GetPropertyLive => {
return complete_get_property_live(page, completion, out);
}
- PendingDomCommandKind::RequestNodeObjectReference => {
- return complete_request_node_object_reference(session_id, page, completion, out);
+ PendingDomCommandKind::RequestNodeObjectReference { top_frame_id } => {
+ return complete_request_node_object_reference(
+ session_id,
+ page,
+ completion,
+ top_frame_id,
+ out,
+ );
}
PendingDomCommandKind::GetOuterHtmlDocument => {
return complete_get_outer_html_document(page, completion, out);
@@ -381,6 +387,7 @@ pub(super) fn complete_pending_dom_command(
&cache_object_id,
0,
false,
+ false,
) {
Ok(pending) => {
DomCommandTaskStep::Pending(Box::new(PendingDomCommandDispatch {
diff --git a/moli-protocol/src/domains/dom/resolve/protocol_dispatch.rs b/moli-protocol/src/domains/dom/resolve/protocol_dispatch.rs
index ac80b276f58..c21f7191bc3 100644
--- a/moli-protocol/src/domains/dom/resolve/protocol_dispatch.rs
+++ b/moli-protocol/src/domains/dom/resolve/protocol_dispatch.rs
@@ -31,7 +31,11 @@ pub(super) fn start_devtools_get_attributes_command(
let page = loaded_page_mut_for_owner(conn, owner)
.ok_or_else(PendingDomCommandStartError::no_document_loaded)?;
let pending = page
- .start_document_node_attributes(command.reference.into_renderer_reference(session))
+ .start_document_node_attributes(
+ command
+ .reference
+ .into_renderer_reference_for_protocol(session, command.context.protocol),
+ )
.map_err(PendingDomCommandStartError::renderer_error)?;
Ok(Some(PendingDomCommandDispatch {
command_id,
@@ -55,15 +59,22 @@ pub(super) fn start_document_frontend_node_binding_command(
command_id: Option,
owner: &CommandOwnerScope,
frontend_node_id: u32,
+ require_published: bool,
kind: PendingDomCommandKind,
) -> Result