fix(utils): respect all flags in format function (#3695)

Author: sheremet-va

packages/utils/src/display.ts

@@ -18,13 +18,13 @@ interface LoupeOptions {
   truncate?: number
 }
 
-const formatRegExp = /%[sdj%]/g
+const formatRegExp = /%[sdjifoOcj%]/g
 
 export function format(...args: unknown[]) {
   if (typeof args[0] !== 'string') {
     const objects = []
     for (let i = 0; i < args.length; i++)
-      objects.push(inspect(args[i]))
+      objects.push(inspect(args[i], { depth: 0, colors: false, compact: 3 }))
     return objects.join(' ')
   }
 
@@ -62,13 +62,26 @@ export function format(...args: unknown[]) {
       case '%f': return Number.parseFloat(String(args[i++])).toString()
       case '%o': return inspect(args[i++], { showHidden: true, showProxy: true })
       case '%O': return inspect(args[i++])
-      case '%c': return ''
+      case '%c': {
+        i++
+        return ''
+      }
       case '%j':
         try {
           return JSON.stringify(args[i++])
         }
-        catch (_) {
-          return '[Circular]'
+        catch (err: any) {
+          const m = err.message
+          if (
+            // chromium
+            m.includes('circular structure')
+            // safari
+            || m.includes('cyclic structures')
+            // firefox
+            || m.includes('cyclic object')
+          )
+            return '[Circular]'
+          throw err
         }
       default:
         return x

pnpm-lock.yaml

@@ -0,0 +1,12 @@
+{
+  "name": "@vitest/test-utils",
+  "private": true,
+  "scripts": {
+    "test": "vitest",
+    "coverage": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@vitest/utils": "workspace:*",
+    "vitest": "workspace:*"
+  }
+}

test/utils/package.json

@@ -0,0 +1,93 @@
+import util from 'node:util'
+import { describe, expect, test } from 'vitest'
+import { format } from '@vitest/utils'
+
+describe('format', () => {
+  const obj = {} as any
+  obj.obj = obj
+
+  test.each([
+    [''],
+    ['test'],
+    [{ obj: { nested: true }, value: 1 }],
+    ['test %s', 'test'],
+    ['test %s %s', 'test', 'test'],
+    ['test %s %s', 'test', 'test', 'test'],
+    ['%s', 100],
+    ['%s', 100n],
+    ['%s', -0],
+    ['%s', null],
+    ['%s', null, 'next'],
+    ['%d', 100],
+    ['%d', 100n],
+    ['%d', null],
+    ['%d', {}],
+    ['%d', {}, 'next'],
+    ['%i', 100],
+    ['%i', 100n],
+    ['%i', null],
+    ['%i', {}],
+    ['%i', {}, 'next'],
+    ['%f', 100],
+    ['%f', 100n],
+    ['%f', null],
+    ['%f', {}],
+    ['%f', {}, 'next'],
+    ['%o', 'string'],
+    ['%o', 100],
+    ['%o', 100n],
+    ['%o', null],
+    ['%o', {}],
+    ['%o', {}, 'next'],
+    ['%O', 'string'],
+    ['%O', 100],
+    ['%O', 100n],
+    ['%O', null],
+    ['%O', {}],
+    ['%O', {}, 'next'],
+    ['%c', 'css value'],
+    ['%c', 'css value', 'some other value'],
+    ['%c %f', 'css value', '100.00'],
+    ['%j', 'string'],
+    ['%j', 100],
+    ['%j', null],
+    ['%j', {}],
+    ['%j', {}, 'next'],
+    ['%j', { obj }],
+    ['%j', { fn: () => {} }],
+    ['%%', 'string'],
+  ])('format(%s)', (formatString, ...args) => {
+    expect(format(formatString, ...args), `failed ${formatString}`).toBe(util.format(formatString, ...args))
+  })
+
+  test('cannont serialize some values', () => {
+    expect(() => format('%j', 100n)).toThrowErrorMatchingInlineSnapshot('"Do not know how to serialize a BigInt"')
+  })
+
+  test.each(
+    [
+      {
+        name: 'without format',
+        args: [{ n: { a: { b: { c: { d: { e: '3' } } } } } }],
+        result: '{ n: { a: { b: { c: { d: { e: \'3\' } } } } } }',
+      },
+      {
+        name: 'as an object',
+        args: ['%o', {}, { n: { a: { b: { c: '3' } } } }],
+        result: '{} { n: { a: { b: { c: \'3\' } } } }',
+      },
+      {
+        name: 'as a full object',
+        args: ['%O', {}, { n: { a: { b: { c: '3' } } } }],
+        result: '{} { n: { a: { b: { c: \'3\' } } } }',
+      },
+      {
+        name: 'as a json',
+        args: ['%j', {}, { n: { a: { b: { c: '3' } } } }],
+        result: '{} { n: { a: { b: { c: \'3\' } } } }',
+      },
+    ],
+  )('formats objects $name (loupe doesn\'t respect depth)', ({ args, result }) => {
+    expect(format(...args)).toBe(result)
+  })
+})