fix: run tests in configs that are not part of the workspace

Author: sheremet-va

src/api.ts

@@ -3,7 +3,7 @@ import * as vscode from 'vscode'
 import { log } from './log'
 import type { SerializedTestSpecification, VitestEvents, VitestRPC } from './api/rpc'
 import type { VitestPackage } from './api/pkg'
-import { showVitestError } from './utils'
+import { createVitestWorkspaceFile, noop, showVitestError } from './utils'
 import type { VitestProcess } from './api/types'
 import { createVitestTerminalProcess } from './api/terminal'
 import { getConfig } from './config'
@@ -257,21 +257,79 @@ function createQueuedHandler<T>(resolver: (value: T[]) => Promise<void>) {
   }
 }
 
-export async function resolveVitestAPI(packages: VitestPackage[]) {
-  const promises = packages.map(async (pkg) => {
-    const config = getConfig(pkg.folder)
-    if (config.cliArguments && !pkg.arguments) {
-      pkg.arguments = `vitest ${config.cliArguments}`
-    }
-    const vitest = config.shellType === 'terminal'
-      ? await createVitestTerminalProcess(pkg)
-      : await createVitestProcess(pkg)
-    return new VitestFolderAPI(pkg, vitest)
+export async function resolveVitestAPI(workspaceConfigs: VitestPackage[], configs: VitestPackage[]) {
+  const usedConfigs = new Set<string>()
+  const workspacePromises = workspaceConfigs.map(pkg => createVitestFolderAPI(usedConfigs, pkg))
+  const apis = await Promise.all(workspacePromises)
+  const configsToResolve = configs.filter((pkg) => {
+    return !pkg.configFile || pkg.workspaceFile || !usedConfigs.has(pkg.configFile)
   })
-  const apis = await Promise.all(promises)
+
+  const maximumConfigs = getConfig().maximumConfigs ?? 3
+
+  if (configsToResolve.length > maximumConfigs) {
+    const warningMessage = [
+      'Vitest found multiple config files.',
+      `The extension will use only the first ${maximumConfigs} due to performance concerns.`,
+      'Consider using a workspace configuration to group your configs or increase',
+      'the limit via "vitest.maximumConfigs" option.',
+    ].join(' ')
+
+    const folders = Array.from(new Set(configsToResolve.map(c => c.folder)))
+    const allConfigs = [...configsToResolve]
+    // remove all but the first 3
+    const discardedConfigs = configsToResolve.splice(maximumConfigs)
+
+    if (folders.every(f => getConfig(f).disableWorkspaceWarning !== true)) {
+      vscode.window.showWarningMessage(
+        warningMessage,
+        'Create vitest.workspace.js',
+        'Disable notification',
+      ).then((result) => {
+        if (result === 'Create vitest.workspace.js')
+          createVitestWorkspaceFile(allConfigs).catch(noop)
+
+        if (result === 'Disable notification') {
+          folders.forEach((folder) => {
+            const rootConfig = vscode.workspace.getConfiguration('vitest', folder)
+            rootConfig.update('disableWorkspaceWarning', true)
+          })
+        }
+      })
+    }
+    else {
+      log.info(warningMessage)
+      log.info(`Discarded config files: ${discardedConfigs.map(x => x.workspaceFile || x.configFile).join(', ')}`)
+    }
+  }
+
+  // one by one because it's possible some of them have "workspace:" -- the configs are already sorted by priority
+  for (const pkg of configsToResolve) {
+    if (pkg.configFile && usedConfigs.has(pkg.configFile)) {
+      continue
+    }
+
+    const api = await createVitestFolderAPI(usedConfigs, pkg)
+    apis.push(api)
+  }
+
   return new VitestAPI(apis)
 }
 
+async function createVitestFolderAPI(usedConfigs: Set<string>, pkg: VitestPackage) {
+  const config = getConfig(pkg.folder)
+  if (config.cliArguments && !pkg.arguments) {
+    pkg.arguments = `vitest ${config.cliArguments}`
+  }
+  const vitest = config.shellType === 'terminal'
+    ? await createVitestTerminalProcess(pkg)
+    : await createVitestProcess(pkg)
+  vitest.configs.forEach((config) => {
+    usedConfigs.add(config)
+  })
+  return new VitestFolderAPI(pkg, vitest)
+}
+
 export interface ResolvedMeta {
   rpc: VitestRPC
   process: VitestProcess

src/api/pkg.ts

@@ -108,17 +108,22 @@ function validateVitestPkg(showWarning: boolean, pkgJsonPath: string, pkg: any)
   return true
 }
 
-export async function resolveVitestPackages(showWarning: boolean): Promise<VitestPackage[]> {
-  // try to resolve configs first
-  const vitest = await resolveVitestPackagesViaConfigs(showWarning)
-  // if no viable configs found, try to resolve via package.json
-  if (!vitest.meta.length && !vitest.warned) {
+export async function resolveVitestPackages(showWarning: boolean): Promise<{ configs: VitestPackage[]; workspaces: VitestPackage[] }> {
+  // TODO: update "warned" logic
+  const [workspaceConfigs, configs] = await Promise.all([
+    resolveVitestWorkspaceConfigs(showWarning),
+    resolveVitestConfigs(showWarning),
+  ])
+  if (!workspaceConfigs.meta.length && !configs.meta.length) {
     const pkg = await resolveVitestPackagesViaPackageJson(showWarning)
     if (!pkg.meta.length && !pkg.warned)
-      return resolveVitestWorkspacePackages(showWarning).meta
-    return pkg.meta
+      return { configs: resolveVitestWorkspacePackages(showWarning).meta, workspaces: [] }
+    return { configs: pkg.meta, workspaces: [] }
+  }
+  return {
+    workspaces: workspaceConfigs.meta,
+    configs: configs.meta,
   }
-  return vitest.meta
 }
 
 function resolveVitestWorkspacePackages(showWarning: boolean) {
@@ -213,7 +218,7 @@ export async function resolveVitestPackagesViaPackageJson(showWarning: boolean):
   }
 }
 
-export async function resolveVitestPackagesViaConfigs(showWarning: boolean): Promise<{ meta: VitestPackage[]; warned: boolean }> {
+async function resolveVitestWorkspaceConfigs(showWarning: boolean) {
   const config = getConfig()
   const userWorkspace = config.workspaceConfig
   const rootConfig = config.rootConfig
@@ -226,7 +231,6 @@ export async function resolveVitestPackagesViaConfigs(showWarning: boolean): Pro
     : await vscode.workspace.findFiles(workspaceGlob, config.configSearchPatternExclude)
 
   let warned = false
-
   if (vitestWorkspaces.length) {
     // if there is a workspace config, use it as root
     const meta = resolvePackagUniquePrefixes(vitestWorkspaces.map((config) => {
@@ -247,6 +251,17 @@ export async function resolveVitestPackagesViaConfigs(showWarning: boolean): Pro
       warned,
     }
   }
+  return {
+    meta: [],
+    warned,
+  }
+}
+
+async function resolveVitestConfigs(showWarning: boolean) {
+  const config = getConfig()
+  const rootConfig = config.rootConfig
+
+  let warned = false
 
   if (rootConfig)
     log.info('[API] Using user root config:', rootConfig)

src/extension.ts

@@ -9,7 +9,7 @@ import { TestRunner } from './runner/runner'
 import { TestTree } from './testTree'
 import { configGlob, workspaceGlob } from './constants'
 import { log } from './log'
-import { createVitestWorkspaceFile, debounce, noop, showVitestError } from './utils'
+import { debounce, showVitestError } from './utils'
 import { resolveVitestPackages } from './api/pkg'
 import { TestFile, getTestData } from './testTreeData'
 import { TagsManager } from './tagsManager'
@@ -72,59 +72,21 @@ class VitestExtension {
     this.runners.forEach(runner => runner.dispose())
     this.runners = []
 
-    const vitest = await resolveVitestPackages(showWarning)
+    const { workspaces, configs } = await resolveVitestPackages(showWarning)
 
     if (cancelToken?.isCancellationRequested) {
       return
     }
 
-    if (!vitest.length) {
+    if (!workspaces.length && !configs.length) {
       log.error('[API]', 'Failed to start Vitest: No vitest config files found')
       this.testController.items.delete(this.loadingTestItem.id)
 
       await this.api?.dispose()
       return
     }
 
-    const configFiles = vitest.filter(x => x.configFile && !x.workspaceFile)
-
-    const maximumConfigs = getConfig().maximumConfigs ?? 3
-
-    if (configFiles.length > maximumConfigs) {
-      const warningMessage = [
-        'Vitest found multiple config files.',
-        `The extension will use only the first ${maximumConfigs} due to performance concerns.`,
-        'Consider using a workspace configuration to group your configs or increase',
-        'the limit via "vitest.maximumConfigs" option.',
-      ].join(' ')
-
-      // remove all but the first 3
-      const discardedConfigs = vitest.splice(maximumConfigs)
-
-      if (configFiles.every(c => getConfig(c.folder).disableWorkspaceWarning !== true)) {
-        vscode.window.showWarningMessage(
-          warningMessage,
-          'Create vitest.workspace.js',
-          'Disable notification',
-        ).then((result) => {
-          if (result === 'Create vitest.workspace.js')
-            createVitestWorkspaceFile(configFiles).catch(noop)
-
-          if (result === 'Disable notification') {
-            configFiles.forEach((c) => {
-              const rootConfig = vscode.workspace.getConfiguration('vitest', c.folder)
-              rootConfig.update('disableWorkspaceWarning', true)
-            })
-          }
-        })
-      }
-      else {
-        log.info(warningMessage)
-        log.info(`Discarded config files: ${discardedConfigs.map(x => x.workspaceFile || x.configFile).join(', ')}`)
-      }
-    }
-
-    const folders = new Set(vitest.map(x => x.folder))
+    const folders = new Set([...workspaces, ...configs].map(x => x.folder))
     this.testTree.reset(Array.from(folders))
 
     const previousRunProfiles = this.runProfiles
@@ -137,7 +99,7 @@ class VitestExtension {
         return
       }
 
-      this.api = await resolveVitestAPI(vitest)
+      this.api = await resolveVitestAPI(workspaces, configs)
 
       this.api.onUnexpectedExit((code) => {
         if (code) {

src/worker/init.ts

@@ -1,5 +1,5 @@
 import { pathToFileURL } from 'node:url'
-import type { UserConfig } from 'vitest/node'
+import type { UserConfig, WorkspaceProject } from 'vitest/node'
 import { VSCodeReporter } from './reporter'
 import type { WorkerMeta } from './types'
 import { normalizeDriveLetter } from './utils'
@@ -87,11 +87,15 @@ export async function initVitest(meta: WorkerMeta, options?: UserConfig) {
     },
   )
   await vitest.report('onInit', vitest)
-  const configs = vitest.projects.map(p => p.server.config.configFile).filter(c => c != null)
+  const configs = ([
+    // @ts-expect-error -- getRootProject in Vitest 3.0
+    'getRootProject' in vitest ? vitest.getRootProject() : vitest.getCoreWorkspaceProject(),
+    ...vitest.projects,
+  ] as WorkspaceProject[]).map(p => p.server.config.configFile).filter(c => c != null)
   return {
     vitest,
     reporter,
-    configs,
+    configs: Array.from(new Set(configs)),
     meta,
   }
 }