fix(runner): ensure sequential suite overrides sequence.concurrent

packages/runner/src/suite.ts

@@ -520,16 +520,17 @@ function createSuite() {
       optionsOrFactory,
     )
 
+    const isConcurrentSpecified = options.concurrent || this.concurrent || options.sequential === false
+    const isSequentialSpecified = options.sequential || this.sequential || options.concurrent === false
+
     // inherit options from current suite
     if (currentSuite?.options) {
       options = { ...currentSuite.options, ...options }
     }
 
     // inherit concurrent / sequential from suite
-    const isConcurrent
-      = options.concurrent || (this.concurrent && !this.sequential)
-    const isSequential
-      = options.sequential || (this.sequential && !this.concurrent)
+    const isConcurrent = isConcurrentSpecified || (options.concurrent && !isSequentialSpecified)
+    const isSequential = isSequentialSpecified || (options.sequential && !isConcurrentSpecified)
     options.concurrent = isConcurrent && !isSequential
     options.sequential = isSequential && !isConcurrent
 

test/config/fixtures/sequence-concurrent/sequence-concurrent-false-concurrent.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test, vi } from 'vitest'
+
+const delay = (timeout: number) => new Promise(resolve => setTimeout(resolve, timeout))
+
+let count = 0
+
+describe.concurrent('concurrent suite', () => {
+  test('first test completes last', async ({ task }) => {
+    await delay(40)
+    expect(task.concurrent).toBeTruthy()
+    expect(++count).toBe(4)
+  })
+
+  test('second test completes third', async ({ task }) => {
+    await delay(30)
+    expect(task.concurrent).toBeTruthy()
+    expect(++count).toBe(3)
+  })
+})
+
+test.concurrent('third test completes second', async ({ task }) => {
+  await delay(20)
+  expect(task.concurrent).toBeTruthy()
+  expect(++count).toBe(2)
+})
+
+test.concurrent('last test completes first', async ({ task }) => {
+  await delay(10)
+  expect(task.concurrent).toBeTruthy()
+  expect(++count).toBe(1)
+})

test/config/fixtures/sequence-concurrent/sequence-concurrent-false-sequential.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test, vi } from 'vitest'
+
+const delay = (timeout: number) => new Promise(resolve => setTimeout(resolve, timeout))
+
+let count = 0
+
+describe('sequential suite', () => {
+  test('first test completes first', async ({ task }) => {
+    await delay(40)
+    expect(task.concurrent).toBeFalsy()
+    expect(++count).toBe(1)
+  })
+
+  test('second test completes second', async ({ task }) => {
+    await delay(30)
+    expect(task.concurrent).toBeFalsy()
+    expect(++count).toBe(2)
+  })
+})
+
+test('third test completes third', async ({ task }) => {
+  await delay(20)
+  expect(task.concurrent).toBeFalsy()
+  expect(++count).toBe(3)
+})
+
+test('last test completes last', async ({ task }) => {
+  await delay(10)
+  expect(task.concurrent).toBeFalsy()
+  expect(++count).toBe(4)
+})

test/config/fixtures/sequence-concurrent/sequence-concurrent-true-concurrent.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test, vi } from 'vitest'
+
+const delay = (timeout: number) => new Promise(resolve => setTimeout(resolve, timeout))
+
+let count = 0
+
+describe('concurrent suite', () => {
+  test('first test completes last', async ({ task }) => {
+    await delay(40)
+    expect(task.concurrent).toBeTruthy()
+    expect(++count).toBe(4)
+  })
+
+  test('second test completes third', async ({ task }) => {
+    await delay(30)
+    expect(task.concurrent).toBeTruthy()
+    expect(++count).toBe(3)
+  })
+})
+
+test('third test completes second', async ({ task }) => {
+  await delay(20)
+  expect(task.concurrent).toBeTruthy()
+  expect(++count).toBe(2)
+})
+
+test('last test completes first', async ({ task }) => {
+  await delay(10)
+  expect(task.concurrent).toBeTruthy()
+  expect(++count).toBe(1)
+})

test/core/test/sequential-sequence-concurrent.test.ts → test/config/fixtures/sequence-concurrent/sequence-concurrent-true-sequential.test.ts

