Skip to content

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

chore: experimental recorder api (#36604)

Pavel Feldman689886c4c769
diff --git a/package.json b/package.json
index 31ddee8dcf..1547e0f7d9 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
"check-deps": "node utils/check_deps.js",
"build-android-driver": "./utils/build_android_driver.sh",
"innerloop": "playwright run-server --reuse-browser",
- "mdd": "playwright-mdd packages/playwright-mdd/specs/integration.spec.md -o packages/playwright-mdd/tests/integration.spec.ts"
+ "mdd": "playwright-mdd run packages/playwright-mdd/specs/integration.spec.md -o packages/playwright-mdd/tests/integration.spec.ts"
},
"workspaces": [
"packages/*"
diff --git a/packages/injected/src/ariaSnapshot.ts b/packages/injected/src/ariaSnapshot.ts
index 92b3059495..2088b81cdc 100644
--- a/packages/injected/src/ariaSnapshot.ts
+++ b/packages/injected/src/ariaSnapshot.ts
@@ -37,6 +37,7 @@ export type AriaNode = AriaProps & {
export type AriaSnapshot = {
root: AriaNode;
elements: Map<string, Element>;
+ refs: Map<Element, string>;
};
type AriaRef = {
@@ -53,6 +54,7 @@ export function generateAriaTree(rootElement: Element, options?: { forAI?: boole
const snapshot: AriaSnapshot = {
root: { role: 'fragment', name: '', children: [], element: rootElement, props: {}, box: box(rootElement), receivesPointerEvents: true },
elements: new Map<string, Element>(),
+ refs: new Map<Element, string>(),
};
const visit = (ariaNode: AriaNode, node: Node, parentElementVisible: boolean) => {
@@ -92,8 +94,10 @@ export function generateAriaTree(rootElement: Element, options?: { forAI?: boole
const visible = !isElementHiddenForAria || isElementVisible(element);
const childAriaNode = visible ? toAriaNode(element, options) : null;
if (childAriaNode) {
- if (childAriaNode.ref)
+ if (childAriaNode.ref) {
snapshot.elements.set(childAriaNode.ref, element);
+ snapshot.refs.set(element, childAriaNode.ref);
+ }
ariaNode.children.push(childAriaNode);
}
processElement(childAriaNode || ariaNode, element, ariaChildren, visible);
diff --git a/packages/injected/src/injectedScript.ts b/packages/injected/src/injectedScript.ts
index 2c9b11f36a..e315b9d324 100644
--- a/packages/injected/src/injectedScript.ts
+++ b/packages/injected/src/injectedScript.ts
@@ -304,6 +304,12 @@ export class InjectedScript {
return renderAriaTree(this._lastAriaSnapshot, options);
}
+ ariaSnapshotForRecorder(): { ariaSnapshot: string, refs: Map<Element, string> } {
+ const tree = generateAriaTree(this.document.body, { forAI: true });
+ const ariaSnapshot = renderAriaTree(tree, { forAI: true });
+ return { ariaSnapshot, refs: tree.refs };
+ }
+
getAllByAria(document: Document, template: AriaTemplateNode): Element[] {
return getAllByAria(document.documentElement, template);
}
diff --git a/packages/injected/src/recorder/pollingRecorder.ts b/packages/injected/src/recorder/pollingRecorder.ts
index c9e824951a..dc567b37c0 100644
--- a/packages/injected/src/recorder/pollingRecorder.ts
+++ b/packages/injected/src/recorder/pollingRecorder.ts
@@ -37,8 +37,8 @@ export class PollingRecorder implements RecorderDelegate {
private _pollRecorderModeTimer: number | undefined;
private _lastStateJSON: string | undefined;
- constructor(injectedScript: InjectedScript) {
- this._recorder = new Recorder(injectedScript);
+ constructor(injectedScript: InjectedScript, options?: { recorderMode?: 'default' | 'api' }) {
+ this._recorder = new Recorder(injectedScript, options);
this._embedder = injectedScript.window as any;
injectedScript.onGlobalListenersRemoved.add(() => this._recorder.installListeners());
diff --git a/packages/injected/src/recorder/recorder.ts b/packages/injected/src/recorder/recorder.ts
index 433e5529fb..852d18f86f 100644
--- a/packages/injected/src/recorder/recorder.ts
+++ b/packages/injected/src/recorder/recorder.ts
@@ -60,6 +60,7 @@ interface RecorderTool {
onMouseLeave?(event: MouseEvent): void;
onFocus?(event: Event): void;
onScroll?(event: Event): void;
+ onLoad?(event: Event): void;
}
class NoneTool implements RecorderTool {
@@ -468,7 +469,7 @@ class RecordActionTool implements RecorderTool {
return;
// Only allow programmatic keyups, ignore user input.
- if (this._recorder.state.recorderMode === 'perform' && !this._expectProgrammaticKeyUp) {
+ if (!this._expectProgrammaticKeyUp) {
consumeEvent(event);
return;
}
@@ -521,8 +522,7 @@ class RecordActionTool implements RecorderTool {
}
// Consume event if action is not being executed.
- if (this._recorder.state.recorderMode === 'perform')
- consumeEvent(event);
+ consumeEvent(event);
return false;
}
@@ -541,18 +541,20 @@ class RecordActionTool implements RecorderTool {
}
private _consumeWhenAboutToPerform(event: Event) {
- if (!this._performingActions.size && this._recorder.state.recorderMode === 'perform')
+ if (!this._performingActions.size)
consumeEvent(event);
}
private _performAction(action: actions.PerformOnRecordAction) {
this._recorder.updateHighlight(null, false);
- let promise = Promise.resolve();
- if (this._recorder.state.recorderMode === 'perform')
- promise = this._innerPerformAction(action);
- else
- this._recorder.recordAction(action);
+ this._performingActions.add(action);
+
+ const promise = this._recorder.performAction(action).then(() => {
+ this._performingActions.delete(action);
+ // If that was a keyboard action, it similarly requires new selectors for active model.
+ this._onFocus(false);
+ });
if (!this._recorder.injectedScript.isUnderTest)
return;
@@ -567,16 +569,6 @@ class RecordActionTool implements RecorderTool {
});
}
- private async _innerPerformAction(action: actions.PerformOnRecordAction) {
- this._performingActions.add(action);
-
- return this._recorder.performAction(action).then(() => {
- this._performingActions.delete(action);
- // If that was a keyboard action, it similarly requires new selectors for active model.
- this._onFocus(false);
- });
- }
-
private _shouldGenerateKeyPressFor(event: KeyboardEvent): boolean {
// IME can generate keyboard events that don't provide a value for the key property (e.g. chrome autofill)
if (typeof event.key !== 'string')
@@ -626,8 +618,227 @@ class RecordActionTool implements RecorderTool {
}
private _updateHighlight(userGesture: boolean) {
- if (this._recorder.state.recorderMode === 'perform' || this._recorder.injectedScript.isUnderTest)
- this._recorder.updateHighlight(this._hoveredModel, userGesture);
+ this._recorder.updateHighlight(this._hoveredModel, userGesture);
+ }
+}
+
+class JsonRecordActionTool implements RecorderTool {
+ private _recorder: Recorder;
+
+ constructor(recorder: Recorder) {
+ this._recorder = recorder;
+ }
+
+ cursor() {
+ return 'pointer';
+ }
+
+ install() {
+ this._pushSnapshot();
+ }
+
+ onClick(event: MouseEvent) {
+ // in webkit, sliding a range element may trigger a click event with a different target if the mouse is released outside the element bounding box.
+ // So we check the hovered element instead, and if it is a range input, we skip click handling
+ const element = this._recorder.deepEventTarget(event);
+ if (isRangeInput(element))
+ return;
+ // Right clicks are handled by 'contextmenu' event if its auxclick
+ if (event.button === 2 && event.type === 'auxclick')
+ return;
+ if (this._shouldIgnoreMouseEvent(event))
+ return;
+
+ const checkbox = asCheckbox(element);
+ const { ariaSnapshot, selector } = this._ariaSnapshot(element);
+ if (checkbox && event.detail === 1) {
+ // Interestingly, inputElement.checked is reversed inside this event handler.
+ this._recorder.recordAction({
+ name: checkbox.checked ? 'check' : 'uncheck',
+ selector,
+ signals: [],
+ ariaSnapshot,
+ });
+ return;
+ }
+
+ this._recorder.recordAction({
+ name: 'click',
+ selector,
+ ariaSnapshot,
+ position: positionForEvent(event),
+ signals: [],
+ button: buttonForEvent(event),
+ modifiers: modifiersForEvent(event),
+ clickCount: event.detail,
+ });
+ }
+
+ onDblClick(event: MouseEvent) {
+ const element = this._recorder.deepEventTarget(event);
+ if (isRangeInput(element))
+ return;
+ if (this._shouldIgnoreMouseEvent(event))
+ return;
+
+ const { ariaSnapshot, selector } = this._ariaSnapshot(element);
+ this._recorder.recordAction({
+ name: 'click',
+ selector,
+ ariaSnapshot,
+ position: positionForEvent(event),
+ signals: [],
+ button: buttonForEvent(event),
+ modifiers: modifiersForEvent(event),
+ clickCount: event.detail
+ });
+ }
+
+ onInput(event: Event) {
+ const element = this._recorder.deepEventTarget(event);
+
+ const { ariaSnapshot, selector } = this._ariaSnapshot(element);
+ if (isRangeInput(element)) {
+ this._recorder.recordAction({
+ name: 'fill',
+ selector,
+ ariaSnapshot,
+ signals: [],
+ text: element.value,
+ });
+ return;
+ }
+
+ if (['INPUT', 'TEXTAREA'].includes(element.nodeName) || element.isContentEditable) {
+ if (element.nodeName === 'INPUT' && ['checkbox', 'radio'].includes((element as HTMLInputElement).type.toLowerCase())) {
+ // Checkbox is handled in click, we can't let input trigger on checkbox - that would mean we dispatched click events while recording.
+ return;
+ }
+
+ this._recorder.recordAction({
+ name: 'fill',
+ selector,
+ ariaSnapshot,
+ signals: [],
+ text: element.isContentEditable ? element.innerText : (element as HTMLInputElement).value,
+ });
+ return;
+ }
+
+ if (element.nodeName === 'SELECT') {
+ const selectElement = element as HTMLSelectElement;
+ this._recorder.recordAction({
+ name: 'select',
+ selector,
+ ariaSnapshot,
+ options: [...selectElement.selectedOptions].map(option => option.value),
+ signals: []
+ });
+ return;
+ }
+ }
+
+ onKeyDown(event: KeyboardEvent) {
+ if (!this._shouldGenerateKeyPressFor(event))
+ return;
+
+ const element = this._recorder.deepEventTarget(event);
+ const { ariaSnapshot, selector } = this._ariaSnapshot(element);
+
+ // Similarly to click, trigger checkbox on key event, not input.
+ if (event.key === ' ') {
+ const checkbox = asCheckbox(element);
+ if (checkbox && event.detail === 0) {
+ this._recorder.recordAction({
+ name: checkbox.checked ? 'uncheck' : 'check',
+ selector,
+ ariaSnapshot,
+ signals: [],
+ });
+ return;
+ }
+ }
+
+ this._recorder.recordAction({
+ name: 'press',
+ selector,
+ ariaSnapshot,
+ signals: [],
+ key: event.key,
+ modifiers: modifiersForEvent(event),
+ });
+ }
+
+ onLoad() {
+ this._pushSnapshot();
+ }
+
+ private _pushSnapshot() {
+ const { ariaSnapshot } = this._ariaSnapshot(this._recorder.document.body);
+ this._recorder.recordAction({
+ selector: '',
+ name: 'assertSnapshot',
+ signals: [],
+ ariaSnapshot,
+ });
+ }
+
+ private _shouldIgnoreMouseEvent(event: MouseEvent): boolean {
+ const target = this._recorder.deepEventTarget(event);
+ const nodeName = target.nodeName;
+ if (nodeName === 'SELECT' || nodeName === 'OPTION')
+ return true;
+ if (nodeName === 'INPUT' && ['date', 'range'].includes((target as HTMLInputElement).type))
+ return true;
+ return false;
+ }
+
+ private _shouldGenerateKeyPressFor(event: KeyboardEvent): boolean {
+ // IME can generate keyboard events that don't provide a value for the key property (e.g. chrome autofill)
+ if (typeof event.key !== 'string')
+ return false;
+
+ // Enter aka. new line is handled in input event.
+ if (event.key === 'Enter' && (this._recorder.deepEventTarget(event).nodeName === 'TEXTAREA' || this._recorder.deepEventTarget(event).isContentEditable))
+ return false;
+ // Backspace, Delete, AltGraph are changing input, will handle it there.
+ if (['Backspace', 'Delete', 'AltGraph'].includes(event.key))
+ return false;
+ // Ignore the QWERTZ shortcut for creating a at sign on MacOS
+ if (event.key === '@' && event.code === 'KeyL')
+ return false;
+ // Allow and ignore common used shortcut for pasting.
+ if (navigator.platform.includes('Mac')) {
+ if (event.key === 'v' && event.metaKey)
+ return false;
+ } else {
+ if (event.key === 'v' && event.ctrlKey)
+ return false;
+ if (event.key === 'Insert' && event.shiftKey)
+ return false;
+ }
+ if (['Shift', 'Control', 'Meta', 'Alt', 'Process'].includes(event.key))
+ return false;
+ const hasModifier = event.ctrlKey || event.altKey || event.metaKey;
+ if (event.key.length === 1 && !hasModifier)
+ return !this._isEditable(this._recorder.deepEventTarget(event));
+ return true;
+ }
+
+ private _isEditable(element: HTMLElement) {
+ if (element.nodeName === 'TEXTAREA' || element.nodeName === 'INPUT')
+ return true;
+ if (element.isContentEditable)
+ return true;
+ return false;
+ }
+
+ private _ariaSnapshot(element: HTMLElement): { ariaSnapshot: string, selector: string };
+ private _ariaSnapshot(element: HTMLElement | undefined): { ariaSnapshot: string, selector?: string } {
+ const { ariaSnapshot, refs } = this._recorder.injectedScript.ariaSnapshotForRecorder();
+ const ref = element ? refs.get(element) : undefined;
+ const selector = ref ? `aria-ref=${ref}` : undefined;
+ return { ariaSnapshot, selector };
}
}
@@ -746,7 +957,7 @@ class TextAssertionTool implements RecorderTool {
name: 'assertSnapshot',
selector: this._hoverHighlight.selector,
signals: [],
- snapshot: this._recorder.injectedScript.ariaSnapshot(target, { mode: 'regex' }),
+ ariaSnapshot: this._recorder.injectedScript.ariaSnapshot(target, { mode: 'regex' }),
};
} else {
const generated = this._recorder.injectedScript.generateSelector(target, { testIdAttributeName: this._recorder.state.testIdAttributeName, forTextExpect: true });
@@ -772,7 +983,7 @@ class TextAssertionTool implements RecorderTool {
if (action?.name === 'assertValue')
return action.value;
if (action?.name === 'assertSnapshot')
- return action.snapshot;
+ return action.ariaSnapshot;
return '';
}
@@ -1060,7 +1271,6 @@ export class Recorder {
private _stylesheet: CSSStyleSheet;
state: UIState = {
mode: 'none',
- recorderMode: 'perform',
testIdAttributeName: 'data-testid',
language: 'javascript',
overlay: { offsetX: 0 },
@@ -1068,7 +1278,7 @@ export class Recorder {
readonly document: Document;
private _delegate: RecorderDelegate = {};
- constructor(injectedScript: InjectedScript) {
+ constructor(injectedScript: InjectedScript, options?: { recorderMode?: 'default' | 'api' }) {
this.document = injectedScript.document;
this.injectedScript = injectedScript;
this.highlight = injectedScript.createHighlight();
@@ -1076,7 +1286,7 @@ export class Recorder {
'none': new NoneTool(),
'standby': new NoneTool(),
'inspecting': new InspectTool(this, false),
- 'recording': new RecordActionTool(this),
+ 'recording': options?.recorderMode === 'api' ? new JsonRecordActionTool(this) : new RecordActionTool(this),
'recording-inspecting': new InspectTool(this, false),
'assertingText': new TextAssertionTool(this, 'text'),
'assertingVisibility': new InspectTool(this, true),
@@ -1121,6 +1331,7 @@ export class Recorder {
addEventListener(this.document, 'mouseenter', event => this._onMouseEnter(event as MouseEvent), true),
addEventListener(this.document, 'focus', event => this._onFocus(event), true),
addEventListener(this.document, 'scroll', event => this._onScroll(event), true),
+ addEventListener(this.injectedScript.window, 'load', event => this._onLoad(event), true),
];
this.highlight.install();
@@ -1304,6 +1515,12 @@ export class Recorder {
this._currentTool.onFocus?.(event);
}
+ private _onLoad(event: Event) {
+ if (!event.isTrusted)
+ return;
+ this._currentTool.onLoad?.(event);
+ }
+
private _onScroll(event: Event) {
if (!event.isTrusted)
return;
diff --git a/packages/playwright-core/src/client/browserContext.ts b/packages/playwright-core/src/client/browserContext.ts
index 97170ce041..384612cccd 100644
--- a/packages/playwright-core/src/client/browserContext.ts
+++ b/packages/playwright-core/src/client/browserContext.ts
@@ -71,6 +71,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
_closingStatus: 'none' | 'closing' | 'closed' = 'none';
private _closeReason: string | undefined;
private _harRouters: HarRouter[] = [];
+ private _onRecorderEventSink: ((event: string, data: any) => void) | undefined;
static from(context: channels.BrowserContextChannel): BrowserContext {
return (context as any)._object;
@@ -140,6 +141,7 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
this._channel.on('requestFailed', ({ request, failureText, responseEndTiming, page }) => this._onRequestFailed(network.Request.from(request), responseEndTiming, failureText, Page.fromNullable(page)));
this._channel.on('requestFinished', params => this._onRequestFinished(params));
this._channel.on('response', ({ response, page }) => this._onResponse(network.Response.from(response), Page.fromNullable(page)));
+ this._channel.on('recorderEvent', ({ event, data }) => this._onRecorderEventSink?.(event, data));
this._closedPromise = new Promise(f => this.once(Events.BrowserContext.Close, f));
this._setEventToSubscriptionMapping(new Map<string, channels.BrowserContextUpdateSubscriptionParams['event']>([
@@ -499,9 +501,16 @@ export class BrowserContext extends ChannelOwner<channels.BrowserContextChannel>
await this._closedPromise;
}
- async _enableRecorder(params: channels.BrowserContextEnableRecorderParams) {
+ async _enableRecorder(params: channels.BrowserContextEnableRecorderParams, callback?: (event: string, data: any) => void) {
+ if (callback)
+ this._onRecorderEventSink = callback;
await this._channel.enableRecorder(params);
}
+
+ async _disableRecorder() {
+ this._onRecorderEventSink = undefined;
+ await this._channel.disableRecorder();
+ }
}
async function prepareStorageState(platform: Platform, options: BrowserContextOptions): Promise<channels.BrowserNewContextParams['storageState']> {
diff --git a/packages/playwright-core/src/protocol/validator.ts b/packages/playwright-core/src/protocol/validator.ts
index 8cb98e1d82..1d53084a39 100644
--- a/packages/playwright-core/src/protocol/validator.ts
+++ b/packages/playwright-core/src/protocol/validator.ts
@@ -979,6 +979,10 @@ scheme.BrowserContextResponseEvent = tObject({
response: tChannel(['Response']),
page: tOptional(tChannel(['Page'])),
});
+scheme.BrowserContextRecorderEventEvent = tObject({
+ event: tString,
+ data: tAny,
+});
scheme.BrowserContextAddCookiesParams = tObject({
cookies: tArray(tType('SetNetworkCookie')),
});
@@ -1085,7 +1089,7 @@ scheme.BrowserContextPauseResult = tOptional(tObject({}));
scheme.BrowserContextEnableRecorderParams = tObject({
language: tOptional(tString),
mode: tOptional(tEnum(['inspecting', 'recording'])),
- recorderMode: tOptional(tEnum(['record', 'perform'])),
+ recorderMode: tOptional(tEnum(['default', 'api'])),
pauseOnNextStatement: tOptional(tBoolean),
testIdAttributeName: tOptional(tString),
launchOptions: tOptional(tAny),
@@ -1097,6 +1101,8 @@ scheme.BrowserContextEnableRecorderParams = tObject({
omitCallTracking: tOptional(tBoolean),
});
scheme.BrowserContextEnableRecorderResult = tOptional(tObject({}));
+scheme.BrowserContextDisableRecorderParams = tOptional(tObject({}));
+scheme.BrowserContextDisableRecorderResult = tOptional(tObject({}));
scheme.BrowserContextNewCDPSessionParams = tObject({
page: tOptional(tChannel(['Page'])),
frame: tOptional(tChannel(['Frame'])),
diff --git a/packages/playwright-core/src/server/browserContext.ts b/packages/playwright-core/src/server/browserContext.ts
index ad3a75ff5c..531556374b 100644
--- a/packages/playwright-core/src/server/browserContext.ts
+++ b/packages/playwright-core/src/server/browserContext.ts
@@ -63,6 +63,7 @@ export abstract class BrowserContext extends SdkObject {
RequestContinued: 'requestcontinued',
BeforeClose: 'beforeclose',
VideoStarted: 'videostarted',
+ RecorderEvent: 'recorderevent',
};
readonly _pageBindings = new Map<string, PageBinding>();
diff --git a/packages/playwright-core/src/server/codegen/csharp.ts b/packages/playwright-core/src/server/codegen/csharp.ts
index 98b5a182fb..dc6745f73b 100644
--- a/packages/playwright-core/src/server/codegen/csharp.ts
+++ b/packages/playwright-core/src/server/codegen/csharp.ts
@@ -157,7 +157,7 @@ export class CSharpLanguageGenerator implements LanguageGenerator {
return `await Expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
}
case 'assertSnapshot':
- return `await Expect(${subject}.${this._asLocator(action.selector)}).ToMatchAriaSnapshotAsync(${quote(action.snapshot)});`;
+ return `await Expect(${subject}.${this._asLocator(action.selector)}).ToMatchAriaSnapshotAsync(${quote(action.ariaSnapshot)});`;
}
}
diff --git a/packages/playwright-core/src/server/codegen/java.ts b/packages/playwright-core/src/server/codegen/java.ts
index 42456eb4a9..19fefdd1db 100644
--- a/packages/playwright-core/src/server/codegen/java.ts
+++ b/packages/playwright-core/src/server/codegen/java.ts
@@ -135,7 +135,7 @@ export class JavaLanguageGenerator implements LanguageGenerator {
return `assertThat(${subject}.${this._asLocator(action.selector, inFrameLocator)}).${assertion};`;
}
case 'assertSnapshot':
- return `assertThat(${subject}.${this._asLocator(action.selector, inFrameLocator)}).matchesAriaSnapshot(${quote(action.snapshot)});`;
+ return `assertThat(${subject}.${this._asLocator(action.selector, inFrameLocator)}).matchesAriaSnapshot(${quote(action.ariaSnapshot)});`;
}
}
diff --git a/packages/playwright-core/src/server/codegen/javascript.ts b/packages/playwright-core/src/server/codegen/javascript.ts
index 568f0a5113..9c5f7273c5 100644
--- a/packages/playwright-core/src/server/codegen/javascript.ts
+++ b/packages/playwright-core/src/server/codegen/javascript.ts
@@ -120,7 +120,7 @@ export class JavaScriptLanguageGenerator implements LanguageGenerator {
}
case 'assertSnapshot': {
const commentIfNeeded = this._isTest ? '' : '// ';
- return `${commentIfNeeded}await expect(${subject}.${this._asLocator(action.selector)}).toMatchAriaSnapshot(${quoteMultiline(action.snapshot, `${commentIfNeeded} `)});`;
+ return `${commentIfNeeded}await expect(${subject}.${this._asLocator(action.selector)}).toMatchAriaSnapshot(${quoteMultiline(action.ariaSnapshot, `${commentIfNeeded} `)});`;
}
}
}
diff --git a/packages/playwright-core/src/server/codegen/python.ts b/packages/playwright-core/src/server/codegen/python.ts
index d7b056f083..314489441a 100644
--- a/packages/playwright-core/src/server/codegen/python.ts
+++ b/packages/playwright-core/src/server/codegen/python.ts
@@ -128,7 +128,7 @@ export class PythonLanguageGenerator implements LanguageGenerator {
return `expect(${subject}.${this._asLocator(action.selector)}).${assertion};`;
}
case 'assertSnapshot':
- return `expect(${subject}.${this._asLocator(action.selector)}).to_match_aria_snapshot(${quote(action.snapshot)})`;
+ return `expect(${subject}.${this._asLocator(action.selector)}).to_match_aria_snapshot(${quote(action.ariaSnapshot)})`;
}
}
diff --git a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
index 089cb0a6ea..e58c2ed005 100644
--- a/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
+++ b/packages/playwright-core/src/server/dispatchers/browserContextDispatcher.ts
@@ -34,7 +34,8 @@ import { WebSocketRouteDispatcher } from './webSocketRouteDispatcher';
import { WritableStreamDispatcher } from './writableStreamDispatcher';
import { createGuid } from '../utils/crypto';
import { urlMatches } from '../../utils/isomorphic/urlMatch';
-import { RecorderApp } from '../recorder/recorderApp';
+import { Recorder } from '../recorder';
+import { ProgrammaticRecorderApp, RecorderApp } from '../recorder/recorderApp';
import type { Artifact } from '../artifact';
import type { ConsoleMessage } from '../console';
@@ -199,6 +200,9 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
page: PageDispatcher.fromNullable(this, request.frame()?._page.initializedOrUndefined()),
});
});
+ this.addObjectListener(BrowserContext.Events.RecorderEvent, ({ event, data }: { event: string, data: any }) => {
+ this._dispatchEvent('recorderEvent', { event, data });
+ });
}
private _shouldDispatchNetworkEvent(request: Request, event: channels.BrowserContextUpdateSubscriptionParams['event'] & channels.PageUpdateSubscriptionParams['event']): boolean {
@@ -332,9 +336,20 @@ export class BrowserContextDispatcher extends Dispatcher<BrowserContext, channel
}
async enableRecorder(params: channels.BrowserContextEnableRecorderParams, progress: Progress): Promise<void> {
+ const recorder = await Recorder.forContext(this._context, params);
+ if (params.recorderMode === 'api') {
+ await ProgrammaticRecorderApp.run(this._context, recorder);
+ return;
+ }
await RecorderApp.show(this._context, params);
}
+ async disableRecorder(params: channels.BrowserContextDisableRecorderParams, progress: Progress): Promise<void> {
+ const recorder = Recorder.existingForContext(this._context);
+ if (recorder)
+ recorder.setMode('none');
+ }
+
async pause(params: channels.BrowserContextPauseParams, progress: Progress) {
// Debugger will take care of this.
}
diff --git a/packages/playwright-core/src/server/recorder.ts b/packages/playwright-core/src/server/recorder.ts
index 8d5d995dcb..8579d0aa5c 100644
--- a/packages/playwright-core/src/server/recorder.ts
+++ b/packages/playwright-core/src/server/recorder.ts
@@ -82,7 +82,7 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
private _debugger: Debugger;
private _omitCallTracking = false;
private _currentLanguage: Language = 'javascript';
- private _recorderMode: 'record' | 'perform';
+ private _recorderMode: 'default' | 'api';
private _signalProcessor: RecorderSignalProcessor;
private _pageAliases = new Map<Page, string>();
@@ -102,6 +102,10 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
return recorderPromise;
}
+ static existingForContext(context: BrowserContext): Recorder | undefined {
+ return (context as any)[recorderSymbol] as Recorder;
+ }
+
private static async _create(context: BrowserContext, params: channels.BrowserContextEnableRecorderParams = {}): Promise<Recorder> {
const recorder = new Recorder(context, params);
await recorder._install();
@@ -113,7 +117,7 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
this._context = context;
this._params = params;
this._mode = params.mode || 'none';
- this._recorderMode = params.recorderMode ?? 'perform';
+ this._recorderMode = params.recorderMode ?? 'default';
this.handleSIGINT = params.handleSIGINT;
this._signalProcessor = new RecorderSignalProcessor();
@@ -172,7 +176,6 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
}
const uiState: UIState = {
mode: this._mode,
- recorderMode: this._recorderMode,
actionPoint,
actionSelector,
ariaTemplate: this._highlightedElement.ariaTemplate,
@@ -222,7 +225,7 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
await this._context.exposeBinding(progress, '__pw_recorderRecordAction', false,
(source: BindingSource, action: actions.Action) => this._recordAction(source.frame, action));
- await this._context.extendInjectedScript(rawRecorderSource.source);
+ await this._context.extendInjectedScript(rawRecorderSource.source, { recorderMode: this._recorderMode });
});
if (this._debugger.isPaused())
@@ -510,7 +513,7 @@ export class Recorder extends EventEmitter<RecorderEventMap> implements Instrume
frame: frameDescription,
action,
description: undefined,
- startTime: monotonicTime()
+ startTime: monotonicTime(),
};
return actionInContext;
}
diff --git a/packages/playwright-core/src/server/recorder/recorderApp.ts b/packages/playwright-core/src/server/recorder/recorderApp.ts
index 3c89c9bb2d..201fdf9d3f 100644
--- a/packages/playwright-core/src/server/recorder/recorderApp.ts
+++ b/packages/playwright-core/src/server/recorder/recorderApp.ts
@@ -25,12 +25,12 @@ import { launchApp } from '../launchApp';
import { ProgressController } from '../progress';
import { ThrottledFile } from './throttledFile';
import { languageSet } from '../codegen/languages';
-import { collapseActions } from './recorderUtils';
+import { collapseActions, shouldMergeAction } from './recorderUtils';
import { generateCode } from '../codegen/language';
import { Recorder, RecorderEvent } from '../recorder';
import { monotonicTime } from '../../utils/isomorphic/time';
+import { BrowserContext } from '../browserContext';
-import type { BrowserContext } from '../browserContext';
import type { Page } from '../page';
import type * as actions from '@recorder/actions';
import type { CallLog, ElementInfo, Mode, Source } from '@recorder/recorderTypes';
@@ -165,6 +165,10 @@ export class RecorderApp {
if (process.env.PW_CODEGEN_NO_INSPECTOR)
return;
const recorder = await Recorder.forContext(context, params);
+ if (params.recorderMode === 'api') {
+ await ProgrammaticRecorderApp.run(context, recorder);
+ return;
+ }
await RecorderApp._show(recorder, context, params);
}
@@ -359,4 +363,20 @@ export class RecorderApp {
}
}
+export class ProgrammaticRecorderApp {
+ static async run(inspectedContext: BrowserContext, recorder: Recorder) {
+ let lastAction: actions.ActionInContext | null = null;
+ recorder.on(RecorderEvent.ActionAdded, action => {
+ if (!lastAction || !shouldMergeAction(action, lastAction))
+ inspectedContext.emit(BrowserContext.Events.RecorderEvent, { event: 'actionAdded', data: action });
+ else
+ inspectedContext.emit(BrowserContext.Events.RecorderEvent, { event: 'actionUpdated', data: action });
+ lastAction = action;
+ });
+ recorder.on(RecorderEvent.SignalAdded, signal => {
+ inspectedContext.emit(BrowserContext.Events.RecorderEvent, { event: 'signalAdded', data: signal });
+ });
+ }
+}
+
const recorderAppSymbol = Symbol('recorderApp');
diff --git a/packages/playwright-core/src/server/recorder/recorderUtils.ts b/packages/playwright-core/src/server/recorder/recorderUtils.ts
index 7694cb5208..61e4e31d5d 100644
--- a/packages/playwright-core/src/server/recorder/recorderUtils.ts
+++ b/packages/playwright-core/src/server/recorder/recorderUtils.ts
@@ -73,13 +73,25 @@ export async function frameForAction(pageAliases: Map<Page, string>, actionInCon
return result.frame;
}
+function isSameAction(a: actions.ActionInContext, b: actions.ActionInContext): boolean {
+ return a.action.name === b.action.name && a.frame.pageAlias === b.frame.pageAlias && a.frame.framePath.join('|') === b.frame.framePath.join('|');
+}
+
+function isSameSelector(action: actions.ActionInContext, lastAction: actions.ActionInContext): boolean {
+ return 'selector' in action.action && 'selector' in lastAction.action && action.action.selector === lastAction.action.selector;
+}
+
+export function shouldMergeAction(action: actions.ActionInContext, lastAction: actions.ActionInContext | undefined): boolean {
+ if (!lastAction)
+ return false;
+ return isSameAction(action, lastAction) && (action.action.name === 'navigate' || (action.action.name === 'fill' && isSameSelector(action, lastAction)));
+}
+
export function collapseActions(actions: actions.ActionInContext[]): actions.ActionInContext[] {
const result: actions.ActionInContext[] = [];
for (const action of actions) {
const lastAction = result[result.length - 1];
- const isSameAction = lastAction && lastAction.action.name === action.action.name && lastAction.frame.pageAlias === action.frame.pageAlias && lastAction.frame.framePath.join('|') === action.frame.framePath.join('|');
- const isSameSelector = lastAction && 'selector' in lastAction.action && 'selector' in action.action && action.action.selector === lastAction.action.selector;
- const shouldMerge = isSameAction && (action.action.name === 'navigate' || (action.action.name === 'fill' && isSameSelector));
+ const shouldMerge = shouldMergeAction(action, lastAction);
if (!shouldMerge) {
result.push(action);
continue;
diff --git a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
index 6739497d09..6874c1dc99 100644
--- a/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
+++ b/packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts
@@ -88,6 +88,7 @@ export const methodMetainfo = new Map<string, { internal?: boolean, title?: stri
['BrowserContext.storageState', { title: 'Get storage state', }],
['BrowserContext.pause', { title: 'Pause', }],
['BrowserContext.enableRecorder', { internal: true, }],
+ ['BrowserContext.disableRecorder', { internal: true, }],
['BrowserContext.newCDPSession', { internal: true, }],
['BrowserContext.harStart', { internal: true, }],
['BrowserContext.harExport', { internal: true, }],
diff --git a/packages/playwright-mdd/src/loop.ts b/packages/playwright-mdd/src/loop.ts
index 0ee4994d56..426d92419a 100644
--- a/packages/playwright-mdd/src/loop.ts
+++ b/packages/playwright-mdd/src/loop.ts
@@ -19,6 +19,7 @@ import OpenAI from 'openai';
import debug from 'debug';
import { zodToJsonSchema } from 'zod-to-json-schema';
+const model = 'gpt-4.1';
/* eslint-disable no-console */
export interface Context {
@@ -59,7 +60,7 @@ async function runTask(openai: OpenAI, context: Context, task: string) {
for (let iteration = 0; iteration < 5; ++iteration) {
debug('history')(messages);
const response = await openai.chat.completions.create({
- model: 'gpt-4.1',
+ model,
messages,
tools: context.tools.map(asOpenAIDeclaration),
tool_choice: 'auto'
@@ -128,3 +129,21 @@ function asOpenAIDeclaration(tool: Tool<any>): OpenAI.Chat.Completions.ChatCompl
},
};
}
+
+export async function runOneShot(prompt: string): Promise<string> {
+ const openai = new OpenAI();
+ const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
+ {
+ role: 'user',
+ content: prompt
+ }
+ ];
+ const response = await openai.chat.completions.create({
+ model,
+ messages,
+ });
+ const message = response.choices[0].message;
+ if (!message.content)
+ throw new Error('Unexpected response from LLM: ' + message.content);
+ return message.content;
+}
diff --git a/packages/playwright-mdd/src/program.ts b/packages/playwright-mdd/src/program.ts
index 396103dc5a..e5931bb23c 100644
--- a/packages/playwright-mdd/src/program.ts
+++ b/packages/playwright-mdd/src/program.ts
@@ -20,6 +20,7 @@ import dotenv from 'dotenv';
import { program } from 'commander';
import { Context } from './codegen/context';
+import { runRecorderLoop } from './recorderLoop';
/* eslint-disable no-console */
@@ -28,10 +29,9 @@ dotenv.config();
const packageJSON = require('../package.json');
program
+ .command('run <spec>').description('Run a test')
.version('Version ' + packageJSON.version)
- .argument('<spec>', 'The test spec to generate code for')
.option('-o, --output <path>', 'The path to save the generated code')
- .name(packageJSON.name)
.action(async (spec, options) => {
const content = await fs.promises.readFile(spec, 'utf8');
const codegenContext = new Context();
@@ -42,4 +42,11 @@ program
console.log(code);
});
+program
+ .command('record').description('Record a test')
+ .version('Version ' + packageJSON.version)
+ .action(async () => {
+ await runRecorderLoop();
+ });
+
export { program };
diff --git a/packages/playwright-mdd/src/recorderLoop.ts b/packages/playwright-mdd/src/recorderLoop.ts
new file mode 100644
index 0000000000..7985626aff
--- /dev/null
+++ b/packages/playwright-mdd/src/recorderLoop.ts
@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* eslint-disable no-console */
+
+import { chromium } from 'playwright-core';
+
+import { runOneShot } from './loop';
+
+import type { BrowserContext } from '../../playwright-core/src/client/browserContext';
+import type * as actions from '@recorder/actions';
+
+export async function runRecorderLoop() {
+ const browser = await chromium.launch({ headless: false });
+ const context = await browser.newContext() as BrowserContext;
+ await context._enableRecorder({
+ mode: 'recording',
+ recorderMode: 'api',
+ }, async (event, data) => {
+ if (event !== 'actionAdded')
+ return;
+ const action = data.action as actions.Action;
+ if (action.name !== 'click' && action.name !== 'press') {
+ console.log('============= action', action.name);
+ return;
+ }
+ const response = await runOneShot(prompt(action)).catch(e => {
+ console.error(e);
+ });
+ console.log(response);
+ });
+ const page = await context.newPage();
+ await page.goto('https://playwright.dev/');
+}
+
+const prompt = (action: actions.ClickAction | actions.PressAction) => [
+ `- User performed an action on a page.`,
+ `- Please describe the action in a single phrase.`,
+ `- You'll be asked to perform the action again, so make sure to describe the action in a way that is easy to understand and perform.`,
+ `- Action: "${action.name}"`,
+ `- Element: [${action.selector}]`,
+ `- Snapshot:`,
+ action.ariaSnapshot,
+].join('\n');
diff --git a/packages/protocol/src/channels.d.ts b/packages/protocol/src/channels.d.ts
index 7b8e8a90ed..f8ae674528 100644
--- a/packages/protocol/src/channels.d.ts
+++ b/packages/protocol/src/channels.d.ts
@@ -1618,6 +1618,7 @@ export interface BrowserContextEventTarget {
on(event: 'requestFailed', callback: (params: BrowserContextRequestFailedEvent) => void): this;
on(event: 'requestFinished', callback: (params: BrowserContextRequestFinishedEvent) => void): this;
on(event: 'response', callback: (params: BrowserContextResponseEvent) => void): this;
+ on(event: 'recorderEvent', callback: (params: BrowserContextRecorderEventEvent) => void): this;
}
export interface BrowserContextChannel extends BrowserContextEventTarget, EventTargetChannel {
_type_BrowserContext: boolean;
@@ -1641,6 +1642,7 @@ export interface BrowserContextChannel extends BrowserContextEventTarget, EventT
storageState(params: BrowserContextStorageStateParams, progress?: Progress): Promise<BrowserContextStorageStateResult>;
pause(params?: BrowserContextPauseParams, progress?: Progress): Promise<BrowserContextPauseResult>;
enableRecorder(params: BrowserContextEnableRecorderParams, progress?: Progress): Promise<BrowserContextEnableRecorderResult>;
+ disableRecorder(params?: BrowserContextDisableRecorderParams, progress?: Progress): Promise<BrowserContextDisableRecorderResult>;
newCDPSession(params: BrowserContextNewCDPSessionParams, progress?: Progress): Promise<BrowserContextNewCDPSessionResult>;
harStart(params: BrowserContextHarStartParams, progress?: Progress): Promise<BrowserContextHarStartResult>;
harExport(params: BrowserContextHarExportParams, progress?: Progress): Promise<BrowserContextHarExportResult>;
@@ -1714,6 +1716,10 @@ export type BrowserContextResponseEvent = {
response: ResponseChannel,
page?: PageChannel,
};
+export type BrowserContextRecorderEventEvent = {
+ event: string,
+ data: any,
+};
export type BrowserContextAddCookiesParams = {
cookies: SetNetworkCookie[],
};
@@ -1887,7 +1893,7 @@ export type BrowserContextPauseResult = void;
export type BrowserContextEnableRecorderParams = {
language?: string,
mode?: 'inspecting' | 'recording',
- recorderMode?: 'record' | 'perform',
+ recorderMode?: 'default' | 'api',
pauseOnNextStatement?: boolean,
testIdAttributeName?: string,
launchOptions?: any,
@@ -1901,7 +1907,7 @@ export type BrowserContextEnableRecorderParams = {
export type BrowserContextEnableRecorderOptions = {
language?: string,
mode?: 'inspecting' | 'recording',
- recorderMode?: 'record' | 'perform',
+ recorderMode?: 'default' | 'api',
pauseOnNextStatement?: boolean,
testIdAttributeName?: string,
launchOptions?: any,
@@ -1913,6 +1919,9 @@ export type BrowserContextEnableRecorderOptions = {
omitCallTracking?: boolean,
};
export type BrowserContextEnableRecorderResult = void;
+export type BrowserContextDisableRecorderParams = {};
+export type BrowserContextDisableRecorderOptions = {};
+export type BrowserContextDisableRecorderResult = void;
export type BrowserContextNewCDPSessionParams = {
page?: PageChannel,
frame?: FrameChannel,
@@ -2039,6 +2048,7 @@ export interface BrowserContextEvents {
'requestFailed': BrowserContextRequestFailedEvent;
'requestFinished': BrowserContextRequestFinishedEvent;
'response': BrowserContextResponseEvent;
+ 'recorderEvent': BrowserContextRecorderEventEvent;
}
// ----------- Page -----------
diff --git a/packages/protocol/src/protocol.yml b/packages/protocol/src/protocol.yml
index fe889d8407..3b34797d31 100644
--- a/packages/protocol/src/protocol.yml
+++ b/packages/protocol/src/protocol.yml
@@ -1365,8 +1365,8 @@ BrowserContext:
recorderMode:
type: enum?
literals:
- - record
- - perform
+ - default
+ - api
pauseOnNextStatement: boolean?
testIdAttributeName: string?
launchOptions: json?
@@ -1377,6 +1377,9 @@ BrowserContext:
handleSIGINT: boolean?
omitCallTracking: boolean?
+ disableRecorder:
+ internal: true
+
newCDPSession:
internal: true
parameters:
@@ -1540,6 +1543,11 @@ BrowserContext:
response: Response
page: Page?
+ recorderEvent:
+ parameters:
+ event: string
+ data: json
+
Page:
type: interface
diff --git a/packages/recorder/src/actions.d.ts b/packages/recorder/src/actions.d.ts
index d4c74b2656..a751dbf40e 100644
--- a/packages/recorder/src/actions.d.ts
+++ b/packages/recorder/src/actions.d.ts
@@ -36,6 +36,7 @@ export type ActionName =
export type ActionBase = {
name: ActionName,
signals: Signal[],
+ ariaSnapshot?: string,
};
export type ActionWithSelector = ActionBase & {
@@ -116,7 +117,7 @@ export type AssertVisibleAction = ActionWithSelector & {
export type AssertSnapshotAction = ActionWithSelector & {
name: 'assertSnapshot',
- snapshot: string,
+ ariaSnapshot: string,
};
export type Action = ClickAction | CheckAction | ClosesPageAction | OpenPageAction | UncheckAction | FillAction | NavigateAction | PressAction | SelectAction | SetInputFilesAction | AssertTextAction | AssertValueAction | AssertCheckedAction | AssertVisibleAction | AssertSnapshotAction;
diff --git a/packages/recorder/src/recorderTypes.d.ts b/packages/recorder/src/recorderTypes.d.ts
index e098ec11e0..9d46447c17 100644
--- a/packages/recorder/src/recorderTypes.d.ts
+++ b/packages/recorder/src/recorderTypes.d.ts
@@ -53,7 +53,6 @@ export type OverlayState = {
export type UIState = {
mode: Mode;
- recorderMode: 'record' | 'perform';
actionPoint?: Point;
actionSelector?: string;
ariaTemplate?: AriaTemplateNode;
diff --git a/packages/trace-viewer/src/ui/snapshotTab.tsx b/packages/trace-viewer/src/ui/snapshotTab.tsx
index c10875241c..bfef4840d6 100644
--- a/packages/trace-viewer/src/ui/snapshotTab.tsx
+++ b/packages/trace-viewer/src/ui/snapshotTab.tsx
@@ -254,7 +254,6 @@ export const InspectModeController: React.FunctionComponent<{
const ariaTemplate = parsedSnapshot?.errors.length === 0 ? parsedSnapshot.fragment : undefined;
recorder.setUIState({
mode: isInspecting ? 'inspecting' : 'none',
- recorderMode: 'perform',
actionSelector,
ariaTemplate,
language: sdkLanguage,
diff --git a/tests/library/inspector/cli-codegen-1.spec.ts b/tests/library/inspector/cli-codegen-1.spec.ts
index a3b7a8ec86..92d65851a8 100644
--- a/tests/library/inspector/cli-codegen-1.spec.ts
+++ b/tests/library/inspector/cli-codegen-1.spec.ts
@@ -14,13 +14,10 @@
* limitations under the License.
*/
-import { test, expect, matrixDescribe } from './inspectorTest';
+import { test, expect } from './inspectorTest';
import type { ConsoleMessage } from 'playwright';
-matrixDescribe<('record' | 'perform')>('cli codegen', ['record', 'perform'], recorderMode => {
- test.skip(({ mode }) => mode !== 'default');
- test.use({ recorderMode });
-
+test.describe('cli codegen', () => {
test('should click', async ({ openRecorder }) => {
const { page, recorder } = await openRecorder();
@@ -761,7 +758,6 @@ await page.Locator(\"#age\").SelectOptionAsync(new[] { \"2\" });`);
test('should await popup', async ({ openRecorder, server }) => {
test.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/36461' });
- test.skip(recorderMode === 'record', 'Navigation is dispatched concurrently (before click is recorded)');
const { page, recorder } = await openRecorder();
server.setRoute('/popup', (req, res) => {
@@ -821,8 +817,6 @@ await page1.GetByRole(AriaRole.Button, new() { Name = \"Click me\" }).ClickAsync
});
test('should attribute navigation to click', async ({ openRecorder }) => {
- test.skip(recorderMode === 'record', 'Navigation is dispatched concurrently (before click is recorded)');
-
const { page, recorder } = await openRecorder();
await recorder.setContentAndWait(`<a onclick="window.location.href='about:blank#foo'">link</a>`);
@@ -878,8 +872,6 @@ await page.GetByText("link").ClickAsync();`);
});
test('should attribute navigation to press/fill', async ({ openRecorder }) => {
- test.skip(recorderMode === 'record', 'Navigation is dispatched concurrently (before press/fill is recorded)');
-
const { page, recorder } = await openRecorder();
await recorder.setContentAndWait(`<input /><script>document.querySelector('input').addEventListener('input', () => window.location.href = 'about:blank#foo');</script>`);
diff --git a/tests/library/inspector/cli-codegen-2.spec.ts b/tests/library/inspector/cli-codegen-2.spec.ts
index 50991805ce..313acc6b18 100644
--- a/tests/library/inspector/cli-codegen-2.spec.ts
+++ b/tests/library/inspector/cli-codegen-2.spec.ts
@@ -14,13 +14,12 @@
* limitations under the License.
*/
-import { test, expect, matrixDescribe } from './inspectorTest';
+import { test, expect } from './inspectorTest';
import * as url from 'url';
import fs from 'fs';
-matrixDescribe<('record' | 'perform')>('cli codegen', ['record', 'perform'], recorderMode => {
+test.describe('cli codegen', () => {
test.skip(({ mode }) => mode !== 'default');
- test.use({ recorderMode });
test('should contain open page', async ({ openRecorder }) => {
const { recorder } = await openRecorder();
@@ -196,7 +195,6 @@ await page.GetByRole(AriaRole.Button, new() { Name = "Choose File" }).SetInputFi
});
test('should download files', async ({ openRecorder, server }) => {
- test.skip(recorderMode === 'record', 'Navigation is dispatched concurrently (before click is recorded)');
const { page, recorder } = await openRecorder();
server.setRoute('/download', (req, res) => {
@@ -248,7 +246,6 @@ var download = await page.RunAndWaitForDownloadAsync(async () =>
});
test('should handle dialogs', async ({ openRecorder }) => {
- test.skip(recorderMode === 'record', 'Navigation is dispatched concurrently (before click is recorded)');
const { page, recorder } = await openRecorder();
await recorder.setContentAndWait(`
@@ -313,7 +310,6 @@ await page.GetByRole(AriaRole.Button, new() { Name = "click me" }).ClickAsync();
});
test('should record open in a new tab with url', async ({ openRecorder, browserName }) => {
- test.skip(recorderMode === 'record', 'Navigation is dispatched concurrently (before click is recorded)');
const { page, recorder } = await openRecorder();
await recorder.setContentAndWait(`<a href="about:blank?foo">link</a>`);
diff --git a/tests/library/inspector/cli-codegen-3.spec.ts b/tests/library/inspector/cli-codegen-3.spec.ts
index a5abaa8f50..d71276b5dd 100644
--- a/tests/library/inspector/cli-codegen-3.spec.ts
+++ b/tests/library/inspector/cli-codegen-3.spec.ts
@@ -16,12 +16,11 @@
import type { TestServer } from 'tests/config/testserver';
import type { Recorder } from './inspectorTest';
-import { test, expect, matrixDescribe } from './inspectorTest';
+import { test, expect } from './inspectorTest';
import type { Page } from '@playwright/test';
-matrixDescribe<('record' | 'perform')>('cli codegen', ['record', 'perform'], recorderMode => {
+test.describe('cli codegen', () => {
test.skip(({ mode }) => mode !== 'default');
- test.use({ recorderMode });
test('should click locator.first', async ({ openRecorder }) => {
const { page, recorder } = await openRecorder();
@@ -658,8 +657,8 @@ await page.GetByRole(AriaRole.Textbox, new() { Name = \"Coun\\\"try\" }).ClickAs
expect(message.text()).toBe('clicked');
expect(await page.evaluate('log')).toEqual([
'pointermove', 'mousemove',
- // There is no second mouse move in record mode
- ...(recorderMode === 'record' ? [] : ['pointermove', 'mousemove']),
+ 'pointermove',
+ 'mousemove',
'pointerdown', 'mousedown',
'pointerup', 'mouseup',
'click',
@@ -667,8 +666,6 @@ await page.GetByRole(AriaRole.Textbox, new() { Name = \"Coun\\\"try\" }).ClickAs
});
test('should consume contextmenu events, despite a custom context menu', async ({ openRecorder, browserName, platform }) => {
- test.skip(recorderMode === 'record', 'It actually works in record mode, perform mode is broken see comments inline');
-
const { page, recorder } = await openRecorder();
await recorder.setContentAndWait(`
diff --git a/tests/library/inspector/inspectorTest.ts b/tests/library/inspector/inspectorTest.ts
index 3baf057603..e7ed9a9526 100644
--- a/tests/library/inspector/inspectorTest.ts
+++ b/tests/library/inspector/inspectorTest.ts
@@ -28,9 +28,8 @@ export { expect } from '@playwright/test';
type CLITestArgs = {
recorderPageGetter: () => Promise<Page>;
closeRecorder: () => Promise<void>;
- openRecorder: (options?: { testIdAttributeName: string, recorderMode?: 'record' | 'perform' }) => Promise<{ recorder: Recorder, page: Page }>;
+ openRecorder: (options?: { testIdAttributeName: string }) => Promise<{ recorder: Recorder, page: Page }>;
runCLI: (args: string[], options?: { autoExitWhen?: string }) => CLIMock;
- recorderMode: 'record' | 'perform';
};
const codegenLang2Id: Map<string, string> = new Map([
@@ -85,20 +84,17 @@ export const test = contextTest.extend<CLITestArgs>({
});
},
- openRecorder: async ({ context, recorderPageGetter, recorderMode }, use) => {
+ openRecorder: async ({ context, recorderPageGetter }, use) => {
await use(async options => {
await (context as any)._enableRecorder({
language: 'javascript',
mode: 'recording',
- recorderMode,
...options
});
const page = await context.newPage();
return { page, recorder: new Recorder(page, await recorderPageGetter()) };
});
},
-
- recorderMode: 'perform',
});
export class Recorder {
@@ -285,11 +281,3 @@ class CLIMock {
return stripAnsi(this.process.output);
}
}
-
-export function matrixDescribe<T = string>(name: string, matrix: T[], fn: (mode: T) => void) {
- for (const mode of matrix) {
- test.describe(`${name} ${mode}`, () => {
- fn(mode as T);
- });
- }
-}