Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

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

Dmitry Gozman3089df794402
diff --git a/docs/src/api/class-worker.md b/docs/src/api/class-worker.md
index fe69a84248..fa7beeda17 100644
--- a/docs/src/api/class-worker.md
+++ b/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
diff --git a/packages/playwright-client/types/types.d.ts b/packages/playwright-client/types/types.d.ts
index b2d81ca90d..2e5274cd5d 100644
--- a/packages/playwright-client/types/types.d.ts
+++ b/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>;
+
}
/**
diff --git a/packages/playwright-core/src/client/browserContext.ts b/packages/playwright-core/src/client/browserContext.ts
index 9f97260f97..c325387467 100644
--- a/packages/playwright-core/src/client/browserContext.ts
+++ b/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);
diff --git a/packages/playwright-core/src/client/events.ts b/packages/playwright-core/src/client/events.ts
index 41544b8c35..cede73640c 100644
--- a/packages/playwright-core/src/client/events.ts
+++ b/packages/playwright-core/src/client/events.ts
@@ -87,6 +87,7 @@ export const Events = {
Worker: {
Close: 'close',
+ Console: 'console',
},
ElectronApplication: {
diff --git a/packages/playwright-core/src/client/worker.ts b/packages/playwright-core/src/client/worker.ts
index 5a5a5fe246..fdca07b520 100644
--- a/packages/playwright-core/src/client/worker.ts
+++ b/packages/playwright-core/src/client/worker.ts
@@ -19,12 +19,15 @@ 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 {
@@ -32,6 +35,10 @@ export class Worker extends ChannelOwner<channels.WorkerChannel> implements api.
_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;
+ });
+ }
}
diff --git a/packages/playwright-core/src/protocol/validator.ts b/packages/playwright-core/src/protocol/validator.ts
index 7c0622a3f9..81bb78cdb7 100644
--- a/packages/playwright-core/src/protocol/validator.ts
+++ b/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,
});
diff --git a/packages/playwright-core/src/server/bidi/bidiPage.ts b/packages/playwright-core/src/server/bidi/bidiPage.ts
index 9041469d57..d46623448d 100644
--- a/packages/playwright-core/src/server/bidi/bidiPage.ts
+++ b/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> {
diff --git a/packages/playwright-core/src/server/chromium/crPage.ts b/packages/playwright-core/src/server/chromium/crPage.ts
index 716ce51c8f..e29da41156 100644
--- a/packages/playwright-core/src/server/chromium/crPage.ts
+++ b/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);
}
}
diff --git a/packages/playwright-core/src/server/console.ts b/packages/playwright-core/src/server/console.ts
index 383b49fc82..cc0c60317f 100644
--- a/packages/playwright-core/src/server/console.ts
+++ b/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;
}
diff --git a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
index b2bf606a18..49e9560c03 100644
--- a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
+++ b/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),
});
}
diff --git a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
index 4075201661..1d460c6472 100644
--- a/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/pageDispatcher.ts
@@ -414,6 +414,9 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
export class WorkerDispatcher extends Dispatcher<Worker, channels.WorkerChannel, PageDispatcher | BrowserContextDispatcher> implements channels.WorkerChannel {
_type_Worker = true;
+ _type_EventTarget = true;
+
+ readonly _subscriptions = new Set<channels.WorkerUpdateSubscriptionParams['event']>();
static fromNullable(scope: PageDispatcher | BrowserContextDispatcher, worker: Worker | null): WorkerDispatcher | undefined {
if (!worker)
@@ -436,6 +439,13 @@ export class WorkerDispatcher extends Dispatcher<Worker, channels.WorkerChannel,
async evaluateExpressionHandle(params: channels.WorkerEvaluateExpressionHandleParams, progress: Progress): Promise<channels.WorkerEvaluateExpressionHandleResult> {
return { handle: JSHandleDispatcher.fromJSHandle(this, await progress.race(this._object.evaluateExpressionHandle(params.expression, params.isFunction, parseArgument(params.arg)))) };
}
+
+ async updateSubscription(params: channels.WorkerUpdateSubscriptionParams, progress: Progress): Promise<void> {
+ if (params.enabled)
+ this._subscriptions.add(params.event);
+ else
+ this._subscriptions.delete(params.event);
+ }
}
export class BindingCallDispatcher extends Dispatcher<SdkObject, channels.BindingCallChannel, PageDispatcher | BrowserContextDispatcher> implements channels.BindingCallChannel {
diff --git a/packages/playwright-core/src/server/electron/electron.ts b/packages/playwright-core/src/server/electron/electron.ts
index 8a341743bd..aab06be4c8 100644
--- a/packages/playwright-core/src/server/electron/electron.ts
+++ b/packages/playwright-core/src/server/electron/electron.ts
@@ -114,7 +114,7 @@ export class ElectronApplication extends SdkObject {
if (!this._nodeExecutionContext)
return;
const args = event.args.map(arg => createHandle(this._nodeExecutionContext!, arg));
- const message = new ConsoleMessage(null, event.type, undefined, args, toConsoleMessageLocation(event.stackTrace));
+ const message = new ConsoleMessage(null, null, event.type, undefined, args, toConsoleMessageLocation(event.stackTrace));
this.emit(ElectronApplication.Events.Console, message);
}
diff --git a/packages/playwright-core/src/server/firefox/ffPage.ts b/packages/playwright-core/src/server/firefox/ffPage.ts
index 3f5fbc2b28..c06611be98 100644
--- a/packages/playwright-core/src/server/firefox/ffPage.ts
+++ b/packages/playwright-core/src/server/firefox/ffPage.ts
@@ -231,7 +231,7 @@ export class FFPage implements PageDelegate {
if (!context)
return;
// Juggler reports 'warn' for some internal messages generated by the browser.
- this._page.addConsoleMessage(type === 'warn' ? 'warning' : type, args.map(arg => createHandle(context, arg)), location);
+ this._page.addConsoleMessage(null, type === 'warn' ? 'warning' : type, args.map(arg => createHandle(context, arg)), location);
}
_onDialogOpened(params: Protocol.Page.dialogOpenedPayload) {
@@ -284,7 +284,7 @@ export class FFPage implements PageDelegate {
workerSession.on('Runtime.console', event => {
const { type, args, location } = event;
const context = worker.existingExecutionContext!;
- this._page.addConsoleMessage(type, args.map(arg => createHandle(context, arg)), location);
+ this._page.addConsoleMessage(worker, type, args.map(arg => createHandle(context, arg)), location);
});
// Note: we receive worker exceptions directly from the page.
}
diff --git a/packages/playwright-core/src/server/page.ts b/packages/playwright-core/src/server/page.ts
index ae67a847d8..d966151141 100644
--- a/packages/playwright-core/src/server/page.ts
+++ b/packages/playwright-core/src/server/page.ts
@@ -361,8 +361,8 @@ export class Page extends SdkObject {
await PageBinding.dispatch(this, payload, context);
}
- addConsoleMessage(type: string, args: js.JSHandle[], location: types.ConsoleMessageLocation, text?: string) {
- const message = new ConsoleMessage(this, type, text, args, location);
+ addConsoleMessage(worker: Worker | null, type: string, args: js.JSHandle[], location: types.ConsoleMessageLocation, text?: string) {
+ const message = new ConsoleMessage(this, worker, type, text, args, location);
const intercepted = this.frameManager.interceptConsoleMessage(message);
if (intercepted) {
args.forEach(arg => arg.dispose());
diff --git a/packages/playwright-core/src/server/webkit/wkPage.ts b/packages/playwright-core/src/server/webkit/wkPage.ts
index 7e4350b99c..cd96f8d54c 100644
--- a/packages/playwright-core/src/server/webkit/wkPage.ts
+++ b/packages/playwright-core/src/server/webkit/wkPage.ts
@@ -582,7 +582,7 @@ export class WKPage implements PageDelegate {
location
} = this._lastConsoleMessage;
for (let i = count; i < event.count; ++i)
- this._page.addConsoleMessage(derivedType, handles, location, handles.length ? undefined : text);
+ this._page.addConsoleMessage(null, derivedType, handles, location, handles.length ? undefined : text);
this._lastConsoleMessage.count = event.count;
}
}
diff --git a/packages/playwright-core/src/server/webkit/wkWorkers.ts b/packages/playwright-core/src/server/webkit/wkWorkers.ts
index 71f06e2c9f..6381b3d9d6 100644
--- a/packages/playwright-core/src/server/webkit/wkWorkers.ts
+++ b/packages/playwright-core/src/server/webkit/wkWorkers.ts
@@ -103,6 +103,6 @@ export class WKWorkers {
lineNumber: (lineNumber || 1) - 1,
columnNumber: (columnNumber || 1) - 1
};
- this._page.addConsoleMessage(derivedType, handles, location, handles.length ? undefined : text);
+ this._page.addConsoleMessage(worker, derivedType, handles, location, handles.length ? undefined : text);
}
}
diff --git a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
index 37b1d32823..3b85ae2eea 100644
--- a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
+++ b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
@@ -62,6 +62,7 @@ export const methodMetainfo = new Map<string, { internal?: boolean, title?: stri
['EventTarget.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
['BrowserContext.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
['Page.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
+ ['Worker.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
['WebSocket.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
['ElectronApplication.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
['AndroidDevice.waitForEventInfo', { title: 'Wait for event "{info.event}"', snapshot: true, }],
@@ -186,6 +187,7 @@ export const methodMetainfo = new Map<string, { internal?: boolean, title?: stri
['Frame.expect', { title: 'Expect "{expression}"', snapshot: true, pausesBeforeAction: true, }],
['Worker.evaluateExpression', { title: 'Evaluate', }],
['Worker.evaluateExpressionHandle', { title: 'Evaluate', }],
+ ['Worker.updateSubscription', { internal: true, }],
['JSHandle.dispose', { internal: true, }],
['ElementHandle.dispose', { internal: true, }],
['JSHandle.evaluateExpression', { title: 'Evaluate', snapshot: true, pausesBeforeAction: true, }],
diff --git a/packages/playwright-core/types/types.d.ts b/packages/playwright-core/types/types.d.ts
index b2d81ca90d..2e5274cd5d 100644
--- a/packages/playwright-core/types/types.d.ts
+++ b/packages/playwright-core/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>;
+
}
/**
diff --git a/packages/protocol/src/channels.d.ts b/packages/protocol/src/channels.d.ts
index 96946db478..ce94be4aaf 100644
--- a/packages/protocol/src/channels.d.ts
+++ b/packages/protocol/src/channels.d.ts
@@ -1622,7 +1622,8 @@ export type BrowserContextConsoleEvent = {
lineNumber: number,
columnNumber: number,
},
- page: PageChannel,
+ page?: PageChannel,
+ worker?: WorkerChannel,
};
export type BrowserContextCloseEvent = {};
export type BrowserContextDialogEvent = {
@@ -3277,10 +3278,11 @@ export type WorkerInitializer = {
export interface WorkerEventTarget {
on(event: 'close', callback: (params: WorkerCloseEvent) => void): this;
}
-export interface WorkerChannel extends WorkerEventTarget, Channel {
+export interface WorkerChannel extends WorkerEventTarget, EventTargetChannel {
_type_Worker: boolean;
evaluateExpression(params: WorkerEvaluateExpressionParams, progress?: Progress): Promise<WorkerEvaluateExpressionResult>;
evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, progress?: Progress): Promise<WorkerEvaluateExpressionHandleResult>;
+ updateSubscription(params: WorkerUpdateSubscriptionParams, progress?: Progress): Promise<WorkerUpdateSubscriptionResult>;
}
export type WorkerCloseEvent = {};
export type WorkerEvaluateExpressionParams = {
@@ -3305,6 +3307,14 @@ export type WorkerEvaluateExpressionHandleOptions = {
export type WorkerEvaluateExpressionHandleResult = {
handle: JSHandleChannel,
};
+export type WorkerUpdateSubscriptionParams = {
+ event: 'console',
+ enabled: boolean,
+};
+export type WorkerUpdateSubscriptionOptions = {
+
+};
+export type WorkerUpdateSubscriptionResult = void;
export interface WorkerEvents {
'close': WorkerCloseEvent;
diff --git a/packages/protocol/src/protocol.yml b/packages/protocol/src/protocol.yml
index 786090a086..dab1ea1cd1 100644
--- a/packages/protocol/src/protocol.yml
+++ b/packages/protocol/src/protocol.yml
@@ -1442,7 +1442,8 @@ BrowserContext:
console:
parameters:
$mixin: ConsoleMessage
- page: Page
+ page: Page?
+ worker: Worker?
close:
@@ -2781,6 +2782,8 @@ Frame:
Worker:
type: interface
+ extends: EventTarget
+
initializer:
url: string
@@ -2804,6 +2807,15 @@ Worker:
returns:
handle: JSHandle
+ updateSubscription:
+ internal: true
+ parameters:
+ event:
+ type: enum
+ literals:
+ - console
+ enabled: boolean
+
events:
close:
diff --git a/tests/page/workers.spec.ts b/tests/page/workers.spec.ts
index 7db80de3b4..6035e8524d 100644
--- a/tests/page/workers.spec.ts
+++ b/tests/page/workers.spec.ts
@@ -90,6 +90,26 @@ it('should evaluate', async function({ page }) {
expect(await worker.evaluate('1+1')).toBe(2);
});
+it('should report console event on the worker', async function({ page }) {
+ const [worker] = await Promise.all([
+ page.waitForEvent('worker'),
+ page.evaluate(() => {
+ (window as any).worker = new Worker(URL.createObjectURL(new Blob(['42'], { type: 'application/javascript' })));
+ }),
+ ]);
+ const [message1, message2, message3] = await Promise.all([
+ worker.waitForEvent('console'),
+ page.waitForEvent('console'),
+ page.context().waitForEvent('console'),
+ worker.evaluate(() => {
+ console.log('hello from worker');
+ }),
+ ]);
+ expect(message1.text()).toBe('hello from worker');
+ expect(message1).toBe(message2);
+ expect(message1).toBe(message3);
+});
+
it('should report errors', async function({ page }) {
const errorPromise = new Promise<Error>(x => page.on('pageerror', x));
await page.evaluate(() => new Worker(URL.createObjectURL(new Blob([`