fix(expect): honor timeout when the page is unresponsive

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

@@ -510,6 +510,28 @@ export type FrameEventMap = {
   [FrameEvent.RemoveLifecycle]: [event: types.LifecycleEvent];
 };
 
+// How long the one-shot expect check may keep running after the call has been aborted.
+const kOneShotGracePeriod = 1000;
+
+async function raceWithGracePeriod<T>(progress: Progress, promise: Promise<T>, gracePeriod: number): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const onAbort = () => {
+    timer = setTimeout(() => rejectOnAbort(progress.signal.reason), gracePeriod);
+  };
+  let rejectOnAbort: (reason: any) => void = () => {};
+  const aborted = new Promise<never>((_, reject) => rejectOnAbort = reject);
+  if (progress.signal.aborted)
+    onAbort();
+  else
+    progress.signal.addEventListener('abort', onAbort, { once: true });
+  try {
+    return await Promise.race([promise, aborted]);
+  } finally {
+    clearTimeout(timer);
+    progress.signal.removeEventListener('abort', onAbort);
+  }
+}
+
 export class Frame extends SdkObject<FrameEventMap> {
   static Events = FrameEvent;
 
@@ -1483,11 +1505,13 @@ export class Frame extends SdkObject<FrameEventMap> {
         progress.log(`waiting for ${this._asLocator(selector)}`);
       await this._page.performActionPreChecks(progress);
 
-      // Step 2: perform one-shot expect check without a timeout.
+      // Step 2: perform one-shot expect check that may run past the deadline.
       // Supports the case of `expect(locator).toBeVisible({ timeout: 1 })`
       // that should succeed when the locator is already visible.
+      // The grace period prevents an unresponsive page (e.g. a blocked event loop)
+      // from holding the call past its timeout.
       try {
-        const resultOneShot = await this._expectInternal(progress, selector, options, lastIntermediateResult, true);
+        const resultOneShot = await raceWithGracePeriod(progress, this._expectInternal(progress, selector, options, lastIntermediateResult, true), kOneShotGracePeriod);
         if (resultOneShot.matches !== options.isNot)
           return;
       } catch (e) {

tests/page/expect-timeout.spec.ts

@@ -211,3 +211,16 @@ Error: The assertion was aborted: stop it
 `);
   }
 });
+
+test('should respect timeout when the page is unresponsive', { annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/42880' } }, async ({ page }) => {
+  test.setTimeout(10000);
+  await page.setContent('<div>hello</div>');
+  await page.evaluate(() => {
+    setTimeout(() => {
+      while (true) {}
+    }, 0);
+  });
+  await new Promise(f => setTimeout(f, 100));
+  const error = await expect(page.locator('div')).toBeVisible({ timeout: 1000 }).catch(e => e);
+  expect(stripAnsi(error.message)).toContain('Timeout:  1000ms');
+});