@contrast/agent-bundle 5.46.0 → 5.48.0

package/node_modules/pino-abstract-transport/test/worker.test.js

@@ -96,8 +96,7 @@ function workerTest (filename, description = '') {
       errorKey: 'err'
     }
 
-    stream.worker.postMessage({ code: 'PINO_CONFIG', config: pinoConfig })
-    // stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
 
     port2.on('message', function (message) {
       same(expected.shift(), message.data)
@@ -156,8 +155,7 @@ function workerTest (filename, description = '') {
     })
 
     const lines = expected.map(JSON.stringify).join('\n')
-    stream.worker.postMessage({ code: 'PINO_CONFIG', config: pinoConfig })
-    // stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
     stream.write(lines)
     stream.end()
   })
@@ -209,12 +207,9 @@ function workerTest (filename, description = '') {
     })
 
     const lines = expected.map(JSON.stringify).join('\n')
-    stream.worker.postMessage('not a PINO_CONFIG')
-    // stream.emit('message', 'not a PINO_CONFIG')
-    stream.worker.postMessage({ code: 'NOT_PINO_CONFIG', config: { levels: 'foo', messageKey: 'bar', errorKey: 'baz' } })
-    // stream.emit('message', { code: 'NOT_PINO_CONFIG', config: { levels: 'foo', messageKey: 'bar', errorKey: 'baz' } })
-    stream.worker.postMessage({ code: 'PINO_CONFIG', config: pinoConfig })
-    // stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.emit('message', 'not a PINO_CONFIG')
+    stream.emit('message', { code: 'NOT_PINO_CONFIG', config: { levels: 'foo', messageKey: 'bar', errorKey: 'baz' } })
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
     stream.write(lines)
     stream.end()
   })
@@ -267,8 +262,7 @@ function workerTest (filename, description = '') {
 
     const lines = expected.map(JSON.stringify).join('\n')
     stream.write(lines)
-    stream.worker.postMessage({ code: 'PINO_CONFIG', config: pinoConfig })
-    // stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+    stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
     stream.end()
   })
 
@@ -357,8 +351,7 @@ test('waits for the pino config when pipelining', function ({ same, plan }) {
     same(expected.shift(), message.data)
   })
 
-  stream.worker.postMessage({ code: 'PINO_CONFIG', config: pinoConfig })
-  // stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
+  stream.emit('message', { code: 'PINO_CONFIG', config: pinoConfig })
   stream.write(lines)
   stream.end()
 })

package/node_modules/pino-std-serializers/.github/workflows/ci.yml

@@ -24,12 +24,12 @@ jobs:
       contents: read
     steps:
       - name: Check out repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           persist-credentials: false
 
       - name: Dependency review
-        uses: actions/dependency-review-action@v3
+        uses: actions/dependency-review-action@v4
 
   test:
     name: Test
@@ -39,15 +39,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [14, 16, 18]
+        node-version: [18, 20]
     steps:
       - name: Check out repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           persist-credentials: false
 
       - name: Setup Node ${{ matrix.node-version }}
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v4
         with:
           node-version: ${{ matrix.node-version }}
 

package/node_modules/pino-std-serializers/Readme.md

@@ -47,6 +47,7 @@ const serialized = serializer(outerError);
         at <...omitted..>
 }
  */
