Skip to content

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

fix(recorder): split showRecorder and startRecording, deliver events per client (#42627)

Pavel Feldman4302dbb90f65
diff --git a/packages/isomorphic/protocolMetainfo.ts b/packages/isomorphic/protocolMetainfo.ts
index 5da32305cd..102877079e 100644
--- a/packages/isomorphic/protocolMetainfo.ts
+++ b/packages/isomorphic/protocolMetainfo.ts
@@ -94,8 +94,9 @@ export const methodMetainfo = new Map<string, MethodMetainfo>([
['BrowserContext.storageState', { title: 'Get storage state', group: 'configuration', }],
['BrowserContext.setStorageState', { title: 'Set storage state', group: 'configuration', }],
['BrowserContext.pause', { title: 'Pause', }],
- ['BrowserContext.enableRecorder', { internal: true, }],
- ['BrowserContext.disableRecorder', { internal: true, }],
+ ['BrowserContext.showRecorder', { internal: true, }],
+ ['BrowserContext.startRecording', { internal: true, }],
+ ['BrowserContext.stopRecording', { internal: true, }],
['BrowserContext.exposeConsoleApi', { internal: true, }],
['BrowserContext.newCDPSession', { title: 'Create CDP session', group: 'configuration', }],
['BrowserContext.createTempFiles', { internal: true, }],
diff --git a/packages/playwright-core/src/cli/browserActions.ts b/packages/playwright-core/src/cli/browserActions.ts
index 741cc6293c..552abb9063 100644
--- a/packages/playwright-core/src/cli/browserActions.ts
+++ b/packages/playwright-core/src/cli/browserActions.ts
@@ -258,7 +258,7 @@ export async function codegen(options: Options & { target: string, output?: stri
const donePromise = new ManualPromise<void>();
maybeSetupTestHooks(browser, closeBrowser, donePromise);
dotenv.config({ path: 'playwright.env', quiet: true });
- await context._enableRecorder({
+ await context._showRecorder({
language,
launchOptions,
contextOptions,
diff --git a/packages/playwright-core/src/client/browserContext.ts b/packages/playwright-core/src/client/browserContext.ts
index 3d3614a00d..8d747e38a9 100644
--- a/packages/playwright-core/src/client/browserContext.ts
+++ b/packages/playwright-core/src/client/browserContext.ts
@@ -538,15 +538,18 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
throw harError;
}
- async _enableRecorder(params: channels.BrowserContextEnableRecorderParams, eventSink?: RecorderEventSink) {
- if (eventSink)
- this._onRecorderEventSink = eventSink;
- await this._channel.enableRecorder(params, kNoTimeout);
+ async _showRecorder(params: channels.BrowserContextShowRecorderParams) {
+ await this._channel.showRecorder(params, kNoTimeout);
}
- async _disableRecorder() {
+ async _startRecording(params: channels.BrowserContextStartRecordingParams, eventSink: RecorderEventSink) {
+ this._onRecorderEventSink = eventSink;
+ await this._channel.startRecording(params, kNoTimeout);
+ }
+
+ async _stopRecording() {
try {
- await this._channel.disableRecorder({}, kNoTimeout);
+ await this._channel.stopRecording({}, kNoTimeout);
} finally {
this._onRecorderEventSink = undefined;
}
diff --git a/packages/playwright-core/src/client/channels.d.ts b/packages/playwright-core/src/client/channels.d.ts
index aecf4c95c1..3d0223a2dd 100644
--- a/packages/playwright-core/src/client/channels.d.ts
+++ b/packages/playwright-core/src/client/channels.d.ts
@@ -1246,8 +1246,9 @@ export interface BrowserContextChannel extends BrowserContextEventTarget, Channe
storageState(params: BrowserContextStorageStateParams, options: TimeoutOptions): Promise<BrowserContextStorageStateResult>;
setStorageState(params: BrowserContextSetStorageStateParams, options: TimeoutOptions): Promise<BrowserContextSetStorageStateResult>;
pause(params: BrowserContextPauseParams, options: TimeoutOptions): Promise<BrowserContextPauseResult>;
- enableRecorder(params: BrowserContextEnableRecorderParams, options: TimeoutOptions): Promise<BrowserContextEnableRecorderResult>;
- disableRecorder(params: BrowserContextDisableRecorderParams, options: TimeoutOptions): Promise<BrowserContextDisableRecorderResult>;
+ showRecorder(params: BrowserContextShowRecorderParams, options: TimeoutOptions): Promise<BrowserContextShowRecorderResult>;
+ startRecording(params: BrowserContextStartRecordingParams, options: TimeoutOptions): Promise<BrowserContextStartRecordingResult>;
+ stopRecording(params: BrowserContextStopRecordingParams, options: TimeoutOptions): Promise<BrowserContextStopRecordingResult>;
exposeConsoleApi(params: BrowserContextExposeConsoleApiParams, options: TimeoutOptions): Promise<BrowserContextExposeConsoleApiResult>;
newCDPSession(params: BrowserContextNewCDPSessionParams, options: TimeoutOptions): Promise<BrowserContextNewCDPSessionResult>;
createTempFiles(params: BrowserContextCreateTempFilesParams, options: TimeoutOptions): Promise<BrowserContextCreateTempFilesResult>;
@@ -1522,10 +1523,9 @@ export type BrowserContextSetStorageStateResult = void;
export type BrowserContextPauseParams = {};
export type BrowserContextPauseOptions = {};
export type BrowserContextPauseResult = void;
-export type BrowserContextEnableRecorderParams = {
+export type BrowserContextShowRecorderParams = {
language?: string,
mode?: 'inspecting' | 'recording',
- recorderMode?: 'default' | 'api',
pauseOnNextStatement?: boolean,
testIdAttributeName?: string,
launchOptions?: any,
@@ -1536,10 +1536,9 @@ export type BrowserContextEnableRecorderParams = {
handleSIGINT?: boolean,
omitCallTracking?: boolean,
};
-export type BrowserContextEnableRecorderOptions = {
+export type BrowserContextShowRecorderOptions = {
language?: string,
mode?: 'inspecting' | 'recording',
- recorderMode?: 'default' | 'api',
pauseOnNextStatement?: boolean,
testIdAttributeName?: string,
launchOptions?: any,
@@ -1550,10 +1549,17 @@ export type BrowserContextEnableRecorderOptions = {
handleSIGINT?: boolean,
omitCallTracking?: boolean,
};
-export type BrowserContextEnableRecorderResult = void;
-export type BrowserContextDisableRecorderParams = {};
-export type BrowserContextDisableRecorderOptions = {};
-export type BrowserContextDisableRecorderResult = void;
+export type BrowserContextShowRecorderResult = void;
+export type BrowserContextStartRecordingParams = {
+ language?: string,
+};
+export type BrowserContextStartRecordingOptions = {
+ language?: string,
+};
+export type BrowserContextStartRecordingResult = void;
+export type BrowserContextStopRecordingParams = {};
+export type BrowserContextStopRecordingOptions = {};
+export type BrowserContextStopRecordingResult = void;
export type BrowserContextExposeConsoleApiParams = {};
export type BrowserContextExposeConsoleApiOptions = {};
export type BrowserContextExposeConsoleApiResult = void;
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index 33b5331e64..42a64cdc70 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -62,7 +62,6 @@ const BrowserContextEvent = {
RequestFulfilled: 'requestfulfilled',
RequestContinued: 'requestcontinued',
BeforeClose: 'beforeclose',
- RecorderEvent: 'recorderevent',
PageClosed: 'pageclosed',
InternalFrameNavigatedToNewDocument: 'internalframenavigatedtonewdocument',
FrameAttached: 'frameattached',
@@ -82,7 +81,6 @@ export type BrowserContextEventMap = {
[BrowserContextEvent.RequestFulfilled]: [request: network.Request];
[BrowserContextEvent.RequestContinued]: [request: network.Request];
[BrowserContextEvent.BeforeClose]: [];
- [BrowserContextEvent.RecorderEvent]: [event: { event: 'actionAdded' | 'actionUpdated' | 'signalAdded', data: any, page: Page, code: string }];
[BrowserContextEvent.PageClosed]: [page: Page];
[BrowserContextEvent.InternalFrameNavigatedToNewDocument]: [frame: frames.Frame];
[BrowserContextEvent.FrameAttached]: [frame: frames.Frame];
@@ -159,14 +157,14 @@ export abstract class BrowserContext<EM extends EventMap = EventMap> extends Sdk
this._debugger.setPauseAt();
this._debugger.on(Debugger.Events.PausedStateChanged, () => {
if (this._debugger.isPaused())
- RecorderApp.enable(this, {}).catch(() => {});
+ RecorderApp.show(this, {}).catch(() => {});
});
}
// When PWDEBUG=1, show inspector for each context.
if (debugMode() === 'inspector') {
this._debugger.setPauseAt({ next: true });
- await RecorderApp.enable(this, { pauseOnNextStatement: true });
+ await RecorderApp.show(this, { pauseOnNextStatement: true });
}
if (debugMode() === 'console')
diff --git a/packages/playwright-core/src/server/channels.d.ts b/packages/playwright-core/src/server/channels.d.ts
index 1119ef3267..c1a1d870c5 100644
--- a/packages/playwright-core/src/server/channels.d.ts
+++ b/packages/playwright-core/src/server/channels.d.ts
@@ -1247,8 +1247,9 @@ export interface BrowserContextChannel extends BrowserContextEventTarget, Channe
storageState(params: BrowserContextStorageStateParams, progress: Progress): Promise<BrowserContextStorageStateResult>;
setStorageState(params: BrowserContextSetStorageStateParams, progress: Progress): Promise<BrowserContextSetStorageStateResult>;
pause(params: BrowserContextPauseParams, progress: Progress): Promise<BrowserContextPauseResult>;
- enableRecorder(params: BrowserContextEnableRecorderParams, progress: Progress): Promise<BrowserContextEnableRecorderResult>;
- disableRecorder(params: BrowserContextDisableRecorderParams, progress: Progress): Promise<BrowserContextDisableRecorderResult>;
+ showRecorder(params: BrowserContextShowRecorderParams, progress: Progress): Promise<BrowserContextShowRecorderResult>;
+ startRecording(params: BrowserContextStartRecordingParams, progress: Progress): Promise<BrowserContextStartRecordingResult>;
+ stopRecording(params: BrowserContextStopRecordingParams, progress: Progress): Promise<BrowserContextStopRecordingResult>;
exposeConsoleApi(params: BrowserContextExposeConsoleApiParams, progress: Progress): Promise<BrowserContextExposeConsoleApiResult>;
newCDPSession(params: BrowserContextNewCDPSessionParams, progress: Progress): Promise<BrowserContextNewCDPSessionResult>;
createTempFiles(params: BrowserContextCreateTempFilesParams, progress: Progress): Promise<BrowserContextCreateTempFilesResult>;
@@ -1523,10 +1524,9 @@ export type BrowserContextSetStorageStateResult = void;
export type BrowserContextPauseParams = {};
export type BrowserContextPauseOptions = {};
export type BrowserContextPauseResult = void;
-export type BrowserContextEnableRecorderParams = {
+export type BrowserContextShowRecorderParams = {
language?: string,
mode?: 'inspecting' | 'recording',
- recorderMode?: 'default' | 'api',
pauseOnNextStatement?: boolean,
testIdAttributeName?: string,
launchOptions?: any,
@@ -1537,10 +1537,9 @@ export type BrowserContextEnableRecorderParams = {
handleSIGINT?: boolean,
omitCallTracking?: boolean,
};
-export type BrowserContextEnableRecorderOptions = {
+export type BrowserContextShowRecorderOptions = {
language?: string,
mode?: 'inspecting' | 'recording',
- recorderMode?: 'default' | 'api',
pauseOnNextStatement?: boolean,
testIdAttributeName?: string,
launchOptions?: any,
@@ -1551,10 +1550,17 @@ export type BrowserContextEnableRecorderOptions = {
handleSIGINT?: boolean,
omitCallTracking?: boolean,
};
-export type BrowserContextEnableRecorderResult = void;
-export type BrowserContextDisableRecorderParams = {};
-export type BrowserContextDisableRecorderOptions = {};
-export type BrowserContextDisableRecorderResult = void;
+export type BrowserContextShowRecorderResult = void;
+export type BrowserContextStartRecordingParams = {
+ language?: string,
+};
+export type BrowserContextStartRecordingOptions = {
+ language?: string,
+};
+export type BrowserContextStartRecordingResult = void;
+export type BrowserContextStopRecordingParams = {};
+export type BrowserContextStopRecordingOptions = {};
+export type BrowserContextStopRecordingResult = void;
export type BrowserContextExposeConsoleApiParams = {};
export type BrowserContextExposeConsoleApiOptions = {};
export type BrowserContextExposeConsoleApiResult = void;
diff --git a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
index 3858519d82..4a77725925 100644
--- a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
@@ -34,7 +34,7 @@ import { DisposableDispatcher } from './disposableDispatcher';
import { TracingDispatcher } from './tracingDispatcher';
import { WebSocketRouteDispatcher } from './webSocketRouteDispatcher';
import { WritableStreamDispatcher } from './writableStreamDispatcher';
-import { RecorderApp } from '../recorder/recorderApp';
+import { ProgrammaticRecorderApp, RecorderApp } from '../recorder/recorderApp';
import { ElementHandleDispatcher } from './elementHandlerDispatcher';
import { JSHandleDispatcher } from './jsHandleDispatcher';
import { disposeAll } from '../disposable';
@@ -61,6 +61,7 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
private _requestInterceptor: RouteHandler;
private _interceptionUrlMatchers: URLMatch[] = [];
private _routeWebSocketInitScript: InitScript | undefined;
+ private _recorderApp: ProgrammaticRecorderApp | undefined;
static from(parentScope: DispatcherScope, context: BrowserContext): BrowserContextDispatcher {
const result = parentScope.connection.existingDispatcher<BrowserContextDispatcher>(context);
@@ -197,9 +198,6 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined()),
});
});
- this.addObjectListener(BrowserContext.Events.RecorderEvent, ({ event, data, page, code }: { event: 'actionAdded' | 'actionUpdated' | 'signalAdded', data: any, page: Page, code: string }) => {
- this._dispatchEvent('recorderEvent', { event, data, code, page: PageDispatcher.from(this, page) });
- });
}
private _shouldDispatchNetworkEvent(request: Request, event: channels.BrowserContextUpdateSubscriptionParams['event'] & channels.PageUpdateSubscriptionParams['event']): boolean {
@@ -354,12 +352,24 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
await this._context.close(progress, params);
}
- async enableRecorder(params: channels.BrowserContextEnableRecorderParams, progress: Progress): Promise<void> {
- await progress.race(RecorderApp.enable(this._context, params));
+ async showRecorder(params: channels.BrowserContextShowRecorderParams, progress: Progress): Promise<void> {
+ await progress.race(RecorderApp.show(this._context, params));
}
- async disableRecorder(params: channels.BrowserContextDisableRecorderParams, progress: Progress): Promise<void> {
- await progress.race(RecorderApp.disable(this._context));
+ async startRecording(params: channels.BrowserContextStartRecordingParams, progress: Progress): Promise<void> {
+ if (this._recorderApp)
+ throw new Error('Recording is already in progress.');
+ // Recorder events only go to the connection that started the recording.
+ this._recorderApp = await progress.race(ProgrammaticRecorderApp.start(this._context, params, ({ event, data, page, code }) => {
+ this._dispatchEvent('recorderEvent', { event, data, code, page: PageDispatcher.from(this, page) });
+ }));
+ }
+
+ async stopRecording(params: channels.BrowserContextStopRecordingParams, progress: Progress): Promise<void> {
+ const recorderApp = this._recorderApp;
+ this._recorderApp = undefined;
+ if (recorderApp)
+ await progress.race(recorderApp.stop());
}
async exposeConsoleApi(params: channels.BrowserContextExposeConsoleApiParams, progress: Progress): Promise<void> {
@@ -443,6 +453,10 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
}
override _onDispose() {
+ const recorderApp = this._recorderApp;
+ this._recorderApp = undefined;
+ recorderApp?.stop().catch(() => {});
+
// Avoid protocol calls for the closed context.
if (this._context.isClosingOrClosed())
return;
diff --git a/packages/playwright-core/src/server/recorder.ts b/packages/playwright-core/src/server/recorder.ts
index 3295adf175..1ef8b79dea 100644
--- a/packages/playwright-core/src/server/recorder.ts
+++ b/packages/playwright-core/src/server/recorder.ts
@@ -45,7 +45,7 @@ import type { RegisteredListener } from '@utils/eventsHelper';
const recorderSymbol = Symbol('recorderSymbol');
type BindingSource = { frame: Frame, page: Page };
-type RecorderParams = channels.BrowserContextEnableRecorderParams & { hideToolbar?: boolean };
+type RecorderParams = channels.BrowserContextShowRecorderParams & { recorderMode?: 'default' | 'api', hideToolbar?: boolean };
export const RecorderEvent = {
PausedStateChanged: 'pausedStateChanged',
@@ -245,6 +245,10 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
return this._mode;
}
+ flushPendingActions() {
+ this._signalProcessor.flush();
+ }
+
async setMode(mode: Mode) {
if (this._mode === mode)
return;
diff --git a/packages/playwright-core/src/server/recorder/recorderApp.ts b/packages/playwright-core/src/server/recorder/recorderApp.ts
index ddd176efbf..1c58b86407 100644
--- a/packages/playwright-core/src/server/recorder/recorderApp.ts
+++ b/packages/playwright-core/src/server/recorder/recorderApp.ts
@@ -40,7 +40,7 @@ import type { Progress } from '../progress';
import type { AriaTemplateNode } from '@isomorphic/ariaSnapshot';
import type { RegisteredListener } from '@utils/eventsHelper';
-export type RecorderAppParams = channels.BrowserContextEnableRecorderParams & {
+export type RecorderAppParams = channels.BrowserContextShowRecorderParams & {
browserName: string;
sdkLanguage: Language;
headed: boolean;
@@ -178,34 +178,23 @@ export class RecorderApp {
});
}
- static async enable(context: BrowserContext, params: channels.BrowserContextEnableRecorderParams) {
+ static async show(context: BrowserContext, params: channels.BrowserContextShowRecorderParams) {
if (process.env.PW_CODEGEN_NO_INSPECTOR)
return;
+ if (programmaticRecorderApps(context).size)
+ throw new Error('Recording is in progress, stop it before showing the recorder.');
const recorder = await Recorder.forContext(context, params);
- if (!(context as any)[recorderAppSymbol]) {
- const app = params.recorderMode === 'api'
- ? new ProgrammaticRecorderApp(context, recorder, params)
- : await RecorderApp._show(recorder, context, params);
- (context as any)[recorderAppSymbol] = app;
- }
+ if (!(context as any)[recorderAppSymbol])
+ (context as any)[recorderAppSymbol] = await RecorderApp._show(recorder, context, params);
if (params.mode)
await recorder.setMode(params.mode);
}
- static async disable(context: BrowserContext) {
- const recorder = await Recorder.existingForContext(context);
- if (recorder)
- await recorder.setMode('none');
- const app = (context as any)[recorderAppSymbol] as RecorderApp | ProgrammaticRecorderApp | undefined;
- delete (context as any)[recorderAppSymbol];
- await app?.close();
- }
-
async close() {
await this._page.close(nullProgress);
}
- private static async _show(recorder: Recorder, inspectedContext: BrowserContext, params: channels.BrowserContextEnableRecorderParams): Promise<RecorderApp> {
+ private static async _show(recorder: Recorder, inspectedContext: BrowserContext, params: channels.BrowserContextShowRecorderParams): Promise<RecorderApp> {
const sdkLanguage = inspectedContext._browser.sdkLanguage();
const isChromium = inspectedContext._browser.options.browserType === 'chromium';
const headed = !!inspectedContext._browser.options.headful;
@@ -359,28 +348,52 @@ function determinePrimaryGeneratorId(sdkLanguage: Language): string {
return sdkLanguage;
}
+export type ProgrammaticRecorderEvent = {
+ event: 'actionAdded' | 'actionUpdated' | 'signalAdded';
+ data: any;
+ page: Page;
+ code: string;
+};
+
+// Each client that records through the api gets its own app, so that clients
+// sharing the context only receive events of the recordings they started.
export class ProgrammaticRecorderApp {
+ private _context: BrowserContext;
+ private _recorder: Recorder;
private _listeners: RegisteredListener[];
- constructor(inspectedContext: BrowserContext, recorder: Recorder, params: channels.BrowserContextEnableRecorderParams) {
+ static async start(context: BrowserContext, params: channels.BrowserContextStartRecordingParams, onEvent: (event: ProgrammaticRecorderEvent) => void): Promise<ProgrammaticRecorderApp> {
+ if ((context as any)[recorderAppSymbol])
+ throw new Error('Recorder is shown, close it before starting a recording.');
+ const recorder = await Recorder.forContext(context, { language: params.language, mode: 'recording', recorderMode: 'api', omitCallTracking: true });
+ const app = new ProgrammaticRecorderApp(context, recorder, params, onEvent);
+ programmaticRecorderApps(context).add(app);
+ await recorder.setMode('recording');
+ return app;
+ }
+
+ private constructor(inspectedContext: BrowserContext, recorder: Recorder, params: channels.BrowserContextStartRecordingParams, onEvent: (event: ProgrammaticRecorderEvent) => void) {
+ this._context = inspectedContext;
+ this._recorder = recorder;
let lastAction: actions.ActionInContext | undefined;
let lastActionPage: Page | undefined;
const languages = [...languageSet()];
+ // Only actions are generated, so the header options do not matter.
const languageGeneratorOptions = {
browserName: inspectedContext._browser.options.name,
- launchOptions: { headless: false, ...params.launchOptions, tracesDir: undefined },
- contextOptions: { ...params.contextOptions },
- deviceName: params.device,
- saveStorage: params.saveStorage,
+ launchOptions: { headless: false },
+ contextOptions: {},
};
const languageGenerator = languages.find(l => l.id === params.language) ?? languages.find(l => l.id === 'playwright-test')!;
this._listeners = [
- eventsHelper.addEventListener(recorder, RecorderEvent.ActionAdded, actionInContext => {
- const page = findPageByGuid(inspectedContext, actionInContext.pageGuid);
+ eventsHelper.addEventListener(recorder, RecorderEvent.ActionAdded, recordedAction => {
+ const page = findPageByGuid(inspectedContext, recordedAction.pageGuid);
if (!page)
return;
+ // Other apps receive the same object, so keep the signals of this app separate.
+ const actionInContext = { ...recordedAction, signals: [...recordedAction.signals] };
let event: 'actionAdded' | 'actionUpdated' = 'actionAdded';
if (shouldMergeAction(actionInContext, lastAction)) {
event = 'actionUpdated';
@@ -390,7 +403,7 @@ export class ProgrammaticRecorderApp {
lastAction = actionInContext;
lastActionPage = page;
const code = languageGenerator.generateAction(actionInContext, languageGeneratorOptions);
- inspectedContext.emit(BrowserContext.Events.RecorderEvent, { event, data: actionInContext.action, page, code });
+ onEvent({ event, data: actionInContext.action, page, code });
}),
eventsHelper.addEventListener(recorder, RecorderEvent.SignalAdded, signalInContext => {
const page = findPageByGuid(inspectedContext, signalInContext.pageGuid);
@@ -403,14 +416,35 @@ export class ProgrammaticRecorderApp {
lastAction.signals.push(signalInContext.signal);
code = languageGenerator.generateAction(lastAction, languageGeneratorOptions);
}
- inspectedContext.emit(BrowserContext.Events.RecorderEvent, { event: 'signalAdded', data: signalInContext.signal, page, code });
+ onEvent({ event: 'signalAdded', data: signalInContext.signal, page, code });
}),
];
}
- close() {
- eventsHelper.removeEventListeners(this._listeners);
+ async stop() {
+ const apps = programmaticRecorderApps(this._context);
+ apps.delete(this);
+ try {
+ if (this._context.isClosingOrClosed())
+ return;
+ // Deliver the buffered action before detaching. Other clients may still be recording.
+ if (apps.size)
+ this._recorder.flushPendingActions();
+ else
+ await this._recorder.setMode('none');
+ } finally {
+ eventsHelper.removeEventListeners(this._listeners);
+ }
+ }
+}
+
+function programmaticRecorderApps(context: BrowserContext): Set<ProgrammaticRecorderApp> {
+ let apps = (context as any)[programmaticRecorderAppsSymbol] as Set<ProgrammaticRecorderApp> | undefined;
+ if (!apps) {
+ apps = new Set();
+ (context as any)[programmaticRecorderAppsSymbol] = apps;
}
+ return apps;
}
function findPageByGuid(context: BrowserContext, guid: string) {
@@ -432,3 +466,4 @@ function createRecorderFrontend(page: Page): RecorderFrontend {
}
const recorderAppSymbol = Symbol('recorderApp');
+const programmaticRecorderAppsSymbol = Symbol('programmaticRecorderApps');
diff --git a/packages/playwright-core/src/tools/backend/browserContextEx.ts b/packages/playwright-core/src/tools/backend/browserContextEx.ts
index 97b2a9de19..79dc9fd27a 100644
--- a/packages/playwright-core/src/tools/backend/browserContextEx.ts
+++ b/packages/playwright-core/src/tools/backend/browserContextEx.ts
@@ -24,13 +24,8 @@ export type RecorderEventSink = {
};
export type BrowserContextInternalApi = {
- _enableRecorder(params: {
- language?: string,
- mode?: 'inspecting' | 'recording',
- recorderMode?: 'default' | 'api',
- omitCallTracking?: boolean,
- }, eventSink?: RecorderEventSink): Promise<void>;
- _disableRecorder(): Promise<void>;
+ _startRecording(params: { language?: string }, eventSink: RecorderEventSink): Promise<void>;
+ _stopRecording(): Promise<void>;
};
export type BrowserContextEx = playwrightTypes.BrowserContext & BrowserContextInternalApi;
diff --git a/packages/playwright-core/src/tools/backend/context.ts b/packages/playwright-core/src/tools/backend/context.ts
index 068e8e8339..9b8bd5aa96 100644
--- a/packages/playwright-core/src/tools/backend/context.ts
+++ b/packages/playwright-core/src/tools/backend/context.ts
@@ -242,13 +242,10 @@ export class Context {
if (this._recordedActions)
throw new Error('Recording is already in progress.');
const browserContext = await this.ensureBrowserContext() as BrowserContextEx;
- if (typeof browserContext._enableRecorder !== 'function')
+ if (typeof browserContext._startRecording !== 'function')
throw new Error('Recording requires a newer version of Playwright, please upgrade.');
const recordedActions: string[] = [];
- await browserContext._enableRecorder({
- mode: 'recording',
- recorderMode: 'api',
- omitCallTracking: true,
+ await browserContext._startRecording({
language: languageGeneratorId(this.codegenLanguage()),
}, {
actionAdded: (page, action, code) => {
@@ -273,7 +270,7 @@ export class Context {
if (!recordedActions)
return undefined;
this._recordedActions = undefined;
- await (this._rawBrowserContext as BrowserContextEx)._disableRecorder();
+ await (this._rawBrowserContext as BrowserContextEx)._stopRecording();
return recordedActions.filter(code => code.trim()).map(dedent);
}
diff --git a/packages/protocol/spec/browserContext.yml b/packages/protocol/spec/browserContext.yml
index 738cb6a3f8..dc86cf29b1 100644
--- a/packages/protocol/spec/browserContext.yml
+++ b/packages/protocol/spec/browserContext.yml
@@ -212,7 +212,8 @@ BrowserContext:
pause:
title: Pause
- enableRecorder:
+ # Shows the recorder window. Throws while a programmatic recording is in progress.
+ showRecorder:
internal: true
parameters:
language: string?
@@ -221,11 +222,6 @@ BrowserContext:
literals:
- inspecting
- recording
- recorderMode:
- type: enum?
- literals:
- - default
- - api
pauseOnNextStatement: boolean?
testIdAttributeName: string?
launchOptions: json?
@@ -236,7 +232,12 @@ BrowserContext:
handleSIGINT: boolean?
omitCallTracking: boolean?
- disableRecorder:
+ startRecording:
+ internal: true
+ parameters:
+ language: string?
+
+ stopRecording:
internal: true
exposeConsoleApi:
diff --git a/packages/protocol/src/validator.ts b/packages/protocol/src/validator.ts
index 3b45fd4e05..35f585460a 100644
--- a/packages/protocol/src/validator.ts
+++ b/packages/protocol/src/validator.ts
@@ -837,10 +837,9 @@ scheme.BrowserContextSetStorageStateParams = tObject({
scheme.BrowserContextSetStorageStateResult = tOptional(tObject({}));
scheme.BrowserContextPauseParams = tOptional(tObject({}));
scheme.BrowserContextPauseResult = tOptional(tObject({}));
-scheme.BrowserContextEnableRecorderParams = tObject({
+scheme.BrowserContextShowRecorderParams = tObject({
language: tOptional(tString),
mode: tOptional(tEnum(['inspecting', 'recording'])),
- recorderMode: tOptional(tEnum(['default', 'api'])),
pauseOnNextStatement: tOptional(tBoolean),
testIdAttributeName: tOptional(tString),
launchOptions: tOptional(tAny),
@@ -851,9 +850,13 @@ scheme.BrowserContextEnableRecorderParams = tObject({
handleSIGINT: tOptional(tBoolean),
omitCallTracking: tOptional(tBoolean),
});
-scheme.BrowserContextEnableRecorderResult = tOptional(tObject({}));
-scheme.BrowserContextDisableRecorderParams = tOptional(tObject({}));
-scheme.BrowserContextDisableRecorderResult = tOptional(tObject({}));
+scheme.BrowserContextShowRecorderResult = tOptional(tObject({}));
+scheme.BrowserContextStartRecordingParams = tObject({
+ language: tOptional(tString),
+});
+scheme.BrowserContextStartRecordingResult = tOptional(tObject({}));
+scheme.BrowserContextStopRecordingParams = tOptional(tObject({}));
+scheme.BrowserContextStopRecordingResult = tOptional(tObject({}));
scheme.BrowserContextExposeConsoleApiParams = tOptional(tObject({}));
scheme.BrowserContextExposeConsoleApiResult = tOptional(tObject({}));
scheme.BrowserContextNewCDPSessionParams = tObject({
diff --git a/tests/library/inspector/inspectorTest.ts b/tests/library/inspector/inspectorTest.ts
index 9fa145a651..3f913f7985 100644
--- a/tests/library/inspector/inspectorTest.ts
+++ b/tests/library/inspector/inspectorTest.ts
@@ -93,7 +93,7 @@ export const test = contextTest.extend<CLITestArgs>({
openRecorder: async ({ context, recorderPageGetter }, use) => {
await use(async options => {
- await (context as any)._enableRecorder({
+ await (context as any)._showRecorder({
mode: 'recording',
omitCallTracking: true,
...options
diff --git a/tests/library/inspector/recorder-api.spec.ts b/tests/library/inspector/recorder-api.spec.ts
index 17d6eeb956..6c2c0482b6 100644
--- a/tests/library/inspector/recorder-api.spec.ts
+++ b/tests/library/inspector/recorder-api.spec.ts
@@ -39,10 +39,7 @@ class RecorderLog {
async function startRecording(context) {
const log = new RecorderLog();
- await (context as any)._enableRecorder({
- mode: 'recording',
- recorderMode: 'api',
- }, log);
+ await (context as any)._startRecording({}, log);
return {
action: (name: string) => log.actions.filter(a => a.action.name === name),
signals: () => log.signals,
@@ -56,8 +53,8 @@ function normalizeCode(code: string): string {
test('context should implement the internal api used by the tools', async ({ context }) => {
// Listing a method here is enforced by the type, so adding one to the interface breaks compilation until it is covered.
const methods: Record<keyof BrowserContextInternalApi, true> = {
- _enableRecorder: true,
- _disableRecorder: true,
+ _startRecording: true,
+ _stopRecording: true,
};
for (const method of Object.keys(methods))
expect(typeof context[method], method).toBe('function');
@@ -180,27 +177,27 @@ test('should type', async ({ context }) => {
expect(normalizeCode(log.action('fill')[0].code)).toEqual(`await page.getByRole('textbox').fill('Hello');`);
});
-test('should disable recorder', async ({ context }) => {
+test('should stop recording', async ({ context }) => {
const log = await startRecording(context);
const page = await context.newPage();
await page.setContent(`<button onclick="console.log('click')">Submit</button>`);
await page.getByRole('button', { name: 'Submit' }).click();
await page.getByRole('button', { name: 'Submit' }).click();
await expect.poll(() => log.action('click').length).toBe(2);
- await (context as any)._disableRecorder();
+ await (context as any)._stopRecording();
await page.getByRole('button', { name: 'Submit' }).click();
// Give it some time to produce more actions - there should be none.
await page.waitForTimeout(2000);
expect(log.action('click')).toHaveLength(2);
});
-test('should record again after disable', async ({ context }) => {
+test('should record again after stop', async ({ context }) => {
const log = await startRecording(context);
const page = await context.newPage();
await page.setContent(`<button onclick="console.log('click')">Submit</button>`);
await page.getByRole('button', { name: 'Submit' }).click();
await expect.poll(() => log.action('click').length).toBe(1);
- await (context as any)._disableRecorder();
+ await (context as any)._stopRecording();
const log2 = await startRecording(context);
await page.getByRole('button', { name: 'Submit' }).click();
@@ -210,17 +207,27 @@ test('should record again after disable', async ({ context }) => {
expect(log2.action('click')).toHaveLength(1);
});
-test('disable should close the inspector window', async ({ context, openRecorder }) => {
+test('should not start recording while the recorder is shown', async ({ context, openRecorder }) => {
const { recorder } = await openRecorder();
- await (context as any)._disableRecorder();
- await expect.poll(() => recorder.recorderPage.isClosed()).toBe(true);
+ await expect(startRecording(context)).rejects.toThrow('Recorder is shown, close it before starting a recording.');
// With the window closed, programmatic recording can start on the same context.
- const log = await startRecording(context);
- const page = await context.newPage();
- await page.setContent(`<button onclick="console.log('click')">Submit</button>`);
- await page.getByRole('button', { name: 'Submit' }).click();
- await expect.poll(() => log.action('click').length).toBe(1);
+ await recorder.recorderPage.close();
+ await expect.poll(() => startRecording(context).then(() => true, () => false)).toBe(true);
+});
+
+test('should not show the recorder while recording', async ({ context }) => {
+ await startRecording(context);
+ await expect((context as any)._showRecorder({ mode: 'recording' })).rejects.toThrow('Recording is in progress, stop it before showing the recorder.');
+
+ // Stopping the recording allows showing the recorder again.
+ await (context as any)._stopRecording();
+ await (context as any)._showRecorder({ mode: 'recording' });
+});
+
+test('should not start recording twice', async ({ context }) => {
+ await startRecording(context);
+ await expect(startRecording(context)).rejects.toThrow('Recording is already in progress.');
});
test('page.pickLocator should return locator for picked element', async ({ page }) => {
diff --git a/tests/library/locator-generator.spec.ts b/tests/library/locator-generator.spec.ts
index 5f3c7e541d..cb3ad87158 100644
--- a/tests/library/locator-generator.spec.ts
+++ b/tests/library/locator-generator.spec.ts
@@ -546,7 +546,7 @@ it('generate multiple locators', async ({ page }) => {
it.describe(() => {
it.beforeEach(async ({ context }) => {
- await (context as any)._enableRecorder({ language: 'javascript' });
+ await (context as any)._showRecorder({ language: 'javascript' });
});
it('reverse engineer internal:has-text locators', async ({ page }) => {
diff --git a/tests/library/selector-generator.spec.ts b/tests/library/selector-generator.spec.ts
index f81171f15d..78bfd559bb 100644
--- a/tests/library/selector-generator.spec.ts
+++ b/tests/library/selector-generator.spec.ts
@@ -40,7 +40,7 @@ it.describe('selector generator', () => {
// we properly wait for `extendInjectedScript` call to finish. Otherwise
// if the page is created later, there is a race between ConsoleAPI
// initialization and playwright.selector(e) call in `generate()` function above.
- await (context as any)._enableRecorder({ language: 'javascript' });
+ await (context as any)._showRecorder({ language: 'javascript' });
});
it('should prefer button over inner span', async ({ page }) => {
diff --git a/tests/mcp/recorder.spec.ts b/tests/mcp/recorder.spec.ts
index b3867c5ea4..e49fbd1e5c 100644
--- a/tests/mcp/recorder.spec.ts
+++ b/tests/mcp/recorder.spec.ts
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-import { test, expect } from './fixtures';
+import { test, expect } from './cli-fixtures';
import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
import type { TestServer } from '../config/testserver';
@@ -196,3 +196,67 @@ test('stop without start is an error', async ({ client }) => {
error: expect.stringContaining('No recording in progress'),
});
});
+
+test('clients sharing a context only receive their own recordings', { annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/42608' } }, async ({ boundBrowser, startClient, server }) => {
+ server.setContent('/', `
+ <title>Title</title>
+ <button>Alpha</button>
+ <button>Beta</button>
+ <button>Gamma</button>
+ `, 'text/html');
+ const page = await boundBrowser.newPage();
+ await page.goto(server.PREFIX);
+
+ // Each client connects to the bound browser with its own connection.
+ const { client: client1 } = await startClient({ args: ['--endpoint=default'] });
+ const { client: client2 } = await startClient({ args: ['--endpoint=default'] });
+ await client1.callTool({ name: 'browser_snapshot' });
+ await client2.callTool({ name: 'browser_snapshot' });
+
+ expect(await client2.callTool({
+ name: 'browser_stop_recording',
+ })).toHaveResponse({
+ isError: true,
+ error: expect.stringContaining('No recording in progress'),
+ });
+
+ await client1.callTool({ name: 'browser_start_recording' });
+ await client1.callTool({
+ name: 'browser_click',
+ arguments: { element: 'Alpha button', target: 'e2' },
+ });
+
+ await client2.callTool({ name: 'browser_start_recording' });
+ await client1.callTool({
+ name: 'browser_click',
+ arguments: { element: 'Beta button', target: 'e3' },
+ });
+
+ expect(await client1.callTool({
+ name: 'browser_stop_recording',
+ })).toHaveResponse({
+ result: expect.stringContaining([
+ '```js',
+ `await page.getByRole('button', { name: 'Alpha' }).click();`,
+ `await page.getByRole('button', { name: 'Beta' }).click();`,
+ '```',
+ ].join('\n')),
+ });
+
+ // Stopping the first client does not stop the second one, which only sees
+ // what happened after it started recording.
+ await client2.callTool({
+ name: 'browser_click',
+ arguments: { element: 'Gamma button', target: 'e4' },
+ });
+ expect(await client2.callTool({
+ name: 'browser_stop_recording',
+ })).toHaveResponse({
+ result: expect.stringContaining([
+ '```js',
+ `await page.getByRole('button', { name: 'Beta' }).click();`,
+ `await page.getByRole('button', { name: 'Gamma' }).click();`,
+ '```',
+ ].join('\n')),
+ });
+});