feat: worker.on('console') event for web workers (#38201)

Author: dgozman

docs/src/api/class-worker.md

@@ -58,6 +58,12 @@ foreach(var pageWorker in page.Workers)
 
 Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is terminated.
 
+## event: Worker.console
+* since: v1.57
+- argument: <[ConsoleMessage]>
+
+Emitted when JavaScript within the Web Worker calls one of console API methods, e.g. `console.log` or `console.dir`. Console is not supported for Service Workers.
+
 ## async method: Worker.evaluate
 * since: v1.8
 - returns: <[Serializable]>
@@ -123,3 +129,58 @@ Performs action and waits for the Worker to close.
 
 ### param: Worker.waitForClose.callback = %%-java-wait-for-event-callback-%%
 * since: v1.9
+
+## async method: Worker.waitForEvent
+* since: v1.57
+* langs: js, python
+  - alias-python: expect_event
+- returns: <[any]>
+
+Waits for event to fire and passes its value into the predicate function.
+Returns when the predicate returns truthy value.
+Will throw an error if the page is closed before the event is fired.
+Returns the event data value.
+
+**Usage**
+
+```js
+// Start waiting for download before clicking. Note no await.
+const consolePromise = worker.waitForEvent('console');
+await worker.evaluate('console.log(42)');
+const consoleMessage = await consolePromise;
+```
+
+```python async
+async with worker.expect_event("console") as event_info:
+    await worker.evaluate("console.log(42)")
+message = await event_info.value
+```
+
+```python sync
+with worker.expect_event("console") as event_info:
+    worker.evaluate("console.log(42)")
+message = event_info.value
+```
+
+## async method: Worker.waitForEvent
+* since: v1.57
+* langs: python
+- returns: <[EventContextManager]>
+
+### param: Worker.waitForEvent.event = %%-wait-for-event-event-%%
+* since: v1.57
+
+### param: Worker.waitForEvent.optionsOrPredicate
+* since: v1.57
+* langs: js
+- `optionsOrPredicate` ?<[function]|[Object]>
+  - `predicate` <[function]> Receives the event data and resolves to truthy value when the waiting should resolve.
+  - `timeout` ?<[float]> Maximum time to wait for in milliseconds. Defaults to `0` - no timeout. The default value can be changed via `actionTimeout` option in the config, or by using the [`method: BrowserContext.setDefaultTimeout`] or [`method: Page.setDefaultTimeout`] methods.
+
+Either a predicate that receives an event or an options object. Optional.
+
+### option: Worker.waitForEvent.predicate = %%-wait-for-event-predicate-%%
+* since: v1.57
+
+### option: Worker.waitForEvent.timeout = %%-wait-for-event-timeout-%%
+* since: v1.57

packages/playwright-client/types/types.d.ts

@@ -10330,34 +10330,80 @@ export interface Worker {
    */
   on(event: 'close', listener: (worker: Worker) => any): this;
 
+  /**
+   * Emitted when JavaScript within the Web Worker calls one of console API methods, e.g. `console.log` or
+   * `console.dir`. Console is not supported for Service Workers.
+   */
+  on(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+
   /**
    * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
    */
   once(event: 'close', listener: (worker: Worker) => any): this;
 
+  /**
+   * Adds an event listener that will be automatically removed after it is triggered once. See `addListener` for more information about this event.
+   */
+  once(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+
   /**
    * Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
    * terminated.
    */
   addListener(event: 'close', listener: (worker: Worker) => any): this;
 
+  /**
+   * Emitted when JavaScript within the Web Worker calls one of console API methods, e.g. `console.log` or
+   * `console.dir`. Console is not supported for Service Workers.
+   */
+  addListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+
   /**
    * Removes an event listener added by `on` or `addListener`.
    */
   removeListener(event: 'close', listener: (worker: Worker) => any): this;
 
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  removeListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+
   /**
    * Removes an event listener added by `on` or `addListener`.
    */
   off(event: 'close', listener: (worker: Worker) => any): this;
 
+  /**
+   * Removes an event listener added by `on` or `addListener`.
+   */
+  off(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+
   /**
    * Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
    * terminated.
    */
   prependListener(event: 'close', listener: (worker: Worker) => any): this;
 
+  /**
+   * Emitted when JavaScript within the Web Worker calls one of console API methods, e.g. `console.log` or
+   * `console.dir`. Console is not supported for Service Workers.
+   */
+  prependListener(event: 'console', listener: (consoleMessage: ConsoleMessage) => any): this;
+
   url(): string;
+
+  /**
+   * Emitted when this dedicated [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API) is
+   * terminated.
+   */
+  waitForEvent(event: 'close', optionsOrPredicate?: { predicate?: (worker: Worker) => boolean | Promise<boolean>, timeout?: number } | ((worker: Worker) => boolean | Promise<boolean>)): Promise<Worker>;
+
+  /**
+   * Emitted when JavaScript within the Web Worker calls one of console API methods, e.g. `console.log` or
+   * `console.dir`. Console is not supported for Service Workers.
+   */
+  waitForEvent(event: 'console', optionsOrPredicate?: { predicate?: (consoleMessage: ConsoleMessage) => boolean | Promise<boolean>, timeout?: number } | ((consoleMessage: ConsoleMessage) => boolean | Promise<boolean>)): Promise<ConsoleMessage>;
+
 }
 
 /**

packages/playwright-core/src/client/browserContext.ts

@@ -109,10 +109,9 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
     });
     this._channel.on('console', event => {
       const consoleMessage = new ConsoleMessage(this._platform, event, Page.fromNullable(event.page));
+      Worker.fromNullable(event.worker)?.emit(Events.Worker.Console, consoleMessage);
+      consoleMessage.page()?.emit(Events.Page.Console, consoleMessage);
       this.emit(Events.BrowserContext.Console, consoleMessage);
-      const page = consoleMessage.page();
-      if (page)
-        page.emit(Events.Page.Console, consoleMessage);
     });
     this._channel.on('pageError', ({ error, page }) => {
       const pageObject = Page.from(page);

packages/playwright-core/src/client/events.ts

@@ -87,6 +87,7 @@ export const Events = {
 
   Worker: {
     Close: 'close',
+    Console: 'console',
   },
 
   ElectronApplication: {

packages/playwright-core/src/client/worker.ts

@@ -19,19 +19,26 @@ import { TargetClosedError } from './errors';
 import { Events } from './events';
 import { JSHandle, assertMaxArguments, parseResult, serializeArgument } from './jsHandle';
 import { LongStandingScope } from '../utils/isomorphic/manualPromise';
+import { TimeoutSettings } from './timeoutSettings';
+import { Waiter } from './waiter';
 
 import type { BrowserContext } from './browserContext';
 import type { Page } from './page';
 import type * as structs from '../../types/structs';
 import type * as api from '../../types/types';
 import type * as channels from '@protocol/channels';
+import type { WaitForEventOptions } from './types';
 
 
 export class Worker extends ChannelOwner<channels.WorkerChannel> implements api.Worker {
   _page: Page | undefined;  // Set for web workers.
   _context: BrowserContext | undefined;  // Set for service workers.
   readonly _closedScope = new LongStandingScope();
 
+  static fromNullable(worker: channels.WorkerChannel | undefined): Worker | null {
+    return worker ? Worker.from(worker) : null;
+  }
+
   static from(worker: channels.WorkerChannel): Worker {
     return (worker as any)._object;
   }
@@ -63,4 +70,19 @@ export class Worker extends ChannelOwner<channels.WorkerChannel> implements api.
     const result = await this._channel.evaluateExpressionHandle({ expression: String(pageFunction), isFunction: typeof pageFunction === 'function', arg: serializeArgument(arg) });
     return JSHandle.from(result.handle) as any as structs.SmartHandle<R>;
   }
+
+  async waitForEvent(event: string, optionsOrPredicate: WaitForEventOptions = {}): Promise<any> {
+    return await this._wrapApiCall(async () => {
+      const timeoutSettings = this._page?._timeoutSettings ?? this._context?._timeoutSettings ?? new TimeoutSettings(this._platform);
+      const timeout = timeoutSettings.timeout(typeof optionsOrPredicate === 'function' ? {} : optionsOrPredicate);
+      const predicate = typeof optionsOrPredicate === 'function' ? optionsOrPredicate : optionsOrPredicate.predicate;
+      const waiter = Waiter.createForEvent(this, event);
+      waiter.rejectOnTimeout(timeout, `Timeout ${timeout}ms exceeded while waiting for event "${event}"`);
+      if (event !== Events.Worker.Close)
+        waiter.rejectOnEvent(this, Events.Worker.Close, () => new TargetClosedError());
+      const result = await waiter.waitForEvent(this, event, predicate as any);
+      waiter.dispose();
+      return result;
+    });
+  }
 }

packages/playwright-core/src/protocol/validator.ts

@@ -810,12 +810,14 @@ scheme.EventTargetWaitForEventInfoParams = tObject({
 });
 scheme.BrowserContextWaitForEventInfoParams = tType('EventTargetWaitForEventInfoParams');
 scheme.PageWaitForEventInfoParams = tType('EventTargetWaitForEventInfoParams');
+scheme.WorkerWaitForEventInfoParams = tType('EventTargetWaitForEventInfoParams');
 scheme.WebSocketWaitForEventInfoParams = tType('EventTargetWaitForEventInfoParams');
 scheme.ElectronApplicationWaitForEventInfoParams = tType('EventTargetWaitForEventInfoParams');
 scheme.AndroidDeviceWaitForEventInfoParams = tType('EventTargetWaitForEventInfoParams');
 scheme.EventTargetWaitForEventInfoResult = tOptional(tObject({}));
 scheme.BrowserContextWaitForEventInfoResult = tType('EventTargetWaitForEventInfoResult');
 scheme.PageWaitForEventInfoResult = tType('EventTargetWaitForEventInfoResult');
+scheme.WorkerWaitForEventInfoResult = tType('EventTargetWaitForEventInfoResult');
 scheme.WebSocketWaitForEventInfoResult = tType('EventTargetWaitForEventInfoResult');
 scheme.ElectronApplicationWaitForEventInfoResult = tType('EventTargetWaitForEventInfoResult');
 scheme.AndroidDeviceWaitForEventInfoResult = tType('EventTargetWaitForEventInfoResult');
@@ -894,7 +896,8 @@ scheme.BrowserContextConsoleEvent = tObject({
     lineNumber: tInt,
     columnNumber: tInt,
   }),
-  page: tChannel(['Page']),
+  page: tOptional(tChannel(['Page'])),
+  worker: tOptional(tChannel(['Worker'])),
 });
 scheme.BrowserContextCloseEvent = tOptional(tObject({}));
 scheme.BrowserContextDialogEvent = tObject({
@@ -1914,6 +1917,11 @@ scheme.WorkerEvaluateExpressionHandleParams = tObject({
 scheme.WorkerEvaluateExpressionHandleResult = tObject({
   handle: tChannel(['ElementHandle', 'JSHandle']),
 });
+scheme.WorkerUpdateSubscriptionParams = tObject({
+  event: tEnum(['console']),
+  enabled: tBoolean,
+});
+scheme.WorkerUpdateSubscriptionResult = tOptional(tObject({}));
 scheme.JSHandleInitializer = tObject({
   preview: tString,
 });

packages/playwright-core/src/server/bidi/bidiPage.ts

@@ -286,7 +286,7 @@ export class BidiPage implements PageDelegate {
 
     const callFrame = params.stackTrace?.callFrames[0];
     const location = callFrame ?? { url: '', lineNumber: 1, columnNumber: 1 };
-    this._page.addConsoleMessage(entry.method, entry.args.map(arg => createHandle(context, arg)), location, params.text || undefined);
+    this._page.addConsoleMessage(null, entry.method, entry.args.map(arg => createHandle(context, arg)), location, params.text || undefined);
   }
 
   async navigateFrame(frame: frames.Frame, url: string, referrer: string | undefined): Promise<frames.GotoResult> {

packages/playwright-core/src/server/chromium/crPage.ts

@@ -759,7 +759,7 @@ class FrameSession {
     session.on('Target.detachedFromTarget', event => this._onDetachedFromTarget(event));
     session.on('Runtime.consoleAPICalled', event => {
       const args = event.args.map(o => createHandle(worker.existingExecutionContext!, o));
-      this._page.addConsoleMessage(event.type, args, toConsoleMessageLocation(event.stackTrace));
+      this._page.addConsoleMessage(worker, event.type, args, toConsoleMessageLocation(event.stackTrace));
     });
     session.on('Runtime.exceptionThrown', exception => this._page.addPageError(exceptionToError(exception.exceptionDetails)));
   }
@@ -822,7 +822,7 @@ class FrameSession {
     if (!context)
       return;
     const values = event.args.map(arg => createHandle(context, arg));
-    this._page.addConsoleMessage(event.type, values, toConsoleMessageLocation(event.stackTrace));
+    this._page.addConsoleMessage(null, event.type, values, toConsoleMessageLocation(event.stackTrace));
   }
 
   async _onBindingCalled(event: Protocol.Runtime.bindingCalledPayload) {
@@ -869,7 +869,7 @@ class FrameSession {
         lineNumber: lineNumber || 0,
         columnNumber: 0,
       };
-      this._page.addConsoleMessage(level, [], location, text);
+      this._page.addConsoleMessage(null, level, [], location, text);
     }
   }
 

packages/playwright-core/src/server/console.ts

@@ -15,7 +15,7 @@
  */
 
 import type * as js from './javascript';
-import type { Page } from './page';
+import type { Page, Worker } from './page';
 import type { ConsoleMessageLocation } from './types';
 
 export class ConsoleMessage {
@@ -24,9 +24,11 @@ export class ConsoleMessage {
   private _args: js.JSHandle[];
   private _location: ConsoleMessageLocation;
   private _page: Page | null;
+  private _worker: Worker | null;
 
-  constructor(page: Page | null, type: string, text: string | undefined, args: js.JSHandle[], location?: ConsoleMessageLocation) {
+  constructor(page: Page | null, worker: Worker | null, type: string, text: string | undefined, args: js.JSHandle[], location?: ConsoleMessageLocation) {
     this._page = page;
+    this._worker = worker;
     this._type = type;
     this._text = text;
     this._args = args;
@@ -37,6 +39,10 @@ export class ConsoleMessage {
     return this._page;
   }
 
+  worker() {
+    return this._worker;
+  }
+
   type(): string {
     return this._type;
   }

packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts

@@ -120,10 +120,12 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
     });
     this.addObjectListener(BrowserContext.Events.Console, (message: ConsoleMessage) => {
       const page = message.page()!;
-      if (this._shouldDispatchEvent(page, 'console')) {
+      const workerDispatcher = WorkerDispatcher.fromNullable(this, message.worker());
+      if (this._shouldDispatchEvent(page, 'console') || workerDispatcher?._subscriptions.has('console')) {
         const pageDispatcher = PageDispatcher.from(this, page);
         this._dispatchEvent('console', {
           page: pageDispatcher,
+          worker: workerDispatcher,
           ...pageDispatcher.serializeConsoleMessage(message),
         });
       }