Merge branch 'main' into fix-fail-ci-obsolete-snapshot

Author: hi-ogawa

README.md

@@ -49,6 +49,7 @@ Next generation testing framework powered by Vite.
 - Out-of-box TypeScript / JSX support
 - Filtering, timeouts, concurrent for suite and tests
 - Sharding support
+- Reporting Uncaught Errors
 - Run your tests in the browser natively (experimental)
 
 > Vitest requires Vite >=v5.0.0 and Node >=v18.0.0

docs/.vitepress/components/FeaturesList.vue

@@ -26,7 +26,8 @@
     <ListItem>Code coverage via <a target="_blank" href="https://v8.dev/blog/javascript-code-coverage" rel="noopener noreferrer">v8</a> or <a target="_blank" href="https://istanbul.js.org/" rel="noopener noreferrer">istanbul</a></ListItem>
     <ListItem>Rust-like <a href="/guide/in-source">in-source testing</a></ListItem>
     <ListItem>Type Testing via <a target="_blank" href="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/mmkal/expect-type" rel="noopener noreferrer">expect-type</a></ListItem>
-    <ListItem>Sharding support</ListItem>
+    <ListItem>Sharding Support</ListItem>
+    <ListItem>Reporting Uncaught Errors</ListItem>
   </ul>
 </template>
 

docs/guide/features.md

