fix: show in-flight expect.poll on test timeout error

packages/expect/src/utils.ts

@@ -1,6 +1,5 @@
 import type { Test } from '@vitest/runner/types'
 import type { Assertion } from './types'
-import { processError } from '@vitest/utils/error'
 import { noop } from '@vitest/utils/helpers'
 
 export function createAssertionMessage(
@@ -86,10 +85,11 @@ export function recordAsyncExpect(
 }
 
 function handleTestError(test: Test, err: unknown) {
-  test.result ||= { state: 'fail' }
-  test.result.state = 'fail'
-  test.result.errors ||= []
-  test.result.errors.push(processError(err))
+  // test.result ||= { state: 'fail' }
+  // test.result.state = 'fail'
+  // test.result.errors ||= []
+  // test.result.errors.push(processError(err))
+  test.context.recordError(err)
 }
 
 /** wrap assertion function to support `expect.soft` and provide assertion name as `_name` */

packages/runner/src/context.ts

@@ -8,6 +8,7 @@ import type {
   TestContext,
   WriteableTestContext,
 } from './types/tasks'
+import { processError } from '@vitest/utils/error'
 import { getSafeTimers } from '@vitest/utils/timers'
 import { manageArtifactAttachment, recordArtifact, recordAsyncOperation } from './artifact'
 import { PendingError } from './errors'
@@ -240,6 +241,44 @@ export function createTestContext(
     )
   }
 
+  function recordError(error: unknown) {
+    test.result ||= { state: 'fail' }
+    test.result.state = 'fail'
+    test.result.errors ||= []
+    test.result.errors.push(processError(error))
+  }
+  context.recordError = recordError
+
+  function recordErrorOnTimeout(createError: () => unknown) {
+    const addError = () => {
+      // as cause?
+      // const timeoutError = context.signal.reason as Error;
+      // if (!timeoutError.cause) {
+      //   timeoutError.cause = createError()
+      // }
+
+      // or as stack?
+      const timeoutError = context.signal.reason as Error
+      if (timeoutError && timeoutError.stack) {
+        copyStackTrace(timeoutError, createError() as any)
+      }
+
+      // or as dedicated error?
+      // recordError(createError())
+    }
+    context.signal.addEventListener('abort', addError)
+    const deregister = () => {
+      context.signal.removeEventListener('abort', addError)
+    }
+    if (Symbol.dispose) {
+      Object.assign(deregister, {
+        [Symbol.dispose]: deregister,
+      })
+    }
+    return deregister as any
+  }
+  context.recordErrorOnTimeout = recordErrorOnTimeout
+
   return runner.extendTaskContext?.(context) || context
 }
 
@@ -257,3 +296,10 @@ function makeTimeoutError(isHook: boolean, timeout: number, stackTraceError?: Er
   }
   return error
 }
+
+function copyStackTrace(target: Error, source: Error) {
+  if (source.stack !== undefined) {
+    target.stack = source.stack.replace(source.message, target.message)
+  }
+  return target
+}

packages/runner/src/types/tasks.ts

@@ -1233,6 +1233,9 @@ export interface TestContext {
     (message: string, type?: string, attachment?: TestAttachment): Promise<TestAnnotation>
     (message: string, attachment?: TestAttachment): Promise<TestAnnotation>
   }
+
+  readonly recordError: (error: unknown) => void
+  readonly recordErrorOnTimeout: (createError: () => unknown) => (() => void) & Disposable
 }
 
 export type OnTestFailedHandler = (context: TestContext) => Awaitable<void>

packages/vitest/src/integrations/chai/poll.ts

@@ -106,6 +106,12 @@ export function createExpectPoll(expect: ExpectStatic): ExpectStatic['poll'] {
         // extracting inline snapshot location to validate and update new snapshots.
         return function __VITEST_POLL_CHAIN__(this: any, ...args: any[]) {
           const STACK_TRACE_ERROR = new Error('STACK_TRACE_ERROR')
+          const deregister = test.context.recordErrorOnTimeout(() => {
+            return copyStackTrace(
+              new Error('expect.poll did not succeed in time.'),
+              STACK_TRACE_ERROR,
+            )
+          })
           const promise = async () => {
             chai.util.flag(assertion, '_name', key)
             chai.util.flag(assertion, 'error', STACK_TRACE_ERROR)
@@ -174,6 +180,7 @@ export function createExpectPoll(expect: ExpectStatic): ExpectStatic['poll'] {
               }
             }
             finally {
+              deregister()
               clearTimeout(timerId)
             }
           }

test/test-utils/cli.ts

@@ -78,6 +78,8 @@ export class Cli {
         return resolve()
       }
 
+      // TODO: can use recordErrorOnTimeout to ensure this error message is surfaced
+      // when test timeout kicked in first.
       const timeout = setTimeout(() => {
         error.message = `Timeout when waiting for error "${expected}".\nReceived:\nstdout: ${this.stdout}\nstderr: ${this.stderr}`
         reject(error)