fix(runner): make around run callbacks non-throwing

Author: hi-ogawa

docs/api/hooks.md

@@ -158,6 +158,8 @@ Register a callback function that wraps around each test within the current suit
 
 The `runTest()` function runs `beforeEach` hooks, the test itself, fixtures accessed in the test, and `afterEach` hooks. Fixtures that are accessed in the `aroundEach` callback are initialized before `runTest()` is called and are torn down after the aroundEach teardown code completes, allowing you to safely use them in both setup and teardown phases.
 
+`runTest()` does not throw when the wrapped test or inner hooks fail. Failures are still reported through Vitest results.
+
 ::: warning
 You **must** call `runTest()` within your callback. If `runTest()` is not called, the test will fail with an error.
 :::
@@ -268,6 +270,8 @@ Register a callback function that wraps around all tests within the current suit
 
 The `runSuite()` function runs all tests in the suite, including `beforeAll`/`afterAll`/`beforeEach`/`afterEach` hooks, `aroundEach` hooks, and fixtures.
 
+`runSuite()` does not throw when wrapped tests or inner hooks fail. Failures are still reported through Vitest results.
+
 ::: warning
 You **must** call `runSuite()` within your callback. If `runSuite()` is not called, the hook will fail with an error and all tests in the suite will be skipped.
 :::

packages/runner/src/run.ts

@@ -241,6 +241,7 @@ interface AroundHooksOptions<THook extends Function> {
   hookName: 'aroundEach' | 'aroundAll'
   callbackName: 'runTest()' | 'runSuite()'
   onTimeout?: (error: Error) => void
+  onInnerError?: (error: unknown) => void
   invokeHook: (hook: THook, use: () => Promise<void>) => Awaitable<unknown>
 }
 