+```
 
 ### `exports.errWithCause(error)`
 Serializes an `Error` like object, including any `error.cause`. Returns an object:

package/node_modules/pino-std-serializers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pino-std-serializers",
-  "version": "6.2.2",
+  "version": "7.0.0",
   "description": "A collection of standard object serializers for Pino",
   "main": "index.js",
   "type": "commonjs",
@@ -8,8 +8,8 @@
   "scripts": {
     "lint": "standard | snazzy",
     "lint-ci": "standard",
-    "test": "tap --no-cov",
-    "test-ci": "tap --cov --no-check-coverage --coverage-report=text",
+    "test": "borp -p 'test/**/*.js'",
+    "test-ci": "borp --coverage -p 'test/**/*.js'",
     "test-types": "tsc && tsd"
   },
   "repository": {
@@ -32,13 +32,14 @@
     "test-types"
   ],
   "devDependencies": {
-    "@types/node": "^20.1.0",
+    "@matteo.collina/tspl": "^0.1.1",
+    "@types/node": "^20.11.17",
+    "borp": "^0.9.1",
     "pre-commit": "^1.2.2",
     "snazzy": "^9.0.0",
-    "standard": "^17.0.0",
-    "tap": "^15.0.10",
-    "tsd": "^0.28.0",
-    "typescript": "^5.0.2"
+    "standard": "^17.1.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.3.3"
   },
   "tsd": {
     "directory": "test/types"

package/node_modules/pino-std-serializers/test/err-with-cause.test.js

@@ -1,54 +1,50 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
+const assert = require('node:assert')
 const serializer = require('../lib/err-with-cause')
-const wrapErrorSerializer = require('../').wrapErrorSerializer
+const { wrapErrorSerializer } = require('../')
 
-test('serializes Error objects', function (t) {
-  t.plan(3)
+test('serializes Error objects', () => {
   const serialized = serializer(Error('foo'))
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
 })
 
-test('serializes Error objects with extra properties', function (t) {
-  t.plan(5)
+test('serializes Error objects with extra properties', () => {
   const err = Error('foo')
   err.statusCode = 500
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.ok(serialized.statusCode)
-  t.equal(serialized.statusCode, 500)
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.ok(serialized.statusCode)
+  assert.strictEqual(serialized.statusCode, 500)
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
 })
 
-test('serializes Error objects with subclass "type"', function (t) {
-  t.plan(1)
-
+test('serializes Error objects with subclass "type"', () => {
   class MyError extends Error {}
 
   const err = new MyError('foo')
   const serialized = serializer(err)
-  t.equal(serialized.type, 'MyError')
+  assert.strictEqual(serialized.type, 'MyError')
 })
 
-test('serializes nested errors', function (t) {
-  t.plan(7)
+test('serializes nested errors', () => {
   const err = Error('foo')
   err.inner = Error('bar')
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
-  t.equal(serialized.inner.type, 'Error')
-  t.equal(serialized.inner.message, 'bar')
-  t.match(serialized.inner.stack, /Error: bar/)
-  t.match(serialized.inner.stack, /err-with-cause\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
+  assert.strictEqual(serialized.inner.type, 'Error')
+  assert.strictEqual(serialized.inner.message, 'bar')
+  assert.match(serialized.inner.stack, /Error: bar/)
+  assert.match(serialized.inner.stack, /err-with-cause\.test\.js:/)
 })
 
-test('serializes error causes', function (t) {
+test('serializes error causes', () => {
   const innerErr = Error('inner')
   const middleErr = Error('middle')
   middleErr.cause = innerErr
@@ -57,44 +53,39 @@ test('serializes error causes', function (t) {
 
   const serialized = serializer(outerErr)
 
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'outer')
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
-
-  t.equal(serialized.cause.type, 'Error')
-  t.equal(serialized.cause.message, 'middle')
-  t.match(serialized.cause.stack, /err-with-cause\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'outer')
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
 
-  t.equal(serialized.cause.cause.type, 'Error')
-  t.equal(serialized.cause.cause.message, 'inner')
-  t.match(serialized.cause.cause.stack, /err-with-cause\.test\.js:/)
+  assert.strictEqual(serialized.cause.type, 'Error')
+  assert.strictEqual(serialized.cause.message, 'middle')
+  assert.match(serialized.cause.stack, /err-with-cause\.test\.js:/)
 
-  t.end()
+  assert.strictEqual(serialized.cause.cause.type, 'Error')
+  assert.strictEqual(serialized.cause.cause.message, 'inner')
+  assert.match(serialized.cause.cause.stack, /err-with-cause\.test\.js:/)
 })
 
-test('keeps non-error cause', function (t) {
-  t.plan(3)
+test('keeps non-error cause', () => {
   const err = Error('foo')
   err.cause = 'abc'
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.equal(serialized.cause, 'abc')
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.strictEqual(serialized.cause, 'abc')
 })
 
-test('prevents infinite recursion', function (t) {
-  t.plan(4)
+test('prevents infinite recursion', () => {
   const err = Error('foo')
   err.inner = err
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
-  t.notOk(serialized.inner)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
+  assert.ok(!serialized.inner)
 })
 
-test('cleans up infinite recursion tracking', function (t) {
-  t.plan(8)
+test('cleans up infinite recursion tracking', () => {
   const err = Error('foo')
   const bar = Error('bar')
   err.inner = bar
@@ -103,29 +94,26 @@ test('cleans up infinite recursion tracking', function (t) {
   serializer(err)
   const serialized = serializer(err)
 
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
-  t.ok(serialized.inner)
-  t.equal(serialized.inner.type, 'Error')
-  t.equal(serialized.inner.message, 'bar')
-  t.match(serialized.inner.stack, /Error: bar/)
-  t.notOk(serialized.inner.inner)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
+  assert.ok(serialized.inner)
+  assert.strictEqual(serialized.inner.type, 'Error')
+  assert.strictEqual(serialized.inner.message, 'bar')
+  assert.match(serialized.inner.stack, /Error: bar/)
+  assert.ok(!serialized.inner.inner)
 })
 
-test('err.raw is available', function (t) {
-  t.plan(1)
+test('err.raw is available', () => {
   const err = Error('foo')
   const serialized = serializer(err)
-  t.equal(serialized.raw, err)
+  assert.strictEqual(serialized.raw, err)
 })
 
-test('redefined err.constructor doesnt crash serializer', function (t) {
-  t.plan(10)
-
+test('redefined err.constructor doesnt crash serializer', () => {
   function check (a, name) {
-    t.equal(a.type, name)
-    t.equal(a.message, 'foo')
+    assert.strictEqual(a.type, name)
+    assert.strictEqual(a.message, 'foo')
   }
 
   const err1 = TypeError('foo')
@@ -154,11 +142,9 @@ test('redefined err.constructor doesnt crash serializer', function (t) {
   check(serializer(err5), 'Error')
 })
 
-test('pass through anything that does not look like an Error', function (t) {
-  t.plan(3)
-
+test('pass through anything that does not look like an Error', () => {
   function check (a) {
-    t.equal(serializer(a), a)
+    assert.strictEqual(serializer(a), a)
   }
 
   check('foo')
@@ -166,8 +152,7 @@ test('pass through anything that does not look like an Error', function (t) {
   check([1, 2])
 })
 
-test('can wrap err serializers', function (t) {
-  t.plan(5)
+test('can wrap err serializers', () => {
   const err = Error('foo')
   err.foo = 'foo'
   const serializer = wrapErrorSerializer(function (err) {
@@ -176,15 +161,14 @@ test('can wrap err serializers', function (t) {
     return err
   })
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err-with-cause\.test\.js:/)
-  t.notOk(serialized.foo)
-  t.equal(serialized.bar, 'bar')
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err-with-cause\.test\.js:/)
+  assert.ok(!serialized.foo)
+  assert.strictEqual(serialized.bar, 'bar')
 })
 
-test('serializes aggregate errors', { skip: !global.AggregateError }, function (t) {
-  t.plan(14)
+test('serializes aggregate errors', { skip: !global.AggregateError }, () => {
   const foo = new Error('foo')
   const bar = new Error('bar')
   for (const aggregate of [
@@ -192,12 +176,12 @@ test('serializes aggregate errors', { skip: !global.AggregateError }, function (
     { errors: [foo, bar], message: 'aggregated message', stack: 'err-with-cause.test.js:' }
   ]) {
     const serialized = serializer(aggregate)
-    t.equal(serialized.message, 'aggregated message')
-    t.equal(serialized.aggregateErrors.length, 2)
-    t.equal(serialized.aggregateErrors[0].message, 'foo')
-    t.equal(serialized.aggregateErrors[1].message, 'bar')
-    t.match(serialized.aggregateErrors[0].stack, /^Error: foo/)
-    t.match(serialized.aggregateErrors[1].stack, /^Error: bar/)
-    t.match(serialized.stack, /err-with-cause\.test\.js:/)
+    assert.strictEqual(serialized.message, 'aggregated message')
+    assert.strictEqual(serialized.aggregateErrors.length, 2)
+    assert.strictEqual(serialized.aggregateErrors[0].message, 'foo')
+    assert.strictEqual(serialized.aggregateErrors[1].message, 'bar')
+    assert.match(serialized.aggregateErrors[0].stack, /^Error: foo/)
+    assert.match(serialized.aggregateErrors[1].stack, /^Error: bar/)
+    assert.match(serialized.stack, /err-with-cause\.test\.js:/)
   }
 })

package/node_modules/pino-std-serializers/test/err.test.js

@@ -1,53 +1,49 @@
 'use strict'
 
-const test = require('tap').test
+const assert = require('node:assert')
+const { test } = require('node:test')
 const serializer = require('../lib/err')
-const wrapErrorSerializer = require('../').wrapErrorSerializer
+const { wrapErrorSerializer } = require('../')
 
-test('serializes Error objects', function (t) {
-  t.plan(3)
+test('serializes Error objects', () => {
   const serialized = serializer(Error('foo'))
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err\.test\.js:/)
 })
 
-test('serializes Error objects with extra properties', function (t) {
-  t.plan(5)
+test('serializes Error objects with extra properties', () => {
   const err = Error('foo')
   err.statusCode = 500
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.ok(serialized.statusCode)
-  t.equal(serialized.statusCode, 500)
-  t.match(serialized.stack, /err\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.ok(serialized.statusCode)
+  assert.strictEqual(serialized.statusCode, 500)
+  assert.match(serialized.stack, /err\.test\.js:/)
 })
 
-test('serializes Error objects with subclass "type"', function (t) {
-  t.plan(1)
+test('serializes Error objects with subclass "type"', () => {
   class MyError extends Error {}
   const err = new MyError('foo')
   const serialized = serializer(err)
-  t.equal(serialized.type, 'MyError')
+  assert.strictEqual(serialized.type, 'MyError')
 })
 
-test('serializes nested errors', function (t) {
-  t.plan(7)
+test('serializes nested errors', () => {
   const err = Error('foo')
   err.inner = Error('bar')
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err\.test\.js:/)
-  t.equal(serialized.inner.type, 'Error')
-  t.equal(serialized.inner.message, 'bar')
-  t.match(serialized.inner.stack, /Error: bar/)
-  t.match(serialized.inner.stack, /err\.test\.js:/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err\.test\.js:/)
+  assert.strictEqual(serialized.inner.type, 'Error')
+  assert.strictEqual(serialized.inner.message, 'bar')
+  assert.match(serialized.inner.stack, /Error: bar/)
+  assert.match(serialized.inner.stack, /err\.test\.js:/)
 })
 
-test('serializes error causes', function (t) {
-  t.plan(14)
+test('serializes error causes', () => {
   for (const cause of [
     Error('bar'),
     { message: 'bar', stack: 'Error: bar: err.test.js:' }
@@ -56,18 +52,17 @@ test('serializes error causes', function (t) {
     err.cause = cause
     err.cause.cause = Error('abc')
     const serialized = serializer(err)
-    t.equal(serialized.type, 'Error')
-    t.equal(serialized.message, 'foo: bar: abc')
-    t.match(serialized.stack, /err\.test\.js:/)
-    t.match(serialized.stack, /Error: foo/)
-    t.match(serialized.stack, /Error: bar/)
-    t.match(serialized.stack, /Error: abc/)
-    t.notOk(serialized.cause)
+    assert.strictEqual(serialized.type, 'Error')
+    assert.strictEqual(serialized.message, 'foo: bar: abc')
+    assert.match(serialized.stack, /err\.test\.js:/)
+    assert.match(serialized.stack, /Error: foo/)
+    assert.match(serialized.stack, /Error: bar/)
+    assert.match(serialized.stack, /Error: abc/)
+    assert.ok(!serialized.cause)
   }
 })
 
 test('serializes error causes with VError support', function (t) {
-  t.plan(6)
   // Fake VError-style setup
   const err = Error('foo: bar')
   err.foo = 'abc'
@@ -77,37 +72,34 @@ test('serializes error causes with VError support', function (t) {
     return err
   }
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo: bar: abc')
-  t.match(serialized.stack, /err\.test\.js:/)
-  t.match(serialized.stack, /Error: foo/)
-  t.match(serialized.stack, /Error: bar/)
-  t.match(serialized.stack, /Error: abc/)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo: bar: abc')
+  assert.match(serialized.stack, /err\.test\.js:/)
+  assert.match(serialized.stack, /Error: foo/)
+  assert.match(serialized.stack, /Error: bar/)
+  assert.match(serialized.stack, /Error: abc/)
 })
 
-test('keeps non-error cause', function (t) {
-  t.plan(3)
+test('keeps non-error cause', () => {
   const err = Error('foo')
   err.cause = 'abc'
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.equal(serialized.cause, 'abc')
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.strictEqual(serialized.cause, 'abc')
 })
 
-test('prevents infinite recursion', function (t) {
-  t.plan(4)
+test('prevents infinite recursion', () => {
   const err = Error('foo')
   err.inner = err
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err\.test\.js:/)
-  t.notOk(serialized.inner)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err\.test\.js:/)
+  assert.ok(!serialized.inner)
 })
 
-test('cleans up infinite recursion tracking', function (t) {
-  t.plan(8)
+test('cleans up infinite recursion tracking', () => {
   const err = Error('foo')
   const bar = Error('bar')
   err.inner = bar
@@ -116,29 +108,26 @@ test('cleans up infinite recursion tracking', function (t) {
   serializer(err)
   const serialized = serializer(err)
 
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err\.test\.js:/)
-  t.ok(serialized.inner)
-  t.equal(serialized.inner.type, 'Error')
-  t.equal(serialized.inner.message, 'bar')
-  t.match(serialized.inner.stack, /Error: bar/)
-  t.notOk(serialized.inner.inner)
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err\.test\.js:/)
+  assert.ok(serialized.inner)
+  assert.strictEqual(serialized.inner.type, 'Error')
+  assert.strictEqual(serialized.inner.message, 'bar')
+  assert.match(serialized.inner.stack, /Error: bar/)
+  assert.ok(!serialized.inner.inner)
 })
 
-test('err.raw is available', function (t) {
-  t.plan(1)
+test('err.raw is available', () => {
   const err = Error('foo')
   const serialized = serializer(err)
-  t.equal(serialized.raw, err)
+  assert.strictEqual(serialized.raw, err)
 })
 
-test('redefined err.constructor doesnt crash serializer', function (t) {
-  t.plan(10)
-
+test('redefined err.constructor doesnt crash serializer', () => {
   function check (a, name) {
-    t.equal(a.type, name)
-    t.equal(a.message, 'foo')
+    assert.strictEqual(a.type, name)
+    assert.strictEqual(a.message, 'foo')
   }
 
   const err1 = TypeError('foo')
@@ -166,11 +155,9 @@ test('redefined err.constructor doesnt crash serializer', function (t) {
   check(serializer(err5), 'Error')
 })
 
-test('pass through anything that does not look like an Error', function (t) {
-  t.plan(3)
-
+test('pass through anything that does not look like an Error', () => {
   function check (a) {
-    t.equal(serializer(a), a)
+    assert.strictEqual(serializer(a), a)
   }
 
   check('foo')
@@ -178,8 +165,7 @@ test('pass through anything that does not look like an Error', function (t) {
   check([1, 2])
 })
 
-test('can wrap err serializers', function (t) {
-  t.plan(5)
+test('can wrap err serializers', () => {
   const err = Error('foo')
   err.foo = 'foo'
   const serializer = wrapErrorSerializer(function (err) {
@@ -188,15 +174,14 @@ test('can wrap err serializers', function (t) {
     return err
   })
   const serialized = serializer(err)
-  t.equal(serialized.type, 'Error')
-  t.equal(serialized.message, 'foo')
-  t.match(serialized.stack, /err\.test\.js:/)
-  t.notOk(serialized.foo)
-  t.equal(serialized.bar, 'bar')
+  assert.strictEqual(serialized.type, 'Error')
+  assert.strictEqual(serialized.message, 'foo')
+  assert.match(serialized.stack, /err\.test\.js:/)
+  assert.ok(!serialized.foo)
+  assert.strictEqual(serialized.bar, 'bar')
 })
 
-test('serializes aggregate errors', { skip: !global.AggregateError }, function (t) {
-  t.plan(14)
+test('serializes aggregate errors', { skip: !global.AggregateError }, () => {
   const foo = new Error('foo')
   const bar = new Error('bar')
   for (const aggregate of [
@@ -204,12 +189,12 @@ test('serializes aggregate errors', { skip: !global.AggregateError }, function (
     { errors: [foo, bar], message: 'aggregated message', stack: 'err.test.js:' }
   ]) {
     const serialized = serializer(aggregate)
-    t.equal(serialized.message, 'aggregated message')
-    t.equal(serialized.aggregateErrors.length, 2)
-    t.equal(serialized.aggregateErrors[0].message, 'foo')
-    t.equal(serialized.aggregateErrors[1].message, 'bar')
-    t.match(serialized.aggregateErrors[0].stack, /^Error: foo/)
-    t.match(serialized.aggregateErrors[1].stack, /^Error: bar/)
-    t.match(serialized.stack, /err\.test\.js:/)
+    assert.strictEqual(serialized.message, 'aggregated message')
+    assert.strictEqual(serialized.aggregateErrors.length, 2)
+    assert.strictEqual(serialized.aggregateErrors[0].message, 'foo')
+    assert.strictEqual(serialized.aggregateErrors[1].message, 'bar')
+    assert.match(serialized.aggregateErrors[0].stack, /^Error: foo/)
+    assert.match(serialized.aggregateErrors[1].stack, /^Error: bar/)
+    assert.match(serialized.stack, /err\.test\.js:/)
   }
 })