@zuplo/cli 7.0.2 → 7.1.0

package/node_modules/pino/test/broken-pipe.test.js

@@ -1,13 +1,15 @@
 'use strict'
 
-const t = require('tap')
+const test = require('node:test')
+const assert = require('node:assert')
 const { join } = require('node:path')
 const { fork } = require('node:child_process')
+const tspl = require('@matteo.collina/tspl')
 const { once } = require('./helper')
 const pino = require('..')
 
 if (process.platform === 'win32') {
-  t.skip('skipping on windows')
+  console.log('skipping on windows')
   process.exit(0)
 }
 
@@ -17,31 +19,29 @@ if (process.env.CITGM) {
   // The failure does not reproduce locally or on our CI.
   // Skipping it is the only way to keep pino in CITGM.
   // https://github.com/nodejs/citgm/pull/1002#issuecomment-1751942988
-  t.skip('Skipping on Node.js core CITGM because it hangs on v18.x')
+  console.log('Skipping on Node.js core CITGM because it hangs on v18.x')
   process.exit(0)
 }
 
-function test (file) {
+function testFile (file) {
   file = join('fixtures', 'broken-pipe', file)
-  t.test(file, { parallel: true }, async ({ equal }) => {
+  test(file, async () => {
     const child = fork(join(__dirname, file), { silent: true })
     child.stdout.destroy()
 
     child.stderr.pipe(process.stdout)
 
     const res = await once(child, 'close')
-    equal(res, 0) // process exits successfully
+    assert.equal(res, 0) // process exits successfully
   })
 }
 
-t.jobs = 42
+testFile('basic.js')
+testFile('destination.js')
+testFile('syncfalse.js')
 
-test('basic.js')
-test('destination.js')
-test('syncfalse.js')
-
-t.test('let error pass through', ({ equal, plan }) => {
-  plan(3)
+test('let error pass through', async (t) => {
+  const plan = tspl(t, { plan: 3 })
   const stream = pino.destination({ sync: true })
 
   // side effect of the pino constructor is that it will set an
@@ -52,6 +52,8 @@ t.test('let error pass through', ({ equal, plan }) => {
   process.nextTick(() => stream.emit('error', new Error('kaboom')))
 
   stream.on('error', (err) => {
-    equal(err.message, 'kaboom')
+    plan.equal(err.message, 'kaboom')
   })
+
+  await plan
 })

package/node_modules/pino/test/browser-is-level-enabled.test.js

@@ -0,0 +1,101 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const assert = require('node:assert')
+const pino = require('../browser')
+
+const customLevels = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+}
+
+describe('Default levels suite', () => {
+  test('can check if current level enabled', async () => {
+    const log = pino({ level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if current level enabled when as object', async () => {
+    const log = pino({ asObject: true, level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async () => {
+    const log = pino()
+    assert.equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async () => {
+    const log = pino({ level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async () => {
+    const log = pino({ level: 'error' })
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('ASC: can check if child has current level enabled', async () => {
+    const log = pino().child({}, { level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async () => {
+    const log = pino({
+      customLevels: { foo: 35 },
+      level: 'debug'
+    })
+    assert.equal(true, log.isLevelEnabled('foo'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+})
+
+describe('Custom levels suite', () => {
+  test('can check if current level enabled', async () => {
+    const log = pino({ level: 'debug', customLevels })
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if level enabled after level set', async () => {
+    const log = pino({ customLevels })
+    assert.equal(false, log.isLevelEnabled('debug'))
+    log.level = 'debug'
+    assert.equal(true, log.isLevelEnabled('debug'))
+  })
+
+  test('can check if higher level enabled', async () => {
+    const log = pino({ level: 'debug', customLevels })
+    assert.equal(true, log.isLevelEnabled('error'))
+  })
+
+  test('can check if lower level is disabled', async () => {
+    const log = pino({ level: 'error', customLevels })
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if child has current level enabled', async () => {
+    const log = pino().child({ customLevels }, { level: 'debug' })
+    assert.equal(true, log.isLevelEnabled('debug'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+
+  test('can check if custom level is enabled', async () => {
+    const log = pino({
+      customLevels: { foo: 35, ...customLevels },
+      level: 'debug'
+    })
+    assert.equal(true, log.isLevelEnabled('foo'))
+    assert.equal(true, log.isLevelEnabled('error'))
+    assert.equal(false, log.isLevelEnabled('trace'))
+  })
+})

package/node_modules/pino/test/browser.test.js

@@ -165,6 +165,7 @@ test('opts.browser.asObject logs pino-like object to console', ({ end, ok, is })
   instance.info('test')
   end()
 })
+
 test('opts.browser.asObject uses opts.messageKey in logs', ({ end, ok, is }) => {
   const messageKey = 'message'
   const instance = require('../browser')({
@@ -183,6 +184,25 @@ test('opts.browser.asObject uses opts.messageKey in logs', ({ end, ok, is }) =>
   end()
 })
 
+test('opts.browser.asObjectBindingsOnly passes the bindings but keep the message unformatted', ({ end, ok, is, deepEqual }) => {
+  const messageKey = 'message'
+  const instance = require('../browser')({
+    messageKey,
+    browser: {
+      asObjectBindingsOnly: true,
+      write: function (o, msg, ...args) {
+        is(o.level, 30)
+        ok(o.time)
+        is(msg, 'test %s')
+        deepEqual(args, ['foo'])
+      }
+    }
+  })
+
+  instance.info('test %s', 'foo')
+  end()
+})
+
 test('opts.browser.formatters (level) logs pino-like object to console', ({ end, ok, is }) => {
   const info = console.info
   console.info = function (o) {
@@ -230,6 +250,25 @@ test('opts.browser.formatters (log) logs pino-like object to console', ({ end, o
   end()
 })
 
+test('opts.browser.reportCaller adds caller in asObject mode', ({ end, ok }) => {
+  const instance = require('../browser')({
+    browser: {
+      asObject: true,
+      reportCaller: true,
+      write: function (o) {
+        ok(typeof o.caller === 'string' && o.caller.length > 0, 'has caller string')
+        ok(/:\\d+:\\d+/.test(o.caller) || /:\d+:\d+/.test(o.caller), `caller has line:col pattern: ${o.caller}`)
+      }
+    }
+  })
+
+  instance.info('test')
+  end()
+})
+
+// NOTE: Default (non-object) mode caller string is covered in docs
+// and manually verified. Keeping the test minimal to avoid cross-env flakiness.
+
 test('opts.browser.serialize and opts.browser.transmit only serializes log data once', ({ end, ok, is }) => {
   const instance = require('../browser')({
     serializers: {

package/node_modules/pino/test/complex-objects.test.js

@@ -1,11 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
-const { sink, once } = require('./helper')
+const test = require('node:test')
+const assert = require('node:assert')
 const { PassThrough } = require('node:stream')
+
+const { sink, once } = require('./helper')
 const pino = require('../')
 
-test('Proxy and stream objects', async ({ equal }) => {
+test('Proxy and stream objects', async () => {
   const s = new PassThrough()
   s.resume()
   s.write('', () => {})
@@ -16,10 +18,10 @@ test('Proxy and stream objects', async ({ equal }) => {
 
   const result = await once(stream, 'data')
 
-  equal(result.obj, '[unable to serialize, circular reference is too complex to analyze]')
+  assert.equal(result.obj, '[unable to serialize, circular reference is too complex to analyze]')
 })
 
-test('Proxy and stream objects', async ({ equal }) => {
+test('Proxy and stream objects', async () => {
   const s = new PassThrough()
   s.resume()
   s.write('', () => {})
@@ -30,5 +32,5 @@ test('Proxy and stream objects', async ({ equal }) => {
 
   const result = await once(stream, 'data')
 
-  equal(result.p, '[unable to serialize, circular reference is too complex to analyze]')
+  assert.equal(result.p, '[unable to serialize, circular reference is too complex to analyze]')
 })

package/node_modules/pino/test/crlf.test.js

@@ -1,6 +1,8 @@
 'use strict'
 
-const { test } = require('tap')
+const test = require('node:test')
+const assert = require('node:assert')
+
 const writer = require('flush-write-stream')
 const pino = require('../')
 
@@ -13,20 +15,20 @@ function capture () {
   return ws
 }
 
-test('pino uses LF by default', async ({ ok }) => {
+test('pino uses LF by default', async () => {
   const stream = capture()
   const logger = pino(stream)
   logger.info('foo')
   logger.error('bar')
-  ok(/foo[^\r\n]+\n[^\r\n]+bar[^\r\n]+\n/.test(stream.data))
+  assert.ok(/foo[^\r\n]+\n[^\r\n]+bar[^\r\n]+\n/.test(stream.data))
 })
 
-test('pino can log CRLF', async ({ ok }) => {
+test('pino can log CRLF', async () => {
   const stream = capture()
   const logger = pino({
     crlf: true
   }, stream)
   logger.info('foo')
   logger.error('bar')
-  ok(/foo[^\n]+\r\n[^\n]+bar[^\n]+\r\n/.test(stream.data))
+  assert.ok(/foo[^\n]+\r\n[^\n]+bar[^\n]+\r\n/.test(stream.data))
 })

package/node_modules/pino/test/custom-levels.test.js

@@ -2,7 +2,9 @@
 
 /* eslint no-prototype-builtins: 0 */
 
-const { test } = require('tap')
+const test = require('node:test')
+const assert = require('node:assert')
+
 const { sink, once } = require('./helper')
 const pino = require('../')
 
@@ -10,7 +12,7 @@ const pino = require('../')
 process.removeAllListeners('warning')
 process.on('warning', () => {})
 
-test('adds additional levels', async ({ equal }) => {
+test('adds additional levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -21,10 +23,10 @@ test('adds additional levels', async ({ equal }) => {
 
   logger.foo('test')
   const { level } = await once(stream, 'data')
-  equal(level, 35)
+  assert.equal(level, 35)
 })
 
-test('custom levels does not override default levels', async ({ equal }) => {
+test('custom levels does not override default levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -34,10 +36,10 @@ test('custom levels does not override default levels', async ({ equal }) => {
 
   logger.info('test')
   const { level } = await once(stream, 'data')
-  equal(level, 30)
+  assert.equal(level, 30)
 })
 
-test('default levels can be redefined using custom levels', async ({ equal }) => {
+test('default levels can be redefined using custom levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -47,14 +49,14 @@ test('default levels can be redefined using custom levels', async ({ equal }) =>
     useOnlyCustomLevels: true
   }, stream)
 
-  equal(logger.hasOwnProperty('info'), true)
+  assert.equal(logger.hasOwnProperty('info'), true)
 
   logger.info('test')
   const { level } = await once(stream, 'data')
-  equal(level, 35)
+  assert.equal(level, 35)
 })
 
-test('custom levels overrides default level label if use useOnlyCustomLevels', async ({ equal }) => {
+test('custom levels overrides default level label if use useOnlyCustomLevels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -64,10 +66,10 @@ test('custom levels overrides default level label if use useOnlyCustomLevels', a
     level: 'foo'
   }, stream)
 
-  equal(logger.hasOwnProperty('info'), false)
+  assert.equal(logger.hasOwnProperty('info'), false)
 })
 
-test('custom levels overrides default level value if use useOnlyCustomLevels', async ({ equal }) => {
+test('custom levels overrides default level value if use useOnlyCustomLevels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -77,10 +79,10 @@ test('custom levels overrides default level value if use useOnlyCustomLevels', a
     level: 35
   }, stream)
 
-  equal(logger.hasOwnProperty('info'), false)
+  assert.equal(logger.hasOwnProperty('info'), false)
 })
 
-test('custom levels are inherited by children', async ({ equal }) => {
+test('custom levels are inherited by children', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -90,12 +92,12 @@ test('custom levels are inherited by children', async ({ equal }) => {
 
   logger.child({ childMsg: 'ok' }).foo('test')
   const { msg, childMsg, level } = await once(stream, 'data')
-  equal(level, 35)
-  equal(childMsg, 'ok')
-  equal(msg, 'test')
+  assert.equal(level, 35)
+  assert.equal(childMsg, 'ok')
+  assert.equal(msg, 'test')
 })
 
-test('custom levels can be specified on child bindings', async ({ equal }) => {
+test('custom levels can be specified on child bindings', async () => {
   const stream = sink()
   const logger = pino(stream).child({
     childMsg: 'ok'
@@ -107,12 +109,12 @@ test('custom levels can be specified on child bindings', async ({ equal }) => {
 
   logger.foo('test')
   const { msg, childMsg, level } = await once(stream, 'data')
-  equal(level, 35)
-  equal(childMsg, 'ok')
-  equal(msg, 'test')
+  assert.equal(level, 35)
+  assert.equal(childMsg, 'ok')
+  assert.equal(msg, 'test')
 })
 
-test('customLevels property child bindings does not get logged', async ({ equal }) => {
+test('customLevels property child bindings does not get logged', async () => {
   const stream = sink()
   const logger = pino(stream).child({
     childMsg: 'ok'
@@ -124,94 +126,106 @@ test('customLevels property child bindings does not get logged', async ({ equal
 
   logger.foo('test')
   const { customLevels } = await once(stream, 'data')
-  equal(customLevels, undefined)
+  assert.equal(customLevels, undefined)
 })
 
-test('throws when specifying pre-existing parent labels via child bindings', async ({ throws }) => {
+test('throws when specifying pre-existing parent labels via child bindings', async () => {
   const stream = sink()
-  throws(() => pino({
-    customLevels: {
-      foo: 35
-    }
-  }, stream).child({}, {
-    customLevels: {
-      foo: 45
-    }
-  }), 'levels cannot be overridden')
+  assert.throws(
+    () => pino({
+      customLevels: {
+        foo: 35
+      }
+    }, stream).child({}, {
+      customLevels: {
+        foo: 45
+      }
+    }),
+    /levels cannot be overridden/
+  )
 })
 
-test('throws when specifying pre-existing parent values via child bindings', async ({ throws }) => {
+test('throws when specifying pre-existing parent values via child bindings', async () => {
   const stream = sink()
-  throws(() => pino({
-    customLevels: {
-      foo: 35
-    }
-  }, stream).child({}, {
-    customLevels: {
-      bar: 35
-    }
-  }), 'pre-existing level values cannot be used for new levels')
+  assert.throws(
+    () => pino({
+      customLevels: {
+        foo: 35
+      }
+    }, stream).child({}, {
+      customLevels: {
+        bar: 35
+      }
+    }),
+    /pre-existing level values cannot be used for new levels/
+  )
 })
 
-test('throws when specifying core values via child bindings', async ({ throws }) => {
+test('throws when specifying core values via child bindings', async () => {
   const stream = sink()
-  throws(() => pino(stream).child({}, {
-    customLevels: {
-      foo: 30
-    }
-  }), 'pre-existing level values cannot be used for new levels')
+  assert.throws(
+    () => pino(stream).child({}, {
+      customLevels: {
+        foo: 30
+      }
+    }),
+    /pre-existing level values cannot be used for new levels/
+  )
 })
 
-test('throws when useOnlyCustomLevels is set true without customLevels', async ({ throws }) => {
+test('throws when useOnlyCustomLevels is set true without customLevels', async () => {
   const stream = sink()
-  throws(() => pino({
-    useOnlyCustomLevels: true
-  }, stream), 'customLevels is required if useOnlyCustomLevels is set true')
+  assert.throws(
+    () => pino({
+      useOnlyCustomLevels: true
+    }, stream),
+    /customLevels is required if useOnlyCustomLevels is set true/
+  )
 })
 
-test('custom level on one instance does not affect other instances', async ({ equal }) => {
+test('custom level on one instance does not affect other instances', async () => {
   pino({
     customLevels: {
       foo: 37
     }
   })
-  equal(typeof pino().foo, 'undefined')
+  assert.equal(typeof pino().foo, 'undefined')
 })
 
-test('setting level below or at custom level will successfully log', async ({ equal }) => {
+test('setting level below or at custom level will successfully log', async () => {
   const stream = sink()
   const instance = pino({ customLevels: { foo: 35 } }, stream)
   instance.level = 'foo'
   instance.info('nope')
   instance.foo('bar')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'bar')
+  assert.equal(msg, 'bar')
 })
 
-test('custom level below level threshold will not log', async ({ equal }) => {
+test('custom level below level threshold will not log', async () => {
   const stream = sink()
   const instance = pino({ customLevels: { foo: 15 } }, stream)
   instance.level = 'info'
   instance.info('bar')
   instance.foo('nope')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'bar')
+  assert.equal(msg, 'bar')
 })
 
-test('does not share custom level state across siblings', async ({ doesNotThrow }) => {
+test('does not share custom level state across siblings', async () => {
   const stream = sink()
   const logger = pino(stream)
   logger.child({}, {
     customLevels: { foo: 35 }
   })
-  doesNotThrow(() => {
+  assert.doesNotThrow(() => {
     logger.child({}, {
       customLevels: { foo: 35 }
     })
   })
 })
 
-test('custom level does not affect the levels serializer', async ({ equal }) => {
+test('custom level does not affect the levels serializer', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -227,10 +241,10 @@ test('custom level does not affect the levels serializer', async ({ equal }) =>
 
   logger.foo('test')
   const { priority } = await once(stream, 'data')
-  equal(priority, 35)
+  assert.equal(priority, 35)
 })
 
-test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async ({ equal }) => {
+test('When useOnlyCustomLevels is set to true, the level formatter should only get custom levels', async () => {
   const stream = sink()
   const logger = pino({
     customLevels: {
@@ -240,8 +254,8 @@ test('When useOnlyCustomLevels is set to true, the level formatter should only g
     level: 42,
     formatters: {
       level (label, number) {
-        equal(label, 'answer')
-        equal(number, 42)
+        assert.equal(label, 'answer')
+        assert.equal(number, 42)
         return { level: number }
       }
     }
@@ -249,5 +263,5 @@ test('When useOnlyCustomLevels is set to true, the level formatter should only g
 
   logger.answer('test')
   const { level } = await once(stream, 'data')
-  equal(level, 42)
+  assert.equal(level, 42)
 })