Merge branch 'main' into feat-resolveSnapshotPath-context

docs/advanced/reporters.md

@@ -402,6 +402,10 @@ declare class TestProject {
    * @experimental The public Vitest API is experimental and does not follow semver.
    */
   readonly workspaceProject: WorkspaceProject
+  /**
+   * Vite's dev server instance. Every workspace project has its own server.
+   */
+  readonly vite: ViteDevServer
   /**
    * Resolved project configuration.
    */

docs/config/index.md

@@ -970,7 +970,7 @@ Silent console output from tests
 Path to setup files. They will be run before each test file.
 
 :::info
-Changing setup files will trigger rerun of all tests.
+Editing a setup file will automatically trigger a rerun of all tests.
 :::
 
 You can use `process.env.VITEST_POOL_ID` (integer-like string) inside to distinguish between threads.

packages/vitest/src/node/core.ts

@@ -352,6 +352,7 @@ export class Vitest {
       process.exitCode = 1
     }
 
+    this.checkUnhandledErrors(errors)
     await this.report('onFinished', files, errors)
     await this.initCoverageProvider()
     await this.coverageProvider?.mergeReports?.(coverages)
@@ -613,9 +614,11 @@ export class Vitest {
       .finally(async () => {
         // can be duplicate files if different projects are using the same file
         const files = Array.from(new Set(specs.map(spec => spec.moduleId)))
+        const errors = this.state.getUnhandledErrors()
         const coverage = await this.coverageProvider?.generateCoverage({ allTestsRun })
 
-        await this.report('onFinished', this.state.getFiles(files), this.state.getUnhandledErrors(), coverage)
+        this.checkUnhandledErrors(errors)
+        await this.report('onFinished', this.state.getFiles(files), errors, coverage)
         await this.reportCoverage(coverage, allTestsRun)
 
         this.runningPromise = undefined
@@ -896,6 +899,12 @@ export class Vitest {
     }
   }
 
+  checkUnhandledErrors(errors: unknown[]) {
+    if (errors.length && !this.config.dangerouslyIgnoreUnhandledErrors) {
+      process.exitCode = 1
+    }
+  }
+
   private unregisterWatcher = noop
   private registerWatcher() {
     const watcher = this.server.watcher

packages/vitest/src/node/logger.ts

@@ -46,6 +46,7 @@ export class Logger {
     this.console = new Console({ stdout: outputStream, stderr: errorStream })
     this.logUpdate = createLogUpdate(this.outputStream)
     this._highlights.clear()
+    this.registerUnhandledRejection()
   }
 
   log(...args: any[]) {
@@ -317,4 +318,24 @@ export class Logger {
     })
     this.log(c.red(divider()))
   }
+
+  private registerUnhandledRejection() {
+    const onUnhandledRejection = (err: unknown) => {
+      process.exitCode = 1
+
+      this.printError(err, {
+        fullStack: true,
+        type: 'Unhandled Rejection',
+      })
+
+      this.error('\n\n')
+      process.exit()
+    }
+
+    process.on('unhandledRejection', onUnhandledRejection)
+
+    this.ctx.onClose(() => {
+      process.off('unhandledRejection', onUnhandledRejection)
+    })
+  }
 }

packages/vitest/src/node/pools/rpc.ts

@@ -96,7 +96,10 @@ export function createMethodsRPC(project: WorkspaceProject, options: MethodsOpti
       ctx.state.catchError(err, type)
     },
     onFinished(files) {
-      return ctx.report('onFinished', files, ctx.state.getUnhandledErrors())
+      const errors = ctx.state.getUnhandledErrors()
+      ctx.checkUnhandledErrors(errors)
+
+      return ctx.report('onFinished', files, errors)
     },
     onCancel(reason) {
       ctx.cancelCurrentRun(reason)

packages/vitest/src/node/reported-workspace-project.ts

@@ -1,3 +1,4 @@
+import type { ViteDevServer } from 'vite'
 import type { ProvidedContext } from '../types/general'
 import type { Vitest } from './core'
 import type { ResolvedConfig, ResolvedProjectConfig, SerializedConfig } from './types/config'
@@ -15,6 +16,10 @@ export class TestProject {
    */
   public readonly workspaceProject: WorkspaceProject
 
+  /**
+   * Vite's dev server instance. Every workspace project has its own server.
+   */
+  public readonly vite: ViteDevServer
   /**
    * Resolved project configuration.
    */
@@ -32,6 +37,7 @@ export class TestProject {
   constructor(workspaceProject: WorkspaceProject) {
     this.workspaceProject = workspaceProject
     this.vitest = workspaceProject.ctx
+    this.vite = workspaceProject.server
     this.globalConfig = workspaceProject.ctx.config
     this.config = workspaceProject.config
     this.name = workspaceProject.getName()

packages/vitest/src/node/reporters/base.ts

@@ -59,11 +59,9 @@ export abstract class BaseReporter implements Reporter {
   private _lastRunTimer: NodeJS.Timeout | undefined
   private _lastRunCount = 0
   private _timeStart = new Date()
-  private _offUnhandledRejection?: () => void
 
   constructor(options: BaseOptions = {}) {
     this.isTTY = options.isTTY ?? ((isNode || isDeno) && process.stdout?.isTTY && !isCI)
-    this.registerUnhandledRejection()
   }
 
   get mode() {
@@ -72,9 +70,6 @@ export abstract class BaseReporter implements Reporter {
 
   onInit(ctx: Vitest) {
     this.ctx = ctx
-    ctx.onClose(() => {
-      this._offUnhandledRejection?.()
-    })
     ctx.logger.printBanner()
     this.start = performance.now()
   }
@@ -90,11 +85,6 @@ export abstract class BaseReporter implements Reporter {
     this.end = performance.now()
 
     this.reportSummary(files, errors)
-    if (errors.length) {
-      if (!this.ctx.config.dangerouslyIgnoreUnhandledErrors) {
-        process.exitCode = 1
-      }
-    }
   }
 
   onTaskUpdate(packs: TaskResultPack[]) {
@@ -631,22 +621,6 @@ export abstract class BaseReporter implements Reporter {
       errorDivider()
     }
   }
-
-  registerUnhandledRejection() {
-    const onUnhandledRejection = async (err: unknown) => {
-      process.exitCode = 1
-      this.ctx.logger.printError(err, {
-        fullStack: true,
-        type: 'Unhandled Rejection',
-      })
-      this.ctx.logger.error('\n\n')
-      process.exit()
-    }
-    process.on('unhandledRejection', onUnhandledRejection)
-    this._offUnhandledRejection = () => {
-      process.off('unhandledRejection', onUnhandledRejection)
-    }
-  }
 }
 
 function padTitle(str: string) {

test/config/fixtures/dangerously-ignore-unhandled-errors/tests/throw-errors.test.ts

@@ -0,0 +1,7 @@
+import { test } from "vitest"
+
+test("Some test", () => {
+  //
+})
+
+new Promise((_, reject) => reject(new Error("intentional unhandled error")))

test/config/fixtures/unhandled-rejections/setup-unhandled-rejections.ts

@@ -0,0 +1,3 @@
+export function setup() {
+  void new Promise((_, reject) => reject(new Error('intentional unhandled rejection')))
+}

test/config/fixtures/unhandled-rejections/tests/example.test.ts

@@ -0,0 +1,4 @@
+import { test } from "vitest"
+
+test("Some test", () => {})
+

test/config/test/dangerously-ignore-unhandled-errors.test.ts

@@ -0,0 +1,35 @@
+import { expect, test } from 'vitest'
+
+import { runVitest } from '../../test-utils'
+
+test('{ dangerouslyIgnoreUnhandledErrors: true }', async () => {
+  const { stderr, stdout, exitCode } = await runVitest({
+    root: 'fixtures/dangerously-ignore-unhandled-errors',
+    dangerouslyIgnoreUnhandledErrors: true,
+  })
+
+  expect(exitCode).toBe(0)
+  expect(stdout).toMatch('Vitest caught 1 unhandled error during the test run')
+  expect(stderr).toMatch('Error: intentional unhandled error')
+})
+
+test('{ dangerouslyIgnoreUnhandledErrors: true } without reporter', async () => {
+  const { exitCode } = await runVitest({
+    root: 'fixtures/dangerously-ignore-unhandled-errors',
+    dangerouslyIgnoreUnhandledErrors: true,
+    reporters: [{ onInit: () => {} }],
+  })
+
+  expect(exitCode).toBe(0)
+})
+
+test('{ dangerouslyIgnoreUnhandledErrors: false }', async () => {
+  const { stderr, stdout, exitCode } = await runVitest({
+    root: 'fixtures/dangerously-ignore-unhandled-errors',
+    dangerouslyIgnoreUnhandledErrors: false,
+  })
+
+  expect(exitCode).toBe(1)
+  expect(stdout).toMatch('Vitest caught 1 unhandled error during the test run')
+  expect(stderr).toMatch('Error: intentional unhandled error')
+})

test/config/test/unhandled-rejections.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from 'vitest'
+
+import { runVitest } from '../../test-utils'
+
+test('unhandled rejections of main thread are reported even when no reporter is used', async () => {
+  const { stderr, exitCode } = await runVitest({
+    root: 'fixtures/unhandled-rejections',
+    globalSetup: ['setup-unhandled-rejections.ts'],
+    reporters: [{ onInit: () => {} }],
+  })
+
+  expect(exitCode).toBe(1)
+  expect(stderr).toContain('Unhandled Rejection')
+  expect(stderr).toContain('Error: intentional unhandled rejection')
+  expect(stderr).toContain('setup-unhandled-rejections.ts:2:42')
+})