@zuplo/cli 7.0.2 → 7.1.1

package/node_modules/pino-pretty/test/basic.test.js

@@ -2,15 +2,15 @@
 
 process.env.TZ = 'UTC'
 
-const { Writable } = require('readable-stream')
-const os = require('os')
-const test = require('tap').test
+const { Writable } = require('node:stream')
+const os = require('node:os')
+const { describe, test, beforeEach, afterEach } = require('node:test')
+const match = require('@jsumners/assert-match')
 const pino = require('pino')
 const dateformat = require('dateformat')
-const path = require('path')
 const rimraf = require('rimraf')
-const { join } = require('path')
-const fs = require('fs')
+const { join } = require('node:path')
+const fs = require('node:fs')
 const semver = require('semver')
 const pinoPretty = require('..')
 const SonicBoom = require('sonic-boom')
@@ -37,30 +37,30 @@ const formattedEpoch = '17:35:28.992'
 const pid = process.pid
 const hostname = os.hostname()
 
-test('basic prettifier tests', (t) => {
-  t.beforeEach(() => {
+describe('basic prettifier tests', () => {
+  beforeEach(() => {
     Date.originalNow = Date.now
     Date.now = () => epoch
   })
-  t.afterEach(() => {
+  afterEach(() => {
     Date.now = Date.originalNow
     delete Date.originalNow
   })
 
-  t.test('preserves output if not valid JSON', (t) => {
+  test('preserves output if not valid JSON', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const formatted = pretty('this is not json\nit\'s just regular output\n')
-    t.equal(formatted, 'this is not json\nit\'s just regular output\n\n')
+    t.assert.strictEqual(formatted, 'this is not json\nit\'s just regular output\n\n')
   })
 
-  t.test('formats a line without any extra options', (t) => {
+  test('formats a line without any extra options', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): foo\n`
         )
@@ -70,13 +70,13 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('will add color codes', (t) => {
+  test('will add color codes', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ colorize: true })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] \u001B[32mINFO\u001B[39m (${pid}): \u001B[36mfoo\u001B[39m\n`
         )
@@ -86,13 +86,13 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('will omit color codes from objects when colorizeObjects = false', (t) => {
+  test('will omit color codes from objects when colorizeObjects = false', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ colorize: true, singleLine: true, colorizeObjects: false })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] \u001B[32mINFO\u001B[39m (${pid}): \u001B[36mfoo\u001B[39m {"foo":"bar"}\n`
         )
@@ -102,11 +102,11 @@ test('basic prettifier tests', (t) => {
     log.info({ foo: 'bar' }, 'foo')
   })
 
-  t.test('can swap date and level position', (t) => {
+  test('can swap date and level position', (t) => {
     t.plan(1)
     const destination = new Writable({
       write (formatted, enc, cb) {
-        t.equal(
+        t.assert.strictEqual(
           formatted.toString(),
           `INFO [${formattedEpoch}] (${pid}): foo\n`
         )
@@ -122,13 +122,13 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('can print message key value when its a string', (t) => {
+  test('can print message key value when its a string', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): baz\n`
         )
@@ -138,13 +138,13 @@ test('basic prettifier tests', (t) => {
     log.info('baz')
   })
 
-  t.test('can print message key value when its a number', (t) => {
+  test('can print message key value when its a number', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): 42\n`
         )
@@ -154,13 +154,13 @@ test('basic prettifier tests', (t) => {
     log.info(42)
   })
 
-  t.test('can print message key value when its a Number(0)', (t) => {
+  test('can print message key value when its a Number(0)', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): 0\n`
         )
@@ -170,13 +170,13 @@ test('basic prettifier tests', (t) => {
     log.info(0)
   })
 
-  t.test('can print message key value when its a boolean', (t) => {
+  test('can print message key value when its a boolean', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): true\n`
         )
@@ -186,13 +186,13 @@ test('basic prettifier tests', (t) => {
     log.info(true)
   })
 
-  t.test('can use different message keys', (t) => {
+  test('can use different message keys', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ messageKey: 'bar' })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): baz\n`
         )
@@ -202,13 +202,13 @@ test('basic prettifier tests', (t) => {
     log.info({ bar: 'baz' })
   })
 
-  t.test('can use different level keys', (t) => {
+  test('can use different level keys', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ levelKey: 'bar' })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] WARN (${pid}): foo\n`
         )
@@ -218,7 +218,23 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo', bar: 'warn' })
   })
 
-  t.test('can use a customPrettifier on default level output', (t) => {
+  test('can use nested level keys', (t) => {
+    t.plan(1)
+    const pretty = prettyFactory({ levelKey: 'log\\.level' })
+    const log = pino({}, new Writable({
+      write (chunk, enc, cb) {
+        const formatted = pretty(chunk.toString())
+        t.assert.strictEqual(
+          formatted,
+          `[${formattedEpoch}] WARN (${pid}): foo\n`
+        )
+        cb()
+      }
+    }))
+    log.info({ msg: 'foo', 'log.level': 'warn' })
+  })
+
+  test('can use a customPrettifier on default level output', (t) => {
     t.plan(1)
     const veryCustomLevels = {
       30: 'ok',
@@ -231,7 +247,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] LEVEL: ok (${pid}): foo\n`
         )
@@ -241,7 +257,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo' })
   })
 
-  t.test('can use a customPrettifier on different-level-key output', (t) => {
+  test('can use a customPrettifier on different-level-key output', (t) => {
     t.plan(1)
     const customPrettifiers = {
       level: (level) => `LEVEL: ${level.toUpperCase()}`
@@ -250,7 +266,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] LEVEL: WARN (${pid}): foo\n`
         )
@@ -260,7 +276,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo', bar: 'warn' })
   })
 
-  t.test('can use a customPrettifier to get final level label (no color)', (t) => {
+  test('can use a customPrettifier to get final level label (no color)', (t) => {
     t.plan(1)
     const customPrettifiers = {
       level: (level, key, logThis, { label }) => {
@@ -271,7 +287,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] LEVEL: INFO (${pid}): foo\n`
         )
@@ -281,7 +297,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo' })
   })
 
-  t.test('can use a customPrettifier to get final level label (colorized)', (t) => {
+  test('can use a customPrettifier to get final level label (colorized)', (t) => {
     t.plan(1)
     const customPrettifiers = {
       level: (level, key, logThis, { label, labelColorized }) => {
@@ -292,7 +308,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] LEVEL: INFO (${pid}): foo\n`
         )
@@ -302,7 +318,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo' })
   })
 
-  t.test('can use a customPrettifier on name output', (t) => {
+  test('can use a customPrettifier on name output', (t) => {
     t.plan(1)
     const customPrettifiers = {
       name: (hostname) => `NAME: ${hostname}`
@@ -311,7 +327,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (NAME: logger/${pid}): foo\n`
         )
@@ -322,7 +338,7 @@ test('basic prettifier tests', (t) => {
     child.info({ msg: 'foo' })
   })
 
-  t.test('can use a customPrettifier on hostname and pid output', (t) => {
+  test('can use a customPrettifier on hostname and pid output', (t) => {
     t.plan(1)
     const customPrettifiers = {
       hostname: (hostname) => `HOSTNAME: ${hostname}`,
@@ -332,7 +348,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (PID: ${pid} on HOSTNAME: ${hostname}): foo\n`
         )
@@ -342,7 +358,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo' })
   })
 
-  t.test('can use a customPrettifier on default time output', (t) => {
+  test('can use a customPrettifier on default time output', (t) => {
     t.plan(1)
     const customPrettifiers = {
       time: (timestamp) => `TIME: ${timestamp}`
@@ -351,7 +367,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `TIME: ${formattedEpoch} INFO (${pid}): foo\n`
         )
@@ -361,7 +377,7 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('can use a customPrettifier on the caller', (t) => {
+  test('can use a customPrettifier on the caller', (t) => {
     t.plan(1)
     const customPrettifiers = {
       caller: (caller) => `CALLER: ${caller}`
@@ -370,7 +386,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}) <CALLER: test.js:10>: foo\n`
         )
@@ -380,7 +396,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'foo', caller: 'test.js:10' })
   })
 
-  t.test('can use a customPrettifier on translateTime-time output', (t) => {
+  test('can use a customPrettifier on translateTime-time output', (t) => {
     t.plan(1)
     const customPrettifiers = {
       time: (timestamp) => `TIME: ${timestamp}`
@@ -389,7 +405,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `TIME: ${formattedEpoch} INFO (${pid}): foo\n`
         )
@@ -399,13 +415,13 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('will format time to UTC', (t) => {
+  test('will format time to UTC', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ translateTime: true })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): foo\n`
         )
@@ -415,7 +431,7 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('will format time to UTC in custom format', (t) => {
+  test('will format time to UTC in custom format', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ translateTime: 'HH:MM:ss o' })
     const log = pino({}, new Writable({
@@ -423,7 +439,7 @@ test('basic prettifier tests', (t) => {
         const formatted = pretty(chunk.toString())
         const utcHour = dateformat(epoch, 'UTC:' + 'HH')
         const offset = dateformat(epoch, 'UTC:' + 'o')
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${utcHour}:35:28 ${offset}] INFO (${pid}): foo\n`
         )
@@ -433,7 +449,7 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('will format time to local systemzone in ISO 8601 format', (t) => {
+  test('will format time to local systemzone in ISO 8601 format', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ translateTime: 'sys:standard' })
     const log = pino({}, new Writable({
@@ -443,7 +459,7 @@ test('basic prettifier tests', (t) => {
         const localMinute = dateformat(epoch, 'MM')
         const localDate = dateformat(epoch, 'yyyy-mm-dd')
         const offset = dateformat(epoch, 'o')
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${localDate} ${localHour}:${localMinute}:28.992 ${offset}] INFO (${pid}): foo\n`
         )
@@ -453,7 +469,7 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('will format time to local systemzone in custom format', (t) => {
+  test('will format time to local systemzone in custom format', (t) => {
     t.plan(1)
     const pretty = prettyFactory({
       translateTime: 'SYS:yyyy/mm/dd HH:MM:ss o'
@@ -465,7 +481,7 @@ test('basic prettifier tests', (t) => {
         const localMinute = dateformat(epoch, 'MM')
         const localDate = dateformat(epoch, 'yyyy/mm/dd')
         const offset = dateformat(epoch, 'o')
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${localDate} ${localHour}:${localMinute}:28 ${offset}] INFO (${pid}): foo\n`
         )
@@ -476,27 +492,27 @@ test('basic prettifier tests', (t) => {
   })
 
   // TODO: 2019-03-30 -- We don't really want the indentation in this case? Or at least some better formatting.
-  t.test('handles missing time', (t) => {
+  test('handles missing time', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const formatted = pretty('{"hello":"world"}')
-    t.equal(formatted, '    hello: "world"\n')
+    t.assert.strictEqual(formatted, '    hello: "world"\n')
   })
 
-  t.test('handles missing pid, hostname and name', (t) => {
+  test('handles missing pid, hostname and name', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({ base: null }, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.match(formatted, /\[.*\] INFO: hello world/)
+        t.assert.match(formatted, /\[.*\] INFO: hello world/)
         cb()
       }
     }))
     log.info('hello world')
   })
 
-  t.test('handles missing pid', (t) => {
+  test('handles missing pid', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const name = 'test'
@@ -512,7 +528,7 @@ test('basic prettifier tests', (t) => {
     const log = pino(opts, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.match(formatted, regex)
+        t.assert.match(formatted, regex)
         cb()
       }
     }))
@@ -520,7 +536,7 @@ test('basic prettifier tests', (t) => {
     log.info(msg)
   })
 
-  t.test('handles missing hostname', (t) => {
+  test('handles missing hostname', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const name = 'test'
@@ -536,7 +552,7 @@ test('basic prettifier tests', (t) => {
     const log = pino(opts, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.match(formatted, regex)
+        t.assert.match(formatted, regex)
         cb()
       }
     }))
@@ -544,7 +560,7 @@ test('basic prettifier tests', (t) => {
     log.info(msg)
   })
 
-  t.test('handles missing name', (t) => {
+  test('handles missing name', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const msg = 'hello world'
@@ -559,7 +575,7 @@ test('basic prettifier tests', (t) => {
     const log = pino(opts, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.match(formatted, regex)
+        t.assert.match(formatted, regex)
         cb()
       }
     }))
@@ -567,33 +583,33 @@ test('basic prettifier tests', (t) => {
     log.info(msg)
   })
 
-  t.test('works without time', (t) => {
+  test('works without time', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({ timestamp: null }, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(formatted, `INFO (${pid}): hello world\n`)
+        t.assert.strictEqual(formatted, `INFO (${pid}): hello world\n`)
         cb()
       }
     }))
     log.info('hello world')
   })
 
-  t.test('prettifies properties', (t) => {
+  test('prettifies properties', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.match(formatted, '    a: "b"')
+        match(formatted, '    a: "b"', t)
         cb()
       }
     }))
     log.info({ a: 'b' }, 'hello world')
   })
 
-  t.test('prettifies nested properties', (t) => {
+  test('prettifies nested properties', (t) => {
     t.plan(6)
     const expectedLines = [
       '    a: {',
@@ -607,10 +623,10 @@ test('basic prettifier tests', (t) => {
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
         const lines = formatted.split('\n')
-        t.equal(lines.length, expectedLines.length + 2)
+        t.assert.strictEqual(lines.length, expectedLines.length + 2)
         lines.shift(); lines.pop()
         for (let i = 0; i < lines.length; i += 1) {
-          t.equal(lines[i], expectedLines[i])
+          t.assert.strictEqual(lines[i], expectedLines[i])
         }
         cb()
       }
@@ -618,74 +634,70 @@ test('basic prettifier tests', (t) => {
     log.info({ a: { b: { c: 'd' } } }, 'hello world')
   })
 
-  t.test('treats the name with care', (t) => {
+  test('treats the name with care', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({ name: 'matteo' }, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(formatted, `[${formattedEpoch}] INFO (matteo/${pid}): hello world\n`)
+        t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (matteo/${pid}): hello world\n`)
         cb()
       }
     }))
     log.info('hello world')
   })
 
-  t.test('handles spec allowed primitives', (t) => {
+  test('handles spec allowed primitives', (t) => {
     const pretty = prettyFactory()
     let formatted = pretty(null)
-    t.equal(formatted, 'null\n')
+    t.assert.strictEqual(formatted, 'null\n')
 
     formatted = pretty(true)
-    t.equal(formatted, 'true\n')
+    t.assert.strictEqual(formatted, 'true\n')
 
     formatted = pretty(false)
-    t.equal(formatted, 'false\n')
-
-    t.end()
+    t.assert.strictEqual(formatted, 'false\n')
   })
 
-  t.test('handles numbers', (t) => {
+  test('handles numbers', (t) => {
     const pretty = prettyFactory()
     let formatted = pretty(2)
-    t.equal(formatted, '2\n')
+    t.assert.strictEqual(formatted, '2\n')
 
     formatted = pretty(-2)
-    t.equal(formatted, '-2\n')
+    t.assert.strictEqual(formatted, '-2\n')
 
     formatted = pretty(0.2)
-    t.equal(formatted, '0.2\n')
+    t.assert.strictEqual(formatted, '0.2\n')
 
     formatted = pretty(Infinity)
-    t.equal(formatted, 'Infinity\n')
+    t.assert.strictEqual(formatted, 'Infinity\n')
 
     formatted = pretty(NaN)
-    t.equal(formatted, 'NaN\n')
-
-    t.end()
+    t.assert.strictEqual(formatted, 'NaN\n')
   })
 
-  t.test('handles `undefined` input', (t) => {
+  test('handles `undefined` input', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const formatted = pretty(undefined)
-    t.equal(formatted, 'undefined\n')
+    t.assert.strictEqual(formatted, 'undefined\n')
   })
 
-  t.test('handles customLogLevel', (t) => {
+  test('handles customLogLevel', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({ customLevels: { testCustom: 35 } }, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.match(formatted, /USERLVL/)
+        t.assert.match(formatted, /USERLVL/)
         cb()
       }
     }))
     log.testCustom('test message')
   })
 
-  t.test('filter some lines based on minimumLevel', (t) => {
+  test('filter some lines based on minimumLevel', (t) => {
     t.plan(3)
     const pretty = prettyFactory({ minimumLevel: 'info' })
     const expected = [
@@ -696,7 +708,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           expected.shift()
         )
@@ -709,7 +721,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'baz', level: 30 })
   })
 
-  t.test('filter lines based on minimumLevel using custom levels and level key', (t) => {
+  test('filter lines based on minimumLevel using custom levels and level key', (t) => {
     t.plan(3)
     const pretty = prettyFactory({ minimumLevel: 20, levelKey: 'bar' })
     const expected = [
@@ -720,7 +732,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           expected.shift()
         )
@@ -732,7 +744,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'baz', bar: 30 })
   })
 
-  t.test('formats a line with an undefined field', (t) => {
+  test('formats a line with an undefined field', (t) => {
     t.plan(1)
     const pretty = prettyFactory()
     const log = pino({}, new Writable({
@@ -741,7 +753,7 @@ test('basic prettifier tests', (t) => {
         // weird hack, but we should not crash
         obj.a = undefined
         const formatted = pretty(obj)
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}): foo\n`
         )
@@ -751,7 +763,7 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('prettifies msg object', (t) => {
+  test('prettifies msg object', (t) => {
     t.plan(6)
     const expectedLines = [
       '    msg: {',
@@ -765,10 +777,10 @@ test('basic prettifier tests', (t) => {
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
         const lines = formatted.split('\n')
-        t.equal(lines.length, expectedLines.length + 2)
+        t.assert.strictEqual(lines.length, expectedLines.length + 2)
         lines.shift(); lines.pop()
         for (let i = 0; i < lines.length; i += 1) {
-          t.equal(lines[i], expectedLines[i])
+          t.assert.strictEqual(lines[i], expectedLines[i])
         }
         cb()
       }
@@ -776,7 +788,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: { b: { c: 'd' } } })
   })
 
-  t.test('prettifies msg object with circular references', (t) => {
+  test('prettifies msg object with circular references', (t) => {
     t.plan(7)
     const expectedLines = [
       '    msg: {',
@@ -791,10 +803,10 @@ test('basic prettifier tests', (t) => {
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
         const lines = formatted.split('\n')
-        t.equal(lines.length, expectedLines.length + 2)
+        t.assert.strictEqual(lines.length, expectedLines.length + 2)
         lines.shift(); lines.pop()
         for (let i = 0; i < lines.length; i += 1) {
-          t.equal(lines[i], expectedLines[i])
+          t.assert.strictEqual(lines[i], expectedLines[i])
         }
         cb()
       }
@@ -805,7 +817,7 @@ test('basic prettifier tests', (t) => {
     log.info({ msg })
   })
 
-  t.test('prettifies custom key', (t) => {
+  test('prettifies custom key', (t) => {
     t.plan(1)
     const pretty = prettyFactory({
       customPrettifiers: {
@@ -814,10 +826,10 @@ test('basic prettifier tests', (t) => {
       }
     })
     const arst = pretty('{"msg":"hello world", "foo": "bar", "cow": "moo", "level":30}')
-    t.equal(arst, 'INFO: hello world\n    foo: bar_baz\n    multiline\n    cow: MOO\n')
+    t.assert.strictEqual(arst, 'INFO: hello world\n    foo: bar_baz\n    multiline\n    cow: MOO\n')
   })
 
-  t.test('does not add trailing space if prettified value begins with eol', (t) => {
+  test('does not add trailing space if prettified value begins with eol', (t) => {
     t.plan(1)
     const pretty = prettyFactory({
       customPrettifiers: {
@@ -825,10 +837,10 @@ test('basic prettifier tests', (t) => {
       }
     })
     const arst = pretty('{"msg":"doing work","calls":["step 1","step 2","step 3"],"level":30}')
-    t.equal(arst, 'INFO: doing work\n    calls:\n      step 1\n      step 2\n      step 3\n')
+    t.assert.strictEqual(arst, 'INFO: doing work\n    calls:\n      step 1\n      step 2\n      step 3\n')
   })
 
-  t.test('does not prettify custom key that does not exists', (t) => {
+  test('does not prettify custom key that does not exists', (t) => {
     t.plan(1)
     const pretty = prettyFactory({
       customPrettifiers: {
@@ -837,14 +849,14 @@ test('basic prettifier tests', (t) => {
       }
     })
     const arst = pretty('{"msg":"hello world", "foo": "bar", "level":30}')
-    t.equal(arst, 'INFO: hello world\n    foo: bar_baz\n')
+    t.assert.strictEqual(arst, 'INFO: hello world\n    foo: bar_baz\n')
   })
 
-  t.test('prettifies object with some undefined values', (t) => {
+  test('prettifies object with some undefined values', (t) => {
     t.plan(1)
     const destination = new Writable({
       write (chunk, _, cb) {
-        t.equal(
+        t.assert.strictEqual(
           chunk + '',
           `[${formattedEpoch}] INFO (${pid}):\n    a: {\n      "b": "c"\n    }\n    n: null\n`
         )
@@ -866,63 +878,63 @@ test('basic prettifier tests', (t) => {
     })
   })
 
-  t.test('ignores multiple keys', (t) => {
+  test('ignores multiple keys', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'pid,hostname' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, `[${formattedEpoch}] INFO: hello world\n`)
+    t.assert.strictEqual(arst, `[${formattedEpoch}] INFO: hello world\n`)
   })
 
-  t.test('ignores a single key', (t) => {
+  test('ignores a single key', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'pid' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, `[${formattedEpoch}] INFO (on ${hostname}): hello world\n`)
+    t.assert.strictEqual(arst, `[${formattedEpoch}] INFO (on ${hostname}): hello world\n`)
   })
 
-  t.test('ignores time', (t) => {
+  test('ignores time', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'time' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, `INFO (${pid} on ${hostname}): hello world\n`)
+    t.assert.strictEqual(arst, `INFO (${pid} on ${hostname}): hello world\n`)
   })
 
-  t.test('ignores time and level', (t) => {
+  test('ignores time and level', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'time,level' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, `(${pid} on ${hostname}): hello world\n`)
+    t.assert.strictEqual(arst, `(${pid} on ${hostname}): hello world\n`)
   })
 
-  t.test('ignores all keys but message', (t) => {
+  test('ignores all keys but message', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'time,level,name,pid,hostname' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, 'hello world\n')
+    t.assert.strictEqual(arst, 'hello world\n')
   })
 
-  t.test('include nothing', (t) => {
+  test('include nothing', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ include: '' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, 'hello world\n')
+    t.assert.strictEqual(arst, 'hello world\n')
   })
 
-  t.test('include multiple keys', (t) => {
+  test('include multiple keys', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ include: 'time,level' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, `[${formattedEpoch}] INFO: hello world\n`)
+    t.assert.strictEqual(arst, `[${formattedEpoch}] INFO: hello world\n`)
   })
 
-  t.test('include a single key', (t) => {
+  test('include a single key', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ include: 'level' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, 'INFO: hello world\n')
+    t.assert.strictEqual(arst, 'INFO: hello world\n')
   })
 
-  t.test('log error-like object', (t) => {
+  test('log error-like object', (t) => {
     t.plan(7)
     const expectedLines = [
       '    type: "Error"',
@@ -937,10 +949,10 @@ test('basic prettifier tests', (t) => {
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
         const lines = formatted.split('\n')
-        t.equal(lines.length, expectedLines.length + 2)
+        t.assert.strictEqual(lines.length, expectedLines.length + 2)
         lines.shift(); lines.pop()
         for (let i = 0; i < lines.length; i += 1) {
-          t.equal(lines[i], expectedLines[i])
+          t.assert.strictEqual(lines[i], expectedLines[i])
         }
         cb()
       }
@@ -948,14 +960,14 @@ test('basic prettifier tests', (t) => {
     log.error({ type: 'Error', message: 'm', stack: ['line1', 'line2'] })
   })
 
-  t.test('include should override ignore', (t) => {
+  test('include should override ignore', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'time,level', include: 'time,level' })
     const arst = pretty(`{"msg":"hello world", "pid":"${pid}", "hostname":"${hostname}", "time":${epoch}, "level":30}`)
-    t.equal(arst, `[${formattedEpoch}] INFO: hello world\n`)
+    t.assert.strictEqual(arst, `[${formattedEpoch}] INFO: hello world\n`)
   })
 
-  t.test('include a single key with null object', (t) => {
+  test('include a single key with null object', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ include: 'level' })
     const obj = new Empty()
@@ -968,10 +980,10 @@ test('basic prettifier tests', (t) => {
       obj,
       level: 30
     })
-    t.equal(arst, 'INFO: hello world\n')
+    t.assert.strictEqual(arst, 'INFO: hello world\n')
   })
 
-  t.test('prettifies trace caller', (t) => {
+  test('prettifies trace caller', (t) => {
     t.plan(1)
     const traceCaller = (instance) => {
       const { symbols: { asJsonSym } } = pino
@@ -990,7 +1002,7 @@ test('basic prettifier tests', (t) => {
     const log = traceCaller(pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] INFO (${pid}) </tmp/script.js>: foo\n`
         )
@@ -1000,40 +1012,40 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('handles specified timestampKey', (t) => {
+  test('handles specified timestampKey', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ timestampKey: '@timestamp' })
     const arst = pretty(`{"msg":"hello world", "@timestamp":${epoch}, "level":30}`)
-    t.equal(arst, `[${formattedEpoch}] INFO: hello world\n`)
+    t.assert.strictEqual(arst, `[${formattedEpoch}] INFO: hello world\n`)
   })
 
-  t.test('keeps "v" key in log', (t) => {
+  test('keeps "v" key in log', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ ignore: 'time' })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(formatted, `INFO (${pid} on ${hostname}):\n    v: 1\n`)
+        t.assert.strictEqual(formatted, `INFO (${pid} on ${hostname}):\n    v: 1\n`)
         cb()
       }
     }))
     log.info({ v: 1 })
   })
 
-  t.test('Hide object `{ key: "value" }` from output when flag `hideObject` is set', (t) => {
+  test('Hide object `{ key: "value" }` from output when flag `hideObject` is set', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ hideObject: true })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(formatted, `[${formattedEpoch}] INFO (${pid}): hello world\n`)
+        t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): hello world\n`)
         cb()
       }
     }))
     log.info({ key: 'value' }, 'hello world')
   })
 
-  t.test('Prints extra objects on one line with singleLine=true', (t) => {
+  test('Prints extra objects on one line with singleLine=true', (t) => {
     t.plan(1)
     const pretty = prettyFactory({
       singleLine: true,
@@ -1046,7 +1058,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(formatted, `[${formattedEpoch}] INFO (${pid}): message {"extra":{"foo":"bar","number":42},"upper":"FOOBAR"}\n`)
+        t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): message {"extra":{"foo":"bar","number":42},"upper":"FOOBAR"}\n`)
 
         cb()
       }
@@ -1054,25 +1066,25 @@ test('basic prettifier tests', (t) => {
     log.info({ msg: 'message', extra: { foo: 'bar', number: 42 }, upper: 'foobar', undef: 'this will not show up' })
   })
 
-  t.test('Does not print empty object with singleLine=true', (t) => {
+  test('Does not print empty object with singleLine=true', (t) => {
     t.plan(1)
     const pretty = prettyFactory({ singleLine: true, colorize: false })
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(formatted, `[${formattedEpoch}] INFO (${pid}): message\n`)
+        t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): message\n`)
         cb()
       }
     }))
     log.info({ msg: 'message' })
   })
 
-  t.test('default options', (t) => {
+  test('default options', (t) => {
     t.plan(1)
-    t.doesNotThrow(pinoPretty)
+    t.assert.doesNotThrow(pinoPretty)
   })
 
-  t.test('does not call fs.close on stdout stream', (t) => {
+  test('does not call fs.close on stdout stream', (t) => {
     t.plan(2)
     const destination = pino.destination({ minLength: 4096, sync: true })
     const prettyDestination = pinoPretty({ destination, colorize: false })
@@ -1094,11 +1106,11 @@ test('basic prettifier tests', (t) => {
     })
     destination.end()
     Object.assign(fs, { close, writeSync })
-    t.match(chunks.join(''), /INFO .+: this message has been buffered/)
-    t.equal(closeCalled, false)
+    t.assert.match(chunks.join(''), /INFO .+: this message has been buffered/)
+    t.assert.strictEqual(closeCalled, false)
   })
 
-  t.test('wait for close event from destination', (t) => {
+  test('wait for close event from destination', (t, end) => {
     t.plan(2)
     const destination = pino.destination({ minLength: 4096, sync: true })
     const prettyDestination = pinoPretty({ destination, colorize: false })
@@ -1116,7 +1128,7 @@ test('basic prettifier tests', (t) => {
         return args[1].length
       }
     })
-    t.teardown(() => {
+    t.after(() => {
       Object.assign(fs, { close, writeSync })
     })
     let destinationClosed = false
@@ -1124,16 +1136,17 @@ test('basic prettifier tests', (t) => {
       destinationClosed = true
     })
     prettyDestination.on('close', () => {
-      t.match(chunks.join(''), /INFO .+: this message has been buffered/)
-      t.equal(destinationClosed, true)
+      t.assert.match(chunks.join(''), /INFO .+: this message has been buffered/)
+      t.assert.strictEqual(destinationClosed, true)
+      end()
     })
     prettyDestination.end()
   })
 
-  t.test('stream usage', async (t) => {
+  test('stream usage', async (t) => {
     t.plan(1)
-    const tmpDir = path.join(__dirname, '.tmp_' + Date.now())
-    t.teardown(() => rimraf.sync(tmpDir))
+    const tmpDir = join(__dirname, '.tmp_' + Date.now())
+    t.after(() => rimraf.sync(tmpDir))
 
     const destination = join(tmpDir, 'output')
 
@@ -1155,13 +1168,13 @@ test('basic prettifier tests', (t) => {
 
     const formatted = fs.readFileSync(destination, 'utf8')
 
-    t.equal(formatted, `[${formattedEpoch}] INFO (${pid}): message {"extra":{"foo":"bar","number":42},"upper":"FOOBAR"}\n`)
+    t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): message {"extra":{"foo":"bar","number":42},"upper":"FOOBAR"}\n`)
   })
 
-  t.test('sync option', async (t) => {
+  test('sync option', async (t) => {
     t.plan(1)
-    const tmpDir = path.join(__dirname, '.tmp_' + Date.now())
-    t.teardown(() => rimraf.sync(tmpDir))
+    const tmpDir = join(__dirname, '.tmp_' + Date.now())
+    t.after(() => rimraf.sync(tmpDir))
 
     const destination = join(tmpDir, 'output')
 
@@ -1182,10 +1195,10 @@ test('basic prettifier tests', (t) => {
 
     const formatted = fs.readFileSync(destination, 'utf8')
 
-    t.equal(formatted, `[${formattedEpoch}] INFO (${pid}): message {"extra":{"foo":"bar","number":43},"upper":"foobar"}\n`)
+    t.assert.strictEqual(formatted, `[${formattedEpoch}] INFO (${pid}): message {"extra":{"foo":"bar","number":43},"upper":"foobar"}\n`)
   })
 
-  t.test('support custom colors object', async (t) => {
+  test('support custom colors object', async (t) => {
     t.plan(1)
     const pretty = prettyFactory({
       colorize: true,
@@ -1201,7 +1214,7 @@ test('basic prettifier tests', (t) => {
     const log = pino({}, new Writable({
       write (chunk, enc, cb) {
         const formatted = pretty(chunk.toString())
-        t.equal(
+        t.assert.strictEqual(
           formatted,
           `[${formattedEpoch}] \u001B[32mINFO\u001B[39m (${pid}): \u001B[36mfoo\u001B[39m\n`
         )
@@ -1211,31 +1224,29 @@ test('basic prettifier tests', (t) => {
     log.info('foo')
   })
 
-  t.test('check support for colors', (t) => {
+  test('check support for colors', (t) => {
     t.plan(1)
     const isColorSupported = pinoPretty.isColorSupported
-    t.type(isColorSupported, 'boolean')
+    t.assert.strictEqual(typeof isColorSupported, 'boolean')
   })
-
-  t.end()
 })
 
 if (semver.gte(pino.version, '8.21.0')) {
-  test('using pino config', (t) => {
-    t.beforeEach(() => {
+  describe('using pino config', () => {
+    beforeEach(() => {
       Date.originalNow = Date.now
       Date.now = () => epoch
     })
-    t.afterEach(() => {
+    afterEach(() => {
       Date.now = Date.originalNow
       delete Date.originalNow
     })
 
-    t.test('can use different message keys', (t) => {
+    test('can use different message keys', (t) => {
       t.plan(1)
       const destination = new Writable({
         write (formatted, enc, cb) {
-          t.equal(
+          t.assert.strictEqual(
             formatted.toString(),
             `[${formattedEpoch}] INFO (${pid}): baz\n`
           )
@@ -1250,11 +1261,11 @@ if (semver.gte(pino.version, '8.21.0')) {
       log.info({ bar: 'baz' })
     })
 
-    t.test('handles customLogLevels', (t) => {
+    test('handles customLogLevels', (t) => {
       t.plan(1)
       const destination = new Writable({
         write (formatted, enc, cb) {
-          t.equal(
+          t.assert.strictEqual(
             formatted.toString(),
             `[${formattedEpoch}] TESTCUSTOM (${pid}): test message\n`
           )
@@ -1268,8 +1279,6 @@ if (semver.gte(pino.version, '8.21.0')) {
       const log = pino({ customLevels: { testCustom: 35 } }, pretty)
       log.testCustom('test message')
     })
-
-    t.end()
   })
 }