+2 -2

docs/config/maxconcurrency.md

Reviewed

··· 9 9 - **Default**: `5` 10 10 - **CLI**: `--max-concurrency=10`, `--maxConcurrency=10` 11 11 12 12 - A number of tests that are allowed to run at the same time marked with `test.concurrent`. 12 12 + The maximum number of tests and hooks that can run at the same time when using `test.concurrent` or `describe.concurrent`. 13 13 14 14 - Test above this limit will be queued to run when available slot appears. 14 14 + The hook execution order within a single group is also controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, the execution is bounded by the same limit of [`maxConcurrency`](/config/maxconcurrency).

+1 -1

docs/config/sequence.md

Reviewed

··· 145 145 146 146 - `stack` will order "after" hooks in reverse order, "before" hooks will run in the order they were defined 147 147 - `list` will order all hooks in the order they are defined 148 148 - - `parallel` will run hooks in a single group in parallel (hooks in parent suites will still run before the current suite's hooks) 148 148 + - `parallel` runs hooks in a single group in parallel (hooks in parent suites still run before the current suite's hooks). The actual number of simultaneously running hooks is limited by [`maxConcurrency`](/config/maxconcurrency). 149 149 150 150 ::: tip 151 151 This option doesn't affect [`onTestFinished`](/api/hooks#ontestfinished). It is always called in reverse order.

+1 -1

docs/guide/cli-generated.md

Reviewed

··· 781 781 - **CLI:** `--maxConcurrency <number>` 782 782 - **Config:** [maxConcurrency](/config/maxconcurrency) 783 783 784 784 - Maximum number of concurrent tests in a suite (default: `5`) 784 784 + Maximum number of concurrent tests and suites during test file execution (default: `5`) 785 785 786 786 ### expect.requireAssertions 787 787

+2

docs/guide/parallelism.md

Reviewed