@@ -1,35 +1,31 @@
 import { describe, expect, test, vi } from 'vitest'
 
-vi.setConfig({
-  sequence: {
-    concurrent: true,
-  },
-})
-
 const delay = (timeout: number) => new Promise(resolve => setTimeout(resolve, timeout))
 
 let count = 0
 
-describe.sequential('running sequential suite when sequence.concurrent is true', () => {
+describe.sequential('sequential suite', () => {
   test('first test completes first', async ({ task }) => {
-    await delay(50)
+    await delay(40)
     expect(task.concurrent).toBeFalsy()
     expect(++count).toBe(1)
   })
 
-  test('second test completes second', ({ task }) => {
+  test('second test completes second', async ({ task }) => {
+    await delay(30)
     expect(task.concurrent).toBeFalsy()
     expect(++count).toBe(2)
   })
 })
 
 test.sequential('third test completes third', async ({ task }) => {
-  await delay(50)
+  await delay(20)
   expect(task.concurrent).toBeFalsy()
   expect(++count).toBe(3)
 })
 
-test.sequential('fourth test completes fourth', ({ task }) => {
+test.sequential('last test completes last', async ({ task }) => {
+  await delay(10)
   expect(task.concurrent).toBeFalsy()
   expect(++count).toBe(4)
 })

test/config/test/sequence-concurrent.test.ts

@@ -0,0 +1,47 @@
+import { expect, test } from 'vitest'
+
+import { runVitest } from '../../test-utils'
+
+test('should run suites and tests concurrently unless sequential specified when sequence.concurrent is true', async () => {
+  const { stderr, stdout } = await runVitest({
+    root: './fixtures/sequence-concurrent',
+    include: ['sequence-concurrent-true-*.test.ts'],
+    sequence: {
+      concurrent: true,
+    },
+  })
+
+  expect(stderr).toBe('')
+
+  expect(stdout).toContain('✓ sequence-concurrent-true-sequential.test.ts > sequential suite > first test completes first')
+  expect(stdout).toContain('✓ sequence-concurrent-true-sequential.test.ts > sequential suite > second test completes second')
+  expect(stdout).toContain('✓ sequence-concurrent-true-sequential.test.ts > third test completes third')
+  expect(stdout).toContain('✓ sequence-concurrent-true-sequential.test.ts > last test completes last')
+  expect(stdout).toContain('✓ sequence-concurrent-true-concurrent.test.ts > concurrent suite > first test completes last')
+  expect(stdout).toContain('✓ sequence-concurrent-true-concurrent.test.ts > concurrent suite > second test completes third')
+  expect(stdout).toContain('✓ sequence-concurrent-true-concurrent.test.ts > third test completes second')
+  expect(stdout).toContain('✓ sequence-concurrent-true-concurrent.test.ts > last test completes first')
+  expect(stdout).toContain('Test Files  2 passed (2)')
+})
+
+test('should run suites and tests sequentially unless concurrent specified when sequence.concurrent is false', async () => {
+  const { stderr, stdout } = await runVitest({
+    root: './fixtures/sequence-concurrent',
+    include: ['sequence-concurrent-false-*.test.ts'],
+    sequence: {
+      concurrent: false,
+    },
+  })
+
+  expect(stderr).toBe('')
+
+  expect(stdout).toContain('✓ sequence-concurrent-false-sequential.test.ts > sequential suite > first test completes first')
+  expect(stdout).toContain('✓ sequence-concurrent-false-sequential.test.ts > sequential suite > second test completes second')
+  expect(stdout).toContain('✓ sequence-concurrent-false-sequential.test.ts > third test completes third')
+  expect(stdout).toContain('✓ sequence-concurrent-false-sequential.test.ts > last test completes last')
+  expect(stdout).toContain('✓ sequence-concurrent-false-concurrent.test.ts > concurrent suite > first test completes last')
+  expect(stdout).toContain('✓ sequence-concurrent-false-concurrent.test.ts > concurrent suite > second test completes third')
+  expect(stdout).toContain('✓ sequence-concurrent-false-concurrent.test.ts > third test completes second')
+  expect(stdout).toContain('✓ sequence-concurrent-false-concurrent.test.ts > last test completes first')
+  expect(stdout).toContain('Test Files  2 passed (2)')
+})