feat!(runner): support concurrent suites

packages/runner/src/run.ts

@@ -325,8 +325,7 @@ export async function runSuite(suite: Suite, runner: VitestRunner) {
       else {
         for (let tasksGroup of partitionSuiteChildren(suite)) {
           if (tasksGroup[0].concurrent === true) {
-            const mutex = limit(runner.config.maxConcurrency)
-            await Promise.all(tasksGroup.map(c => mutex(() => runSuiteChild(c, runner))))
+            await Promise.all(tasksGroup.map(c => runSuiteChild(c, runner)))
           }
           else {
             const { sequence } = runner.config
@@ -379,15 +378,19 @@ export async function runSuite(suite: Suite, runner: VitestRunner) {
   }
 }
 
+let limitMaxConcurrency: ReturnType<typeof limit>
+
 async function runSuiteChild(c: Task, runner: VitestRunner) {
   if (c.type === 'test' || c.type === 'custom')
-    return runTest(c, runner)
+    return limitMaxConcurrency(() => runTest(c, runner))
 
   else if (c.type === 'suite')
     return runSuite(c, runner)
 }
 
 export async function runFiles(files: File[], runner: VitestRunner) {
+  limitMaxConcurrency ??= limit(runner.config.maxConcurrency)
+
   for (const file of files) {
     if (!file.tasks.length && !runner.config.passWithNoTests) {
       if (!file.result?.errors?.length) {

packages/runner/src/suite.ts

@@ -215,6 +215,7 @@ function createSuiteCollector(name: string, factory: SuiteFactory = () => { }, m
       tasks: [],
       meta: Object.create(null),
       projectName: '',
+      concurrent: suiteOptions?.concurrentSuite,
     }
 
     if (runner && includeLocation && runner.config.includeTaskLocation) {

packages/runner/src/types/tasks.ts

@@ -185,6 +185,10 @@ export interface TestOptions {
    * Tests inherit `concurrent` from `describe()` and nested `describe()` will inherit from parent's `concurrent`.
    */
   concurrent?: boolean
+  /**
+   * TODO: suite only options?
+   */
+  concurrentSuite?: boolean
   /**
    * Whether tests run sequentially.
    * Tests inherit `sequential` from `describe()` and nested `describe()` will inherit from parent's `sequential`.

test/cli/fixtures/fails/concurrent-suite-deadlock.test.ts

@@ -0,0 +1,41 @@
+import { describe, test, vi } from 'vitest'
+import { createDefer } from 'vitest/dist/utils.js'
+
+// 3 tests depend on each other,
+// so they will deadlock when maxConcurrency < 3
+//
+//  [a]  [b]  [c]
+//   * ->
+//        * ->
+//          <- *
+//     <------
+
+vi.setConfig({ maxConcurrency: 2 })
+
+describe('wrapper', { concurrent: true, timeout: 500 }, () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  describe('1st suite', () => {
+    test('a', async () => {
+      defers[0].resolve()
+      await defers[2]
+    })
+
+    test('b', async () => {
+      await defers[0]
+      defers[1].resolve()
+      await defers[2]
+    })
+  })
+
+  describe('2nd suite', () => {
+    test('c', async () => {
+      await defers[1]
+      defers[2].resolve()
+    })
+  })
+})

test/cli/fixtures/fails/concurrent-test-deadlock.test.ts

@@ -0,0 +1,37 @@
+import { describe, test, vi } from 'vitest'
+import { createDefer } from 'vitest/dist/utils.js'
+
+// 3 tests depend on each other,
+// so they will deadlock when maxConcurrency < 3
+//
+//  [a]  [b]  [c]
+//   * ->
+//        * ->
+//          <- *
+//     <------
+
+vi.setConfig({ maxConcurrency: 2 })
+
+describe('wrapper', { concurrent: true, timeout: 500 }, () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  test('a', async () => {
+    defers[0].resolve()
+    await defers[2]
+  })
+
+  test('b', async () => {
+    await defers[0]
+    defers[1].resolve()
+    await defers[2]
+  })
+
+  test('c', async () => {
+    await defers[1]
+    defers[2].resolve()
+  })
+})

test/cli/test/__snapshots__/fails.test.ts.snap

@@ -2,6 +2,10 @@
 
 exports[`should fail .dot-folder/dot-test.test.ts > .dot-folder/dot-test.test.ts 1`] = `"AssertionError: expected true to be false // Object.is equality"`;
 
+exports[`should fail concurrent-suite-deadlock.test.ts > concurrent-suite-deadlock.test.ts 1`] = `"Error: Test timed out in 500ms."`;
+
+exports[`should fail concurrent-test-deadlock.test.ts > concurrent-test-deadlock.test.ts 1`] = `"Error: Test timed out in 500ms."`;
+
 exports[`should fail each-timeout.test.ts > each-timeout.test.ts 1`] = `"Error: Test timed out in 10ms."`;
 
 exports[`should fail empty.test.ts > empty.test.ts 1`] = `"Error: No test suite found in file <rootDir>/empty.test.ts"`;

test/core/test/concurrent-suite.test.ts

@@ -0,0 +1,131 @@
+import { createDefer } from '@vitest/utils'
+import { afterAll, describe, expect, test } from 'vitest'
+
+describe('basic', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  afterAll(async () => {
+    await defers[3]
+  })
+
+  describe('1st suite', { concurrentSuite: true }, () => {
+    test('0', async () => {
+      defers[0].resolve()
+    })
+
+    test('1', async () => {
+      await defers[2] // this would deadlock if sequential
+      defers[1].resolve()
+    })
+  })
+
+  describe('2nd suite', { concurrentSuite: true }, () => {
+    test('2', async () => {
+      await defers[0]
+      defers[2].resolve()
+    })
+    test('3', async () => {
+      await defers[1]
+      defers[3].resolve()
+    })
+  })
+})
+
+describe('inherits option', { concurrentSuite: true }, () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  afterAll(async () => {
+    await defers[3]
+  })
+
+  describe('1st suite', () => {
+    test('0', async () => {
+      defers[0].resolve()
+    })
+
+    test('1', async () => {
+      await defers[2] // this would deadlock if sequential
+      defers[1].resolve()
+    })
+  })
+
+  describe('2nd suite', () => {
+    test('2', async () => {
+      await defers[0]
+      defers[2].resolve()
+    })
+    test('3', async () => {
+      await defers[1]
+      defers[3].resolve()
+    })
+  })
+})
+
+describe('works with describe.each', () => {
+  const defers = [
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+    createDefer<void>(),
+  ]
+
+  afterAll(async () => {
+    await defers[3]
+  })
+
+  describe.each(['1st suite', '2nd suite'])('%s', { concurrentSuite: true }, (s) => {
+    if (s === '1st suite') {
+      test('0', async () => {
+        defers[0].resolve()
+      })
+
+      test('1', async () => {
+        await defers[2] // this would deadlock if sequential
+        defers[1].resolve()
+      })
+    }
+
+    if (s === '2nd suite') {
+      test('2', async () => {
+        await defers[0]
+        defers[2].resolve()
+      })
+      test('3', async () => {
+        await defers[1]
+        defers[3].resolve()
+      })
+    }
+  })
+})
+
+const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
+describe('tests are sequential', () => {
+  describe('1st suite', { concurrentSuite: true }, () => {
+    let done = false
+
+    test('0', async () => {
+      await sleep(200)
+      expect(done).toBe(false)
+    })
+
+    test('1', async () => {
+      await sleep(100)
+      done = true
+    })
+
+    test('2', () => {
+      expect(done).toBe(true)
+    })
+  })
+})