@zuplo/cli 7.0.2 → 7.1.0

package/node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.test.js

@@ -1,67 +1,65 @@
 'use strict'
 
-const tap = require('tap')
-const rimraf = require('rimraf')
-const fs = require('fs')
-const { join } = require('path')
+const { test } = require('node:test')
+const { rimraf } = require('rimraf')
+const fs = require('node:fs')
+const { join } = require('node:path')
 
 const buildSafeSonicBoom = require('./build-safe-sonic-boom')
 
-function noop () {}
-
 const file = () => {
   const dest = join(__dirname, `${process.pid}-${process.hrtime().toString()}`)
   const fd = fs.openSync(dest, 'w')
   return { dest, fd }
 }
 
-tap.test('should not write when error emitted and code is "EPIPE"', async t => {
+test('should not write when error emitted and code is "EPIPE"', t => {
   t.plan(1)
 
   const { fd, dest } = file()
   const stream = buildSafeSonicBoom({ sync: true, fd, mkdir: true })
-  t.teardown(() => rimraf(dest, noop))
+  t.after(() => rimraf(dest))
 
   stream.emit('error', { code: 'EPIPE' })
   stream.write('will not work')
 
   const dataFile = fs.readFileSync(dest)
-  t.equal(dataFile.length, 0)
+  t.assert.strictEqual(dataFile.length, 0)
 })
 
-tap.test('should stream.write works when error code is not "EPIPE"', async t => {
+test('should stream.write works when error code is not "EPIPE"', t => {
   t.plan(3)
   const { fd, dest } = file()
   const stream = buildSafeSonicBoom({ sync: true, fd, mkdir: true })
 
-  t.teardown(() => rimraf(dest, noop))
+  t.after(() => rimraf(dest))
 
-  stream.on('error', () => t.pass('error emitted'))
+  stream.on('error', () => t.assert.ok('error emitted'))
 
   stream.emit('error', 'fake error description')
 
-  t.ok(stream.write('will work'))
+  t.assert.ok(stream.write('will work'))
 
   const dataFile = fs.readFileSync(dest)
-  t.equal(dataFile.toString(), 'will work')
+  t.assert.strictEqual(dataFile.toString(), 'will work')
 })
 
-tap.test('cover setupOnExit', async t => {
+test('cover setupOnExit', async t => {
   t.plan(3)
   const { fd, dest } = file()
   const stream = buildSafeSonicBoom({ sync: false, fd, mkdir: true })
 
-  t.teardown(() => rimraf(dest, noop))
+  t.after(() => rimraf(dest))
 
-  stream.on('error', () => t.pass('error emitted'))
+  stream.on('error', () => t.assert.ok('error emitted'))
   stream.emit('error', 'fake error description')
 
-  t.ok(stream.write('will work'))
+  t.assert.ok(stream.write('will work'))
 
   await watchFileCreated(dest)
 
   const dataFile = fs.readFileSync(dest)
-  t.equal(dataFile.toString(), 'will work')
+  t.assert.strictEqual(dataFile.toString(), 'will work')
 })
 
 function watchFileCreated (filename) {

package/node_modules/pino-pretty/lib/utils/create-date.test.js

@@ -1,20 +1,20 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const createDate = require('./create-date')
 
 const wanted = 1624450038567
 
-tap.test('accepts arguments the Date constructor would accept', async t => {
+test('accepts arguments the Date constructor would accept', t => {
   t.plan(2)
-  t.same(createDate(1624450038567).getTime(), wanted)
-  t.same(createDate('2021-06-23T12:07:18.567Z').getTime(), wanted)
+  t.assert.strictEqual(createDate(1624450038567).getTime(), wanted)
+  t.assert.strictEqual(createDate('2021-06-23T12:07:18.567Z').getTime(), wanted)
 })
 
-tap.test('accepts epoch as a string', async t => {
+test('accepts epoch as a string', t => {
   // If Date() accepts this argument, the createDate function is not needed
   // and can be replaced with Date()
   t.plan(2)
-  t.notSame(new Date('16244500385-67').getTime(), wanted)
-  t.same(createDate('1624450038567').getTime(), wanted)
+  t.assert.notEqual(new Date('16244500385-67').getTime(), wanted)
+  t.assert.strictEqual(createDate('1624450038567').getTime(), wanted)
 })

package/node_modules/pino-pretty/lib/utils/delete-log-property.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const { createCopier } = require('fast-copy')
 const fastCopy = createCopier({})
 const deleteLogProperty = require('./delete-log-property')
@@ -12,20 +12,20 @@ const logData = {
   }
 }
 
-tap.test('deleteLogProperty deletes property of depth 1', async t => {
+test('deleteLogProperty deletes property of depth 1', t => {
   const log = fastCopy(logData)
   deleteLogProperty(log, 'data1')
-  t.same(log, { level: 30 })
+  t.assert.deepStrictEqual(log, { level: 30 })
 })
 
-tap.test('deleteLogProperty deletes property of depth 2', async t => {
+test('deleteLogProperty deletes property of depth 2', t => {
   const log = fastCopy(logData)
   deleteLogProperty(log, 'data1.data2')
-  t.same(log, { level: 30, data1: { } })
+  t.assert.deepStrictEqual(log, { level: 30, data1: { } })
 })
 
-tap.test('deleteLogProperty deletes property of depth 3', async t => {
+test('deleteLogProperty deletes property of depth 3', t => {
   const log = fastCopy(logData)
   deleteLogProperty(log, 'data1.data2.data-3')
-  t.same(log, { level: 30, data1: { data2: { } } })
+  t.assert.deepStrictEqual(log, { level: 30, data1: { data2: { } } })
 })

package/node_modules/pino-pretty/lib/utils/filter-log.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const tap = require('tap')
+const { describe, test } = require('node:test')
 const filterLog = require('./filter-log')
 
 const context = {
@@ -22,8 +22,8 @@ const logData2 = Object.assign({
   }
 }, logData)
 
-tap.test('#filterLog with an ignoreKeys option', t => {
-  t.test('filterLog removes single entry', async t => {
+describe('#filterLog with an ignoreKeys option', () => {
+  test('filterLog removes single entry', t => {
     const result = filterLog({
       log: logData,
       context: {
@@ -31,10 +31,10 @@ tap.test('#filterLog with an ignoreKeys option', t => {
         ignoreKeys: ['data1.data2.data-3']
       }
     })
-    t.same(result, { level: 30, time: 1522431328992, data1: { data2: { }, error: new Error('test') } })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992, data1: { data2: { }, error: new Error('test') } })
   })
 
-  t.test('filterLog removes multiple entries', async t => {
+  test('filterLog removes multiple entries', t => {
     const result = filterLog({
       log: logData,
       context: {
@@ -42,10 +42,10 @@ tap.test('#filterLog with an ignoreKeys option', t => {
         ignoreKeys: ['time', 'data1']
       }
     })
-    t.same(result, { level: 30 })
+    t.assert.deepStrictEqual(result, { level: 30 })
   })
 
-  t.test('filterLog keeps error instance', async t => {
+  test('filterLog keeps error instance', t => {
     const result = filterLog({
       log: logData,
       context: {
@@ -53,10 +53,10 @@ tap.test('#filterLog with an ignoreKeys option', t => {
         ignoreKeys: []
       }
     })
-    t.equal(logData.data1.error, result.data1.error)
+    t.assert.strictEqual(logData.data1.error, result.data1.error)
   })
 
-  t.test('filterLog removes entry with escape sequence', async t => {
+  test('filterLog removes entry with escape sequence', t => {
     const result = filterLog({
       log: logData2,
       context: {
@@ -64,10 +64,10 @@ tap.test('#filterLog with an ignoreKeys option', t => {
         ignoreKeys: ['data1', 'logging\\.domain\\.corp/operation']
       }
     })
-    t.same(result, { level: 30, time: 1522431328992 })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992 })
   })
 
-  t.test('filterLog removes entry with escape sequence nested', async t => {
+  test('filterLog removes entry with escape sequence nested', t => {
     const result = filterLog({
       log: logData2,
       context: {
@@ -75,20 +75,17 @@ tap.test('#filterLog with an ignoreKeys option', t => {
         ignoreKeys: ['data1', 'logging\\.domain\\.corp/operation.producer']
       }
     })
-    t.same(result, { level: 30, time: 1522431328992, 'logging.domain.corp/operation': { id: 'foo' } })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992, 'logging.domain.corp/operation': { id: 'foo' } })
   })
-
-  t.end()
 })
 
-const ignoreKeysArray = [
+for (const ignoreKeys of [
   undefined,
   ['level'],
   ['level', 'data1.data2.data-3']
-]
-ignoreKeysArray.forEach(ignoreKeys => {
-  tap.test(`#filterLog with an includeKeys option when the ignoreKeys being ${ignoreKeys}`, t => {
-    t.test('filterLog include nothing', async t => {
+]) {
+  describe(`#filterLog with an includeKeys option when the ignoreKeys being ${ignoreKeys}`, () => {
+    test('filterLog include nothing', t => {
       const result = filterLog({
         log: logData,
         context: {
@@ -97,10 +94,10 @@ ignoreKeysArray.forEach(ignoreKeys => {
           includeKeys: []
         }
       })
-      t.same(result, {})
+      t.assert.deepStrictEqual(result, {})
     })
 
-    t.test('filterLog include single entry', async t => {
+    test('filterLog include single entry', t => {
       const result = filterLog({
         log: logData,
         context: {
@@ -109,10 +106,10 @@ ignoreKeysArray.forEach(ignoreKeys => {
           includeKeys: ['time']
         }
       })
-      t.same(result, { time: 1522431328992 })
+      t.assert.deepStrictEqual(result, { time: 1522431328992 })
     })
 
-    t.test('filterLog include multiple entries', async t => {
+    test('filterLog include multiple entries', t => {
       const result = filterLog({
         log: logData,
         context: {
@@ -121,7 +118,7 @@ ignoreKeysArray.forEach(ignoreKeys => {
           includeKeys: ['time', 'data1']
         }
       })
-      t.same(result, {
+      t.assert.deepStrictEqual(result, {
         time: 1522431328992,
         data1: {
           data2: { 'data-3': 'bar' },
@@ -129,12 +126,10 @@ ignoreKeysArray.forEach(ignoreKeys => {
         }
       })
     })
-
-    t.end()
   })
-})
+}
 
-tap.test('#filterLog with circular references', t => {
+describe('#filterLog with circular references', () => {
   const logData = {
     level: 30,
     time: 1522431328992,
@@ -142,7 +137,7 @@ tap.test('#filterLog with circular references', t => {
   }
   logData.circular = logData
 
-  t.test('filterLog removes single entry', async t => {
+  test('filterLog removes single entry', t => {
     const result = filterLog({
       log: logData,
       context: {
@@ -151,14 +146,14 @@ tap.test('#filterLog with circular references', t => {
       }
     })
 
-    t.same(result.circular.level, result.level)
-    t.same(result.circular.time, result.time)
+    t.assert.deepStrictEqual(result.circular.level, result.level)
+    t.assert.deepStrictEqual(result.circular.time, result.time)
 
     delete result.circular
-    t.same(result, { level: 30, time: 1522431328992 })
+    t.assert.deepStrictEqual(result, { level: 30, time: 1522431328992 })
   })
 
-  t.test('filterLog includes single entry', async t => {
+  test('filterLog includes single entry', t => {
     const result = filterLog({
       log: logData,
       context: {
@@ -167,10 +162,10 @@ tap.test('#filterLog with circular references', t => {
       }
     })
 
-    t.same(result, { data1: 'test' })
+    t.assert.deepStrictEqual(result, { data1: 'test' })
   })
 
-  t.test('filterLog includes circular keys', async t => {
+  test('filterLog includes circular keys', t => {
     const result = filterLog({
       log: logData,
       context: {
@@ -179,12 +174,10 @@ tap.test('#filterLog with circular references', t => {
       }
     })
 
-    t.same(result.circular.level, logData.level)
-    t.same(result.circular.time, logData.time)
+    t.assert.deepStrictEqual(result.circular.level, logData.level)
+    t.assert.deepStrictEqual(result.circular.time, logData.time)
 
     delete result.circular
-    t.same(result, { level: 30 })
+    t.assert.deepStrictEqual(result, { level: 30 })
   })
-
-  t.end()
 })

package/node_modules/pino-pretty/lib/utils/format-time.js

@@ -18,7 +18,7 @@ const isValidDate = require('./is-valid-date')
  * valid for `new Date()`.
  * @param {boolean|string} [translateTime=false] When `false`, the given `epoch`
  * will simply be returned. When `true`, the given `epoch` will be converted
- * to a string at UTC using the `DATE_FORMAT` constant. If `translateTime` is
+ * to a string at UTC using the `DATE_FORMAT_SIMPLE` constant. If `translateTime` is
  * a string, the following rules are available:
  *
  * - `<format string>`: The string is a literal format string. This format

package/node_modules/pino-pretty/lib/utils/format-time.test.js

@@ -2,70 +2,70 @@
 
 process.env.TZ = 'UTC'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const formatTime = require('./format-time')
 
 const dateStr = '2019-04-06T13:30:00.000-04:00'
 const epoch = new Date(dateStr)
 const epochMS = epoch.getTime()
 
-tap.test('passes through epoch if `translateTime` is `false`', async t => {
+test('passes through epoch if `translateTime` is `false`', t => {
   const formattedTime = formatTime(epochMS)
-  t.equal(formattedTime, epochMS)
+  t.assert.strictEqual(formattedTime, epochMS)
 })
 
-tap.test('passes through epoch if date is invalid', async t => {
+test('passes through epoch if date is invalid', t => {
   const input = 'this is not a date'
   const formattedTime = formatTime(input, true)
-  t.equal(formattedTime, input)
+  t.assert.strictEqual(formattedTime, input)
 })
 
-tap.test('translates epoch milliseconds if `translateTime` is `true`', async t => {
+test('translates epoch milliseconds if `translateTime` is `true`', t => {
   const formattedTime = formatTime(epochMS, true)
-  t.equal(formattedTime, '17:30:00.000')
+  t.assert.strictEqual(formattedTime, '17:30:00.000')
 })
 
-tap.test('translates epoch milliseconds to UTC string given format', async t => {
+test('translates epoch milliseconds to UTC string given format', t => {
   const formattedTime = formatTime(epochMS, 'd mmm yyyy H:MM')
-  t.equal(formattedTime, '6 Apr 2019 17:30')
+  t.assert.strictEqual(formattedTime, '6 Apr 2019 17:30')
 })
 
-tap.test('translates epoch milliseconds to SYS:STANDARD', async t => {
+test('translates epoch milliseconds to SYS:STANDARD', t => {
   const formattedTime = formatTime(epochMS, 'SYS:STANDARD')
-  t.match(formattedTime, /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [-+]?\d{4}/)
+  t.assert.match(formattedTime, /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [-+]?\d{4}/)
 })
 
-tap.test('translates epoch milliseconds to SYS:<FORMAT>', async t => {
+test('translates epoch milliseconds to SYS:<FORMAT>', t => {
   const formattedTime = formatTime(epochMS, 'SYS:d mmm yyyy H:MM')
-  t.match(formattedTime, /\d{1} \w{3} \d{4} \d{1,2}:\d{2}/)
+  t.assert.match(formattedTime, /\d{1} \w{3} \d{4} \d{1,2}:\d{2}/)
 })
 
-tap.test('passes through date string if `translateTime` is `false`', async t => {
+test('passes through date string if `translateTime` is `false`', t => {
   const formattedTime = formatTime(dateStr)
-  t.equal(formattedTime, dateStr)
+  t.assert.strictEqual(formattedTime, dateStr)
 })
 
-tap.test('translates date string if `translateTime` is `true`', async t => {
+test('translates date string if `translateTime` is `true`', t => {
   const formattedTime = formatTime(dateStr, true)
-  t.equal(formattedTime, '17:30:00.000')
+  t.assert.strictEqual(formattedTime, '17:30:00.000')
 })
 
-tap.test('translates date string to UTC string given format', async t => {
+test('translates date string to UTC string given format', t => {
   const formattedTime = formatTime(dateStr, 'd mmm yyyy H:MM')
-  t.equal(formattedTime, '6 Apr 2019 17:30')
+  t.assert.strictEqual(formattedTime, '6 Apr 2019 17:30')
 })
 
-tap.test('translates date string to SYS:STANDARD', async t => {
+test('translates date string to SYS:STANDARD', t => {
   const formattedTime = formatTime(dateStr, 'SYS:STANDARD')
-  t.match(formattedTime, /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [-+]?\d{4}/)
+  t.assert.match(formattedTime, /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [-+]?\d{4}/)
 })
 
-tap.test('translates date string to UTC:<FORMAT>', async t => {
+test('translates date string to UTC:<FORMAT>', t => {
   const formattedTime = formatTime(dateStr, 'UTC:d mmm yyyy H:MM')
-  t.equal(formattedTime, '6 Apr 2019 17:30')
+  t.assert.strictEqual(formattedTime, '6 Apr 2019 17:30')
 })
 
-tap.test('translates date string to SYS:<FORMAT>', async t => {
+test('translates date string to SYS:<FORMAT>', t => {
   const formattedTime = formatTime(dateStr, 'SYS:d mmm yyyy H:MM')
-  t.match(formattedTime, /\d{1} \w{3} \d{4} \d{1,2}:\d{2}/)
+  t.assert.match(formattedTime, /\d{1} \w{3} \d{4} \d{1,2}:\d{2}/)
 })

package/node_modules/pino-pretty/lib/utils/get-property-value.test.js

@@ -1,31 +1,31 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const getPropertyValue = require('./get-property-value')
 
-tap.test('getPropertyValue returns the value of the property', async t => {
+test('getPropertyValue returns the value of the property', t => {
   const result = getPropertyValue({
     foo: 'bar'
   }, 'foo')
-  t.same(result, 'bar')
+  t.assert.strictEqual(result, 'bar')
 })
 
-tap.test('getPropertyValue returns the value of the nested property', async t => {
+test('getPropertyValue returns the value of the nested property', t => {
   const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, 'extra.foo.value')
-  t.same(result, 'bar')
+  t.assert.strictEqual(result, 'bar')
 })
 
-tap.test('getPropertyValue returns the value of the nested property using the array of nested property keys', async t => {
+test('getPropertyValue returns the value of the nested property using the array of nested property keys', t => {
   const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, ['extra', 'foo', 'value'])
-  t.same(result, 'bar')
+  t.assert.strictEqual(result, 'bar')
 })
 
-tap.test('getPropertyValue returns undefined for non-existing properties', async t => {
+test('getPropertyValue returns undefined for non-existing properties', t => {
   const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, 'extra.foo.value-2')
-  t.same(result, undefined)
+  t.assert.strictEqual(result, undefined)
 })
 
-tap.test('getPropertyValue returns undefined for non-existing properties using the array of nested property keys', async t => {
+test('getPropertyValue returns undefined for non-existing properties using the array of nested property keys', t => {
   const result = getPropertyValue({ extra: { foo: { value: 'bar' } } }, ['extra', 'foo', 'value-2'])
-  t.same(result, undefined)
+  t.assert.strictEqual(result, undefined)
 })

package/node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.test.js

@@ -1,44 +1,45 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
+const match = require('@jsumners/assert-match')
 const handleCustomLevelsNamesOpts = require('./handle-custom-levels-names-opts')
 
-tap.test('returns a empty object `{}` for undefined parameter', async t => {
+test('returns a empty object `{}` for undefined parameter', t => {
   const handledCustomLevelNames = handleCustomLevelsNamesOpts()
-  t.same(handledCustomLevelNames, {})
+  t.assert.deepStrictEqual(handledCustomLevelNames, {})
 })
 
-tap.test('returns a empty object `{}` for unknown parameter', async t => {
+test('returns a empty object `{}` for unknown parameter', t => {
   const handledCustomLevelNames = handleCustomLevelsNamesOpts(123)
-  t.same(handledCustomLevelNames, {})
+  t.assert.deepStrictEqual(handledCustomLevelNames, {})
 })
 
-tap.test('returns a filled object for string parameter', async t => {
+test('returns a filled object for string parameter', t => {
   const handledCustomLevelNames = handleCustomLevelsNamesOpts('ok:10,warn:20,error:35')
-  t.same(handledCustomLevelNames, {
+  match(handledCustomLevelNames, {
     ok: 10,
     warn: 20,
     error: 35
-  })
+  }, t)
 })
 
-tap.test('returns a filled object for object parameter', async t => {
+test('returns a filled object for object parameter', t => {
   const handledCustomLevelNames = handleCustomLevelsNamesOpts({
     ok: 10,
     warn: 20,
     error: 35
   })
-  t.same(handledCustomLevelNames, {
+  match(handledCustomLevelNames, {
     ok: 10,
     warn: 20,
     error: 35
-  })
+  }, t)
 })
 
-tap.test('defaults missing level num to first index', async t => {
+test('defaults missing level num to first index', t => {
   const result = handleCustomLevelsNamesOpts('ok:10,info')
-  t.same(result, {
+  match(result, {
     ok: 10,
     info: 1
-  })
+  }, t)
 })

package/node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.test.js

@@ -1,21 +1,21 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const handleCustomLevelsOpts = require('./handle-custom-levels-opts')
 
-tap.test('returns a empty object `{}` for undefined parameter', async t => {
+test('returns a empty object `{}` for undefined parameter', t => {
   const handledCustomLevel = handleCustomLevelsOpts()
-  t.same(handledCustomLevel, {})
+  t.assert.deepStrictEqual(handledCustomLevel, {})
 })
 
-tap.test('returns a empty object `{}` for unknown parameter', async t => {
+test('returns a empty object `{}` for unknown parameter', t => {
   const handledCustomLevel = handleCustomLevelsOpts(123)
-  t.same(handledCustomLevel, {})
+  t.assert.deepStrictEqual(handledCustomLevel, {})
 })
 
-tap.test('returns a filled object for string parameter', async t => {
+test('returns a filled object for string parameter', t => {
   const handledCustomLevel = handleCustomLevelsOpts('ok:10,warn:20,error:35')
-  t.same(handledCustomLevel, {
+  t.assert.deepStrictEqual(handledCustomLevel, {
     10: 'OK',
     20: 'WARN',
     35: 'ERROR',
@@ -23,13 +23,13 @@ tap.test('returns a filled object for string parameter', async t => {
   })
 })
 
-tap.test('returns a filled object for object parameter', async t => {
+test('returns a filled object for object parameter', t => {
   const handledCustomLevel = handleCustomLevelsOpts({
     ok: 10,
     warn: 20,
     error: 35
   })
-  t.same(handledCustomLevel, {
+  t.assert.deepStrictEqual(handledCustomLevel, {
     10: 'OK',
     20: 'WARN',
     35: 'ERROR',
@@ -37,9 +37,9 @@ tap.test('returns a filled object for object parameter', async t => {
   })
 })
 
-tap.test('defaults missing level num to first index', async t => {
+test('defaults missing level num to first index', t => {
   const result = handleCustomLevelsOpts('ok:10,info')
-  t.same(result, {
+  t.assert.deepStrictEqual(result, {
     10: 'OK',
     1: 'INFO',
     default: 'USERLVL'

package/node_modules/pino-pretty/lib/utils/index.test.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const index = require('./index.js')
-const { readdirSync } = require('fs')
-const { basename } = require('path')
+const { readdirSync } = require('node:fs')
+const { basename } = require('node:path')
 
-tap.test(
+test(
   'index exports exactly all non-test files excluding itself',
-  async t => {
+  t => {
     // Read all files in the `util` directory
     const files = readdirSync(__dirname)
 
@@ -20,10 +20,10 @@ tap.test(
 
       if (file.endsWith('.test.js') === false && file !== 'index.js') {
         // We expect all files to be exported except…
-        t.ok(index[snakeName], `exports ${snakeName}`)
+        t.assert.ok(index[snakeName], `exports ${snakeName}`)
       } else {
         // …test files and the index file itself – those must not be exported
-        t.notOk(index[snakeName], `does not export ${snakeName}`)
+        t.assert.ok(!index[snakeName], `does not export ${snakeName}`)
       }
 
       // Remove the exported file from the index object
@@ -32,6 +32,6 @@ tap.test(
 
     // Now the index is expected to be empty, as nothing else should be
     // exported from it
-    t.same(index, {}, 'does not export anything else')
+    t.assert.deepStrictEqual(index, {}, 'does not export anything else')
   }
 )