@@ -263,7 +264,7 @@ async function callAroundHooks<THook extends Function>(
   runInner: () => Promise<void>,
   options: AroundHooksOptions<THook>,
 ): Promise<void> {
-  const { hooks, hookName, callbackName, onTimeout, invokeHook } = options
+  const { hooks, hookName, callbackName, onTimeout, onInnerError, invokeHook } = options
 
   if (!hooks.length) {
     await runInner()
@@ -369,7 +370,7 @@ async function callAroundHooks<THook extends Function>(
       resolveUseReturned()
 
       if (innerError) {
-        throw innerError
+        onInnerError?.(innerError)
       }
     }
 
@@ -444,19 +445,22 @@ async function callAroundHooks<THook extends Function>(
 
 async function callAroundAllHooks(
   suite: Suite,
+  runner: VitestRunner,
   runSuiteInner: () => Promise<void>,
 ): Promise<void> {
   await callAroundHooks(runSuiteInner, {
     hooks: getAroundAllHooks(suite),
     hookName: 'aroundAll',
     callbackName: 'runSuite()',
+    onInnerError: error => failTask(suite.result!, error, runner.config.diffOptions),
     invokeHook: (hook, use) => hook(use, suite),
   })
 }
 
 async function callAroundEachHooks(
   suite: Suite,
   test: Test,
+  runner: VitestRunner,
   runTest: (fixtureCheckpoint: number) => Promise<void>,
 ): Promise<void> {
   await callAroundHooks(
@@ -468,6 +472,7 @@ async function callAroundEachHooks(
       hooks: getAroundEachHooks(suite),
       hookName: 'aroundEach',
       callbackName: 'runTest()',
+      onInnerError: error => failTask(test.result!, error, runner.config.diffOptions),
       onTimeout: error => abortContextSignal(test.context, error),
       invokeHook: (hook, use) => hook(use, test.context, suite),
     },
@@ -626,7 +631,7 @@ export async function runTest(test: Test, runner: VitestRunner): Promise<void> {
       // of fixture cleanup functions AFTER all aroundEach fixtures have been resolved
       // but BEFORE the test runs. This allows us to clean up only fixtures created
       // inside runTest while preserving aroundEach fixtures for teardown.
-      await callAroundEachHooks(suite, test, async (fixtureCheckpoint) => {
+      await callAroundEachHooks(suite, test, runner, async (fixtureCheckpoint) => {
         try {
           await runner.onBeforeTryTask?.(test, {
             retry: retryCount,
@@ -861,7 +866,7 @@ export async function runSuite(suite: Suite, runner: VitestRunner): Promise<void
     let suiteRan = false
 
     try {
-      await callAroundAllHooks(suite, async () => {
+      await callAroundAllHooks(suite, runner, async () => {
         suiteRan = true
         try {
           // beforeAll

test/cli/test/around-each.test.ts

@@ -920,7 +920,8 @@ test('multiple aroundEach hooks with different timeouts', async () => {
 
   expect(extractLogs(stdout)).toMatchInlineSnapshot(`
     ">> outer setup
-    >> inner setup start"
+    >> inner setup start
+    >> outer teardown"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -982,7 +983,8 @@ test('multiple aroundEach hooks where inner teardown times out', async () => {
     ">> outer setup
     >> inner setup
     >> test
-    >> inner teardown start"
+    >> inner teardown start
+    >> outer teardown"
   `)
   expect(stderr).toMatchInlineSnapshot(`
     "
@@ -1095,6 +1097,7 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
       "caught-inner-error-timeout.test.ts": {
         "suite": {
           "test": [
+            "inner aroundEach teardown failure",
             "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
           ],
         },
@@ -1103,6 +1106,51 @@ test('aroundEach teardown timeout works when runTest error is caught', async ()
   `)
 })
 
+test('runTest does not throw when inner aroundEach fails', async () => {
+  const { errorTree } = await runInlineTests({
+    'non-throwing-run-test.test.ts': `
+      import { aroundEach, describe, expect, test } from 'vitest'
+
+      describe('suite', () => {
+        aroundEach(async (runTest) => {
+          let caught = false
+          try {
+            await runTest()
+          }
+          catch {
+            caught = true
+          }
+
+          if (caught) {
+            throw new Error('runTest should not throw')
+          }
+        })
+
+        aroundEach(async (runTest) => {
+          await runTest()
+          throw new Error('inner aroundEach teardown failure')
+        })
+
+        test('test', () => {
+          expect(1).toBe(1)
+        })
+      })
+    `,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "non-throwing-run-test.test.ts": {
+        "suite": {
+          "test": [
+            "inner aroundEach teardown failure",
+          ],
+        },
+      },
+    }
+  `)
+})
+
 test('aroundEach with AsyncLocalStorage', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'async-local-storage.test.ts': `
@@ -1705,6 +1753,7 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
       "caught-inner-suite-error-timeout.test.ts": {
         "suite": {
           "__suite_errors__": [
+            "inner aroundAll teardown failure",
             "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
           ],
           "test": "passed",
@@ -1714,6 +1763,52 @@ test('aroundAll teardown timeout works when runSuite error is caught', async ()
   `)
 })
 
+test('runSuite does not throw when inner aroundAll fails', async () => {
+  const { errorTree } = await runInlineTests({
+    'non-throwing-run-suite.test.ts': `
+      import { aroundAll, describe, expect, test } from 'vitest'
+
+      describe('suite', () => {
+        aroundAll(async (runSuite) => {
+          let caught = false
+          try {
+            await runSuite()
+          }
+          catch {
+            caught = true
+          }
+
+          if (caught) {
+            throw new Error('runSuite should not throw')
+          }
+        })
+
+        aroundAll(async (runSuite) => {
+          await runSuite()
+          throw new Error('inner aroundAll teardown failure')
+        })
+
+        test('test', () => {
+          expect(1).toBe(1)
+        })
+      })
+    `,
+  })
+
+  expect(errorTree()).toMatchInlineSnapshot(`
+    {
+      "non-throwing-run-suite.test.ts": {
+        "suite": {
+          "__suite_errors__": [
+            "inner aroundAll teardown failure",
+          ],
+          "test": "passed",
+        },
+      },
+    }
+  `)
+})
+
 test('aroundAll with server start/stop pattern', async () => {
   const { stdout, stderr, errorTree } = await runInlineTests({
     'server.test.ts': `

test/cli/test/concurrent.test.ts

@@ -956,6 +956,7 @@ test('aroundEach enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "wrapper": {
           "a": [
+            "inner aroundEach teardown failure",
             "The teardown phase of \"aroundEach\" hook timed out after 50ms.",
           ],
         },
@@ -1001,6 +1002,7 @@ test('aroundAll enforces teardown timeout when inner error is caught', async ()
       "basic.test.ts": {
         "suite": {
           "__suite_errors__": [
+            "inner aroundAll teardown failure",
             "The teardown phase of \"aroundAll\" hook timed out after 50ms.",
           ],
           "a": "passed",