[pull] main from microsoft:main

packages/playwright-core/src/server/agent/actionRunner.ts

@@ -18,7 +18,6 @@ import { serializeExpectedTextValues } from '../utils/expectUtils';
 import { monotonicTime } from '../../utils/isomorphic/time';
 import { createGuid } from '../utils/crypto';
 import { parseAriaSnapshotUnsafe } from '../../utils/isomorphic/ariaSnapshot';
-import { renderTitleForCall } from '../../utils/isomorphic/protocolFormatter';
 import { ProgressController } from '../progress';
 import { yaml } from '../../utilsBundle';
 import { serializeError } from '../errors';
@@ -43,7 +42,7 @@ export async function runAction(parentProgress: Progress, mode: 'generate' | 'ru
     await frame.instrumentation.onBeforeCall(frame, callMetadata, parentProgress.metadata.id);
 
     let error: Error | undefined;
-    const result = await innerRunAction(progress, page, action, secrets).catch(e => error = e);
+    const result = await innerRunAction(progress, mode, page, action, secrets).catch(e => error = e);
     callMetadata.endTime = monotonicTime();
     callMetadata.error = error ? serializeError(error) : undefined;
     callMetadata.result = error ? undefined : result;
@@ -54,8 +53,9 @@ export async function runAction(parentProgress: Progress, mode: 'generate' | 'ru
   }, minDeadline - mt);
 }
 
