Filip/playwright
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

feat(trace): trace more actions (#3853)

Browse source
This commit is contained in:
Dmitry Gozman 2020-09-11 13:28:24 -07:00 committed by GitHub
parent 75e847a6fa
commit 263aa06fa4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
5 changed files with 136 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

66
src/dispatchers/elementHandlerDispatcher.ts
View file

@ -75,59 +75,83 @@ export class ElementHandleDispatcher extends JSHandleDispatcher implements chann
await this._elementHandle.scrollIntoViewIfNeeded(params); await this._elementHandle.scrollIntoViewIfNeeded(params);
} }
async hover(params: channels.ElementHandleHoverParams): Promise<void> { async hover(params: channels.ElementHandleHoverParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.hover(params); const actionMetadata: ActionMetadata = { ...metadata, type: 'hover', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.hover(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async click(params: channels.ElementHandleClickParams, metadata?: channels.Metadata): Promise<void> { async click(params: channels.ElementHandleClickParams, metadata?: channels.Metadata): Promise<void> {
const clickMetadata: ActionMetadata = { ...metadata, type: 'click', target: this._elementHandle, page: this._elementHandle._page }; const actionMetadata: ActionMetadata = { ...metadata, type: 'click', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => { return runAbortableTask(async progress => {
return await this._elementHandle.click(progress, params); return await this._elementHandle.click(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), clickMetadata); }, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async dblclick(params: channels.ElementHandleDblclickParams): Promise<void> { async dblclick(params: channels.ElementHandleDblclickParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.dblclick(params); const actionMetadata: ActionMetadata = { ...metadata, type: 'dblclick', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.dblclick(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async selectOption(params: channels.ElementHandleSelectOptionParams): Promise<channels.ElementHandleSelectOptionResult> { async selectOption(params: channels.ElementHandleSelectOptionParams, metadata?: channels.Metadata): Promise<channels.ElementHandleSelectOptionResult> {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle); const actionMetadata: ActionMetadata = { ...metadata, type: 'selectOption', target: this._elementHandle, page: this._elementHandle._page };
return { values: await this._elementHandle.selectOption(elements, params.options || [], params) }; return runAbortableTask(async progress => {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle);
return { values: await this._elementHandle.selectOption(progress, elements, params.options || [], params) };
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async fill(params: channels.ElementHandleFillParams, metadata?: channels.Metadata): Promise<void> { async fill(params: channels.ElementHandleFillParams, metadata?: channels.Metadata): Promise<void> {
const fillMetadata: ActionMetadata = { ...metadata, type: 'fill', value: params.value, target: this._elementHandle, page: this._elementHandle._page }; const actionMetadata: ActionMetadata = { ...metadata, type: 'fill', value: params.value, target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => { return runAbortableTask(async progress => {
return await this._elementHandle.fill(progress, params.value, params); return await this._elementHandle.fill(progress, params.value, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), fillMetadata); }, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async selectText(params: channels.ElementHandleSelectTextParams): Promise<void> { async selectText(params: channels.ElementHandleSelectTextParams): Promise<void> {
await this._elementHandle.selectText(params); await this._elementHandle.selectText(params);
} }
async setInputFiles(params: channels.ElementHandleSetInputFilesParams): Promise<void> { async setInputFiles(params: channels.ElementHandleSetInputFilesParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.setInputFiles(params.files, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'setInputFiles', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.setInputFiles(progress, params.files, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async focus(): Promise<void> { async focus(): Promise<void> {
await this._elementHandle.focus(); await this._elementHandle.focus();
} }
async type(params: channels.ElementHandleTypeParams): Promise<void> { async type(params: channels.ElementHandleTypeParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.type(params.text, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'type', value: params.text, target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.type(progress, params.text, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async press(params: channels.ElementHandlePressParams): Promise<void> { async press(params: channels.ElementHandlePressParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.press(params.key, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'press', value: params.key, target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.press(progress, params.key, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async check(params: channels.ElementHandleCheckParams): Promise<void> { async check(params: channels.ElementHandleCheckParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.check(params); const actionMetadata: ActionMetadata = { ...metadata, type: 'check', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.check(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async uncheck(params: channels.ElementHandleUncheckParams): Promise<void> { async uncheck(params: channels.ElementHandleUncheckParams, metadata?: channels.Metadata): Promise<void> {
await this._elementHandle.uncheck(params); const actionMetadata: ActionMetadata = { ...metadata, type: 'uncheck', target: this._elementHandle, page: this._elementHandle._page };
return runAbortableTask(async progress => {
return await this._elementHandle.uncheck(progress, params);
}, this._elementHandle._page._timeoutSettings.timeout(params), actionMetadata);
} }
async boundingBox(): Promise<channels.ElementHandleBoundingBoxResult> { async boundingBox(): Promise<channels.ElementHandleBoundingBoxResult> {

70
src/dispatchers/frameDispatcher.ts
View file

@ -111,21 +111,24 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
} }
async click(params: channels.FrameClickParams, metadata?: channels.Metadata): Promise<void> { async click(params: channels.FrameClickParams, metadata?: channels.Metadata): Promise<void> {
const clickMetadata: ActionMetadata = { ...metadata, type: 'click', target: params.selector, page: this._frame._page }; const actionMetadata: ActionMetadata = { ...metadata, type: 'click', target: params.selector, page: this._frame._page };
await runAbortableTask(async progress => { return runAbortableTask(async progress => {
return await this._frame.click(progress, params.selector, params); return await this._frame.click(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), clickMetadata); }, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async dblclick(params: channels.FrameDblclickParams): Promise<void> { async dblclick(params: channels.FrameDblclickParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.dblclick(params.selector, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'dblclick', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.dblclick(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async fill(params: channels.FrameFillParams, metadata?: channels.Metadata): Promise<void> { async fill(params: channels.FrameFillParams, metadata?: channels.Metadata): Promise<void> {
const fillMetadata: ActionMetadata = { ...metadata, type: 'fill', value: params.value, target: params.selector, page: this._frame._page }; const actionMetadata: ActionMetadata = { ...metadata, type: 'fill', value: params.value, target: params.selector, page: this._frame._page };
await runAbortableTask(async progress => { return runAbortableTask(async progress => {
return await this._frame.fill(progress, params.selector, params.value, params); return await this._frame.fill(progress, params.selector, params.value, params);
}, this._frame._page._timeoutSettings.timeout(params), fillMetadata); }, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async focus(params: channels.FrameFocusParams): Promise<void> { async focus(params: channels.FrameFocusParams): Promise<void> {
@ -150,33 +153,54 @@ export class FrameDispatcher extends Dispatcher<Frame, channels.FrameInitializer
return { value: value === null ? undefined : value }; return { value: value === null ? undefined : value };
} }
async hover(params: channels.FrameHoverParams): Promise<void> { async hover(params: channels.FrameHoverParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.hover(params.selector, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'hover', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.hover(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async selectOption(params: channels.FrameSelectOptionParams): Promise<channels.FrameSelectOptionResult> { async selectOption(params: channels.FrameSelectOptionParams, metadata?: channels.Metadata): Promise<channels.FrameSelectOptionResult> {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle); const actionMetadata: ActionMetadata = { ...metadata, type: 'selectOption', target: params.selector, page: this._frame._page };
return { values: await this._frame.selectOption(params.selector, elements, params.options || [], params) }; return runAbortableTask(async progress => {
const elements = (params.elements || []).map(e => (e as ElementHandleDispatcher)._elementHandle);
return { values: await this._frame.selectOption(progress, params.selector, elements, params.options || [], params) };
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async setInputFiles(params: channels.FrameSetInputFilesParams): Promise<void> { async setInputFiles(params: channels.FrameSetInputFilesParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.setInputFiles(params.selector, params.files, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'setInputFiles', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.setInputFiles(progress, params.selector, params.files, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async type(params: channels.FrameTypeParams): Promise<void> { async type(params: channels.FrameTypeParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.type(params.selector, params.text, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'type', value: params.text, target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.type(progress, params.selector, params.text, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async press(params: channels.FramePressParams): Promise<void> { async press(params: channels.FramePressParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.press(params.selector, params.key, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'press', value: params.key, target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.press(progress, params.selector, params.key, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async check(params: channels.FrameCheckParams): Promise<void> { async check(params: channels.FrameCheckParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.check(params.selector, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'check', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.check(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async uncheck(params: channels.FrameUncheckParams): Promise<void> { async uncheck(params: channels.FrameUncheckParams, metadata?: channels.Metadata): Promise<void> {
await this._frame.uncheck(params.selector, params); const actionMetadata: ActionMetadata = { ...metadata, type: 'uncheck', target: params.selector, page: this._frame._page };
return runAbortableTask(async progress => {
return await this._frame.uncheck(progress, params.selector, params);
}, this._frame._page._timeoutSettings.timeout(params), actionMetadata);
} }
async waitForFunction(params: channels.FrameWaitForFunctionParams): Promise<channels.FrameWaitForFunctionResult> { async waitForFunction(params: channels.FrameWaitForFunctionParams): Promise<channels.FrameWaitForFunctionResult> {

66
src/server/dom.ts
View file

@ -358,11 +358,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return 'done'; return 'done';
} }
hover(options: types.PointerActionOptions & types.PointerActionWaitOptions = {}): Promise<void> { async hover(progress: Progress, options: types.PointerActionOptions & types.PointerActionWaitOptions): Promise<void> {
return this._page._runAbortableTask(async progress => { const result = await this._hover(progress, options);
const result = await this._hover(progress, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
_hover(progress: Progress, options: types.PointerActionOptions & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> { _hover(progress: Progress, options: types.PointerActionOptions & types.PointerActionWaitOptions): Promise<'error:notconnected' | 'done'> {
@ -378,22 +376,18 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return this._retryPointerAction(progress, 'click', true /* waitForEnabled */, point => this._page.mouse.click(point.x, point.y, options), options); return this._retryPointerAction(progress, 'click', true /* waitForEnabled */, point => this._page.mouse.click(point.x, point.y, options), options);
} }
dblclick(options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}): Promise<void> { async dblclick(progress: Progress, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions): Promise<void> {
return this._page._runAbortableTask(async progress => { const result = await this._dblclick(progress, options);
const result = await this._dblclick(progress, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
_dblclick(progress: Progress, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> { _dblclick(progress: Progress, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> {
return this._retryPointerAction(progress, 'dblclick', true /* waitForEnabled */, point => this._page.mouse.dblclick(point.x, point.y, options), options); return this._retryPointerAction(progress, 'dblclick', true /* waitForEnabled */, point => this._page.mouse.dblclick(point.x, point.y, options), options);
} }
async selectOption(elements: ElementHandle[], values: types.SelectOption[], options: types.NavigatingActionWaitOptions = {}): Promise<string[]> { async selectOption(progress: Progress, elements: ElementHandle[], values: types.SelectOption[], options: types.NavigatingActionWaitOptions): Promise<string[]> {
return this._page._runAbortableTask(async progress => { const result = await this._selectOption(progress, elements, values, options);
const result = await this._selectOption(progress, elements, values, options); return throwRetargetableDOMError(result);
return throwRetargetableDOMError(result);
}, this._page._timeoutSettings.timeout(options));
} }
async _selectOption(progress: Progress, elements: ElementHandle[], values: types.SelectOption[], options: types.NavigatingActionWaitOptions): Promise<string[] | 'error:notconnected'> { async _selectOption(progress: Progress, elements: ElementHandle[], values: types.SelectOption[], options: types.NavigatingActionWaitOptions): Promise<string[] | 'error:notconnected'> {
@ -449,11 +443,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}, this._page._timeoutSettings.timeout(options)); }, this._page._timeoutSettings.timeout(options));
} }
async setInputFiles(files: types.FilePayload[], options: types.NavigatingActionWaitOptions = {}) { async setInputFiles(progress: Progress, files: types.FilePayload[], options: types.NavigatingActionWaitOptions) {
return this._page._runAbortableTask(async progress => { const result = await this._setInputFiles(progress, files, options);
const result = await this._setInputFiles(progress, files, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
async _setInputFiles(progress: Progress, files: types.FilePayload[], options: types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> { async _setInputFiles(progress: Progress, files: types.FilePayload[], options: types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> {
@ -490,11 +482,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
return throwFatalDOMError(result); return throwFatalDOMError(result);
} }
async type(text: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}): Promise<void> { async type(progress: Progress, text: string, options: { delay?: number } & types.NavigatingActionWaitOptions): Promise<void> {
return this._page._runAbortableTask(async progress => { const result = await this._type(progress, text, options);
const result = await this._type(progress, text, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
async _type(progress: Progress, text: string, options: { delay?: number } & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> { async _type(progress: Progress, text: string, options: { delay?: number } & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> {
@ -509,11 +499,9 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}, 'input'); }, 'input');
} }
async press(key: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}): Promise<void> { async press(progress: Progress, key: string, options: { delay?: number } & types.NavigatingActionWaitOptions): Promise<void> {
return this._page._runAbortableTask(async progress => { const result = await this._press(progress, key, options);
const result = await this._press(progress, key, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
async _press(progress: Progress, key: string, options: { delay?: number } & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> { async _press(progress: Progress, key: string, options: { delay?: number } & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> {
@ -528,18 +516,14 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
}, 'input'); }, 'input');
} }
async check(options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) { async check(progress: Progress, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
return this._page._runAbortableTask(async progress => { const result = await this._setChecked(progress, true, options);
const result = await this._setChecked(progress, true, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
async uncheck(options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) { async uncheck(progress: Progress, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
return this._page._runAbortableTask(async progress => { const result = await this._setChecked(progress, false, options);
const result = await this._setChecked(progress, false, options); return assertDone(throwRetargetableDOMError(result));
return assertDone(throwRetargetableDOMError(result));
}, this._page._timeoutSettings.timeout(options));
} }
async _setChecked(progress: Progress, state: boolean, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> { async _setChecked(progress: Progress, state: boolean, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions): Promise<'error:notconnected' | 'done'> {
@ -789,7 +773,7 @@ function throwRetargetableDOMError<T>(result: T | RetargetableDOMError): T {
return result; return result;
} }
function assertDone(result: 'done'): void { export function assertDone(result: 'done'): void {
// This function converts 'done' to void and ensures typescript catches unhandled errors. // This function converts 'done' to void and ensures typescript catches unhandled errors.
} }

36
src/server/frames.ts
View file

@ -805,15 +805,15 @@ export class Frame extends EventEmitter {
} }
async click(progress: Progress, selector: string, options: types.MouseClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) { async click(progress: Progress, selector: string, options: types.MouseClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions) {
return this._retryWithProgressIfNotConnected(progress, selector, handle => handle._click(progress, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._click(progress, options)));
} }
async dblclick(selector: string, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) { async dblclick(progress: Progress, selector: string, options: types.MouseMultiClickOptions & types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._dblclick(progress, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._dblclick(progress, options)));
} }
async fill(progress: Progress, selector: string, value: string, options: types.NavigatingActionWaitOptions) { async fill(progress: Progress, selector: string, value: string, options: types.NavigatingActionWaitOptions) {
return this._retryWithProgressIfNotConnected(progress, selector, handle => handle._fill(progress, value, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._fill(progress, value, options)));
} }
async focus(selector: string, options: types.TimeoutOptions = {}) { async focus(selector: string, options: types.TimeoutOptions = {}) {
@ -858,32 +858,32 @@ export class Frame extends EventEmitter {
}, this._page._timeoutSettings.timeout(options)); }, this._page._timeoutSettings.timeout(options));
} }
async hover(selector: string, options: types.PointerActionOptions & types.PointerActionWaitOptions = {}) { async hover(progress: Progress, selector: string, options: types.PointerActionOptions & types.PointerActionWaitOptions = {}) {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._hover(progress, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._hover(progress, options)));
} }
async selectOption(selector: string, elements: dom.ElementHandle[], values: types.SelectOption[], options: types.NavigatingActionWaitOptions = {}): Promise<string[]> { async selectOption(progress: Progress, selector: string, elements: dom.ElementHandle[], values: types.SelectOption[], options: types.NavigatingActionWaitOptions = {}): Promise<string[]> {
return this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._selectOption(progress, elements, values, options)); return await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._selectOption(progress, elements, values, options));
} }
async setInputFiles(selector: string, files: types.FilePayload[], options: types.NavigatingActionWaitOptions = {}): Promise<void> { async setInputFiles(progress: Progress, selector: string, files: types.FilePayload[], options: types.NavigatingActionWaitOptions = {}): Promise<void> {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._setInputFiles(progress, files, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._setInputFiles(progress, files, options)));
} }
async type(selector: string, text: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}) { async type(progress: Progress, selector: string, text: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}) {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._type(progress, text, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._type(progress, text, options)));
} }
async press(selector: string, key: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}) { async press(progress: Progress, selector: string, key: string, options: { delay?: number } & types.NavigatingActionWaitOptions = {}) {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._press(progress, key, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._press(progress, key, options)));
} }
async check(selector: string, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) { async check(progress: Progress, selector: string, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._setChecked(progress, true, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._setChecked(progress, true, options)));
} }
async uncheck(selector: string, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) { async uncheck(progress: Progress, selector: string, options: types.PointerActionWaitOptions & types.NavigatingActionWaitOptions = {}) {
await this._retryWithSelectorIfNotConnected(selector, options, (progress, handle) => handle._setChecked(progress, false, options)); return dom.assertDone(await this._retryWithProgressIfNotConnected(progress, selector, handle => handle._setChecked(progress, false, options)));
} }
async _waitForFunctionExpression<R>(expression: string, isFunction: boolean, arg: any, options: types.WaitForFunctionOptions = {}): Promise<js.SmartHandle<R>> { async _waitForFunctionExpression<R>(expression: string, isFunction: boolean, arg: any, options: types.WaitForFunctionOptions = {}): Promise<js.SmartHandle<R>> {

2
src/server/instrumentation.ts
View file

@ -19,7 +19,7 @@ import type { ElementHandle } from './dom';
import type { Page } from './page'; import type { Page } from './page';
export type ActionMetadata = { export type ActionMetadata = {
type: 'click' | 'fill', type: 'click' | 'fill' | 'dblclick' | 'hover' | 'selectOption' | 'setInputFiles' | 'type' | 'press' | 'check' | 'uncheck',
page: Page, page: Page,
target: ElementHandle | string, target: ElementHandle | string,
value?: string, value?: string,