@@ -259,3 +259,60 @@ export default defineConfig(({ mode }) => ({
   },
 }))
 ```
+
+## Unhandled Errors
+
+By default, Vitest catches and reports all [unhandled rejections](https://developer.mozilla.org/en-US/docs/Web/API/Window/unhandledrejection_event), [uncaught exceptions](https://nodejs.org/api/process.html#event-uncaughtexception) (in Node.js) and [error](https://developer.mozilla.org/en-US/docs/Web/API/Window/error_event) events (in the [browser](/guide/browser/)).
+
+You can disable this behaviour by catching them manually. Vitest assumes the callback is handled by you and won't report the error.
+
+::: code-group
+```ts [setup.node.js]
+// in Node.js
+process.on('unhandledRejection', () => {
+  // your own handler
+})
+
+process.on('uncaughtException', () => {
+  // your own handler
+})
+```
+```ts [setup.browser.js]
+// in the browser
+window.addEventListener('error', () => {
+  // your own handler
+})
+
+window.addEventListener('unhandledrejection', () => {
+  // your own handler
+})
+```
+:::
+
+Alternatively, you can also ignore reported errors with a [`dangerouslyIgnoreUnhandledErrors`](/config/#dangerouslyignoreunhandlederrors) option. Vitest will still report them, but they won't affect the test result (exit code won't be changed).
+
+If you need to test that error was not caught, you can create a test that looks like this:
+
+```ts
+test('my function throws uncaught error', async ({ onTestFinished }) => {
+  onTestFinished(() => {
+    // if the event was never called during the test,
+    // make sure it's removed before the next test starts
+    process.removeAllListeners('unhandledrejection')
+  })
+
+  return new Promise((resolve, reject) => {
+    process.once('unhandledrejection', (error) => {
+      try {
+        expect(error.message).toBe('my error')
+        resolve()
+      }
+      catch (error) {
+        reject(error)
+      }
+    })
+
+    callMyFunctionThatRejectsError()
+  })
+})
+```

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

@@ -213,7 +213,7 @@ export function createVmForksPool(
 
 function getMemoryLimit(config: ResolvedConfig) {
   const memory = nodeos.totalmem()
-  const limit = getWorkerMemoryLimit(config)
+  const limit = getWorkerMemoryLimit(config, 'vmForks')
 
   if (typeof memory === 'number') {
     return stringToBytes(limit, config.watch ? memory / 2 : memory)

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

@@ -206,7 +206,7 @@ export function createVmThreadsPool(
 
 function getMemoryLimit(config: ResolvedConfig) {
   const memory = nodeos.totalmem()
-  const limit = getWorkerMemoryLimit(config)
+  const limit = getWorkerMemoryLimit(config, 'vmThreads')
 
   if (typeof memory === 'number') {
     return stringToBytes(limit, config.watch ? memory / 2 : memory)

packages/vitest/src/runtime/execute.ts

@@ -58,14 +58,11 @@ function listenForErrors(state: () => WorkerGlobalState) {
   function catchError(err: unknown, type: string, event: 'uncaughtException' | 'unhandledRejection') {
     const worker = state()
 
-    // if error happens during a test
-    if (worker.current?.type === 'test') {
-      const listeners = process.listeners(event as 'uncaughtException')
-      // if there is another listener, assume that it's handled by user code
-      // one is Vitest's own listener
-      if (listeners.length > 1) {
-        return
-      }
+    const listeners = process.listeners(event as 'uncaughtException')
+    // if there is another listener, assume that it's handled by user code
+    // one is Vitest's own listener
+    if (listeners.length > 1) {
+      return
     }
 
     const error = processError(err)

packages/vitest/src/utils/memory-limit.ts

@@ -19,18 +19,25 @@ function getDefaultThreadsCount(config: ResolvedConfig) {
     : Math.max(numCpus - 1, 1)
 }
 
-export function getWorkerMemoryLimit(config: ResolvedConfig): string | number {
-  const memoryLimit = config.poolOptions?.vmThreads?.memoryLimit
+export function getWorkerMemoryLimit(config: ResolvedConfig, pool: 'vmThreads' | 'vmForks'): string | number {
+  if (pool === 'vmForks') {
+    const opts = config.poolOptions?.vmForks ?? {}
+    if (opts.memoryLimit) {
+      return opts.memoryLimit
+    }
+    const workers = opts.maxForks ?? getDefaultThreadsCount(config)
 
-  if (memoryLimit) {
-    return memoryLimit
+    return 1 / workers
   }
+  else {
+    const opts = config.poolOptions?.vmThreads ?? {}
+    if (opts.memoryLimit) {
+      return opts.memoryLimit
+    }
+    const workers = opts.maxThreads ?? getDefaultThreadsCount(config)
 
-  return (
-    1
-    / (config.poolOptions?.vmThreads?.maxThreads
-      ?? getDefaultThreadsCount(config))
-  )
+    return 1 / workers
+  }
 }
 
 /**

test/cli/fixtures/fails/unhandled-suite.test.ts

@@ -0,0 +1,8 @@
+import { expect, it } from 'vitest';
+
+it('foo', () => {
+  expect(1).toBe(1)
+  new Promise((resolve, reject) => {
+    reject('promise error');
+  });
+});

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

@@ -127,3 +127,5 @@ exports[`should fail unhandled.test.ts 1`] = `
 "Error: some error
 Error: Uncaught [Error: some error]"
 `;
+
+exports[`should fail unhandled-suite.test.ts 1`] = `"Unknown Error: promise error"`;

test/core/test/memory-limit.test.ts

@@ -0,0 +1,46 @@
+import type { PoolOptions, ResolvedConfig } from 'vitest/node'
+import { describe, expect, it } from 'vitest'
+import { getWorkerMemoryLimit } from 'vitest/src/utils/memory-limit.js'
+
+function makeConfig(poolOptions: PoolOptions): ResolvedConfig {
+  return {
+    poolOptions: {
+      vmForks: {
+        maxForks: poolOptions.maxForks,
+        memoryLimit: poolOptions.memoryLimit,
+      },
+      vmThreads: {
+        maxThreads: poolOptions.maxThreads,
+        memoryLimit: poolOptions.memoryLimit,
+      },
+    },
+  } as ResolvedConfig
+}
+
+describe('getWorkerMemoryLimit', () => {
+  it('should prioritize vmThreads.memoryLimit when pool is vmThreads', () => {
+    const config = {
+      poolOptions: {
+        vmForks: { memoryLimit: undefined },
+        vmThreads: { memoryLimit: '256MB' },
+      },
+    } as ResolvedConfig
+
+    expect(getWorkerMemoryLimit(config, 'vmThreads')).toBe('256MB')
+  })
+
+  it('should prioritize vmForks.memoryLimit when pool is vmForks', () => {
+    const config = makeConfig({ memoryLimit: '512MB' })
+    expect(getWorkerMemoryLimit(config, 'vmForks')).toBe('512MB')
+  })
+
+  it('should calculate 1/maxThreads when vmThreads.memoryLimit is unset', () => {
+    const config = makeConfig({ maxThreads: 4 })
+    expect(getWorkerMemoryLimit(config, 'vmThreads')).toBe(1 / 4)
+  })
+
+  it('should calculate 1/maxForks when vmForks.memoryLimit is unset', () => {
+    const config = makeConfig({ maxForks: 4 })
+    expect(getWorkerMemoryLimit(config, 'vmForks')).toBe(1 / 4)
+  })
+})