··· 22 22 23 23 Vitest supports the [`concurrent`](/api/test#test-concurrent) option to run tests together. If this option is set, Vitest will group concurrent tests in the same _file_ (the number of simultaneously running tests depends on the [`maxConcurrency`](/config/maxconcurrency) option) and run them with [`Promise.all`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all). 24 24 25 25 + The hook execution order within a single group is also controlled by [`sequence.hooks`](/config/sequence#sequence-hooks). With `sequence.hooks: 'parallel'`, the execution is bounded by the same limit of [`maxConcurrency`](/config/maxconcurrency). 26 26 + 25 27 Vitest doesn't perform any smart analysis and doesn't create additional workers to run these tests. This means that the performance of your tests will improve only if you rely heavily on asynchronous operations. For example, these tests will still run one after another even though the `concurrent` option is specified. This is because they are synchronous: 26 28 27 29 ```ts

+32 -13

test/test-utils/index.ts

Reviewed

··· 1 1 import type { Options } from 'tinyexec' 2 2 import type { UserConfig as ViteUserConfig } from 'vite' 3 3 - import type { SerializedConfig, WorkerGlobalState } from 'vitest' 3 3 + import type { SerializedConfig, TestContext, WorkerGlobalState } from 'vitest' 4 4 import type { TestProjectConfiguration } from 'vitest/config' 5 5 import type { 6 6 TestCase, ··· 8 8 TestCollection, 9 9 TestModule, 10 10 TestSpecification, 11 11 + TestSuite, 11 12 TestUserConfig, 12 13 Vitest, 13 14 } from 'vitest/node' ··· 423 424 return `export default ${JSON.stringify(content)}` 424 425 } 425 426 426 426 - export function useFS<T extends TestFsStructure>(root: string, structure: T, ensureConfig = true) { 427 427 + export function useFS<T extends TestFsStructure>(root: string, structure: T, ensureConfig = true, task?: TestContext['task']) { 427 428 const files = new Set<string>() 428 429 const hasConfig = Object.keys(structure).some(file => file.includes('.config.')) 429 430 if (ensureConfig && !hasConfig) { ··· 436 437 fs.mkdirSync(dirname(filepath), { recursive: true }) 437 438 fs.writeFileSync(filepath, String(content), 'utf-8') 438 439 } 439 439 - onTestFinished(() => { 440 440 + (task?.context.onTestFinished ?? onTestFinished)(() => { 440 441 if (process.env.VITEST_FS_CLEANUP !== 'false') { 441 442 fs.rmSync(root, { recursive: true, force: true }) 442 443 } ··· 493 494 structure: TestFsStructure, 494 495 config?: RunVitestConfig, 495 496 options?: VitestRunnerCLIOptions, 497 497 + task?: TestContext['task'], 496 498 ) { 497 499 const root = resolve(process.cwd(), `vitest-test-${crypto.randomUUID()}`) 498 498 - const fs = useFS(root, structure) 500 500 + const fs = useFS(root, structure, undefined, task) 499 501 const vitest = await runVitest({ 500 502 root, 501 503 ...config, ··· 554 556 } 555 557 556 558 export function buildErrorTree(testModules: TestModule[]) { 557 557 - return buildTestTree(testModules, (testCase) => { 558 558 - const result = testCase.result() 559 559 - if (result.state === 'failed') { 560 560 - return result.errors.map(e => e.message) 561 561 - } 562 562 - return result.state 563 563 - }) 559 559 + return buildTestTree( 560 560 + testModules, 561 561 + (testCase) => { 562 562 + const result = testCase.result() 563 563 + if (result.state === 'failed') { 564 564 + return result.errors.map(e => e.message) 565 565 + } 566 566 + return result.state 567 567 + }, 568 568 + (testSuite, suiteChildren) => { 569 569 + const errors = testSuite.errors().map(error => error.message) 570 570 + if (errors.length > 0) { 571 571 + return { 572 572 + ...suiteChildren, 573 573 + __suite_errors__: errors, 574 574 + } 575 575 + } 576 576 + return suiteChildren 577 577 + }, 578 578 + ) 564 579 } 565 580 566 566 - export function buildTestTree(testModules: TestModule[], onTestCase?: (result: TestCase) => unknown) { 581 581 + export function buildTestTree( 582 582 + testModules: TestModule[], 583 583 + onTestCase?: (result: TestCase) => unknown, 584 584 + onTestSuite?: (testSuite: TestSuite, suiteChildren: Record<string, any>) => unknown, 585 585 + ) { 567 586 type TestTree = Record<string, any> 568 587 569 588 function walkCollection(collection: TestCollection): TestTree { ··· 573 592 if (child.type === 'suite') { 574 593 // Recursively walk suite children 575 594 const suiteChildren = walkCollection(child.children) 576 576 - node[child.name] = suiteChildren 595 595 + node[child.name] = onTestSuite ? onTestSuite(child, suiteChildren) : suiteChildren 577 596 } 578 597 else if (child.type === 'test') { 579 598 const result = child.result()

+30 -15

packages/runner/src/run.ts

Reviewed

··· 18 18 TestContext, 19 19 WriteableTestContext, 20 20 } from './types/tasks' 21 21 + import type { ConcurrencyLimiter } from './utils/limit-concurrency' 21 22 import { processError } from '@vitest/utils/error' // TODO: load dynamically 22 23 import { shuffle } from '@vitest/utils/helpers' 23 24 import { getSafeTimers } from '@vitest/utils/timers' ··· 35 36 const now = globalThis.performance ? globalThis.performance.now.bind(globalThis.performance) : Date.now 36 37 const unixNow = Date.now 37 38 const { clearTimeout, setTimeout } = getSafeTimers() 39 39 + let limitMaxConcurrency: ConcurrencyLimiter 38 40 39 41 /** 40 42 * Normalizes retry configuration to extract individual values. ··· 141 143 142 144 if (sequence === 'parallel') { 143 145 try { 144 144 - await Promise.all(hooks.map(fn => fn(test.context))) 146 146 + await Promise.all(hooks.map(fn => limitMaxConcurrency(() => fn(test.context)))) 145 147 } 146 148 catch (e) { 147 149 failTask(test.result!, e, runner.config.diffOptions) ··· 150 152 else { 151 153 for (const fn of hooks) { 152 154 try { 153 153 - await fn(test.context) 155 155 + await limitMaxConcurrency(() => fn(test.context)) 154 156 } 155 157 catch (e) { 156 158 failTask(test.result!, e, runner.config.diffOptions) ··· 188 190 } 189 191 190 192 async function runHook(hook: Function) { 191 191 - return getBeforeHookCleanupCallback( 192 192 - hook, 193 193 - await hook(...args), 194 194 - name === 'beforeEach' ? args[0] as TestContext : undefined, 195 195 - ) 193 193 + return limitMaxConcurrency(async () => { 194 194 + return getBeforeHookCleanupCallback( 195 195 + hook, 196 196 + await hook(...args), 197 197 + name === 'beforeEach' ? args[0] as TestContext : undefined, 198 198 + ) 199 199 + }) 196 200 } 197 201 198 202 if (sequence === 'parallel') { ··· 311 315 let useCalled = false 312 316 let setupTimeout: ReturnType<typeof createTimeoutPromise> 313 317 let teardownTimeout: ReturnType<typeof createTimeoutPromise> | undefined 318 318 + let setupLimitConcurrencyRelease: (() => void) | undefined 319 319 + let teardownLimitConcurrencyRelease: (() => void) | undefined 314 320 315 321 // Promise that resolves when use() is called (setup phase complete) 316 322 let resolveUseCalled!: () => void ··· 352 358 353 359 // Setup phase completed - clear setup timer 354 360 setupTimeout.clear() 361 361 + setupLimitConcurrencyRelease?.() 355 362 356 363 // Run inner hooks - don't time this against our teardown timeout 357 364 await runNextHook(index + 1).catch(e => hookErrors.push(e)) 365 365 + 366 366 + teardownLimitConcurrencyRelease = await limitMaxConcurrency.acquire() 358 367 359 368 // Start teardown timer after inner hooks complete - only times this hook's teardown code 360 369 teardownTimeout = createTimeoutPromise(timeout, 'teardown', stackTraceError) ··· 362 371 // Signal that use() is returning (teardown phase starting) 363 372 resolveUseReturned() 364 373 } 374 374 + 375 375 + setupLimitConcurrencyRelease = await limitMaxConcurrency.acquire() 365 376 366 377 // Start setup timeout 367 378 setupTimeout = createTimeoutPromise(timeout, 'setup', stackTraceError) ··· 381 392 catch (error) { 382 393 rejectHookComplete(error as Error) 383 394 } 395 395 + finally { 396 396 + setupLimitConcurrencyRelease?.() 397 397 + teardownLimitConcurrencyRelease?.() 398 398 + } 384 399 })() 385 400 386 401 // Wait for either: use() to be called OR hook to complete (error) OR setup timeout ··· 392 407 ]) 393 408 } 394 409 finally { 410 410 + setupLimitConcurrencyRelease?.() 395 411 setupTimeout.clear() 396 412 } 397 413 ··· 410 426 ]) 411 427 } 412 428 finally { 429 429 + teardownLimitConcurrencyRelease?.() 413 430 teardownTimeout?.clear() 414 431 } 415 432 } ··· 524 541 if (typeof fn !== 'function') { 525 542 return 526 543 } 527 527 - await fn() 544 544 + await limitMaxConcurrency(() => fn()) 528 545 }), 529 546 ) 530 547 } ··· 533 550 if (typeof fn !== 'function') { 534 551 continue 535 552 } 536 536 - await fn() 553 553 + await limitMaxConcurrency(() => fn()) 537 554 } 538 555 } 539 556 } ··· 623 640 )) 624 641 625 642 if (runner.runTask) { 626 626 - await $('test.callback', () => runner.runTask!(test)) 643 643 + await $('test.callback', () => limitMaxConcurrency(() => runner.runTask!(test))) 627 644 } 628 645 else { 629 646 const fn = getFn(test) ··· 632 649 'Test function is not found. Did you add it using `setFn`?', 633 650 ) 634 651 } 635 635 - await $('test.callback', () => fn()) 652 652 + await $('test.callback', () => limitMaxConcurrency(() => fn())) 636 653 } 637 654 638 655 await runner.onAfterTryTask?.(test, { ··· 940 957 } 941 958 } 942 959 943 943 - let limitMaxConcurrency: ReturnType<typeof limitConcurrency> 944 944 - 945 960 async function runSuiteChild(c: Task, runner: VitestRunner) { 946 961 const $ = runner.trace! 947 962 if (c.type === 'test') { 948 948 - return limitMaxConcurrency(() => $( 963 963 + return $( 949 964 'run.test', 950 965 { 951 966 'vitest.test.id': c.id, ··· 957 972 'code.column.number': c.location?.column, 958 973 }, 959 974 () => runTest(c, runner), 960 960 - )) 975 975 + ) 961 976 } 962 977 else if (c.type === 'suite') { 963 978 return $(

+94 -2

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

Reviewed

··· 1064 1064 `) 1065 1065 }) 1066 1066 1067 1067 + test('aroundEach teardown timeout works when runTest error is caught', async () => { 1068 1068 + const { errorTree } = await runInlineTests({ 1069 1069 + 'caught-inner-error-timeout.test.ts': ` 1070 1070 + import { aroundEach, describe, expect, test } from 'vitest' 1071 1071 + 1072 1072 + describe('suite', () => { 1073 1073 + aroundEach(async (runTest) => { 1074 1074 + try { 1075 1075 + await runTest() 1076 1076 + } 1077 1077 + catch { 1078 1078 + // swallow inner hook failure, then run teardown work 1079 1079 + } 1080 1080 + await new Promise(resolve => setTimeout(resolve, 200)) 1081 1081 + }, 50) 1082 1082 + 1083 1083 + aroundEach(async (runTest) => { 1084 1084 + await runTest() 1085 1085 + throw new Error('inner aroundEach teardown failure') 1086 1086 + }) 1087 1087 + 1088 1088 + test('test', () => { 1089 1089 + expect(1).toBe(1) 1090 1090 + }) 1091 1091 + }) 1092 1092 + `, 1093 1093 + }) 1094 1094 + 1095 1095 + expect(errorTree()).toMatchInlineSnapshot(` 1096 1096 + { 1097 1097 + "caught-inner-error-timeout.test.ts": { 1098 1098 + "suite": { 1099 1099 + "test": [ 1100 1100 + "inner aroundEach teardown failure", 1101 1101 + "The teardown phase of "aroundEach" hook timed out after 50ms.", 1102 1102 + ], 1103 1103 + }, 1104 1104 + }, 1105 1105 + } 1106 1106 + `) 1107 1107 + }) 1108 1108 + 1067 1109 test('aroundEach with AsyncLocalStorage', async () => { 1068 1110 const { stdout, stderr, errorTree } = await runInlineTests({ 1069 1111 'async-local-storage.test.ts': ` ··· 1633 1675 `) 1634 1676 }) 1635 1677 1678 1678 + test('aroundAll teardown timeout works when runSuite error is caught', async () => { 1679 1679 + const { errorTree } = await runInlineTests({ 1680 1680 + 'caught-inner-suite-error-timeout.test.ts': ` 1681 1681 + import { aroundAll, describe, expect, test } from 'vitest' 1682 1682 + 1683 1683 + describe('suite', () => { 1684 1684 + aroundAll(async (runSuite) => { 1685 1685 + try { 1686 1686 + await runSuite() 1687 1687 + } 1688 1688 + catch { 1689 1689 + // swallow inner hook failure, then run teardown work 1690 1690 + } 1691 1691 + await new Promise(resolve => setTimeout(resolve, 200)) 1692 1692 + }, 50) 1693 1693 + 1694 1694 + aroundAll(async (runSuite) => { 1695 1695 + await runSuite() 1696 1696 + throw new Error('inner aroundAll teardown failure') 1697 1697 + }) 1698 1698 + 1699 1699 + test('test', () => { 1700 1700 + expect(1).toBe(1) 1701 1701 + }) 1702 1702 + }) 1703 1703 + `, 1704 1704 + }) 1705 1705 + 1706 1706 + expect(errorTree()).toMatchInlineSnapshot(` 1707 1707 + { 1708 1708 + "caught-inner-suite-error-timeout.test.ts": { 1709 1709 + "suite": { 1710 1710 + "__suite_errors__": [ 1711 1711 + "inner aroundAll teardown failure", 1712 1712 + "The teardown phase of "aroundAll" hook timed out after 50ms.", 1713 1713 + ], 1714 1714 + "test": "passed", 1715 1715 + }, 1716 1716 + }, 1717 1717 + } 1718 1718 + `) 1719 1719 + }) 1720 1720 + 1636 1721 test('aroundAll with server start/stop pattern', async () => { 1637 1722 const { stdout, stderr, errorTree } = await runInlineTests({ 1638 1723 'server.test.ts': ` ··· 2043 2128 { 2044 2129 "caught-inner-error-timeout.test.ts": { 2045 2130 "suite": { 2131 2131 + "__suite_errors__": [ 2132 2132 + "inner aroundAll teardown failure", 2133 2133 + "The teardown phase of "aroundAll" hook timed out after 50ms.", 2134 2134 + ], 2046 2135 "test": "passed", 2047 2136 }, 2048 2137 }, ··· 2181 2270 { 2182 2271 "late-run-suite-after-timeout.test.ts": { 2183 2272 "timed out suite": { 2273 2273 + "__suite_errors__": [ 2274 2274 + "The setup phase of "aroundAll" hook timed out after 10ms.", 2275 2275 + ], 2184 2276 "basic": "skipped", 2185 2277 }, 2186 2278 }, ··· 2228 2320 | ^ 2229 2321 18| }) 2230 2322 19| 2231 2231 - ❯ nested-around-each-setup-error.test.ts:7:17 2323 2323 + ❯ nested-around-each-setup-error.test.ts:7:11 2232 2324 2233 2325 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯ 2234 2326 ··· 2355 2447 | ^ 2356 2448 18| }) 2357 2449 19| 2358 2358 - ❯ nested-around-all-setup-error.test.ts:7:17 2450 2450 + ❯ nested-around-all-setup-error.test.ts:7:11 2359 2451 2360 2452 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/1]⎯ 2361 2453

+1076

test/cli/test/concurrent.test.ts

Reviewed

··· 1 1 + import { expect, test } from 'vitest' 2 2 + import { runInlineTests } from '../../test-utils' 3 3 + 4 4 + // 3 tests depend on each other, 5 5 + // so they will deadlock when maxConcurrency < 3 6 6 + // 7 7 + // [a] [b] [c] 8 8 + // * -> 9 9 + // * -> 10 10 + // <- * 11 11 + // <------ 12 12 + 13 13 + const deadlockSource = ` 14 14 + import { describe, expect, test } from 'vitest' 15 15 + import { createDefer } from '@vitest/utils/helpers' 16 16 + 17 17 + describe.concurrent('wrapper', () => { 18 18 + const defers = [ 19 19 + createDefer<void>(), 20 20 + createDefer<void>(), 21 21 + createDefer<void>(), 22 22 + ] 23 23 + 24 24 + test('a', async () => { 25 25 + expect(1).toBe(1) 26 26 + defers[0].resolve() 27 27 + await defers[2] 28 28 + }) 29 29 + 30 30 + test('b', async () => { 31 31 + expect(1).toBe(1) 32 32 + await defers[0] 33 33 + defers[1].resolve() 34 34 + await defers[2] 35 35 + }) 36 36 + 37 37 + test('c', async () => { 38 38 + expect(1).toBe(1) 39 39 + await defers[1] 40 40 + defers[2].resolve() 41 41 + }) 42 42 + }) 43 43 + ` 44 44 + 45 45 + test('deadlocks with insufficient maxConcurrency', async () => { 46 46 + const { errorTree } = await runInlineTests({ 47 47 + 'basic.test.ts': deadlockSource, 48 48 + }, { 49 49 + maxConcurrency: 2, 50 50 + testTimeout: 500, 51 51 + }) 52 52 + 53 53 + // "a" and "b" fill both concurrency slots and wait for `defers[2]`. 54 54 + // "c" is queued until one slot is released by timeout, then it starts, 55 55 + // observes `defers[1]` already resolved by "b", resolves `defers[2]`, and passes. 56 56 + expect(errorTree()).toMatchInlineSnapshot(` 57 57 + { 58 58 + "basic.test.ts": { 59 59 + "wrapper": { 60 60 + "a": [ 61 61 + "Test timed out in 500ms. 62 62 + If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".", 63 63 + ], 64 64 + "b": [ 65 65 + "Test timed out in 500ms. 66 66 + If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".", 67 67 + ], 68 68 + "c": "passed", 69 69 + }, 70 70 + }, 71 71 + } 72 72 + `) 73 73 + }) 74 74 + 75 75 + test('passes when maxConcurrency is high enough', async () => { 76 76 + const { stderr, errorTree } = await runInlineTests({ 77 77 + 'basic.test.ts': deadlockSource, 78 78 + }, { 79 79 + maxConcurrency: 3, 80 80 + }) 81 81 + 82 82 + expect(stderr).toBe('') 83 83 + expect(errorTree()).toMatchInlineSnapshot(` 84 84 + { 85 85 + "basic.test.ts": { 86 86 + "wrapper": { 87 87 + "a": "passed", 88 88 + "b": "passed", 89 89 + "c": "passed", 90 90 + }, 91 91 + }, 92 92 + } 93 93 + `) 94 94 + }) 95 95 + 96 96 + const suiteDeadlockSource = ` 97 97 + import { describe, expect, test } from 'vitest' 98 98 + import { createDefer } from '@vitest/utils/helpers' 99 99 + 100 100 + describe.concurrent('wrapper', () => { 101 101 + const defers = [ 102 102 + createDefer<void>(), 103 103 + createDefer<void>(), 104 104 + createDefer<void>(), 105 105 + ] 106 106 + 107 107 + describe('1st suite', () => { 108 108 + test('a', async () => { 109 109 + expect(1).toBe(1) 110 110 + defers[0].resolve() 111 111 + await defers[2] 112 112 + }) 113 113 + 114 114 + test('b', async () => { 115 115 + expect(1).toBe(1) 116 116 + await defers[0] 117 117 + defers[1].resolve() 118 118 + await defers[2] 119 119 + }) 120 120 + }) 121 121 + 122 122 + describe('2nd suite', () => { 123 123 + test('c', async () => { 124 124 + expect(1).toBe(1) 125 125 + await defers[1] 126 126 + defers[2].resolve() 127 127 + }) 128 128 + }) 129 129 + }) 130 130 + ` 131 131 + 132 132 + test('suite deadlocks with insufficient maxConcurrency', async () => { 133 133 + const { errorTree } = await runInlineTests({ 134 134 + 'basic.test.ts': suiteDeadlockSource, 135 135 + }, { 136 136 + maxConcurrency: 2, 137 137 + testTimeout: 500, 138 138 + }) 139 139 + 140 140 + expect(errorTree()).toMatchInlineSnapshot(` 141 141 + { 142 142 + "basic.test.ts": { 143 143 + "wrapper": { 144 144 + "1st suite": { 145 145 + "a": [ 146 146 + "Test timed out in 500ms. 147 147 + If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".", 148 148 + ], 149 149 + "b": [ 150 150 + "Test timed out in 500ms. 151 151 + If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".", 152 152 + ], 153 153 + }, 154 154 + "2nd suite": { 155 155 + "c": "passed", 156 156 + }, 157 157 + }, 158 158 + }, 159 159 + } 160 160 + `) 161 161 + }) 162 162 + 163 163 + test('suite passes when maxConcurrency is high enough', async () => { 164 164 + const { stderr, errorTree } = await runInlineTests({ 165 165 + 'basic.test.ts': suiteDeadlockSource, 166 166 + }, { 167 167 + maxConcurrency: 3, 168 168 + }) 169 169 + 170 170 + expect(stderr).toBe('') 171 171 + expect(errorTree()).toMatchInlineSnapshot(` 172 172 + { 173 173 + "basic.test.ts": { 174 174 + "wrapper": { 175 175 + "1st suite": { 176 176 + "a": "passed", 177 177 + "b": "passed", 178 178 + }, 179 179 + "2nd suite": { 180 180 + "c": "passed", 181 181 + }, 182 182 + }, 183 183 + }, 184 184 + } 185 185 + `) 186 186 + }) 187 187 + 188 188 + const beforeAllNeighboringSuitesSource = ` 189 189 + import { beforeAll, describe, expect, test } from 'vitest' 190 190 + import { createDefer } from '@vitest/utils/helpers' 191 191 + 192 192 + const defers = [ 193 193 + createDefer<void>(), 194 194 + createDefer<void>(), 195 195 + ] 196 196 + 197 197 + describe.concurrent('s1', () => { 198 198 + beforeAll(async () => { 199 199 + defers[0].resolve() 200 200 + await defers[1] 201 201 + }) 202 202 + 203 203 + test('a', () => { 204 204 + expect(1).toBe(1) 205 205 + }) 206 206 + }) 207 207 + 208 208 + describe.concurrent('s2', () => { 209 209 + beforeAll(async () => { 210 210 + await defers[0] 211 211 + defers[1].resolve() 212 212 + }) 213 213 + 214 214 + test('b', () => { 215 215 + expect(1).toBe(1) 216 216 + }) 217 217 + }) 218 218 + ` 219 219 + 220 220 + test('neighboring suite beforeAll deadlocks with insufficient maxConcurrency', async () => { 221 221 + const { errorTree } = await runInlineTests({ 222 222 + 'basic.test.ts': beforeAllNeighboringSuitesSource, 223 223 + }, { 224 224 + maxConcurrency: 1, 225 225 + hookTimeout: 500, 226 226 + }) 227 227 + 228 228 + expect(errorTree()).toMatchInlineSnapshot(` 229 229 + { 230 230 + "basic.test.ts": { 231 231 + "s1": { 232 232 + "__suite_errors__": [ 233 233 + "Hook timed out in 500ms. 234 234 + If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".", 235 235 + ], 236 236 + "a": "skipped", 237 237 + }, 238 238 + "s2": { 239 239 + "b": "passed", 240 240 + }, 241 241 + }, 242 242 + } 243 243 + `) 244 244 + }) 245 245 + 246 246 + test('neighboring suite beforeAll passes when maxConcurrency is high enough', async () => { 247 247 + const { stderr, errorTree } = await runInlineTests({ 248 248 + 'basic.test.ts': beforeAllNeighboringSuitesSource, 249 249 + }, { 250 250 + maxConcurrency: 2, 251 251 + }) 252 252 + 253 253 + expect(stderr).toBe('') 254 254 + expect(errorTree()).toMatchInlineSnapshot(` 255 255 + { 256 256 + "basic.test.ts": { 257 257 + "s1": { 258 258 + "a": "passed", 259 259 + }, 260 260 + "s2": { 261 261 + "b": "passed", 262 262 + }, 263 263 + }, 264 264 + } 265 265 + `) 266 266 + }) 267 267 + 268 268 + const afterAllNeighboringSuitesSource = ` 269 269 + import { afterAll, describe, expect, test } from 'vitest' 270 270 + import { createDefer } from '@vitest/utils/helpers' 271 271 + 272 272 + const defers = [ 273 273 + createDefer<void>(), 274 274 + createDefer<void>(), 275 275 + ] 276 276 + 277 277 + describe.concurrent('s1', () => { 278 278 + afterAll(async () => { 279 279 + defers[0].resolve() 280 280 + await defers[1] 281 281 + }) 282 282 + 283 283 + test('a', () => { 284 284 + expect(1).toBe(1) 285 285 + }) 286 286 + }) 287 287 + 288 288 + describe.concurrent('s2', () => { 289 289 + afterAll(async () => { 290 290 + await defers[0] 291 291 + defers[1].resolve() 292 292 + }) 293 293 + 294 294 + test('b', () => { 295 295 + expect(1).toBe(1) 296 296 + }) 297 297 + }) 298 298 + ` 299 299 + 300 300 + test('neighboring suite afterAll deadlocks with insufficient maxConcurrency', async () => { 301 301 + const { errorTree } = await runInlineTests({ 302 302 + 'basic.test.ts': afterAllNeighboringSuitesSource, 303 303 + }, { 304 304 + maxConcurrency: 1, 305 305 + hookTimeout: 500, 306 306 + }) 307 307 + 308 308 + expect(errorTree()).toMatchInlineSnapshot(` 309 309 + { 310 310 + "basic.test.ts": { 311 311 + "s1": { 312 312 + "__suite_errors__": [ 313 313 + "Hook timed out in 500ms. 314 314 + If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".", 315 315 + ], 316 316 + "a": "passed", 317 317 + }, 318 318 + "s2": { 319 319 + "b": "passed", 320 320 + }, 321 321 + }, 322 322 + } 323 323 + `) 324 324 + }) 325 325 + 326 326 + test('neighboring suite afterAll passes when maxConcurrency is high enough', async () => { 327 327 + const { stderr, errorTree } = await runInlineTests({ 328 328 + 'basic.test.ts': afterAllNeighboringSuitesSource, 329 329 + }, { 330 330 + maxConcurrency: 2, 331 331 + }) 332 332 + 333 333 + expect(stderr).toBe('') 334 334 + expect(errorTree()).toMatchInlineSnapshot(` 335 335 + { 336 336 + "basic.test.ts": { 337 337 + "s1": { 338 338 + "a": "passed", 339 339 + }, 340 340 + "s2": { 341 341 + "b": "passed", 342 342 + }, 343 343 + }, 344 344 + } 345 345 + `) 346 346 + }) 347 347 + 348 348 + const beforeEachDeadlockSource = ` 349 349 + import { beforeEach, describe, expect, test } from 'vitest' 350 350 + import { createDefer } from '@vitest/utils/helpers' 351 351 + 352 352 + describe.concurrent('wrapper', () => { 353 353 + const defers = [ 354 354 + createDefer<void>(), 355 355 + createDefer<void>(), 356 356 + createDefer<void>(), 357 357 + ] 358 358 + 359 359 + beforeEach(async () => { 360 360 + defers[0].resolve() 361 361 + await defers[2] 362 362 + }) 363 363 + 364 364 + beforeEach(async () => { 365 365 + await defers[0] 366 366 + defers[1].resolve() 367 367 + await defers[2] 368 368 + }) 369 369 + 370 370 + beforeEach(async () => { 371 371 + await defers[1] 372 372 + defers[2].resolve() 373 373 + }) 374 374 + 375 375 + test('t', () => { 376 376 + expect(1).toBe(1) 377 377 + }) 378 378 + }) 379 379 + ` 380 380 + 381 381 + test('beforeEach deadlocks with insufficient maxConcurrency', async () => { 382 382 + const { errorTree } = await runInlineTests({ 383 383 + 'basic.test.ts': beforeEachDeadlockSource, 384 384 + }, { 385 385 + maxConcurrency: 2, 386 386 + sequence: { hooks: 'parallel' }, 387 387 + hookTimeout: 500, 388 388 + }) 389 389 + 390 390 + expect(errorTree()).toMatchInlineSnapshot(` 391 391 + { 392 392 + "basic.test.ts": { 393 393 + "wrapper": { 394 394 + "t": [ 395 395 + "Hook timed out in 500ms. 396 396 + If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".", 397 397 + ], 398 398 + }, 399 399 + }, 400 400 + } 401 401 + `) 402 402 + }) 403 403 + 404 404 + test('beforeEach passes when maxConcurrency is high enough', async () => { 405 405 + const { stderr, errorTree } = await runInlineTests({ 406 406 + 'basic.test.ts': beforeEachDeadlockSource, 407 407 + }, { 408 408 + maxConcurrency: 3, 409 409 + sequence: { hooks: 'parallel' }, 410 410 + }) 411 411 + 412 412 + expect(stderr).toBe('') 413 413 + expect(errorTree()).toMatchInlineSnapshot(` 414 414 + { 415 415 + "basic.test.ts": { 416 416 + "wrapper": { 417 417 + "t": "passed", 418 418 + }, 419 419 + }, 420 420 + } 421 421 + `) 422 422 + }) 423 423 + 424 424 + const afterEachDeadlockSource = ` 425 425 + import { afterEach, describe, expect, test } from 'vitest' 426 426 + import { createDefer } from '@vitest/utils/helpers' 427 427 + 428 428 + describe.concurrent('wrapper', () => { 429 429 + const defers = [ 430 430 + createDefer<void>(), 431 431 + createDefer<void>(), 432 432 + createDefer<void>(), 433 433 + ] 434 434 + 435 435 + afterEach(async () => { 436 436 + defers[0].resolve() 437 437 + await defers[2] 438 438 + }) 439 439 + 440 440 + afterEach(async () => { 441 441 + await defers[0] 442 442 + defers[1].resolve() 443 443 + await defers[2] 444 444 + }) 445 445 + 446 446 + afterEach(async () => { 447 447 + await defers[1] 448 448 + defers[2].resolve() 449 449 + }) 450 450 + 451 451 + test('t', () => { 452 452 + expect(1).toBe(1) 453 453 + }) 454 454 + }) 455 455 + ` 456 456 + 457 457 + test('afterEach deadlocks with insufficient maxConcurrency', async () => { 458 458 + const { errorTree } = await runInlineTests({ 459 459 + 'basic.test.ts': afterEachDeadlockSource, 460 460 + }, { 461 461 + maxConcurrency: 2, 462 462 + sequence: { hooks: 'parallel' }, 463 463 + hookTimeout: 500, 464 464 + }) 465 465 + 466 466 + expect(errorTree()).toMatchInlineSnapshot(` 467 467 + { 468 468 + "basic.test.ts": { 469 469 + "wrapper": { 470 470 + "t": [ 471 471 + "Hook timed out in 500ms. 472 472 + If this is a long-running hook, pass a timeout value as the last argument or configure it globally with "hookTimeout".", 473 473 + ], 474 474 + }, 475 475 + }, 476 476 + } 477 477 + `) 478 478 + }) 479 479 + 480 480 + test('afterEach passes when maxConcurrency is high enough', async () => { 481 481 + const { stderr, errorTree } = await runInlineTests({ 482 482 + 'basic.test.ts': afterEachDeadlockSource, 483 483 + }, { 484 484 + maxConcurrency: 3, 485 485 + sequence: { hooks: 'parallel' }, 486 486 + }) 487 487 + 488 488 + expect(stderr).toBe('') 489 489 + expect(errorTree()).toMatchInlineSnapshot(` 490 490 + { 491 491 + "basic.test.ts": { 492 492 + "wrapper": { 493 493 + "t": "passed", 494 494 + }, 495 495 + }, 496 496 + } 497 497 + `) 498 498 + }) 499 499 + 500 500 + const aroundAllNeighboringSuitesSource = ` 501 501 + import { aroundAll, describe, expect, test } from 'vitest' 502 502 + import { createDefer } from '@vitest/utils/helpers' 503 503 + 504 504 + const defers = [ 505 505 + createDefer<void>(), 506 506 + createDefer<void>(), 507 507 + ] 508 508 + 509 509 + describe.concurrent('s1', () => { 510 510 + aroundAll(async (runSuite) => { 511 511 + defers[0].resolve() 512 512 + await defers[1] 513 513 + await runSuite() 514 514 + }) 515 515 + 516 516 + test('a', () => { 517 517 + expect(1).toBe(1) 518 518 + }) 519 519 + }) 520 520 + 521 521 + describe.concurrent('s2', () => { 522 522 + aroundAll(async (runSuite) => { 523 523 + await defers[0] 524 524 + defers[1].resolve() 525 525 + await runSuite() 526 526 + }) 527 527 + 528 528 + test('b', () => { 529 529 + expect(1).toBe(1) 530 530 + }) 531 531 + }) 532 532 + ` 533 533 + 534 534 + test('neighboring suite aroundAll deadlocks with insufficient maxConcurrency', async () => { 535 535 + const { errorTree } = await runInlineTests({ 536 536 + 'basic.test.ts': aroundAllNeighboringSuitesSource, 537 537 + }, { 538 538 + maxConcurrency: 1, 539 539 + hookTimeout: 500, 540 540 + }) 541 541 + 542 542 + expect(errorTree()).toMatchInlineSnapshot(` 543 543 + { 544 544 + "basic.test.ts": { 545 545 + "s1": { 546 546 + "__suite_errors__": [ 547 547 + "The setup phase of "aroundAll" hook timed out after 500ms.", 548 548 + ], 549 549 + "a": "skipped", 550 550 + }, 551 551 + "s2": { 552 552 + "b": "passed", 553 553 + }, 554 554 + }, 555 555 + } 556 556 + `) 557 557 + }) 558 558 + 559 559 + test('neighboring suite aroundAll passes when maxConcurrency is high enough', async () => { 560 560 + const { stderr, errorTree } = await runInlineTests({ 561 561 + 'basic.test.ts': aroundAllNeighboringSuitesSource, 562 562 + }, { 563 563 + maxConcurrency: 2, 564 564 + }) 565 565 + 566 566 + expect(stderr).toBe('') 567 567 + expect(errorTree()).toMatchInlineSnapshot(` 568 568 + { 569 569 + "basic.test.ts": { 570 570 + "s1": { 571 571 + "a": "passed", 572 572 + }, 573 573 + "s2": { 574 574 + "b": "passed", 575 575 + }, 576 576 + }, 577 577 + } 578 578 + `) 579 579 + }) 580 580 + 581 581 + const aroundAllNeighboringSuitesPostSource = ` 582 582 + import { aroundAll, describe, expect, test } from 'vitest' 583 583 + import { createDefer } from '@vitest/utils/helpers' 584 584 + 585 585 + const defers = [ 586 586 + createDefer<void>(), 587 587 + createDefer<void>(), 588 588 + ] 589 589 + 590 590 + describe.concurrent('s1', () => { 591 591 + aroundAll(async (runSuite) => { 592 592 + await runSuite() 593 593 + defers[0].resolve() 594 594 + await defers[1] 595 595 + }) 596 596 + 597 597 + test('a', () => { 598 598 + expect(1).toBe(1) 599 599 + }) 600 600 + }) 601 601 + 602 602 + describe.concurrent('s2', () => { 603 603 + aroundAll(async (runSuite) => { 604 604 + await runSuite() 605 605 + await defers[0] 606 606 + defers[1].resolve() 607 607 + }) 608 608 + 609 609 + test('b', () => { 610 610 + expect(1).toBe(1) 611 611 + }) 612 612 + }) 613 613 + ` 614 614 + 615 615 + test('neighboring suite aroundAll teardown deadlocks with insufficient maxConcurrency', async () => { 616 616 + const { errorTree } = await runInlineTests({ 617 617 + 'basic.test.ts': aroundAllNeighboringSuitesPostSource, 618 618 + }, { 619 619 + maxConcurrency: 1, 620 620 + hookTimeout: 500, 621 621 + }) 622 622 + 623 623 + expect(errorTree()).toMatchInlineSnapshot(` 624 624 + { 625 625 + "basic.test.ts": { 626 626 + "s1": { 627 627 + "__suite_errors__": [ 628 628 + "The teardown phase of \"aroundAll\" hook timed out after 500ms.", 629 629 + ], 630 630 + "a": "passed", 631 631 + }, 632 632 + "s2": { 633 633 + "b": "passed", 634 634 + }, 635 635 + }, 636 636 + } 637 637 + `) 638 638 + }) 639 639 + 640 640 + test('neighboring suite aroundAll teardown passes when maxConcurrency is high enough', async () => { 641 641 + const { stderr, errorTree } = await runInlineTests({ 642 642 + 'basic.test.ts': aroundAllNeighboringSuitesPostSource, 643 643 + }, { 644 644 + maxConcurrency: 2, 645 645 + }) 646 646 + 647 647 + expect(stderr).toBe('') 648 648 + expect(errorTree()).toMatchInlineSnapshot(` 649 649 + { 650 650 + "basic.test.ts": { 651 651 + "s1": { 652 652 + "a": "passed", 653 653 + }, 654 654 + "s2": { 655 655 + "b": "passed", 656 656 + }, 657 657 + }, 658 658 + } 659 659 + `) 660 660 + }) 661 661 + 662 662 + const aroundAllSetupTimeoutLateTeardownAcquireSource = ` 663 663 + import { aroundAll, describe, expect, test } from 'vitest' 664 664 + import { createDefer } from '@vitest/utils/helpers' 665 665 + 666 666 + const unblockS1Setup = createDefer<void>() 667 667 + const allowS2TestFinish = createDefer<void>() 668 668 + const blockForever = createDefer<void>() 669 669 + 670 670 + describe.concurrent('s1', () => { 671 671 + aroundAll(async (runSuite) => { 672 672 + await unblockS1Setup 673 673 + await runSuite() 674 674 + allowS2TestFinish.resolve() 675 675 + await blockForever 676 676 + }) 677 677 + 678 678 + test('a', () => { 679 679 + expect(1).toBe(1) 680 680 + }) 681 681 + }) 682 682 + 683 683 + describe.concurrent('s2', () => { 684 684 + aroundAll(async (runSuite) => { 685 685 + unblockS1Setup.resolve() 686 686 + await runSuite() 687 687 + }) 688 688 + 689 689 + test('b', async () => { 690 690 + await allowS2TestFinish 691 691 + expect(1).toBe(1) 692 692 + }) 693 693 + }) 694 694 + ` 695 695 + 696 696 + test('neighboring suite aroundAll does not hang when setup times out before late teardown acquire', async () => { 697 697 + const { errorTree } = await runInlineTests({ 698 698 + 'basic.test.ts': aroundAllSetupTimeoutLateTeardownAcquireSource, 699 699 + }, { 700 700 + maxConcurrency: 1, 701 701 + hookTimeout: 500, 702 702 + testTimeout: 500, 703 703 + }) 704 704 + 705 705 + expect(errorTree()).toMatchInlineSnapshot(` 706 706 + { 707 707 + "basic.test.ts": { 708 708 + "s1": { 709 709 + "__suite_errors__": [ 710 710 + "The setup phase of "aroundAll" hook timed out after 500ms.", 711 711 + ], 712 712 + "a": "skipped", 713 713 + }, 714 714 + "s2": { 715 715 + "b": [ 716 716 + "Test timed out in 500ms. 717 717 + If this is a long-running test, pass a timeout value as the last argument or configure it globally with "testTimeout".", 718 718 + ], 719 719 + }, 720 720 + }, 721 721 + } 722 722 + `) 723 723 + }) 724 724 + 725 725 + const aroundEachNeighboringTestsSource = ` 726 726 + import { aroundEach, describe, expect, test } from 'vitest' 727 727 + import { createDefer } from '@vitest/utils/helpers' 728 728 + 729 729 + const defers = [ 730 730 + createDefer<void>(), 731 731 + createDefer<void>(), 732 732 + ] 733 733 + 734 734 + describe.concurrent('wrapper', () => { 735 735 + aroundEach(async (runTest, context) => { 736 736 + if (context.task.name === 'a') { 737 737 + defers[0].resolve() 738 738 + await defers[1] 739 739 + await runTest() 740 740 + return 741 741 + } 742 742 + 743 743 + await defers[0] 744 744 + defers[1].resolve() 745 745 + await runTest() 746 746 + }) 747 747 + 748 748 + test('a', () => { 749 749 + expect(1).toBe(1) 750 750 + }) 751 751 + 752 752 + test('b', () => { 753 753 + expect(1).toBe(1) 754 754 + }) 755 755 + }) 756 756 + ` 757 757 + 758 758 + test('neighboring test aroundEach deadlocks with insufficient maxConcurrency', async () => { 759 759 + const { errorTree } = await runInlineTests({ 760 760 + 'basic.test.ts': aroundEachNeighboringTestsSource, 761 761 + }, { 762 762 + maxConcurrency: 1, 763 763 + hookTimeout: 500, 764 764 + }) 765 765 + 766 766 + expect(errorTree()).toMatchInlineSnapshot(` 767 767 + { 768 768 + "basic.test.ts": { 769 769 + "wrapper": { 770 770 + "a": [ 771 771 + "The setup phase of \"aroundEach\" hook timed out after 500ms.", 772 772 + ], 773 773 + "b": "passed", 774 774 + }, 775 775 + }, 776 776 + } 777 777 + `) 778 778 + }) 779 779 + 780 780 + test('neighboring test aroundEach passes when maxConcurrency is high enough', async () => { 781 781 + const { stderr, errorTree } = await runInlineTests({ 782 782 + 'basic.test.ts': aroundEachNeighboringTestsSource, 783 783 + }, { 784 784 + maxConcurrency: 2, 785 785 + }) 786 786 + 787 787 + expect(stderr).toBe('') 788 788 + expect(errorTree()).toMatchInlineSnapshot(` 789 789 + { 790 790 + "basic.test.ts": { 791 791 + "wrapper": { 792 792 + "a": "passed", 793 793 + "b": "passed", 794 794 + }, 795 795 + }, 796 796 + } 797 797 + `) 798 798 + }) 799 799 + 800 800 + const aroundEachNeighboringTestsPostSource = ` 801 801 + import { aroundEach, describe, expect, test } from 'vitest' 802 802 + import { createDefer } from '@vitest/utils/helpers' 803 803 + 804 804 + const defers = [ 805 805 + createDefer<void>(), 806 806 + createDefer<void>(), 807 807 + ] 808 808 + 809 809 + describe.concurrent('wrapper', () => { 810 810 + aroundEach(async (runTest, context) => { 811 811 + await runTest() 812 812 + 813 813 + if (context.task.name === 'a') { 814 814 + defers[0].resolve() 815 815 + await defers[1] 816 816 + return 817 817 + } 818 818 + 819 819 + await defers[0] 820 820 + defers[1].resolve() 821 821 + }) 822 822 + 823 823 + test('a', () => { 824 824 + expect(1).toBe(1) 825 825 + }) 826 826 + 827 827 + test('b', () => { 828 828 + expect(1).toBe(1) 829 829 + }) 830 830 + }) 831 831 + ` 832 832 + 833 833 + test('neighboring test aroundEach teardown deadlocks with insufficient maxConcurrency', async () => { 834 834 + const { errorTree } = await runInlineTests({ 835 835 + 'basic.test.ts': aroundEachNeighboringTestsPostSource, 836 836 + }, { 837 837 + maxConcurrency: 1, 838 838 + hookTimeout: 500, 839 839 + }) 840 840 + 841 841 + expect(errorTree()).toMatchInlineSnapshot(` 842 842 + { 843 843 + "basic.test.ts": { 844 844 + "wrapper": { 845 845 + "a": [ 846 846 + "The teardown phase of \"aroundEach\" hook timed out after 500ms.", 847 847 + ], 848 848 + "b": "passed", 849 849 + }, 850 850 + }, 851 851 + } 852 852 + `) 853 853 + }) 854 854 + 855 855 + test('neighboring test aroundEach teardown passes when maxConcurrency is high enough', async () => { 856 856 + const { stderr, errorTree } = await runInlineTests({ 857 857 + 'basic.test.ts': aroundEachNeighboringTestsPostSource, 858 858 + }, { 859 859 + maxConcurrency: 2, 860 860 + }) 861 861 + 862 862 + expect(stderr).toBe('') 863 863 + expect(errorTree()).toMatchInlineSnapshot(` 864 864 + { 865 865 + "basic.test.ts": { 866 866 + "wrapper": { 867 867 + "a": "passed", 868 868 + "b": "passed", 869 869 + }, 870 870 + }, 871 871 + } 872 872 + `) 873 873 + }) 874 874 + 875 875 + const aroundEachOuterCatchesInnerErrorSource = ` 876 876 + import { aroundEach, describe, expect, test } from 'vitest' 877 877 + 878 878 + describe.concurrent('wrapper', () => { 879 879 + aroundEach(async (runTest) => { 880 880 + let runTestError: unknown 881 881 + try { 882 882 + await runTest() 883 883 + } 884 884 + catch (error) { 885 885 + runTestError = error 886 886 + } 887 887 + 888 888 + await Promise.resolve() 889 889 + 890 890 + if (runTestError) { 891 891 + throw runTestError 892 892 + } 893 893 + }) 894 894 + 895 895 + aroundEach(async (runTest, context) => { 896 896 + await runTest() 897 897 + if (context.task.name === 'a') { 898 898 + throw new Error('inner aroundEach teardown failure') 899 899 + } 900 900 + }) 901 901 + 902 902 + test('a', () => { 903 903 + expect(1).toBe(1) 904 904 + }) 905 905 + 906 906 + test('b', () => { 907 907 + expect(1).toBe(1) 908 908 + }) 909 909 + }) 910 910 + ` 911 911 + 912 912 + test('aroundEach continues protocol when outer hook catches runTest error', async () => { 913 913 + const { errorTree } = await runInlineTests({ 914 914 + 'basic.test.ts': aroundEachOuterCatchesInnerErrorSource, 915 915 + }, { 916 916 + maxConcurrency: 1, 917 917 + }) 918 918 + 919 919 + expect(errorTree()).toMatchInlineSnapshot(` 920 920 + { 921 921 + "basic.test.ts": { 922 922 + "wrapper": { 923 923 + "a": [ 924 924 + "inner aroundEach teardown failure", 925 925 + ], 926 926 + "b": "passed", 927 927 + }, 928 928 + }, 929 929 + } 930 930 + `) 931 931 + }) 932 932 + 933 933 + const aroundAllOuterCatchesInnerErrorSource = ` 934 934 + import { aroundAll, describe, expect, test } from 'vitest' 935 935 + 936 936 + describe.concurrent('suite', () => { 937 937 + aroundAll(async (runSuite) => { 938 938 + let runSuiteError: unknown 939 939 + try { 940 940 + await runSuite() 941 941 + } 942 942 + catch (error) { 943 943 + runSuiteError = error 944 944 + } 945 945 + 946 946 + await Promise.resolve() 947 947 + 948 948 + if (runSuiteError) { 949 949 + throw runSuiteError 950 950 + } 951 951 + }) 952 952 + 953 953 + aroundAll(async (runSuite) => { 954 954 + await runSuite() 955 955 + throw new Error('inner aroundAll teardown failure') 956 956 + }) 957 957 + 958 958 + test('a', () => { 959 959 + expect(1).toBe(1) 960 960 + }) 961 961 + }) 962 962 + ` 963 963 + 964 964 + test('aroundAll continues protocol when outer hook catches runSuite error', async () => { 965 965 + const { errorTree } = await runInlineTests({ 966 966 + 'basic.test.ts': aroundAllOuterCatchesInnerErrorSource, 967 967 + }, { 968 968 + maxConcurrency: 1, 969 969 + }) 970 970 + 971 971 + expect(errorTree()).toMatchInlineSnapshot(` 972 972 + { 973 973 + "basic.test.ts": { 974 974 + "suite": { 975 975 + "__suite_errors__": [ 976 976 + "inner aroundAll teardown failure", 977 977 + ], 978 978 + "a": "passed", 979 979 + }, 980 980 + }, 981 981 + } 982 982 + `) 983 983 + }) 984 984 + 985 985 + const aroundEachCaughtInnerErrorTeardownTimeoutSource = ` 986 986 + import { aroundEach, describe, expect, test } from 'vitest' 987 987 + 988 988 + describe.concurrent('wrapper', () => { 989 989 + aroundEach(async (runTest) => { 990 990 + try { 991 991 + await runTest() 992 992 + } 993 993 + catch { 994 994 + // swallow inner failure, then run long teardown logic 995 995 + } 996 996 + await new Promise(resolve => setTimeout(resolve, 200)) 997 997 + }, 50) 998 998 + 999 999 + aroundEach(async (runTest) => { 1000 1000 + await runTest() 1001 1001 + throw new Error('inner aroundEach teardown failure') 1002 1002 + }) 1003 1003 + 1004 1004 + test('a', () => { 1005 1005 + expect(1).toBe(1) 1006 1006 + }) 1007 1007 + }) 1008 1008 + ` 1009 1009 + 1010 1010 + test('aroundEach enforces teardown timeout when inner error is caught', async () => { 1011 1011 + const { errorTree } = await runInlineTests({ 1012 1012 + 'basic.test.ts': aroundEachCaughtInnerErrorTeardownTimeoutSource, 1013 1013 + }, { 1014 1014 + maxConcurrency: 1, 1015 1015 + }) 1016 1016 + 1017 1017 + expect(errorTree()).toMatchInlineSnapshot(` 1018 1018 + { 1019 1019 + "basic.test.ts": { 1020 1020 + "wrapper": { 1021 1021 + "a": [ 1022 1022 + "inner aroundEach teardown failure", 1023 1023 + "The teardown phase of "aroundEach" hook timed out after 50ms.", 1024 1024 + ], 1025 1025 + }, 1026 1026 + }, 1027 1027 + } 1028 1028 + `) 1029 1029 + }) 1030 1030 + 1031 1031 + const aroundAllCaughtInnerErrorTeardownTimeoutSource = ` 1032 1032 + import { aroundAll, describe, expect, test } from 'vitest' 1033 1033 + 1034 1034 + describe.concurrent('suite', () => { 1035 1035 + aroundAll(async (runSuite) => { 1036 1036 + try { 1037 1037 + await runSuite() 1038 1038 + } 1039 1039 + catch { 1040 1040 + // swallow inner failure, then run long teardown logic 1041 1041 + } 1042 1042 + await new Promise(resolve => setTimeout(resolve, 200)) 1043 1043 + }, 50) 1044 1044 + 1045 1045 + aroundAll(async (runSuite) => { 1046 1046 + await runSuite() 1047 1047 + throw new Error('inner aroundAll teardown failure') 1048 1048 + }) 1049 1049 + 1050 1050 + test('a', () => { 1051 1051 + expect(1).toBe(1) 1052 1052 + }) 1053 1053 + }) 1054 1054 + ` 1055 1055 + 1056 1056 + test('aroundAll enforces teardown timeout when inner error is caught', async () => { 1057 1057 + const { errorTree } = await runInlineTests({ 1058 1058 + 'basic.test.ts': aroundAllCaughtInnerErrorTeardownTimeoutSource, 1059 1059 + }, { 1060 1060 + maxConcurrency: 1, 1061 1061 + }) 1062 1062 + 1063 1063 + expect(errorTree()).toMatchInlineSnapshot(` 1064 1064 + { 1065 1065 + "basic.test.ts": { 1066 1066 + "suite": { 1067 1067 + "__suite_errors__": [ 1068 1068 + "inner aroundAll teardown failure", 1069 1069 + "The teardown phase of "aroundAll" hook timed out after 50ms.", 1070 1070 + ], 1071 1071 + "a": "passed", 1072 1072 + }, 1073 1073 + }, 1074 1074 + } 1075 1075 + `) 1076 1076 + })

+9 -3

test/cli/test/expect-task.test.ts

Reviewed

··· 172 172 name: 'test-bound extend & local extend', 173 173 test: testBoundLocalExtend, 174 174 }, 175 175 - ] as const)('works with $name', async ({ options, test }, { expect }) => { 175 175 + ] as const)('works with $name', async ({ options, test }, { task, expect }) => { 176 176 const { stdout, stderr } = await runInlineTests( 177 177 { 178 178 'basic.test.ts': test, 179 179 'to-match-test.ts': toMatchTest, 180 180 }, 181 181 { reporters: ['tap'], ...options }, 182 182 + undefined, 183 183 + task, 182 184 ) 183 185 184 186 expect(stderr).toBe('') ··· 210 212 name: 'global import', 211 213 test: withConcurrency(globalImport), 212 214 }, 213 213 - ] as const)('fails with $name', async ({ options, test }, { expect }) => { 215 215 + ] as const)('fails with $name', async ({ options, test }, { task, expect }) => { 214 216 const { stdout, ctx } = await runInlineTests( 215 217 { 216 218 'basic.test.ts': test, 217 219 'to-match-test.ts': toMatchTest, 218 220 }, 219 221 { reporters: ['tap'], ...options }, 222 222 + undefined, 223 223 + task, 220 224 ) 221 225 222 226 expect( ··· 263 267 name: 'test-bound extend & local extend', 264 268 test: withConcurrency(testBoundLocalExtend), 265 269 }, 266 266 - ])('works with $name', async ({ test }, { expect }) => { 270 270 + ])('works with $name', async ({ test }, { task, expect }) => { 267 271 const { stdout } = await runInlineTests( 268 272 { 269 273 'basic.test.ts': test, 270 274 'to-match-test.ts': toMatchTest, 271 275 }, 272 276 { reporters: ['tap'] }, 277 277 + undefined, 278 278 + task, 273 279 ) 274 280 275 281 expect(stdout.replace(/[\d.]+m?s/g, '<time>')).toMatchInlineSnapshot(`

+44 -1

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

Reviewed

··· 1 1 import { createDefer } from '@vitest/utils/helpers' 2 2 - import { afterAll, describe, expect, test } from 'vitest' 2 2 + import { afterAll, beforeAll, describe, expect, test } from 'vitest' 3 3 4 4 describe('basic', () => { 5 5 const defers = [ ··· 181 181 }) 182 182 }) 183 183 } 184 184 + 185 185 + describe('suite hook concurrency', () => { 186 186 + const logs: string[] = [] 187 187 + 188 188 + afterAll(() => { 189 189 + expect(logs).toEqual(['s2-before', 's2-after', 's1-before', 's1-before-2', 's1-after-2', 's1-after']) 190 190 + }) 191 191 + 192 192 + describe.concurrent('s1', () => { 193 193 + // before/afterAll inside same suite runs sequentially in stack order 194 194 + beforeAll(async () => { 195 195 + await sleep(200) 196 196 + logs.push('s1-before') 197 197 + }) 198 198 + 199 199 + beforeAll(async () => { 200 200 + logs.push('s1-before-2') 201 201 + }) 202 202 + 203 203 + afterAll(async () => { 204 204 + logs.push('s1-after') 205 205 + }) 206 206 + 207 207 + afterAll(async () => { 208 208 + logs.push('s1-after-2') 209 209 + }) 210 210 + 211 211 + test('s1-t', () => {}) 212 212 + }) 213 213 + 214 214 + describe.concurrent('s2', () => { 215 215 + // before/afterAll in neighboring concurrent suite runs in parallel 216 216 + beforeAll(async () => { 217 217 + logs.push('s2-before') 218 218 + }) 219 219 + 220 220 + afterAll(async () => { 221 221 + logs.push('s2-after') 222 222 + }) 223 223 + 224 224 + test('s2-t', () => {}) 225 225 + }) 226 226 + })

+46 -18

packages/runner/src/utils/limit-concurrency.ts

Reviewed

··· 1 1 // A compact (code-wise, probably not memory-wise) singly linked list node. 2 2 type QueueNode<T> = [value: T, next?: QueueNode<T>] 3 3 4 4 + export interface ConcurrencyLimiter extends ConcurrencyLimiterFn { 5 5 + acquire: () => (() => void) | Promise<() => void> 6 6 + } 7 7 + 8 8 + type ConcurrencyLimiterFn = <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T> 9 9 + 4 10 /** 5 11 * Return a function for running multiple async operations with limited concurrency. 6 12 */ 7 7 - export function limitConcurrency(concurrency: number = Infinity): <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T> { 13 13 + export function limitConcurrency(concurrency: number = Infinity): ConcurrencyLimiter { 8 14 // The number of currently active + pending tasks. 9 15 let count = 0 10 16 ··· 30 36 } 31 37 } 32 38 33 33 - return (func, ...args) => { 34 34 - // Create a promise chain that: 35 35 - // 1. Waits for its turn in the task queue (if necessary). 36 36 - // 2. Runs the task. 37 37 - // 3. Allows the next pending task (if any) to run. 38 38 - return new Promise<void>((resolve) => { 39 39 - if (count++ < concurrency) { 40 40 - // No need to queue if fewer than maxConcurrency tasks are running. 41 41 - resolve() 39 39 + const acquire = () => { 40 40 + let released = false 41 41 + const release = () => { 42 42 + if (!released) { 43 43 + released = true 44 44 + finish() 42 45 } 43 43 - else if (tail) { 46 46 + } 47 47 + 48 48 + if (count++ < concurrency) { 49 49 + return release 50 50 + } 51 51 + 52 52 + return new Promise<() => void>((resolve) => { 53 53 + if (tail) { 44 54 // There are pending tasks, so append to the queue. 45 45 - tail = tail[1] = [resolve] 55 55 + tail = tail[1] = [() => resolve(release)] 46 56 } 47 57 else { 48 58 // No other pending tasks, initialize the queue with a new tail and head. 49 49 - head = tail = [resolve] 59 59 + head = tail = [() => resolve(release)] 50 60 } 51 51 - }).then(() => { 52 52 - // Running func here ensures that even a non-thenable result or an 53 53 - // immediately thrown error gets wrapped into a Promise. 54 54 - return func(...args) 55 55 - }).finally(finish) 61 61 + }) 56 62 } 63 63 + 64 64 + const limiterFn: ConcurrencyLimiterFn = (func, ...args) => { 65 65 + function run(release: () => void) { 66 66 + try { 67 67 + const result = func(...args) 68 68 + if (result instanceof Promise) { 69 69 + return result.finally(release) 70 70 + } 71 71 + release() 72 72 + return Promise.resolve(result) 73 73 + } 74 74 + catch (error) { 75 75 + release() 76 76 + return Promise.reject(error) 77 77 + } 78 78 + } 79 79 + 80 80 + const release = acquire() 81 81 + return release instanceof Promise ? release.then(run) : run(release) 82 82 + } 83 83 + 84 84 + return Object.assign(limiterFn, { acquire }) 57 85 }

-44

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

Reviewed

··· 1 1 - import { createDefer } from '@vitest/utils/helpers' 2 2 - import { describe, test, vi, expect } from 'vitest' 3 3 - 4 4 - // 3 tests depend on each other, 5 5 - // so they will deadlock when maxConcurrency < 3 6 6 - // 7 7 - // [a] [b] [c] 8 8 - // * -> 9 9 - // * -> 10 10 - // <- * 11 11 - // <------ 12 12 - 13 13 - vi.setConfig({ maxConcurrency: 2 }) 14 14 - 15 15 - describe('wrapper', { concurrent: true, timeout: 500 }, () => { 16 16 - const defers = [ 17 17 - createDefer<void>(), 18 18 - createDefer<void>(), 19 19 - createDefer<void>(), 20 20 - ] 21 21 - 22 22 - describe('1st suite', () => { 23 23 - test('a', async () => { 24 24 - expect(1).toBe(1) 25 25 - defers[0].resolve() 26 26 - await defers[2] 27 27 - }) 28 28 - 29 29 - test('b', async () => { 30 30 - expect(1).toBe(1) 31 31 - await defers[0] 32 32 - defers[1].resolve() 33 33 - await defers[2] 34 34 - }) 35 35 - }) 36 36 - 37 37 - describe('2nd suite', () => { 38 38 - test('c', async () => { 39 39 - expect(1).toBe(1) 40 40 - await defers[1] 41 41 - defers[2].resolve() 42 42 - }) 43 43 - }) 44 44 - })

-40

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

Reviewed

··· 1 1 - import { describe, expect, test, vi } from 'vitest' 2 2 - import { createDefer } from '@vitest/utils/helpers' 3 3 - 4 4 - // 3 tests depend on each other, 5 5 - // so they will deadlock when maxConcurrency < 3 6 6 - // 7 7 - // [a] [b] [c] 8 8 - // * -> 9 9 - // * -> 10 10 - // <- * 11 11 - // <------ 12 12 - 13 13 - vi.setConfig({ maxConcurrency: 2 }) 14 14 - 15 15 - describe('wrapper', { concurrent: true, timeout: 500 }, () => { 16 16 - const defers = [ 17 17 - createDefer<void>(), 18 18 - createDefer<void>(), 19 19 - createDefer<void>(), 20 20 - ] 21 21 - 22 22 - test('a', async () => { 23 23 - expect(1).toBe(1) 24 24 - defers[0].resolve() 25 25 - await defers[2] 26 26 - }) 27 27 - 28 28 - test('b', async () => { 29 29 - expect(1).toBe(1) 30 30 - await defers[0] 31 31 - defers[1].resolve() 32 32 - await defers[2] 33 33 - }) 34 34 - 35 35 - test('c', async () => { 36 36 - expect(1).toBe(1) 37 37 - await defers[1] 38 38 - defers[2].resolve() 39 39 - }) 40 40 - })

-10

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

Reviewed

··· 7 7 AssertionError: expected 'xx' to be 'yy' // Object.is equality" 8 8 `; 9 9 10 10 - exports[`should fail concurrent-suite-deadlock.test.ts 1`] = ` 11 11 - "Error: Test timed out in 500ms. 12 12 - Error: Test timed out in 500ms." 13 13 - `; 14 14 - 15 15 - exports[`should fail concurrent-test-deadlock.test.ts 1`] = ` 16 16 - "Error: Test timed out in 500ms. 17 17 - Error: Test timed out in 500ms." 18 18 - `; 19 19 - 20 10 exports[`should fail each-timeout.test.ts 1`] = `"Error: Test timed out in 10ms."`; 21 11 22 12 exports[`should fail empty.test.ts 1`] = `"Error: No test suite found in file <rootDir>/empty.test.ts"`;

+1 -1

packages/vitest/src/node/cli/cli-config.ts

Reviewed

··· 733 733 }, 734 734 }, 735 735 maxConcurrency: { 736 736 - description: 'Maximum number of concurrent tests in a suite (default: `5`)', 736 736 + description: 'Maximum number of concurrent tests and suites during test file execution (default: `5`)', 737 737 argument: '<number>', 738 738 }, 739 739 expect: {