fix(bail): fix race condition in bail

packages/vitest/src/node/pools/pool.ts

@@ -34,7 +34,7 @@ export class Pool {
   private activeTasks: ActiveTask[] = []
   private sharedRunners: PoolRunner[] = []
   private exitPromises: Promise<void>[] = []
-  private _isCancelling: boolean = false
+  private cancellingPromise: Promise<void> | null = null
 
   constructor(private options: Options, private logger: Logger) {}
 
@@ -47,9 +47,9 @@ export class Pool {
   }
 
   async run(task: PoolTask, method: 'run' | 'collect'): Promise<void> {
-    // Prevent new tasks from being queued during cancellation
-    if (this._isCancelling) {
-      throw new Error('[vitest-pool]: Cannot run tasks while pool is cancelling')
+    // Wait for any ongoing cancellation to complete before accepting new tasks
+    if (this.cancellingPromise) {
+      await this.cancellingPromise
     }
 
     // Every runner related failure should make this promise reject so that it's picked by pool.
@@ -167,28 +167,30 @@ export class Pool {
   }
 
   async cancel(): Promise<void> {
-    // Set flag to prevent new tasks from being queued
-    this._isCancelling = true
+    // Create a promise to track cancellation completion
+    const cancelPromise = (async () => {
+      const pendingTasks = this.queue.splice(0)
 
-    const pendingTasks = this.queue.splice(0)
+      if (pendingTasks.length) {
+        const error = new Error('Cancelled')
+        pendingTasks.forEach(task => task.resolver.reject(error))
+      }
 
-    if (pendingTasks.length) {
-      const error = new Error('Cancelled')
-      pendingTasks.forEach(task => task.resolver.reject(error))
-    }
+      const activeTasks = this.activeTasks.splice(0)
+      await Promise.all(activeTasks.map(task => task.cancelTask()))
 
-    const activeTasks = this.activeTasks.splice(0)
-    await Promise.all(activeTasks.map(task => task.cancelTask()))
+      const sharedRunners = this.sharedRunners.splice(0)
+      await Promise.all(sharedRunners.map(runner => runner.stop()))
 
-    const sharedRunners = this.sharedRunners.splice(0)
-    await Promise.all(sharedRunners.map(runner => runner.stop()))
+      await Promise.all(this.exitPromises.splice(0))
 
-    await Promise.all(this.exitPromises.splice(0))
+      this.workerIds.forEach((_, id) => this.freeWorkerId(id))
 
-    this.workerIds.forEach((_, id) => this.freeWorkerId(id))
+      this.cancellingPromise = null
+    })()
 
-    // Reset flag after cancellation completes
-    this._isCancelling = false
+    this.cancellingPromise = cancelPromise
+    await cancelPromise
   }
 
   async close(): Promise<void> {

test/cli/fixtures/bail-race/add.spec.js

@@ -0,0 +1,9 @@
+import { expect, test } from 'vitest'
+
+test('adds two numbers', () => {
+  expect(2 + 3).toBe(5)
+})
+
+test('fails adding two numbers', () => {
+  expect(2 + 3).toBe(6)
+})

test/cli/test/bail-race.test.ts

@@ -0,0 +1,44 @@
+import { resolve } from 'pathe'
+import { expect, test } from 'vitest'
+import { createVitest } from 'vitest/node'
+
+test('cancels previous run before starting new one', async () => {
+  const results: string[] = []
+
+  const vitest = await createVitest('test', {
+    root: resolve(import.meta.dirname, '../fixtures/bail-race'),
+    bail: 1,
+    maxWorkers: 1,
+    watch: false,
+    reporters: [{
+      onTestCaseResult(testCase) {
+        const result = testCase.result()
+
+        results.push(`${result.state}${result.errors ? `: ${result.errors?.[0].message}` : ''}`)
+      },
+    }],
+  })
+
+  let rounds = 0
+
+  while (vitest.state.errorsSet.size === 0) {
+    await vitest.start()
+
+    if (rounds >= 2) {
+      break
+    }
+
+    rounds++
+  }
+
+  expect(results).toMatchInlineSnapshot(`
+    [
+      "passed",
+      "failed: expected 5 to be 6 // Object.is equality",
+      "passed",
+      "failed: expected 5 to be 6 // Object.is equality",
+      "passed",
+      "failed: expected 5 to be 6 // Object.is equality",
+    ]
+  `)
+})