feat: implement evaluate for dedicated workers

src/bidiMapper/domains/context/BrowsingContextProcessor.ts

@@ -400,7 +400,17 @@ export class BrowsingContextProcessor {
           this.#acceptInsecureCerts
         );
 
-        this.#handleWorkerTarget(cdpTarget);
+        const browsingContext =
+          parentSessionCdpClient.sessionId &&
+          this.#browsingContextStorage.findContextBySession(
+            parentSessionCdpClient.sessionId
+          );
+        // If there is no browsing context, this worker is already terminated.
+        if (!browsingContext) {
+          break;
+        }
+
+        this.#handleWorkerTarget(cdpTarget, browsingContext.id);
         return;
       }
     }
@@ -416,14 +426,14 @@ export class BrowsingContextProcessor {
   }
 
   #workers = new Map<string, Realm>();
-  #handleWorkerTarget(cdpTarget: CdpTarget) {
+  #handleWorkerTarget(cdpTarget: CdpTarget, browsingContextId: string) {
     cdpTarget.cdpClient.on('Runtime.executionContextCreated', (params) => {
       const {uniqueId, id, origin} = params.context;
       const realm = new Realm(
         this.#realmStorage,
         this.#browsingContextStorage,
         uniqueId,
-        cdpTarget.targetId,
+        browsingContextId,
         id,
         serializeOrigin(origin),
         'dedicated-worker',
@@ -439,9 +449,9 @@ export class BrowsingContextProcessor {
   #handleDetachedFromTargetEvent(
     params: Protocol.Target.DetachedFromTargetEvent
   ) {
-    const context = this.#browsingContextStorage
-      .getAllContexts()
-      .find((context) => context.cdpTarget.cdpSessionId === params.sessionId);
+    const context = this.#browsingContextStorage.findContextBySession(
+      params.sessionId
+    );
     if (context) {
       context.dispose();
       this.#preloadScriptStorage

src/bidiMapper/domains/context/BrowsingContextStorage.ts

@@ -84,6 +84,15 @@ export class BrowsingContextStorage {
     return this.findTopLevelContextId(parentId);
   }
 
+  findContextBySession(sessionId: string): BrowsingContextImpl | undefined {
+    for (const context of this.#contexts.values()) {
+      if (context.cdpTarget.cdpSessionId === sessionId) {
+        return context;
+      }
+    }
+    return;
+  }
+
   /** Gets the context with the given ID, if any, otherwise throws. */
   getContext(id: BrowsingContext.BrowsingContext): BrowsingContextImpl {
     const result = this.findContext(id);

src/bidiMapper/domains/script/Realm.ts

@@ -224,8 +224,10 @@ export class Realm {
 
   get navigableId(): string {
     return (
-      this.#browsingContextStorage.findContext(this.#browsingContextId)
-        ?.navigableId ?? 'UNKNOWN'
+      (this.browsingContextId &&
+        this.#browsingContextStorage.findContext(this.browsingContextId)
+          ?.navigableId) ??
+      'UNKNOWN'
     );
   }
 
@@ -250,13 +252,22 @@ export class Realm {
   }
 
   get realmInfo(): Script.RealmInfo {
-    return {
-      realm: this.realmId,
-      origin: this.origin,
-      type: this.type,
-      context: this.browsingContextId,
-      ...(this.sandbox === undefined ? {} : {sandbox: this.sandbox}),
-    };
+    switch (this.type) {
+      case 'window':
+        return {
+          realm: this.realmId,
+          origin: this.origin,
+          type: this.type,
+          context: this.browsingContextId,
+          ...(this.sandbox === undefined ? {} : {sandbox: this.sandbox}),
+        };
+      default:
+        return {
+          realm: this.realmId,
+          origin: this.origin,
+          type: this.type,
+        };
+    }
   }
 
   async evaluate(

tests/script/__snapshots__/test_evaluate.ambr

@@ -0,0 +1,10 @@
+# serializer version: 1
+# name: test_scriptEvaluate_dedicated_worker[websocket0]
+  dict({
+    'result': dict({
+      'type': 'string',
+      'value': 'hello world',
+    }),
+    'type': 'success',
+  })
+# ---

tests/script/test_evaluate.py

@@ -16,7 +16,9 @@
 
 import pytest
 from anys import ANY_STR
-from test_helpers import execute_command, get_tree
+from syrupy.filters import props
+from test_helpers import (execute_command, get_tree, send_JSON_command,
+                          subscribe, wait_for_command, wait_for_event)
 
 
 @pytest.mark.asyncio
@@ -395,3 +397,63 @@ async def test_scriptEvaluate_realm(websocket, context_id):
         "exceptionDetails": ANY,
         "realm": realm
     } == result
+
+
+@pytest.mark.asyncio
+async def test_scriptEvaluate_dedicated_worker(websocket, context_id, html,
+                                               snapshot):
+    worker_url = 'data:application/javascript,'
+    url = html(f"<script>window.w = new Worker('{worker_url}');</script>")
+
+    await subscribe(websocket, ["script.realmCreated"])
+
+    await send_JSON_command(
+        websocket, {
+            "method": "browsingContext.navigate",
+            "params": {
+                "context": context_id,
+                "url": url,
+                "wait": "complete",
+            }
+        })
+
+    # Wait for worker to be created
+    while True:
+        message = await wait_for_event(websocket, "script.realmCreated")
+        if message["params"] == {
+                "realm": ANY_STR,
+                "origin": worker_url,
+                "type": "dedicated-worker"
+        }:
+            realm = message["params"]["realm"]
+            break
+
+    # Set up a listener on the page.
+    command_id = await send_JSON_command(
+        websocket, {
+            "method": "script.evaluate",
+            "params": {
+                "target": {
+                    "context": context_id
+                },
+                "expression": "new Promise(resolve => window.w.addEventListener('message', ({data}) => resolve(data), {once: true}))",
+                "awaitPromise": True
+            }
+        })
+
+    # Post a message from the worker.
+    await send_JSON_command(
+        websocket, {
+            "method": "script.evaluate",
+            "params": {
+                "target": {
+                    "realm": realm
+                },
+                "expression": "self.postMessage('hello world')",
+                "awaitPromise": True
+            }
+        })
+
+    # Check the promise
+    assert await wait_for_command(
+        websocket, command_id) == snapshot(exclude=props("realm"))

tests/script/test_realm.py

@@ -152,7 +152,7 @@ async def test_realm_realmDestroyed_sandbox(websocket, context_id):
 
 
 @pytest.mark.asyncio
-async def test_realm_worker(websocket, context_id, html):
+async def test_realm_dedicated_worker(websocket, context_id, html):
     worker_url = 'data:application/javascript,while(true){}'
     url = html(f"<script>window.w = new Worker('{worker_url}');</script>")
 
@@ -175,7 +175,6 @@ async def test_realm_worker(websocket, context_id, html):
         if message["params"] == {
                 "realm": ANY_STR,
                 "origin": worker_url,
-                "context": ANY_STR,
                 "type": "dedicated-worker"
         }:
             realm = message["params"]["realm"]

tests/test_helpers.py

@@ -79,10 +79,14 @@ async def execute_command(websocket, command: dict) -> dict:
     logger.info(
         f"Executing command with method '{command['method']}' and params '{command['params']}'..."
     )
+    return await wait_for_command(websocket, command["id"])
+
+
+async def wait_for_command(websocket, command_id: int) -> dict:
     while True:
         # Wait for the command to be finished.
         resp = await read_JSON_message(websocket)
-        if "id" in resp and resp["id"] == command["id"]:
+        if "id" in resp and resp["id"] == command_id:
             if "result" in resp:
                 return resp["result"]
             raise Exception({