fix: ensure errors keep their message and stack after toJSON serialisation (#8053)

Author: sheremet-va

packages/ui/client/components/views/ViewReport.vue

@@ -34,23 +34,23 @@ function collectFailed(task: Task, level: number): LeveledTask[] {
 function createHtmlError(filter: Convert, error: ErrorWithDiff) {
   let htmlError = ''
   if (error.message?.includes('\x1B')) {
-    htmlError = `<b>${error.nameStr || error.name}</b>: ${filter.toHtml(
+    htmlError = `<b>${error.name}</b>: ${filter.toHtml(
       escapeHtml(error.message),
     )}`
   }
 
-  const startStrWithX1B = error.stackStr?.includes('\x1B')
-  if (startStrWithX1B || error.stack?.includes('\x1B')) {
+  const startStrWithX1B = error.stack?.includes('\x1B')
+  if (startStrWithX1B) {
     if (htmlError.length > 0) {
       htmlError += filter.toHtml(
-        escapeHtml((startStrWithX1B ? error.stackStr : error.stack) as string),
+        escapeHtml((error.stack) as string),
       )
     }
     else {
-      htmlError = `<b>${error.nameStr || error.name}</b>: ${
+      htmlError = `<b>${error.name}</b>: ${
         error.message
       }${filter.toHtml(
-        escapeHtml((startStrWithX1B ? error.stackStr : error.stack) as string),
+        escapeHtml((error.stack) as string),
       )}`
     }
   }

packages/ui/client/composables/error.ts

@@ -44,7 +44,7 @@ export function parseError(e: unknown) {
     }
   }
 
-  error.stacks = parseStacktrace(error.stack || error.stackStr || '', {
+  error.stacks = parseStacktrace(error.stack || '', {
     ignoreStackEntries: [],
   })
 

packages/utils/src/error.ts

@@ -32,6 +32,25 @@ export function serializeValue(val: any, seen: WeakMap<WeakKey, any> = new WeakM
   if (!val || typeof val === 'string') {
     return val
   }
+  if (val instanceof Error && 'toJSON' in val && typeof val.toJSON === 'function') {
+    const jsonValue = val.toJSON()
+
+    if (jsonValue && jsonValue !== val && typeof jsonValue === 'object') {
+      if (typeof val.message === 'string') {
+        safe(() => jsonValue.message ??= val.message)
+      }
+      if (typeof val.stack === 'string') {
+        safe(() => jsonValue.stack ??= val.stack)
+      }
+      if (typeof val.name === 'string') {
+        safe(() => jsonValue.name ??= val.name)
+      }
+      if (val.cause != null) {
+        safe(() => jsonValue.cause ??= serializeValue(val.cause, seen))
+      }
+    }
+    return serializeValue(jsonValue, seen)
+  }
   if (typeof val === 'function') {
     return `Function<${val.name || 'anonymous'}>`
   }
@@ -106,6 +125,15 @@ export function serializeValue(val: any, seen: WeakMap<WeakKey, any> = new WeakM
   }
 }
 
+function safe(fn: () => void) {
+  try {
+    return fn()
+  }
+  catch {
+    // ignore
+  }
+}
+
 export { serializeValue as serializeError }
 
 function normalizeErrorMessage(message: string) {
@@ -122,15 +150,6 @@ export function processError(
   }
   const err = _err as TestError
 
-  // stack is not serialized in worker communication
-  // we stringify it first
-  if (typeof err.stack === 'string') {
-    err.stackStr = String(err.stack)
-  }
-  if (typeof err.name === 'string') {
-    err.nameStr = String(err.name)
-  }
-
   if (
     err.showDiff
     || (err.showDiff === undefined
@@ -143,10 +162,10 @@ export function processError(
     })
   }
 
-  if (typeof err.expected !== 'string') {
+  if ('expected' in err && typeof err.expected !== 'string') {
     err.expected = stringify(err.expected, 10)
   }
-  if (typeof err.actual !== 'string') {
+  if ('actual' in err && typeof err.actual !== 'string') {
     err.actual = stringify(err.actual, 10)
   }
 

packages/utils/src/source-map.ts

@@ -281,7 +281,7 @@ export function parseErrorStacktrace(
     return e.stacks
   }
 
-  const stackStr = e.stack || e.stackStr || ''
+  const stackStr = e.stack || ''
   // if "stack" property was overwritten at runtime to be something else,
   // ignore the value because we don't know how to process it
   let stackFrames = typeof stackStr === 'string'

packages/utils/src/types.ts

@@ -55,9 +55,7 @@ export interface ErrorWithDiff {
   message: string
   name?: string
   cause?: unknown
-  nameStr?: string
   stack?: string
-  stackStr?: string
   stacks?: ParsedStack[]
   showDiff?: boolean
   actual?: any

packages/vitest/src/node/printError.ts

@@ -240,7 +240,7 @@ function printErrorInner(
     })
   }
 
-  handleImportOutsideModuleError(e.stack || e.stackStr || '', logger)
+  handleImportOutsideModuleError(e.stack || '', logger)
 
   return { nearest }
 }
@@ -250,10 +250,8 @@ function printErrorType(type: string, ctx: Vitest) {
 }
 
 const skipErrorProperties = new Set([
-  'nameStr',
   'cause',
   'stacks',
-  'stackStr',
   'type',
   'showDiff',
   'ok',
@@ -274,6 +272,7 @@ const skipErrorProperties = new Set([
   'VITEST_TEST_NAME',
   'VITEST_TEST_PATH',
   'VITEST_AFTER_ENV_TEARDOWN',
+  '__vitest_rollup_error__',
   ...Object.getOwnPropertyNames(Error.prototype),
   ...Object.getOwnPropertyNames(Object.prototype),
 ])
@@ -366,7 +365,7 @@ function printModuleWarningForSourceCode(logger: ErrorLogger, path: string) {
 }
 
 function printErrorMessage(error: ErrorWithDiff, logger: ErrorLogger) {
-  const errorName = error.name || error.nameStr || 'Unknown Error'
+  const errorName = error.name || 'Unknown Error'
   if (!error.message) {
     logger.error(error)
     return

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

@@ -585,9 +585,9 @@ export abstract class BaseReporter implements Reporter {
       task.result?.errors?.forEach((error) => {
         let previous
 
-        if (error?.stackStr) {
+        if (error?.stack) {
           previous = errorsQueue.find((i) => {
-            if (i[0]?.stackStr !== error.stackStr) {
+            if (i[0]?.stack !== error.stack) {
               return false
             }
 

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

@@ -250,7 +250,7 @@ export class JUnitReporter implements Reporter {
                 'failure',
                 {
                   message: error?.message,
-                  type: error?.name ?? error?.nameStr,
+                  type: error?.name,
                 },
                 async () => {
                   if (!error) {

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

@@ -41,7 +41,7 @@ export class TapReporter implements Reporter {
   }
 
   private logErrorDetails(error: ErrorWithDiff, stack?: ParsedStack) {
-    const errorName = error.name || error.nameStr || 'Unknown Error'
+    const errorName = error.name || 'Unknown Error'
     this.logger.log(`name: ${yamlString(String(errorName))}`)
     this.logger.log(`message: ${yamlString(String(error.message))}`)
 

packages/vitest/src/typecheck/typechecker.ts

@@ -244,11 +244,9 @@ export class Typechecker {
           originalError: info,
           error: {
             name: error.name,
-            nameStr: String(error.name),
             message: errMsg,
             stacks: error.stacks,
             stack: '',
-            stackStr: '',
           },
         }
       })