@contrast/agent-bundle 5.47.0 → 5.48.0

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

@@ -1,80 +1,83 @@
 'use strict'
-const os = require('os')
-const { readFileSync } = require('fs')
-const { test } = require('tap')
-const { sink, check, once, watchFileCreated, file } = require('./helper')
+
+const os = require('node:os')
+const { readFileSync } = require('node:fs')
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, check, match, once, watchFileCreated, file } = require('./helper')
 const pino = require('../')
 const { version } = require('../package.json')
 const { pid } = process
 const hostname = os.hostname()
 
-test('pino version is exposed on export', async ({ equal }) => {
-  equal(pino.version, version)
+test('pino version is exposed on export', () => {
+  assert.equal(pino.version, version)
 })
 
-test('pino version is exposed on instance', async ({ equal }) => {
+test('pino version is exposed on instance', () => {
   const instance = pino()
-  equal(instance.version, version)
+  assert.equal(instance.version, version)
 })
 
-test('child instance exposes pino version', async ({ equal }) => {
+test('child instance exposes pino version', () => {
   const child = pino().child({ foo: 'bar' })
-  equal(child.version, version)
+  assert.equal(child.version, version)
 })
 
-test('bindings are exposed on every instance', async ({ same }) => {
+test('bindings are exposed on every instance', () => {
   const instance = pino()
-  same(instance.bindings(), {})
+  assert.deepEqual(instance.bindings(), {})
 })
 
-test('bindings contain the name and the child bindings', async ({ same }) => {
+test('bindings contain the name and the child bindings', () => {
   const instance = pino({ name: 'basicTest', level: 'info' }).child({ foo: 'bar' }).child({ a: 2 })
-  same(instance.bindings(), { name: 'basicTest', foo: 'bar', a: 2 })
+  assert.deepEqual(instance.bindings(), { name: 'basicTest', foo: 'bar', a: 2 })
 })
 
-test('set bindings on instance', async ({ same }) => {
+test('set bindings on instance', () => {
   const instance = pino({ name: 'basicTest', level: 'info' })
   instance.setBindings({ foo: 'bar' })
-  same(instance.bindings(), { name: 'basicTest', foo: 'bar' })
+  assert.deepEqual(instance.bindings(), { name: 'basicTest', foo: 'bar' })
 })
 
-test('newly set bindings overwrite old bindings', async ({ same }) => {
+test('newly set bindings overwrite old bindings', () => {
   const instance = pino({ name: 'basicTest', level: 'info', base: { foo: 'bar' } })
   instance.setBindings({ foo: 'baz' })
-  same(instance.bindings(), { name: 'basicTest', foo: 'baz' })
+  assert.deepEqual(instance.bindings(), { name: 'basicTest', foo: 'baz' })
 })
 
-test('set bindings on child instance', async ({ same }) => {
+test('set bindings on child instance', () => {
   const child = pino({ name: 'basicTest', level: 'info' }).child({})
   child.setBindings({ foo: 'bar' })
-  same(child.bindings(), { name: 'basicTest', foo: 'bar' })
+  assert.deepEqual(child.bindings(), { name: 'basicTest', foo: 'bar' })
 })
 
-test('child should have bindings set by parent', async ({ same }) => {
+test('child should have bindings set by parent', () => {
   const instance = pino({ name: 'basicTest', level: 'info' })
   instance.setBindings({ foo: 'bar' })
   const child = instance.child({})
-  same(child.bindings(), { name: 'basicTest', foo: 'bar' })
+  assert.deepEqual(child.bindings(), { name: 'basicTest', foo: 'bar' })
 })
 
-test('child should not share bindings of parent set after child creation', async ({ same }) => {
+test('child should not share bindings of parent set after child creation', () => {
   const instance = pino({ name: 'basicTest', level: 'info' })
   const child = instance.child({})
   instance.setBindings({ foo: 'bar' })
-  same(instance.bindings(), { name: 'basicTest', foo: 'bar' })
-  same(child.bindings(), { name: 'basicTest' })
+  assert.deepEqual(instance.bindings(), { name: 'basicTest', foo: 'bar' })
+  assert.deepEqual(child.bindings(), { name: 'basicTest' })
 })
 
 function levelTest (name, level) {
-  test(`${name} logs as ${level}`, async ({ equal }) => {
+  test(`${name} logs as ${level}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
     instance[name]('hello world')
-    check(equal, await once(stream, 'data'), level, 'hello world')
+    check(assert.equal, await once(stream, 'data'), level, 'hello world')
   })
 
-  test(`passing objects at level ${name}`, async ({ equal, same }) => {
+  test(`passing objects at level ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
@@ -82,42 +85,42 @@ function levelTest (name, level) {
     instance[name](obj)
 
     const result = await once(stream, 'data')
-    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
-    equal(result.pid, pid)
-    equal(result.hostname, hostname)
-    equal(result.level, level)
-    equal(result.hello, 'world')
-    same(Object.keys(obj), ['hello'])
+    assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    assert.equal(result.pid, pid)
+    assert.equal(result.hostname, hostname)
+    assert.equal(result.level, level)
+    assert.equal(result.hello, 'world')
+    assert.deepEqual(Object.keys(obj), ['hello'])
   })
 
-  test(`passing an object and a string at level ${name}`, async ({ equal, same }) => {
+  test(`passing an object and a string at level ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
     const obj = { hello: 'world' }
     instance[name](obj, 'a string')
     const result = await once(stream, 'data')
-    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
     delete result.time
-    same(result, {
+    assert.deepEqual(result, {
       pid,
       hostname,
       level,
       msg: 'a string',
       hello: 'world'
     })
-    same(Object.keys(obj), ['hello'])
+    assert.deepEqual(Object.keys(obj), ['hello'])
   })
 
-  test(`passing a undefined and a string at level ${name}`, async ({ equal, same }) => {
+  test(`passing a undefined and a string at level ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
     instance[name](undefined, 'a string')
     const result = await once(stream, 'data')
-    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
     delete result.time
-    same(result, {
+    assert.deepEqual(result, {
       pid,
       hostname,
       level,
@@ -125,15 +128,15 @@ function levelTest (name, level) {
     })
   })
 
-  test(`overriding object key by string at level ${name}`, async ({ equal, same }) => {
+  test(`overriding object key by string at level ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
     instance[name]({ hello: 'world', msg: 'object' }, 'string')
     const result = await once(stream, 'data')
-    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
     delete result.time
-    same(result, {
+    assert.deepEqual(result, {
       pid,
       hostname,
       level,
@@ -142,16 +145,16 @@ function levelTest (name, level) {
     })
   })
 
-  test(`formatting logs as ${name}`, async ({ equal }) => {
+  test(`formatting logs as ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
     instance[name]('hello %d', 42)
     const result = await once(stream, 'data')
-    check(equal, result, level, 'hello 42')
+    check(assert.equal, result, level, 'hello 42')
   })
 
-  test(`formatting a symbol at level ${name}`, async ({ equal }) => {
+  test(`formatting a symbol at level ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
@@ -161,10 +164,10 @@ function levelTest (name, level) {
 
     const result = await once(stream, 'data')
 
-    check(equal, result, level, 'hello Symbol(foo)')
+    check(assert.equal, result, level, 'hello Symbol(foo)')
   })
 
-  test(`passing error with a serializer at level ${name}`, async ({ equal, same }) => {
+  test(`passing error with a serializer at level ${name}`, async () => {
     const stream = sink()
     const err = new Error('myerror')
     const instance = pino({
@@ -175,9 +178,9 @@ function levelTest (name, level) {
     instance.level = name
     instance[name]({ err })
     const result = await once(stream, 'data')
-    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
     delete result.time
-    same(result, {
+    assert.deepEqual(result, {
       pid,
       hostname,
       level,
@@ -190,16 +193,16 @@ function levelTest (name, level) {
     })
   })
 
-  test(`child logger for level ${name}`, async ({ equal, same }) => {
+  test(`child logger for level ${name}`, async () => {
     const stream = sink()
     const instance = pino(stream)
     instance.level = name
     const child = instance.child({ hello: 'world' })
     child[name]('hello world')
     const result = await once(stream, 'data')
-    equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+    assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
     delete result.time
-    same(result, {
+    assert.deepEqual(result, {
       pid,
       hostname,
       level,
@@ -216,7 +219,7 @@ levelTest('info', 30)
 levelTest('debug', 20)
 levelTest('trace', 10)
 
-test('serializers can return undefined to strip field', async ({ equal }) => {
+test('serializers can return undefined to strip field', async () => {
   const stream = sink()
   const instance = pino({
     serializers: {
@@ -226,10 +229,10 @@ test('serializers can return undefined to strip field', async ({ equal }) => {
 
   instance.info({ test: 'sensitive info' })
   const result = await once(stream, 'data')
-  equal('test' in result, false)
+  assert.equal('test' in result, false)
 })
 
-test('streams receive a message event with PINO_CONFIG', ({ match, end }) => {
+test('streams receive a message event with PINO_CONFIG', (t, end) => {
   const stream = sink()
   stream.once('message', (message) => {
     match(message, {
@@ -262,7 +265,7 @@ test('streams receive a message event with PINO_CONFIG', ({ match, end }) => {
   pino(stream)
 })
 
-test('does not explode with a circular ref', async ({ doesNotThrow }) => {
+test('does not explode with a circular ref', () => {
   const stream = sink()
   const instance = pino(stream)
   const b = {}
@@ -270,19 +273,19 @@ test('does not explode with a circular ref', async ({ doesNotThrow }) => {
     hello: b
   }
   b.a = a // circular ref
-  doesNotThrow(() => instance.info(a))
+  assert.doesNotThrow(() => instance.info(a))
 })
 
-test('set the name', async ({ equal, same }) => {
+test('set the name', async () => {
   const stream = sink()
   const instance = pino({
     name: 'hello'
   }, stream)
   instance.fatal('this is fatal')
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 60,
@@ -291,7 +294,7 @@ test('set the name', async ({ equal, same }) => {
   })
 })
 
-test('set the messageKey', async ({ equal, same }) => {
+test('set the messageKey', async () => {
   const stream = sink()
   const message = 'hello world'
   const messageKey = 'fooMessage'
@@ -300,9 +303,9 @@ test('set the messageKey', async ({ equal, same }) => {
   }, stream)
   instance.info(message)
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -310,7 +313,7 @@ test('set the messageKey', async ({ equal, same }) => {
   })
 })
 
-test('set the nestedKey', async ({ equal, same }) => {
+test('set the nestedKey', async () => {
   const stream = sink()
   const object = { hello: 'world' }
   const nestedKey = 'stuff'
@@ -319,9 +322,9 @@ test('set the nestedKey', async ({ equal, same }) => {
   }, stream)
   instance.info(object)
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -329,14 +332,14 @@ test('set the nestedKey', async ({ equal, same }) => {
   })
 })
 
-test('set undefined properties', async ({ equal, same }) => {
+test('set undefined properties', async () => {
   const stream = sink()
   const instance = pino(stream)
   instance.info({ hello: 'world', property: undefined })
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -344,15 +347,15 @@ test('set undefined properties', async ({ equal, same }) => {
   })
 })
 
-test('prototype properties are not logged', async ({ equal }) => {
+test('prototype properties are not logged', async () => {
   const stream = sink()
   const instance = pino(stream)
   instance.info(Object.create({ hello: 'world' }))
   const { hello } = await once(stream, 'data')
-  equal(hello, undefined)
+  assert.equal(hello, undefined)
 })
 
-test('set the base', async ({ equal, same }) => {
+test('set the base', async () => {
   const stream = sink()
   const instance = pino({
     base: {
@@ -362,31 +365,31 @@ test('set the base', async ({ equal, same }) => {
 
   instance.fatal('this is fatal')
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     a: 'b',
     level: 60,
     msg: 'this is fatal'
   })
 })
 
-test('set the base to null', async ({ equal, same }) => {
+test('set the base to null', async () => {
   const stream = sink()
   const instance = pino({
     base: null
   }, stream)
   instance.fatal('this is fatal')
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     level: 60,
     msg: 'this is fatal'
   })
 })
 
-test('set the base to null and use a formatter', async ({ equal, same }) => {
+test('set the base to null and use a formatter', async () => {
   const stream = sink()
   const instance = pino({
     base: null,
@@ -398,27 +401,27 @@ test('set the base to null and use a formatter', async ({ equal, same }) => {
   }, stream)
   instance.fatal('this is fatal too')
   const result = await once(stream, 'data')
-  equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
+  assert.equal(new Date(result.time) <= new Date(), true, 'time is greater than Date.now()')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     level: 60,
     msg: 'this is fatal too',
     additionalMessage: 'using pino'
   })
 })
 
-test('throw if creating child without bindings', async ({ equal, fail }) => {
+test('throw if creating child without bindings', () => {
   const stream = sink()
   const instance = pino(stream)
   try {
     instance.child()
-    fail('it should throw')
+    assert.fail('it should throw')
   } catch (err) {
-    equal(err.message, 'missing bindings for child Pino')
+    assert.equal(err.message, 'missing bindings for child Pino')
   }
 })
 
-test('correctly escapes msg strings with stray double quote at end', async ({ same }) => {
+test('correctly escapes msg strings with stray double quote at end', async () => {
   const stream = sink()
   const instance = pino({
     name: 'hello'
@@ -427,7 +430,7 @@ test('correctly escapes msg strings with stray double quote at end', async ({ sa
   instance.fatal('this contains "')
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 60,
@@ -436,7 +439,7 @@ test('correctly escapes msg strings with stray double quote at end', async ({ sa
   })
 })
 
-test('correctly escape msg strings with unclosed double quote', async ({ same }) => {
+test('correctly escape msg strings with unclosed double quote', async () => {
   const stream = sink()
   const instance = pino({
     name: 'hello'
@@ -444,7 +447,7 @@ test('correctly escape msg strings with unclosed double quote', async ({ same })
   instance.fatal('" this contains')
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 60,
@@ -453,32 +456,32 @@ test('correctly escape msg strings with unclosed double quote', async ({ same })
   })
 })
 
-test('correctly escape quote in a key', async ({ same }) => {
+test('correctly escape quote in a key', async () => {
   const stream = sink()
   const instance = pino(stream)
   const obj = { 'some"obj': 'world' }
   instance.info(obj, 'a string')
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     level: 30,
     pid,
     hostname,
     msg: 'a string',
     'some"obj': 'world'
   })
-  same(Object.keys(obj), ['some"obj'])
+  assert.deepEqual(Object.keys(obj), ['some"obj'])
 })
 
 // https://github.com/pinojs/pino/issues/139
-test('object and format string', async ({ same }) => {
+test('object and format string', async () => {
   const stream = sink()
   const instance = pino(stream)
   instance.info({}, 'foo %s', 'bar')
 
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -486,13 +489,13 @@ test('object and format string', async ({ same }) => {
   })
 })
 
-test('object and format string property', async ({ same }) => {
+test('object and format string property', async () => {
   const stream = sink()
   const instance = pino(stream)
   instance.info({ answer: 42 }, 'foo %s', 'bar')
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -501,42 +504,43 @@ test('object and format string property', async ({ same }) => {
   })
 })
 
-test('correctly strip undefined when returned from toJSON', async ({ equal }) => {
+test('correctly strip undefined when returned from toJSON', async () => {
   const stream = sink()
   const instance = pino({
     test: 'this'
   }, stream)
   instance.fatal({ test: { toJSON () { return undefined } } })
   const result = await once(stream, 'data')
-  equal('test' in result, false)
+  assert.equal('test' in result, false)
 })
 
-test('correctly supports stderr', async ({ same }) => {
+test('correctly supports stderr', (t, end) => {
   // stderr inherits from Stream, rather than Writable
   const dest = {
     writable: true,
     write (result) {
       result = JSON.parse(result)
       delete result.time
-      same(result, {
+      assert.deepEqual(result, {
         pid,
         hostname,
         level: 60,
         msg: 'a message'
       })
+      end()
     }
   }
   const instance = pino(dest)
   instance.fatal('a message')
 })
 
-test('normalize number to string', async ({ same }) => {
+test('normalize number to string', async () => {
   const stream = sink()
   const instance = pino(stream)
   instance.info(1)
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -544,13 +548,13 @@ test('normalize number to string', async ({ same }) => {
   })
 })
 
-test('normalize number to string with an object', async ({ same }) => {
+test('normalize number to string with an object', async () => {
   const stream = sink()
   const instance = pino(stream)
   instance.info({ answer: 42 }, 1)
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -559,7 +563,7 @@ test('normalize number to string with an object', async ({ same }) => {
   })
 })
 
-test('handles objects with null prototype', async ({ same }) => {
+test('handles objects with null prototype', async () => {
   const stream = sink()
   const instance = pino(stream)
   const o = Object.create(null)
@@ -567,7 +571,7 @@ test('handles objects with null prototype', async ({ same }) => {
   instance.info(o)
   const result = await once(stream, 'data')
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -575,14 +579,14 @@ test('handles objects with null prototype', async ({ same }) => {
   })
 })
 
-test('pino.destination', async ({ same }) => {
+test('pino.destination', async () => {
   const tmp = file()
   const instance = pino(pino.destination(tmp))
   instance.info('hello')
   await watchFileCreated(tmp)
   const result = JSON.parse(readFileSync(tmp).toString())
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -590,14 +594,14 @@ test('pino.destination', async ({ same }) => {
   })
 })
 
-test('auto pino.destination with a string', async ({ same }) => {
+test('auto pino.destination with a string', async () => {
   const tmp = file()
   const instance = pino(tmp)
   instance.info('hello')
   await watchFileCreated(tmp)
   const result = JSON.parse(readFileSync(tmp).toString())
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -605,14 +609,14 @@ test('auto pino.destination with a string', async ({ same }) => {
   })
 })
 
-test('auto pino.destination with a string as second argument', async ({ same }) => {
+test('auto pino.destination with a string as second argument', async () => {
   const tmp = file()
   const instance = pino(null, tmp)
   instance.info('hello')
   await watchFileCreated(tmp)
   const result = JSON.parse(readFileSync(tmp).toString())
   delete result.time
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -620,7 +624,7 @@ test('auto pino.destination with a string as second argument', async ({ same })
   })
 })
 
-test('does not override opts with a string as second argument', async ({ same }) => {
+test('does not override opts with a string as second argument', async () => {
   const tmp = file()
   const instance = pino({
     timestamp: () => ',"time":"none"'
@@ -628,7 +632,7 @@ test('does not override opts with a string as second argument', async ({ same })
   instance.info('hello')
   await watchFileCreated(tmp)
   const result = JSON.parse(readFileSync(tmp).toString())
-  same(result, {
+  assert.deepEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -638,15 +642,15 @@ test('does not override opts with a string as second argument', async ({ same })
 })
 
 // https://github.com/pinojs/pino/issues/222
-test('children with same names render in correct order', async ({ equal }) => {
+test('children with same names render in correct order', async () => {
   const stream = sink()
   const root = pino(stream)
   root.child({ a: 1 }).child({ a: 2 }).info({ a: 3 })
   const { a } = await once(stream, 'data')
-  equal(a, 3, 'last logged object takes precedence')
+  assert.equal(a, 3, 'last logged object takes precedence')
 })
 
-test('use `safe-stable-stringify` to avoid circular dependencies', async ({ same }) => {
+test('use `safe-stable-stringify` to avoid circular dependencies', async () => {
   const stream = sink()
   const root = pino(stream)
   // circular depth
@@ -654,10 +658,10 @@ test('use `safe-stable-stringify` to avoid circular dependencies', async ({ same
   obj.a = obj
   root.info(obj)
   const { a } = await once(stream, 'data')
-  same(a, { a: '[Circular]' })
+  assert.deepEqual(a, { a: '[Circular]' })
 })
 
-test('correctly log non circular objects', async ({ same }) => {
+test('correctly log non circular objects', async () => {
   const stream = sink()
   const root = pino(stream)
   const obj = {}
@@ -668,10 +672,10 @@ test('correctly log non circular objects', async ({ same }) => {
   }
   root.info(obj)
   const { node } = await once(stream, 'data')
-  same(node, { node: { node: { node: { node: { node: { node: { node: { node: { node: {} } } } } } } } } })
+  assert.deepEqual(node, { node: { node: { node: { node: { node: { node: { node: { node: { node: {} } } } } } } } } })
 })
 
-test('safe-stable-stringify must be used when interpolating', async (t) => {
+test('safe-stable-stringify must be used when interpolating', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -680,18 +684,21 @@ test('safe-stable-stringify must be used when interpolating', async (t) => {
   instance.info('test %j', o)
 
   const { msg } = await once(stream, 'data')
-  t.equal(msg, 'test {"a":{"b":{"c":"[Circular]"}}}')
+  assert.equal(msg, 'test {"a":{"b":{"c":"[Circular]"}}}')
 })
 
-test('throws when setting useOnlyCustomLevels without customLevels', async ({ throws }) => {
-  throws(() => {
-    pino({
-      useOnlyCustomLevels: true
-    })
-  }, 'customLevels is required if useOnlyCustomLevels is set true')
+test('throws when setting useOnlyCustomLevels without customLevels', () => {
+  assert.throws(
+    () => {
+      pino({
+        useOnlyCustomLevels: true
+      })
+    },
+    /customLevels is required if useOnlyCustomLevels is set true/
+  )
 })
 
-test('correctly log Infinity', async (t) => {
+test('correctly log Infinity', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -699,10 +706,10 @@ test('correctly log Infinity', async (t) => {
   instance.info(o)
 
   const { num } = await once(stream, 'data')
-  t.equal(num, null)
+  assert.equal(num, null)
 })
 
-test('correctly log -Infinity', async (t) => {
+test('correctly log -Infinity', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -710,10 +717,10 @@ test('correctly log -Infinity', async (t) => {
   instance.info(o)
 
   const { num } = await once(stream, 'data')
-  t.equal(num, null)
+  assert.equal(num, null)
 })
 
-test('correctly log NaN', async (t) => {
+test('correctly log NaN', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -721,19 +728,19 @@ test('correctly log NaN', async (t) => {
   instance.info(o)
 
   const { num } = await once(stream, 'data')
-  t.equal(num, null)
+  assert.equal(num, null)
 })
 
-test('offers a .default() method to please typescript', async ({ equal }) => {
-  equal(pino.default, pino)
+test('offers a .default() method to please typescript', async () => {
+  assert.equal(pino.default, pino)
 
   const stream = sink()
   const instance = pino.default(stream)
   instance.info('hello world')
-  check(equal, await once(stream, 'data'), 30, 'hello world')
+  check(assert.equal, await once(stream, 'data'), 30, 'hello world')
 })
 
-test('correctly skip function', async (t) => {
+test('correctly skip function', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -741,10 +748,10 @@ test('correctly skip function', async (t) => {
   instance.info(o, () => {})
 
   const { msg } = await once(stream, 'data')
-  t.equal(msg, undefined)
+  assert.equal(msg, undefined)
 })
 
-test('correctly skip Infinity', async (t) => {
+test('correctly skip Infinity', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -752,10 +759,10 @@ test('correctly skip Infinity', async (t) => {
   instance.info(o, Infinity)
 
   const { msg } = await once(stream, 'data')
-  t.equal(msg, null)
+  assert.equal(msg, null)
 })
 
-test('correctly log number', async (t) => {
+test('correctly log number', async () => {
   const stream = sink()
   const instance = pino(stream)
 
@@ -763,10 +770,10 @@ test('correctly log number', async (t) => {
   instance.info(o, 42)
 
   const { msg } = await once(stream, 'data')
-  t.equal(msg, 42)
+  assert.equal(msg, 42)
 })
 
-test('nestedKey should not be used for non-objects', async ({ strictSame }) => {
+test('nestedKey should not be used for non-objects', async () => {
   const stream = sink()
   const message = 'hello'
   const nestedKey = 'stuff'
@@ -776,7 +783,7 @@ test('nestedKey should not be used for non-objects', async ({ strictSame }) => {
   instance.info(message)
   const result = await once(stream, 'data')
   delete result.time
-  strictSame(result, {
+  assert.deepStrictEqual(result, {
     pid,
     hostname,
     level: 30,
@@ -784,75 +791,80 @@ test('nestedKey should not be used for non-objects', async ({ strictSame }) => {
   })
 })
 
-test('throws if prettyPrint is passed in as an option', async (t) => {
-  t.throws(() => {
-    pino({
-      prettyPrint: true
-    })
-  }, new Error('prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)'))
+test('throws if prettyPrint is passed in as an option', async () => {
+  assert.throws(
+    () => {
+      pino({
+        prettyPrint: true
+      })
+    },
+    Error('prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)')
+  )
 })
 
-test('Should invoke `onChild` with the newly created child', async ({ equal }) => {
+test('Should invoke `onChild` with the newly created child', () => {
   let innerChild
   const child = pino({
     onChild: (instance) => {
       innerChild = instance
     }
   }).child({ foo: 'bar' })
-  equal(child, innerChild)
+  assert.equal(child, innerChild)
 })
 
-test('logger message should have the prefix message that defined in the logger creation', async ({ equal }) => {
+test('logger message should have the prefix message that defined in the logger creation', async () => {
   const stream = sink()
   const logger = pino({
     msgPrefix: 'My name is Bond '
   }, stream)
+  assert.equal(logger.msgPrefix, 'My name is Bond ')
   logger.info('James Bond')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'My name is Bond James Bond')
+  assert.equal(msg, 'My name is Bond James Bond')
 })
 
-test('child message should have the prefix message that defined in the child creation', async ({ equal }) => {
+test('child message should have the prefix message that defined in the child creation', async () => {
   const stream = sink()
   const instance = pino(stream)
   const child = instance.child({}, { msgPrefix: 'My name is Bond ' })
   child.info('James Bond')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'My name is Bond James Bond')
+  assert.equal(msg, 'My name is Bond James Bond')
 })
 
-test('child message should have the prefix message that defined in the child creation when logging with log meta', async ({ equal }) => {
+test('child message should have the prefix message that defined in the child creation when logging with log meta', async () => {
   const stream = sink()
   const instance = pino(stream)
   const child = instance.child({}, { msgPrefix: 'My name is Bond ' })
   child.info({ hello: 'world' }, 'James Bond')
   const { msg, hello } = await once(stream, 'data')
-  equal(hello, 'world')
-  equal(msg, 'My name is Bond James Bond')
+  assert.equal(hello, 'world')
+  assert.equal(msg, 'My name is Bond James Bond')
 })
 
-test('logged message should not have the prefix when not providing any message', async ({ equal }) => {
+test('logged message should not have the prefix when not providing any message', async () => {
   const stream = sink()
   const instance = pino(stream)
   const child = instance.child({}, { msgPrefix: 'This should not be shown ' })
   child.info({ hello: 'world' })
   const { msg, hello } = await once(stream, 'data')
-  equal(hello, 'world')
-  equal(msg, undefined)
+  assert.equal(hello, 'world')
+  assert.equal(msg, undefined)
 })
 
-test('child message should append parent prefix to current prefix that defined in the child creation', async ({ equal }) => {
+test('child message should append parent prefix to current prefix that defined in the child creation', async () => {
   const stream = sink()
   const instance = pino({
     msgPrefix: 'My name is Bond '
   }, stream)
   const child = instance.child({}, { msgPrefix: 'James ' })
   child.info('Bond')
+  assert.equal(child.msgPrefix, 'My name is Bond James ')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'My name is Bond James Bond')
+  assert.equal(msg, 'My name is Bond James Bond')
 })
 
-test('child message should inherent parent prefix', async ({ equal }) => {
+test('child message should inherent parent prefix', async () => {
   const stream = sink()
   const instance = pino({
     msgPrefix: 'My name is Bond '
@@ -860,15 +872,15 @@ test('child message should inherent parent prefix', async ({ equal }) => {
   const child = instance.child({})
   child.info('James Bond')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'My name is Bond James Bond')
+  assert.equal(msg, 'My name is Bond James Bond')
 })
 
-test('grandchild message should inherent parent prefix', async ({ equal }) => {
+test('grandchild message should inherent parent prefix', async () => {
   const stream = sink()
   const instance = pino(stream)
   const child = instance.child({}, { msgPrefix: 'My name is Bond ' })
   const grandchild = child.child({})
   grandchild.info('James Bond')
   const { msg } = await once(stream, 'data')
-  equal(msg, 'My name is Bond James Bond')
+  assert.equal(msg, 'My name is Bond James Bond')
 })