@contrast/agent-bundle 5.46.0 → 5.48.0

package/node_modules/pino/test/serializers.test.js

@@ -1,7 +1,10 @@
 'use strict'
-const { test } = require('tap')
-const { sink, once } = require('./helper')
+
+const test = require('node:test')
+const assert = require('node:assert')
 const stdSerializers = require('pino-std-serializers')
+
+const { sink, once } = require('./helper')
 const pino = require('../')
 
 const parentSerializers = {
@@ -12,19 +15,19 @@ const childSerializers = {
   test: () => 'child'
 }
 
-test('default err namespace error serializer', async ({ equal }) => {
+test('default err namespace error serializer', async () => {
   const stream = sink()
   const parent = pino(stream)
 
   parent.info({ err: ReferenceError('test') })
   const o = await once(stream, 'data')
-  equal(typeof o.err, 'object')
-  equal(o.err.type, 'ReferenceError')
-  equal(o.err.message, 'test')
-  equal(typeof o.err.stack, 'string')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(o.err.type, 'ReferenceError')
+  assert.equal(o.err.message, 'test')
+  assert.equal(typeof o.err.stack, 'string')
 })
 
-test('custom serializer overrides default err namespace error serializer', async ({ equal }) => {
+test('custom serializer overrides default err namespace error serializer', async () => {
   const stream = sink()
   const parent = pino({
     serializers: {
@@ -38,13 +41,13 @@ test('custom serializer overrides default err namespace error serializer', async
 
   parent.info({ err: ReferenceError('test') })
   const o = await once(stream, 'data')
-  equal(typeof o.err, 'object')
-  equal(o.err.t, 'ReferenceError')
-  equal(o.err.m, 'test')
-  equal(typeof o.err.s, 'string')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(o.err.t, 'ReferenceError')
+  assert.equal(o.err.m, 'test')
+  assert.equal(typeof o.err.s, 'string')
 })
 
-test('custom serializer overrides default err namespace error serializer when nestedKey is on', async ({ equal }) => {
+test('custom serializer overrides default err namespace error serializer when nestedKey is on', async () => {
   const stream = sink()
   const parent = pino({
     nestedKey: 'obj',
@@ -61,47 +64,47 @@ test('custom serializer overrides default err namespace error serializer when ne
 
   parent.info({ err: ReferenceError('test') })
   const o = await once(stream, 'data')
-  equal(typeof o.obj.err, 'object')
-  equal(o.obj.err.t, 'ReferenceError')
-  equal(o.obj.err.m, 'test')
-  equal(typeof o.obj.err.s, 'string')
+  assert.equal(typeof o.obj.err, 'object')
+  assert.equal(o.obj.err.t, 'ReferenceError')
+  assert.equal(o.obj.err.m, 'test')
+  assert.equal(typeof o.obj.err.s, 'string')
 })
 
-test('null overrides default err namespace error serializer', async ({ equal }) => {
+test('null overrides default err namespace error serializer', async () => {
   const stream = sink()
   const parent = pino({ serializers: { err: null } }, stream)
 
   parent.info({ err: ReferenceError('test') })
   const o = await once(stream, 'data')
-  equal(typeof o.err, 'object')
-  equal(typeof o.err.type, 'undefined')
-  equal(typeof o.err.message, 'undefined')
-  equal(typeof o.err.stack, 'undefined')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(typeof o.err.type, 'undefined')
+  assert.equal(typeof o.err.message, 'undefined')
+  assert.equal(typeof o.err.stack, 'undefined')
 })
 
-test('undefined overrides default err namespace error serializer', async ({ equal }) => {
+test('undefined overrides default err namespace error serializer', async () => {
   const stream = sink()
   const parent = pino({ serializers: { err: undefined } }, stream)
 
   parent.info({ err: ReferenceError('test') })
   const o = await once(stream, 'data')
-  equal(typeof o.err, 'object')
-  equal(typeof o.err.type, 'undefined')
-  equal(typeof o.err.message, 'undefined')
-  equal(typeof o.err.stack, 'undefined')
+  assert.equal(typeof o.err, 'object')
+  assert.equal(typeof o.err.type, 'undefined')
+  assert.equal(typeof o.err.message, 'undefined')
+  assert.equal(typeof o.err.stack, 'undefined')
 })
 
-test('serializers override values', async ({ equal }) => {
+test('serializers override values', async () => {
   const stream = sink()
   const parent = pino({ serializers: parentSerializers }, stream)
   parent.child({}, { serializers: childSerializers })
 
   parent.fatal({ test: 'test' })
   const o = await once(stream, 'data')
-  equal(o.test, 'parent')
+  assert.equal(o.test, 'parent')
 })
 
-test('child does not overwrite parent serializers', async ({ equal }) => {
+test('child does not overwrite parent serializers', async () => {
   const stream = sink()
   const parent = pino({ serializers: parentSerializers }, stream)
   const child = parent.child({}, { serializers: childSerializers })
@@ -109,13 +112,13 @@ test('child does not overwrite parent serializers', async ({ equal }) => {
   parent.fatal({ test: 'test' })
 
   const o = once(stream, 'data')
-  equal((await o).test, 'parent')
+  assert.equal((await o).test, 'parent')
   const o2 = once(stream, 'data')
   child.fatal({ test: 'test' })
-  equal((await o2).test, 'child')
+  assert.equal((await o2).test, 'child')
 })
 
-test('Symbol.for(\'pino.serializers\')', async ({ equal, same, not }) => {
+test('Symbol.for(\'pino.serializers\')', async () => {
   const stream = sink()
   const expected = Object.assign({
     err: stdSerializers.err
@@ -123,9 +126,9 @@ test('Symbol.for(\'pino.serializers\')', async ({ equal, same, not }) => {
   const parent = pino({ serializers: parentSerializers }, stream)
   const child = parent.child({ a: 'property' })
 
-  same(parent[Symbol.for('pino.serializers')], expected)
-  same(child[Symbol.for('pino.serializers')], expected)
-  equal(parent[Symbol.for('pino.serializers')], child[Symbol.for('pino.serializers')])
+  assert.deepEqual(parent[Symbol.for('pino.serializers')], expected)
+  assert.deepEqual(child[Symbol.for('pino.serializers')], expected)
+  assert.equal(parent[Symbol.for('pino.serializers')], child[Symbol.for('pino.serializers')])
 
   const child2 = parent.child({}, {
     serializers: {
@@ -137,22 +140,23 @@ test('Symbol.for(\'pino.serializers\')', async ({ equal, same, not }) => {
     return 'hello'
   }
 
-  not(child2[Symbol.for('pino.serializers')], parentSerializers)
-  equal(child2[Symbol.for('pino.serializers')].a, a)
-  equal(child2[Symbol.for('pino.serializers')].test, parentSerializers.test)
+  // eslint-disable-next-line eqeqeq
+  assert.equal(child2[Symbol.for('pino.serializers')] != parentSerializers, true)
+  assert.equal(child2[Symbol.for('pino.serializers')].a, a)
+  assert.equal(child2[Symbol.for('pino.serializers')].test, parentSerializers.test)
 })
 
-test('children inherit parent serializers', async ({ equal }) => {
+test('children inherit parent serializers', async () => {
   const stream = sink()
   const parent = pino({ serializers: parentSerializers }, stream)
 
   const child = parent.child({ a: 'property' })
   child.fatal({ test: 'test' })
   const o = await once(stream, 'data')
-  equal(o.test, 'parent')
+  assert.equal(o.test, 'parent')
 })
 
-test('children inherit parent Symbol serializers', async ({ equal, same, not }) => {
+test('children inherit parent Symbol serializers', async () => {
   const stream = sink()
   const symbolSerializers = {
     [Symbol.for('b')]: b
@@ -162,7 +166,7 @@ test('children inherit parent Symbol serializers', async ({ equal, same, not })
   }, symbolSerializers)
   const parent = pino({ serializers: symbolSerializers }, stream)
 
-  same(parent[Symbol.for('pino.serializers')], expected)
+  assert.deepEqual(parent[Symbol.for('pino.serializers')], expected)
 
   const child = parent.child({}, {
     serializers: {
@@ -179,12 +183,12 @@ test('children inherit parent Symbol serializers', async ({ equal, same, not })
     return 'world'
   }
 
-  same(child[Symbol.for('pino.serializers')].a, a)
-  same(child[Symbol.for('pino.serializers')][Symbol.for('b')], b)
-  same(child[Symbol.for('pino.serializers')][Symbol.for('a')], a)
+  assert.deepEqual(child[Symbol.for('pino.serializers')].a, a)
+  assert.deepEqual(child[Symbol.for('pino.serializers')][Symbol.for('b')], b)
+  assert.deepEqual(child[Symbol.for('pino.serializers')][Symbol.for('a')], a)
 })
 
-test('children serializers get called', async ({ equal }) => {
+test('children serializers get called', async () => {
   const stream = sink()
   const parent = pino({
     test: 'this'
@@ -194,10 +198,10 @@ test('children serializers get called', async ({ equal }) => {
 
   child.fatal({ test: 'test' })
   const o = await once(stream, 'data')
-  equal(o.test, 'child')
+  assert.equal(o.test, 'child')
 })
 
-test('children serializers get called when inherited from parent', async ({ equal }) => {
+test('children serializers get called when inherited from parent', async () => {
   const stream = sink()
   const parent = pino({
     test: 'this',
@@ -208,10 +212,10 @@ test('children serializers get called when inherited from parent', async ({ equa
 
   child.fatal({ test: 'fail' })
   const o = await once(stream, 'data')
-  equal(o.test, 'pass')
+  assert.equal(o.test, 'pass')
 })
 
-test('non-overridden serializers are available in the children', async ({ equal }) => {
+test('non-overridden serializers are available in the children', async () => {
   const stream = sink()
   const pSerializers = {
     onlyParent: function () { return 'parent' },
@@ -229,19 +233,19 @@ test('non-overridden serializers are available in the children', async ({ equal
 
   const o = once(stream, 'data')
   child.fatal({ shared: 'test' })
-  equal((await o).shared, 'child')
+  assert.equal((await o).shared, 'child')
   const o2 = once(stream, 'data')
   child.fatal({ onlyParent: 'test' })
-  equal((await o2).onlyParent, 'parent')
+  assert.equal((await o2).onlyParent, 'parent')
   const o3 = once(stream, 'data')
   child.fatal({ onlyChild: 'test' })
-  equal((await o3).onlyChild, 'child')
+  assert.equal((await o3).onlyChild, 'child')
   const o4 = once(stream, 'data')
   parent.fatal({ onlyChild: 'test' })
-  equal((await o4).onlyChild, 'test')
+  assert.equal((await o4).onlyChild, 'test')
 })
 
-test('custom serializer for messageKey', async (t) => {
+test('custom serializer for messageKey', async () => {
   const stream = sink()
   const instance = pino({ serializers: { msg: () => '422' } }, stream)
 
@@ -249,5 +253,5 @@ test('custom serializer for messageKey', async (t) => {
   instance.info(o, 42)
 
   const { msg } = await once(stream, 'data')
-  t.equal(msg, '422')
+  assert.equal(msg, '422')
 })

package/node_modules/pino/test/stdout-protection.test.js

@@ -1,13 +1,15 @@
 'use strict'
 
-const { test } = require('tap')
-const { join } = require('path')
-const { fork } = require('child_process')
-const { once } = require('./helper')
+const test = require('node:test')
+const assert = require('node:assert')
+const { join } = require('node:path')
+const { fork } = require('node:child_process')
 const writer = require('flush-write-stream')
+
+const { once } = require('./helper')
 const pino = require('..')
 
-test('do not use SonicBoom is someone tampered with process.stdout.write', async ({ not }) => {
+test('do not use SonicBoom is someone tampered with process.stdout.write', async () => {
   let actual = ''
   const child = fork(join(__dirname, 'fixtures', 'stdout-hack-protection.js'), { silent: true })
 
@@ -16,24 +18,24 @@ test('do not use SonicBoom is someone tampered with process.stdout.write', async
     cb()
   }))
   await once(child, 'close')
-  not(actual.match(/^hack/), null)
+  assert.equal(actual.match(/^hack/) != null, true)
 })
 
-test('do not use SonicBoom is someone has passed process.stdout to pino', async ({ equal }) => {
+test('do not use SonicBoom is someone has passed process.stdout to pino', async () => {
   const logger = pino(process.stdout)
-  equal(logger[pino.symbols.streamSym], process.stdout)
+  assert.equal(logger[pino.symbols.streamSym], process.stdout)
 })
 
-test('do not crash if process.stdout has no fd', async ({ teardown }) => {
+test('do not crash if process.stdout has no fd', async (t) => {
   const fd = process.stdout.fd
   delete process.stdout.fd
-  teardown(function () { process.stdout.fd = fd })
+  t.after(function () { process.stdout.fd = fd })
   pino()
 })
 
-test('use fd=1 if process.stdout has no fd in pino.destination() (worker case)', async ({ teardown }) => {
+test('use fd=1 if process.stdout has no fd in pino.destination() (worker case)', async (t) => {
   const fd = process.stdout.fd
   delete process.stdout.fd
-  teardown(function () { process.stdout.fd = fd })
+  t.after(function () { process.stdout.fd = fd })
   pino.destination()
 })

package/node_modules/pino/test/syncfalse.test.js

@@ -1,13 +1,11 @@
 'use strict'
 
-const os = require('os')
-const {
-  createWriteStream
-} = require('fs')
-const { readFile } = require('fs').promises
-const { join } = require('path')
-const { test } = require('tap')
-const { fork } = require('child_process')
+const test = require('node:test')
+const assert = require('node:assert')
+const os = require('node:os')
+const { promises: { readFile }, createWriteStream } = require('node:fs')
+const { join } = require('node:path')
+const { fork } = require('node:child_process')
 const writer = require('flush-write-stream')
 const {
   once,
@@ -15,14 +13,12 @@ const {
   file,
   watchFileCreated
 } = require('./helper')
-const { promisify } = require('util')
+const { promisify } = require('node:util')
+const tspl = require('@matteo.collina/tspl')
 
 const sleep = promisify(setTimeout)
 
-test('asynchronous logging', async ({
-  equal,
-  teardown
-}) => {
+test('asynchronous logging', async (t) => {
   const now = Date.now
   const hostname = os.hostname
   const proc = process
@@ -64,20 +60,17 @@ test('asynchronous logging', async ({
   await once(child, 'close')
   // Wait for the last write to be flushed
   await sleep(100)
-  equal(actual, expected)
-  equal(actual2.trim(), expected2)
+  assert.equal(actual, expected)
+  assert.equal(actual2.trim(), expected2)
 
-  teardown(() => {
+  t.after(() => {
     os.hostname = hostname
     Date.now = now
     global.process = proc
   })
 })
 
-test('sync false with child', async ({
-  equal,
-  teardown
-}) => {
+test('sync false with child', async (t) => {
   const now = Date.now
   const hostname = os.hostname
   const proc = process
@@ -123,36 +116,38 @@ test('sync false with child', async ({
     cb()
   }))
   await once(child, 'close')
-  equal(actual, expected)
-  equal(actual2.trim(), expected2)
+  assert.equal(actual, expected)
+  assert.equal(actual2.trim(), expected2)
 
-  teardown(() => {
+  t.after(() => {
     os.hostname = hostname
     Date.now = now
     global.process = proc
   })
 })
 
-test('flush does nothing with sync true (default)', async ({ equal }) => {
+test('flush does nothing with sync true (default)', async () => {
   const instance = require('..')()
-  equal(instance.flush(), undefined)
+  assert.equal(instance.flush(), undefined)
 })
 
-test('should still call flush callback even when does nothing with sync true (default)', (t) => {
-  t.plan(3)
+test('should still call flush callback even when does nothing with sync true (default)', async (t) => {
+  const plan = tspl(t, { plan: 3 })
   const instance = require('..')()
   instance.flush((...args) => {
-    t.ok('flush called')
-    t.same(args, [])
+    plan.ok('flush called')
+    plan.deepEqual(args, [])
 
     // next tick to make flush not called more than once
     process.nextTick(() => {
-      t.ok('flush next tick called')
+      plan.ok('flush next tick called')
     })
   })
+
+  await plan
 })
 
-test('should call the flush callback when flushed the data for async logger', async (t) => {
+test('should call the flush callback when flushed the data for async logger', async () => {
   const outputPath = file()
   async function getOutputLogLines () {
     return (await readFile(outputPath)).toString().trim().split('\n').map(JSON.parse)
@@ -174,18 +169,18 @@ test('should call the flush callback when flushed the data for async logger', as
 
   const [firstFlushData] = await getOutputLogLines()
 
-  t.equal(firstFlushData.msg, 'hello')
+  assert.equal(firstFlushData.msg, 'hello')
 
   // should not flush this as no data accumulated that's bigger than min length
   instance.info('world')
 
   // Making sure data is not flushed yet
   const afterLogData = await getOutputLogLines()
-  t.equal(afterLogData.length, 1)
+  assert.equal(afterLogData.length, 1)
 
   await flushPromise()
 
   // Making sure data is not flushed yet
   const afterSecondFlush = (await getOutputLogLines())[1]
-  t.equal(afterSecondFlush.msg, 'world')
+  assert.equal(afterSecondFlush.msg, 'world')
 })

package/node_modules/pino/test/timestamp-nano.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+/* eslint no-prototype-builtins: 0 */
+
+const test = require('node:test')
+const assert = require('node:assert')
+
+const { sink, once } = require('./helper')
+
+test('pino.stdTimeFunctions.isoTimeNano returns RFC 3339 timestamps', async () => {
+  // Mock Date.now at module initialization time
+  const now = Date.now
+  Date.now = () => new Date('2025-08-01T15:03:45.000000000Z').getTime()
+
+  // Mock process.hrtime.bigint at module initialization time
+  const hrTimeBigint = process.hrtime.bigint
+  process.hrtime.bigint = () => 100000000000000n
+
+  const pino = require('../')
+
+  const opts = {
+    timestamp: pino.stdTimeFunctions.isoTimeNano
+  }
+  const stream = sink()
+
+  // Mock process.hrtime.bigint at invocation time, add 1 day to the timestamp
+  process.hrtime.bigint = () => 100000000000000n + 86400012345678n
+
+  const instance = pino(opts, stream)
+  instance.info('foobar')
+  const result = await once(stream, 'data')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, '2025-08-02T15:03:45.012345678Z')
+
+  Date.now = now
+  process.hrtime.bigint = hrTimeBigint
+})

package/node_modules/pino/test/timestamp.test.js

@@ -2,19 +2,22 @@
 
 /* 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('../')
 
-test('pino exposes standard time functions', async ({ ok }) => {
-  ok(pino.stdTimeFunctions)
-  ok(pino.stdTimeFunctions.epochTime)
-  ok(pino.stdTimeFunctions.unixTime)
-  ok(pino.stdTimeFunctions.nullTime)
-  ok(pino.stdTimeFunctions.isoTime)
+test('pino exposes standard time functions', async () => {
+  assert.ok(pino.stdTimeFunctions)
+  assert.ok(pino.stdTimeFunctions.epochTime)
+  assert.ok(pino.stdTimeFunctions.unixTime)
+  assert.ok(pino.stdTimeFunctions.nullTime)
+  assert.ok(pino.stdTimeFunctions.isoTime)
+  assert.ok(pino.stdTimeFunctions.isoTimeNano)
 })
 
-test('pino accepts external time functions', async ({ equal }) => {
+test('pino accepts external time functions', async () => {
   const opts = {
     timestamp: () => ',"time":"none"'
   }
@@ -22,11 +25,11 @@ test('pino accepts external time functions', async ({ equal }) => {
   const instance = pino(opts, stream)
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), true)
-  equal(result.time, 'none')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, 'none')
 })
 
-test('pino accepts external time functions with custom label', async ({ equal }) => {
+test('pino accepts external time functions with custom label', async () => {
   const opts = {
     timestamp: () => ',"custom-time-label":"none"'
   }
@@ -34,8 +37,8 @@ test('pino accepts external time functions with custom label', async ({ equal })
   const instance = pino(opts, stream)
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('custom-time-label'), true)
-  equal(result['custom-time-label'], 'none')
+  assert.equal(result.hasOwnProperty('custom-time-label'), true)
+  assert.equal(result['custom-time-label'], 'none')
 })
 
 test('inserts timestamp by default', async ({ ok, equal }) => {
@@ -43,18 +46,18 @@ test('inserts timestamp by default', async ({ ok, equal }) => {
   const instance = pino(stream)
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), true)
-  ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
-  equal(result.msg, 'foobar')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  assert.equal(result.msg, 'foobar')
 })
 
-test('omits timestamp when timestamp option is false', async ({ equal }) => {
+test('omits timestamp when timestamp option is false', async () => {
   const stream = sink()
   const instance = pino({ timestamp: false }, stream)
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), false)
-  equal(result.msg, 'foobar')
+  assert.equal(result.hasOwnProperty('time'), false)
+  assert.equal(result.msg, 'foobar')
 })
 
 test('inserts timestamp when timestamp option is true', async ({ ok, equal }) => {
@@ -62,9 +65,9 @@ test('inserts timestamp when timestamp option is true', async ({ ok, equal }) =>
   const instance = pino({ timestamp: true }, stream)
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), true)
-  ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
-  equal(result.msg, 'foobar')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  assert.equal(result.msg, 'foobar')
 })
 
 test('child inserts timestamp by default', async ({ ok, equal }) => {
@@ -73,22 +76,22 @@ test('child inserts timestamp by default', async ({ ok, equal }) => {
   const instance = logger.child({ component: 'child' })
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), true)
-  ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
-  equal(result.msg, 'foobar')
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.ok(new Date(result.time) <= new Date(), 'time is greater than timestamp')
+  assert.equal(result.msg, 'foobar')
 })
 
-test('child omits timestamp with option', async ({ equal }) => {
+test('child omits timestamp with option', async () => {
   const stream = sink()
   const logger = pino({ timestamp: false }, stream)
   const instance = logger.child({ component: 'child' })
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), false)
-  equal(result.msg, 'foobar')
+  assert.equal(result.hasOwnProperty('time'), false)
+  assert.equal(result.msg, 'foobar')
 })
 
-test('pino.stdTimeFunctions.unixTime returns seconds based timestamps', async ({ equal }) => {
+test('pino.stdTimeFunctions.unixTime returns seconds based timestamps', async () => {
   const opts = {
     timestamp: pino.stdTimeFunctions.unixTime
   }
@@ -98,12 +101,12 @@ test('pino.stdTimeFunctions.unixTime returns seconds based timestamps', async ({
   Date.now = () => 1531069919686
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), true)
-  equal(result.time, 1531069920)
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, 1531069920)
   Date.now = now
 })
 
-test('pino.stdTimeFunctions.isoTime returns ISO 8601 timestamps', async ({ equal }) => {
+test('pino.stdTimeFunctions.isoTime returns ISO 8601 timestamps', async () => {
   const opts = {
     timestamp: pino.stdTimeFunctions.isoTime
   }
@@ -115,7 +118,7 @@ test('pino.stdTimeFunctions.isoTime returns ISO 8601 timestamps', async ({ equal
   const iso = new Date(ms).toISOString()
   instance.info('foobar')
   const result = await once(stream, 'data')
-  equal(result.hasOwnProperty('time'), true)
-  equal(result.time, iso)
+  assert.equal(result.hasOwnProperty('time'), true)
+  assert.equal(result.time, iso)
   Date.now = now
 })