-async function innerRunAction(progress: Progress, page: Page, action: actions.Action, secrets: NameValue[]) {
+async function innerRunAction(progress: Progress, mode: 'generate' | 'run', page: Page, action: actions.Action, secrets: NameValue[]) {
   const frame = page.mainFrame();
+  const commonOptions =  { strict: true, noAutoWaiting: mode === 'generate' };
   switch (action.method) {
     case 'navigate':
       await frame.goto(progress, action.url);
@@ -65,43 +65,43 @@ async function innerRunAction(progress: Progress, page: Page, action: actions.Ac
         button: action.button,
         clickCount: action.clickCount,
         modifiers: action.modifiers,
-        ...strictTrue
+        ...commonOptions
       });
       break;
     case 'drag':
-      await frame.dragAndDrop(progress, action.sourceSelector, action.targetSelector, { ...strictTrue });
+      await frame.dragAndDrop(progress, action.sourceSelector, action.targetSelector, { ...commonOptions });
       break;
     case 'hover':
       await frame.hover(progress, action.selector, {
         modifiers: action.modifiers,
-        ...strictTrue
+        ...commonOptions
       });
       break;
     case 'selectOption':
-      await frame.selectOption(progress, action.selector, [], action.labels.map(a => ({ label: a })), { ...strictTrue });
+      await frame.selectOption(progress, action.selector, [], action.labels.map(a => ({ label: a })), { ...commonOptions });
       break;
     case 'pressKey':
       await page.keyboard.press(progress, action.key);
       break;
     case 'pressSequentially': {
       const secret = secrets?.find(s => s.name === action.text)?.value ?? action.text;
-      await frame.type(progress, action.selector, secret, { ...strictTrue });
+      await frame.type(progress, action.selector, secret, { ...commonOptions });
       if (action.submit)
         await page.keyboard.press(progress, 'Enter');
       break;
     }
     case 'fill': {
       const secret = secrets?.find(s => s.name === action.text)?.value ?? action.text;
-      await frame.fill(progress, action.selector, secret, { ...strictTrue });
+      await frame.fill(progress, action.selector, secret, { ...commonOptions });
       if (action.submit)
         await page.keyboard.press(progress, 'Enter');
       break;
     }
     case 'setChecked':
       if (action.checked)
-        await frame.check(progress, action.selector, { ...strictTrue });
+        await frame.check(progress, action.selector, { ...commonOptions });
       else
-        await frame.uncheck(progress, action.selector, { ...strictTrue });
+        await frame.uncheck(progress, action.selector, { ...commonOptions });
       break;
     case 'expectVisible': {
       const result = await frame.expect(progress, action.selector, { expression: 'to.be.visible', isNot: !!action.isNot });
@@ -307,24 +307,17 @@ export function traceParamsForAction(action: actions.Action): { title?: string,
 }
 
 function callMetadataForAction(frame: Frame, action: actions.Action): CallMetadata {
-  const traceParams = traceParamsForAction(action);
-  const title = renderTitleForCall(traceParams);
-
   const callMetadata: CallMetadata = {
     id: `call@${createGuid()}`,
     objectId: frame.guid,
     pageId: frame._page.guid,
     frameId: frame.guid,
     startTime: monotonicTime(),
     endTime: 0,
-    type: 'Frame',
-    method: traceParams.method,
-    params: traceParams.params,
-    title,
     log: [],
+    ...traceParamsForAction(action),
   };
   return callMetadata;
 }
 
 const kDefaultTimeout = 5000;
-const strictTrue =  { strict: true };

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

@@ -264,6 +264,8 @@ export abstract class BrowserType extends SdkObject {
         this.waitForReadyState(options, browserLogsCollector),
         exitPromise.then(() => ({ wsEndpoint: undefined })),
       ]);
+      if (exitPromise.isDone())
+        throw new Error(`Failed to launch the browser process.`);
       if (options.cdpPort !== undefined || !this.supportsPipeTransport()) {
         transport = await WebSocketTransport.connect(progress, wsEndpoint!);
       } else {

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

@@ -294,10 +294,11 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
     };
   }
 
-  async _retryAction(progress: Progress, actionName: string, action: (retry: number) => Promise<PerformActionResult>, options: { trial?: boolean, force?: boolean, skipActionPreChecks?: boolean }): Promise<'error:notconnected' | 'done'> {
+  async _retryAction(progress: Progress, actionName: string, action: (retry: number) => Promise<PerformActionResult>, options: { trial?: boolean, force?: boolean, skipActionPreChecks?: boolean, noAutoWaiting?: boolean }): Promise<'error:notconnected' | 'done'> {
     let retry = 0;
     // We progressively wait longer between retries, up to 500ms.
     const waitTime = [0, 20, 100, 100, 500];
+    const noAutoWaiting = (options as any).__testHookNoAutoWaiting ?? options.noAutoWaiting;
 
     while (true) {
       if (retry) {
@@ -312,35 +313,43 @@ export class ElementHandle<T extends Node = Node> extends js.JSHandle<T> {
       } else {
         progress.log(`attempting ${actionName} action${options.trial ? ' (trial run)' : ''}`);
       }
-      if (!options.skipActionPreChecks && !options.force)
+      if (!options.skipActionPreChecks && !options.force && !noAutoWaiting)
         await this._frame._page.performActionPreChecks(progress);
       const result = await action(retry);
       ++retry;
       if (result === 'error:notvisible') {
-        if (options.force)
+        if (options.force || noAutoWaiting)
           throw new NonRecoverableDOMError('Element is not visible');
         progress.log('  element is not visible');
         continue;
       }
       if (result === 'error:notinviewport') {
-        if (options.force)
+        if (options.force || noAutoWaiting)
           throw new NonRecoverableDOMError('Element is outside of the viewport');
         progress.log('  element is outside of the viewport');
         continue;
       }
       if (result === 'error:optionsnotfound') {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError('Did not find some options');
         progress.log('  did not find some options');
         continue;
       }
       if (result === 'error:optionnotenabled') {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError('Option being selected is not enabled');
         progress.log('  option being selected is not enabled');
         continue;
       }
       if (typeof result === 'object' && 'hitTargetDescription' in result) {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError(`${result.hitTargetDescription} intercepts pointer events`);
         progress.log(`  ${result.hitTargetDescription} intercepts pointer events`);
         continue;
       }
       if (typeof result === 'object' && 'missingState' in result) {
+        if (noAutoWaiting)
+          throw new NonRecoverableDOMError(`Element is not ${result.missingState}`);
         progress.log(`  element is not ${result.missingState}`);
         continue;
       }