fix: fix per-project sequence config (#10659)

hi-ogawa · OpenCode (claude-opus-4-8) · web-flow · commit 40cdc7fd6b9e · 2026-06-25T09:40:32.000+02:00
Co-authored-by: Hiroshi Ogawa &lt;4232207+hi-ogawa@users.noreply.github.com&gt;
Co-authored-by: OpenCode (claude-opus-4-8) &lt;noreply@opencode.ai&gt;
diff --git a/docs/config/sequence.md b/docs/config/sequence.md
@@ -99,14 +99,16 @@ If you want files and tests to run randomly, you can enable it with this option,
 
 Vitest usually uses cache to sort tests, so long-running tests start earlier, which makes tests run faster. If your files and tests run in random order, you will lose this performance improvement, but it may be useful to track tests that accidentally depend on another test run previously.
 
-### sequence.shuffle.files {#sequence-shuffle-files}
+### sequence.shuffle.files <CRoot /> {#sequence-shuffle-files}
 
 - **Type:** `boolean`
 - **Default:** `false`
 - **CLI:** `--sequence.shuffle.files`, `--sequence.shuffle.files=false`
 
 Whether to randomize files, be aware that long running tests will not start earlier if you enable this option.
 
+Because file ordering is shared across [projects](/guide/projects), this option is resolved from the root config only. A project can still randomize its own tests with [`sequence.shuffle.tests`](#sequence-shuffle-tests).
+
 ### sequence.shuffle.tests {#sequence-shuffle-tests}
 
 - **Type:** `boolean`
diff --git a/packages/vitest/src/node/config/resolveConfig.ts b/packages/vitest/src/node/config/resolveConfig.ts
@@ -790,10 +790,7 @@ export function resolveConfig(
   }
   resolved.sequence.groupOrder ??= 0
   resolved.sequence.hooks ??= 'stack'
-  // Set seed if either files or tests are shuffled
-  if (resolved.sequence.sequencer === RandomSequencer || resolved.sequence.shuffle) {
-    resolved.sequence.seed ??= Date.now()
-  }
+  resolved.sequence.seed ??= Date.now()
 
   resolved.typecheck = {
     ...configDefaults.typecheck,
diff --git a/packages/vitest/src/node/config/serializeConfig.ts b/packages/vitest/src/node/config/serializeConfig.ts
@@ -87,11 +87,13 @@ export function serializeConfig(project: TestProject): SerializedConfig {
         ?? globalConfig.snapshotOptions.expand,
     },
     sequence: {
-      shuffle: globalConfig.sequence.shuffle,
-      concurrent: globalConfig.sequence.concurrent,
+      shuffle: config.sequence.shuffle,
+      concurrent: config.sequence.concurrent,
+      // `seed` and `sequencer` drive cross-project file ordering, so they are
+      // resolved from the root config and shared across all projects.
       seed: globalConfig.sequence.seed,
-      hooks: globalConfig.sequence.hooks,
-      setupFiles: globalConfig.sequence.setupFiles,
+      hooks: config.sequence.hooks,
+      setupFiles: config.sequence.setupFiles,
     },
     inspect: globalConfig.inspect,
     inspectBrk: globalConfig.inspectBrk,
diff --git a/packages/vitest/src/node/core.ts b/packages/vitest/src/node/core.ts
@@ -51,6 +51,7 @@ import { HangingProcessReporter } from './reporters/hanging-process'
 import { createReport } from './reporters/report'
 import { createReporters } from './reporters/utils'
 import { VitestResolver } from './resolver'
+import { RandomSequencer } from './sequencers/RandomSequencer'
 import { VitestSpecifications } from './specifications'
 import { StateManager } from './state'
 import { populateProjectsTags } from './tags'
@@ -680,7 +681,11 @@ export class Vitest {
    * Returns the seed, if tests are running in a random order.
    */
   public getSeed(): number | null {
-    return this.config.sequence.seed ?? null
+    // Tests can be shuffled per project, so check projects as well.
+    const randomized = this.config.sequence.sequencer === RandomSequencer
+      || !!this.config.sequence.shuffle
+      || this.projects.some(p => !!p.config.sequence.shuffle)
+    return randomized ? this.config.sequence.seed : null
   }
 
   /** @internal */
diff --git a/packages/vitest/src/node/logger.ts b/packages/vitest/src/node/logger.ts
@@ -9,7 +9,6 @@ import c from 'tinyrainbow'
 import { highlightCode } from '../utils/colors'
 import { capturePrintError, printError } from './printError'
 import { divider, errorBanner, formatProjectName, withLabel } from './reporters/renderers/utils'
-import { RandomSequencer } from './sequencers/RandomSequencer'
 
 export interface ErrorOptions {
   type?: string
@@ -235,9 +234,9 @@ export class Logger {
 
     this.log(withLabel(color, mode, `v${this.ctx.version} `) + c.gray(this.ctx.config.root))
 
-    // Log seed if either files (RandomSequencer) or tests are shuffled
-    if (this.ctx.config.sequence.sequencer === RandomSequencer || this.ctx.config.sequence.shuffle) {
-      this.log(PAD + c.gray(`Running tests with seed "${this.ctx.config.sequence.seed}"`))
+    const seed = this.ctx.getSeed()
+    if (seed != null) {
+      this.log(PAD + c.gray(`Running tests with seed "${seed}"`))
     }
 
     if (this.ctx.config.ui) {
diff --git a/packages/vitest/src/node/types/config.ts b/packages/vitest/src/node/types/config.ts
@@ -1296,11 +1296,15 @@ export interface ServerDepsOptions {
 export type ProjectConfig = Omit<
   InlineConfig,
   NonProjectOptions
-  | 'sequencer'
+  | 'sequence'
   | 'deps'
 > & {
   mode?: string
-  sequencer?: Omit<SequenceOptions, 'sequencer' | 'seed'>
+  sequence?: Omit<SequenceOptions, 'sequencer' | 'seed' | 'shuffle'> & {
+    // `shuffle.files` controls cross-project file ordering, which is resolved
+    // from the root config only, so projects can only shuffle their own tests.
+    shuffle?: boolean | { tests?: boolean }
+  }
   deps?: Omit<DepsOptions, 'moduleDirectories'>
 }
 
diff --git a/test/e2e/test/config/sequence-shuffle.test.ts b/test/e2e/test/config/sequence-shuffle.test.ts
@@ -148,8 +148,25 @@ test('should log seed when shuffle is true', async () => {
   expect(stdout).toContain('Running tests with seed "67890"')
 })
 
+test('should log seed when a project shuffles tests', async () => {
+  const { stdout, ctx } = await runInlineTests({
+    'a.test.js': /* js */ `
+      import { test } from 'vitest'
+      test('example', () => {})
+    `,
+  }, {
+    projects: [
+      { test: { sequence: { shuffle: { tests: true } } } },
+    ],
+  })
+
+  const seed = ctx?.getSeed()
+  expect(seed).toEqual(expect.any(Number))
+  expect(stdout).toContain(`Running tests with seed "${seed}"`)
+})
+
 test('should not log seed when shuffle is disabled', async () => {
-  const { stdout } = await runInlineTests({
+  const { stdout, ctx } = await runInlineTests({
     'basic.test.js': /* js */ `
       import { test } from 'vitest'
       test('example', () => {})
@@ -160,5 +177,6 @@ test('should not log seed when shuffle is disabled', async () => {
     },
   })
 
+  expect(ctx?.getSeed()).toBe(null)
   expect(stdout).not.toContain('Running tests with seed')
 })
diff --git a/test/e2e/test/sequence-concurrent.test.ts b/test/e2e/test/sequence-concurrent.test.ts
@@ -65,3 +65,59 @@ test('should run suites and tests sequentially unless concurrent specified when
     }
   `)
 })
+
+test('applies sequence.concurrent per project (not just the root config)', async () => {
+  // The root config leaves `sequence.concurrent` at its default (false). Each
+  // project sets it independently, so the fixtures only pass if the project's
+  // value reaches the runtime. The fixtures self-assert `task.concurrent` and
+  // their completion order via staggered delays, so this is deterministic.
+  const { stderr, errorTree } = await runVitest({
+    root: './fixtures/sequence-concurrent',
+    projects: [
+      {
+        test: {
+          name: 'concurrent',
+          include: ['sequence-concurrent-true-concurrent.test.ts'],
+          sequence: {
+            concurrent: true,
+          },
+        },
+      },
+      {
+        test: {
+          name: 'sequential',
+          include: ['sequence-concurrent-false-sequential.test.ts'],
+          sequence: {
+            concurrent: false,
+          },
+        },
+      },
+    ],
+  })
+
+  expect(stderr).toBe('')
+  expect(errorTree({ project: true })).toMatchInlineSnapshot(`
+    {
+      "concurrent": {
+        "sequence-concurrent-true-concurrent.test.ts": {
+          "concurrent suite": {
+            "first test completes last": "passed",
+            "second test completes third": "passed",
+          },
+          "last test completes first": "passed",
+          "third test completes second": "passed",
+        },
+      },
+      "sequential": {
+        "sequence-concurrent-false-sequential.test.ts": {
+          "last test completes last": "passed",
+          "sequential suite": {
+            "first test completes first": "passed",
+            "second test completes second": "passed",
+          },
+          "third test completes third": "passed",
+        },
+      },
+    }
+  `)
+})
