@zuplo/cli 7.0.2 → 7.1.0

package/node_modules/pino-pretty/lib/utils/interpret-conditionals.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 interpretConditionals = require('./interpret-conditionals')
@@ -13,57 +13,57 @@ const logData = {
   msg: 'foo'
 }
 
-tap.test('interpretConditionals translates if / else statement to found property value', async t => {
+test('interpretConditionals translates if / else statement to found property value', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level} - {if data1.data2}{data1.data2}{end}', log), '{level} - bar')
+  t.assert.strictEqual(interpretConditionals('{level} - {if data1.data2}{data1.data2}{end}', log), '{level} - bar')
 })
 
-tap.test('interpretConditionals translates if / else statement to found property value and leave unmatched property key untouched', async t => {
+test('interpretConditionals translates if / else statement to found property value and leave unmatched property key untouched', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level} - {if data1.data2}{data1.data2} ({msg}){end}', log), '{level} - bar ({msg})')
+  t.assert.strictEqual(interpretConditionals('{level} - {if data1.data2}{data1.data2} ({msg}){end}', log), '{level} - bar ({msg})')
 })
 
-tap.test('interpretConditionals removes non-terminated if statements', async t => {
+test('interpretConditionals removes non-terminated if statements', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level} - {if data1.data2}{data1.data2}', log), '{level} - {data1.data2}')
+  t.assert.strictEqual(interpretConditionals('{level} - {if data1.data2}{data1.data2}', log), '{level} - {data1.data2}')
 })
 
-tap.test('interpretConditionals removes floating end statements', async t => {
+test('interpretConditionals removes floating end statements', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level} - {data1.data2}{end}', log), '{level} - {data1.data2}')
+  t.assert.strictEqual(interpretConditionals('{level} - {data1.data2}{end}', log), '{level} - {data1.data2}')
 })
 
-tap.test('interpretConditionals removes floating end statements within translated if / end statements', async t => {
+test('interpretConditionals removes floating end statements within translated if / end statements', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level} - {if msg}({msg}){end}{end}', log), '{level} - (foo)')
+  t.assert.strictEqual(interpretConditionals('{level} - {if msg}({msg}){end}{end}', log), '{level} - (foo)')
 })
 
-tap.test('interpretConditionals removes if / end blocks if existent condition key does not match existent property key', async t => {
+test('interpretConditionals removes if / end blocks if existent condition key does not match existent property key', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level}{if msg}{data1.data2}{end}', log), '{level}')
+  t.assert.strictEqual(interpretConditionals('{level}{if msg}{data1.data2}{end}', log), '{level}')
 })
 
-tap.test('interpretConditionals removes if / end blocks if non-existent condition key does not match existent property key', async t => {
+test('interpretConditionals removes if / end blocks if non-existent condition key does not match existent property key', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level}{if foo}{msg}{end}', log), '{level}')
+  t.assert.strictEqual(interpretConditionals('{level}{if foo}{msg}{end}', log), '{level}')
 })
 
-tap.test('interpretConditionals removes if / end blocks if existent condition key does not match non-existent property key', async t => {
+test('interpretConditionals removes if / end blocks if existent condition key does not match non-existent property key', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level}{if msg}{foo}{end}', log), '{level}')
+  t.assert.strictEqual(interpretConditionals('{level}{if msg}{foo}{end}', log), '{level}')
 })
 
-tap.test('interpretConditionals removes if / end blocks if non-existent condition key does not match non-existent property key', async t => {
+test('interpretConditionals removes if / end blocks if non-existent condition key does not match non-existent property key', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level}{if foo}{bar}{end}', log), '{level}')
+  t.assert.strictEqual(interpretConditionals('{level}{if foo}{bar}{end}', log), '{level}')
 })
 
-tap.test('interpretConditionals removes if / end blocks if nested condition key does not match property key', async t => {
+test('interpretConditionals removes if / end blocks if nested condition key does not match property key', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{level}{if data1.msg}{data1.data2}{end}', log), '{level}')
+  t.assert.strictEqual(interpretConditionals('{level}{if data1.msg}{data1.data2}{end}', log), '{level}')
 })
 
-tap.test('interpretConditionals removes nested if / end statement blocks', async t => {
+test('interpretConditionals removes nested if / end statement blocks', t => {
   const log = fastCopy(logData)
-  t.equal(interpretConditionals('{if msg}{if data1.data2}{msg}{data1.data2}{end}{end}', log), 'foo{data1.data2}')
+  t.assert.strictEqual(interpretConditionals('{if msg}{if data1.data2}{msg}{data1.data2}{end}{end}', log), 'foo{data1.data2}')
 })

package/node_modules/pino-pretty/lib/utils/is-object.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const isObject = require('./is-object')
 
-tap.test('returns correct answer', async t => {
-  t.equal(isObject({}), true)
-  t.equal(isObject([]), false)
-  t.equal(isObject(42), false)
+test('returns correct answer', t => {
+  t.assert.strictEqual(isObject({}), true)
+  t.assert.strictEqual(isObject([]), false)
+  t.assert.strictEqual(isObject(42), false)
 })

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

@@ -2,15 +2,15 @@
 
 process.env.TZ = 'UTC'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const isValidDate = require('./is-valid-date')
 
-tap.test('returns true for valid dates', async t => {
-  t.same(isValidDate(new Date()), true)
+test('returns true for valid dates', t => {
+  t.assert.strictEqual(isValidDate(new Date()), true)
 })
 
-tap.test('returns false for non-dates and invalid dates', async t => {
+test('returns false for non-dates and invalid dates', t => {
   t.plan(2)
-  t.same(isValidDate('20210621'), false)
-  t.same(isValidDate(new Date('2021-41-99')), false)
+  t.assert.strictEqual(isValidDate('20210621'), false)
+  t.assert.strictEqual(isValidDate(new Date('2021-41-99')), false)
 })

package/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.test.js

@@ -1,16 +1,16 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const joinLinesWithIndentation = require('./join-lines-with-indentation')
 
-tap.test('joinLinesWithIndentation adds indentation to beginning of subsequent lines', async t => {
+test('joinLinesWithIndentation adds indentation to beginning of subsequent lines', t => {
   const input = 'foo\nbar\nbaz'
   const result = joinLinesWithIndentation({ input })
-  t.equal(result, 'foo\n    bar\n    baz')
+  t.assert.strictEqual(result, 'foo\n    bar\n    baz')
 })
 
-tap.test('joinLinesWithIndentation accepts custom indentation, line breaks, and eol', async t => {
+test('joinLinesWithIndentation accepts custom indentation, line breaks, and eol', t => {
   const input = 'foo\nbar\r\nbaz'
   const result = joinLinesWithIndentation({ input, ident: '  ', eol: '^' })
-  t.equal(result, 'foo^  bar^  baz')
+  t.assert.strictEqual(result, 'foo^  bar^  baz')
 })

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

@@ -1,12 +1,12 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const noop = require('./noop')
 
-tap.test('is a function', async t => {
-  t.type(noop, Function)
+test('is a function', t => {
+  t.assert.strictEqual(typeof noop, 'function')
 })
 
-tap.test('does nothing', async t => {
-  t.equal(noop('stuff'), undefined)
+test('does nothing', t => {
+  t.assert.strictEqual(noop('stuff'), undefined)
 })

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

@@ -1,7 +1,8 @@
 'use strict'
 
-const tap = require('tap')
+const { test, describe } = require('node:test')
 const prettifyErrorLog = require('./prettify-error-log')
+const colors = require('../colors')
 const {
   ERROR_LIKE_KEYS,
   MESSAGE_KEY
@@ -13,16 +14,17 @@ const context = {
   customPrettifiers: {},
   errorLikeObjectKeys: ERROR_LIKE_KEYS,
   errorProps: [],
-  messageKey: MESSAGE_KEY
+  messageKey: MESSAGE_KEY,
+  objectColorizer: colors()
 }
 
-tap.test('returns string with default settings', async t => {
+test('returns string with default settings', t => {
   const err = Error('Something went wrong')
   const str = prettifyErrorLog({ log: err, context })
-  t.ok(str.startsWith('    Error: Something went wrong'))
+  t.assert.ok(str.startsWith('    Error: Something went wrong'))
 })
 
-tap.test('returns string with custom ident', async t => {
+test('returns string with custom ident', t => {
   const err = Error('Something went wrong')
   const str = prettifyErrorLog({
     log: err,
@@ -31,10 +33,10 @@ tap.test('returns string with custom ident', async t => {
       IDENT: '  '
     }
   })
-  t.ok(str.startsWith('  Error: Something went wrong'))
+  t.assert.ok(str.startsWith('  Error: Something went wrong'))
 })
 
-tap.test('returns string with custom eol', async t => {
+test('returns string with custom eol', t => {
   const err = Error('Something went wrong')
   const str = prettifyErrorLog({
     log: err,
@@ -43,11 +45,11 @@ tap.test('returns string with custom eol', async t => {
       EOL: '\r\n'
     }
   })
-  t.ok(str.startsWith('    Error: Something went wrong\r\n'))
+  t.assert.ok(str.startsWith('    Error: Something went wrong\r\n'))
 })
 
-tap.test('errorProperties', t => {
-  t.test('excludes all for wildcard', async t => {
+describe('errorProperties', () => {
+  test('excludes all for wildcard', t => {
     const err = Error('boom')
     err.foo = 'foo'
     const str = prettifyErrorLog({
@@ -57,11 +59,11 @@ tap.test('errorProperties', t => {
         errorProps: ['*']
       }
     })
-    t.ok(str.startsWith('    Error: boom'))
-    t.equal(str.includes('foo: "foo"'), false)
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: "foo"'), false)
   })
 
-  t.test('excludes only selected properties', async t => {
+  test('excludes only selected properties', t => {
     const err = Error('boom')
     err.foo = 'foo'
     const str = prettifyErrorLog({
@@ -71,11 +73,11 @@ tap.test('errorProperties', t => {
         errorProps: ['foo']
       }
     })
-    t.ok(str.startsWith('    Error: boom'))
-    t.equal(str.includes('foo: foo'), true)
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: foo'), true)
   })
 
-  t.test('ignores specified properties if not present', async t => {
+  test('ignores specified properties if not present', t => {
     const err = Error('boom')
     err.foo = 'foo'
     const str = prettifyErrorLog({
@@ -85,12 +87,12 @@ tap.test('errorProperties', t => {
         errorProps: ['foo', 'bar']
       }
     })
-    t.ok(str.startsWith('    Error: boom'))
-    t.equal(str.includes('foo: foo'), true)
-    t.equal(str.includes('bar'), false)
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: foo'), true)
+    t.assert.strictEqual(str.includes('bar'), false)
   })
 
-  t.test('processes nested objects', async t => {
+  test('processes nested objects', t => {
     const err = Error('boom')
     err.foo = { bar: 'bar', message: 'included' }
     const str = prettifyErrorLog({
@@ -100,11 +102,9 @@ tap.test('errorProperties', t => {
         errorProps: ['foo']
       }
     })
-    t.ok(str.startsWith('    Error: boom'))
-    t.equal(str.includes('foo: {'), true)
-    t.equal(str.includes('bar: "bar"'), true)
-    t.equal(str.includes('message: "included"'), true)
+    t.assert.ok(str.startsWith('    Error: boom'))
+    t.assert.strictEqual(str.includes('foo: {'), true)
+    t.assert.strictEqual(str.includes('bar: "bar"'), true)
+    t.assert.strictEqual(str.includes('message: "included"'), true)
   })
-
-  t.end()
 })

package/node_modules/pino-pretty/lib/utils/prettify-error.test.js

@@ -1,14 +1,13 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const stringifySafe = require('fast-safe-stringify')
 const prettifyError = require('./prettify-error')
 
-tap.test('prettifies error', t => {
+test('prettifies error', t => {
   const error = Error('Bad error!')
   const lines = stringifySafe(error, Object.getOwnPropertyNames(error), 2)
 
   const prettyError = prettifyError({ keyName: 'errorKey', lines, ident: '    ', eol: '\n' })
-  t.match(prettyError, /\s*errorKey: {\n\s*"stack":[\s\S]*"message": "Bad error!"/)
-  t.end()
+  t.assert.match(prettyError, /\s*errorKey: {\n\s*"stack":[\s\S]*"message": "Bad error!"/)
 })

package/node_modules/pino-pretty/lib/utils/prettify-level.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const prettifyLevel = require('./prettify-level')
 const getColorizer = require('../colors')
 const getLevelLabelData = require('./get-level-label-data')
@@ -17,17 +17,17 @@ const context = {
   getLevelLabelData: getLevelLabelData(false, {}, {})
 }
 
-tap.test('returns `undefined` for unknown level', async t => {
+test('returns `undefined` for unknown level', t => {
   const colorized = prettifyLevel({
     log: {},
     context: {
       ...context
     }
   })
-  t.equal(colorized, undefined)
+  t.assert.strictEqual(colorized, undefined)
 })
 
-tap.test('returns non-colorized value for default colorizer', async t => {
+test('returns non-colorized value for default colorizer', t => {
   const log = {
     level: 30
   }
@@ -37,10 +37,10 @@ tap.test('returns non-colorized value for default colorizer', async t => {
       ...context
     }
   })
-  t.equal(colorized, 'INFO')
+  t.assert.strictEqual(colorized, 'INFO')
 })
 
-tap.test('returns colorized value for color colorizer', async t => {
+test('returns colorized value for color colorizer', t => {
   const log = {
     level: 30
   }
@@ -52,10 +52,10 @@ tap.test('returns colorized value for color colorizer', async t => {
       colorizer
     }
   })
-  t.equal(colorized, '\u001B[32mINFO\u001B[39m')
+  t.assert.strictEqual(colorized, '\u001B[32mINFO\u001B[39m')
 })
 
-tap.test('passes output through provided prettifier', async t => {
+test('passes output through provided prettifier', t => {
   const log = {
     level: 30
   }
@@ -66,5 +66,5 @@ tap.test('passes output through provided prettifier', async t => {
       customPrettifiers: { level () { return 'modified' } }
     }
   })
-  t.equal(colorized, 'modified')
+  t.assert.strictEqual(colorized, 'modified')
 })

package/node_modules/pino-pretty/lib/utils/prettify-message.js

@@ -49,7 +49,8 @@ function prettifyMessage ({ log, context }) {
         }
 
         // Parse nested key access, e.g. `{keyA.subKeyB}`.
-        return getPropertyValue(log, p1) || ''
+        const value = getPropertyValue(log, p1)
+        return value !== undefined ? value : ''
       })
     return colorizer.message(message)
   }

package/node_modules/pino-pretty/lib/utils/prettify-message.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const prettifyMessage = require('./prettify-message')
 const getColorizer = require('../colors')
 const {
@@ -14,68 +14,68 @@ const context = {
   messageKey: 'msg'
 }
 
-tap.test('returns `undefined` if `messageKey` not found', async t => {
+test('returns `undefined` if `messageKey` not found', t => {
   const str = prettifyMessage({ log: {}, context })
-  t.equal(str, undefined)
+  t.assert.strictEqual(str, undefined)
 })
 
-tap.test('returns `undefined` if `messageKey` not string', async t => {
+test('returns `undefined` if `messageKey` not string', t => {
   const str = prettifyMessage({ log: { msg: {} }, context })
-  t.equal(str, undefined)
+  t.assert.strictEqual(str, undefined)
 })
 
-tap.test('returns non-colorized value for default colorizer', async t => {
+test('returns non-colorized value for default colorizer', t => {
   const colorizer = getColorizer()
   const str = prettifyMessage({
     log: { msg: 'foo' },
     context: { ...context, colorizer }
   })
-  t.equal(str, 'foo')
+  t.assert.strictEqual(str, 'foo')
 })
 
-tap.test('returns non-colorized value for alternate `messageKey`', async t => {
+test('returns non-colorized value for alternate `messageKey`', t => {
   const str = prettifyMessage({
     log: { message: 'foo' },
     context: { ...context, messageKey: 'message' }
   })
-  t.equal(str, 'foo')
+  t.assert.strictEqual(str, 'foo')
 })
 
-tap.test('returns colorized value for color colorizer', async t => {
+test('returns colorized value for color colorizer', t => {
   const colorizer = getColorizer(true)
   const str = prettifyMessage({
     log: { msg: 'foo' },
     context: { ...context, colorizer }
   })
-  t.equal(str, '\u001B[36mfoo\u001B[39m')
+  t.assert.strictEqual(str, '\u001B[36mfoo\u001B[39m')
 })
 
-tap.test('returns colorized value for color colorizer for alternate `messageKey`', async t => {
+test('returns colorized value for color colorizer for alternate `messageKey`', t => {
   const colorizer = getColorizer(true)
   const str = prettifyMessage({
     log: { message: 'foo' },
     context: { ...context, messageKey: 'message', colorizer }
   })
-  t.equal(str, '\u001B[36mfoo\u001B[39m')
+  t.assert.strictEqual(str, '\u001B[36mfoo\u001B[39m')
 })
 
-tap.test('returns message formatted by `messageFormat` option', async t => {
+test('returns message formatted by `messageFormat` option', t => {
   const str = prettifyMessage({
     log: { msg: 'foo', context: 'appModule' },
     context: { ...context, messageFormat: '{context} - {msg}' }
   })
-  t.equal(str, 'appModule - foo')
+  t.assert.strictEqual(str, 'appModule - foo')
 })
 
-tap.test('returns message formatted by `messageFormat` option - missing prop', async t => {
+test('returns message formatted by `messageFormat` option - missing prop', t => {
   const str = prettifyMessage({
     log: { context: 'appModule' },
     context: { ...context, messageFormat: '{context} - {msg}' }
   })
-  t.equal(str, 'appModule - ')
+  t.assert.strictEqual(str, 'appModule - ')
 })
 
-tap.test('returns message formatted by `messageFormat` option - levelLabel & useOnlyCustomProps false', async t => {
+test('returns message formatted by `messageFormat` option - levelLabel & useOnlyCustomProps false', t => {
   const str = prettifyMessage({
     log: { msg: 'foo', context: 'appModule', level: 30 },
     context: {
@@ -84,10 +84,10 @@ tap.test('returns message formatted by `messageFormat` option - levelLabel & use
       customLevels: {}
     }
   })
-  t.equal(str, '[30] INFO appModule - foo')
+  t.assert.strictEqual(str, '[30] INFO appModule - foo')
 })
 
-tap.test('returns message formatted by `messageFormat` option - levelLabel & useOnlyCustomProps true', async t => {
+test('returns message formatted by `messageFormat` option - levelLabel & useOnlyCustomProps true', t => {
   const str = prettifyMessage({
     log: { msg: 'foo', context: 'appModule', level: 30 },
     context: {
@@ -97,10 +97,10 @@ tap.test('returns message formatted by `messageFormat` option - levelLabel & use
       useOnlyCustomProps: true
     }
   })
-  t.equal(str, '[30] CHECK appModule - foo')
+  t.assert.strictEqual(str, '[30] CHECK appModule - foo')
 })
 
-tap.test('returns message formatted by `messageFormat` option - levelLabel & customLevels', async t => {
+test('returns message formatted by `messageFormat` option - levelLabel & customLevels', t => {
   const str = prettifyMessage({
     log: { msg: 'foo', context: 'appModule', level: 123 },
     context: {
@@ -109,10 +109,10 @@ tap.test('returns message formatted by `messageFormat` option - levelLabel & cus
       customLevels: { 123: 'CUSTOM' }
     }
   })
-  t.equal(str, '[123] CUSTOM appModule - foo')
+  t.assert.strictEqual(str, '[123] CUSTOM appModule - foo')
 })
 
-tap.test('returns message formatted by `messageFormat` option - levelLabel, customLevels & useOnlyCustomProps', async t => {
+test('returns message formatted by `messageFormat` option - levelLabel, customLevels & useOnlyCustomProps', t => {
   const str = prettifyMessage({
     log: { msg: 'foo', context: 'appModule', level: 123 },
     context: {
@@ -122,10 +122,10 @@ tap.test('returns message formatted by `messageFormat` option - levelLabel, cust
       useOnlyCustomProps: true
     }
   })
-  t.equal(str, '[123] CUSTOM appModule - foo')
+  t.assert.strictEqual(str, '[123] CUSTOM appModule - foo')
 })
 
-tap.test('returns message formatted by `messageFormat` option - levelLabel, customLevels & useOnlyCustomProps false', async t => {
+test('returns message formatted by `messageFormat` option - levelLabel, customLevels & useOnlyCustomProps false', t => {
   const str = prettifyMessage({
     log: { msg: 'foo', context: 'appModule', level: 40 },
     context: {
@@ -135,10 +135,42 @@ tap.test('returns message formatted by `messageFormat` option - levelLabel, cust
       useOnlyCustomProps: false
     }
   })
-  t.equal(str, '[40] WARN appModule - foo')
+  t.assert.strictEqual(str, '[40] WARN appModule - foo')
 })
 
-tap.test('`messageFormat` supports nested curly brackets', async t => {
+test('returns message formatted by `messageFormat` option - value 0', t => {
+  const str = prettifyMessage({
+    log: { value: 0 },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, '0')
+})
+
+test('returns message formatted by `messageFormat` option - value false', t => {
+  const str = prettifyMessage({
+    log: { value: false },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, 'false')
+})
+
+test('returns message formatted by `messageFormat` option - value undefined', t => {
+  const str = prettifyMessage({
+    log: { value: undefined },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, '')
+})
+
+test('returns message formatted by `messageFormat` option - value null', t => {
+  const str = prettifyMessage({
+    log: { value: null },
+    context: { ...context, messageFormat: '{value}' },
+  })
+  t.assert.strictEqual(str, 'null')
+})
+
+test('`messageFormat` supports nested curly brackets', t => {
   const str = prettifyMessage({
     log: { level: 30 },
     context: {
@@ -146,10 +178,10 @@ tap.test('`messageFormat` supports nested curly brackets', async t => {
       messageFormat: '{{level}}-{level}-{{level}-{level}}'
     }
   })
-  t.equal(str, '{30}-30-{30-30}')
+  t.assert.strictEqual(str, '{30}-30-{30-30}')
 })
 
-tap.test('`messageFormat` supports nested object', async t => {
+test('`messageFormat` supports nested object', t => {
   const str = prettifyMessage({
     log: { level: 30, request: { url: 'localhost/test' }, msg: 'foo' },
     context: {
@@ -157,10 +189,10 @@ tap.test('`messageFormat` supports nested object', async t => {
       messageFormat: '{request.url} - param: {request.params.process} - {msg}'
     }
   })
-  t.equal(str, 'localhost/test - param:  - foo')
+  t.assert.strictEqual(str, 'localhost/test - param:  - foo')
 })
 
-tap.test('`messageFormat` supports conditional blocks', async t => {
+test('`messageFormat` supports conditional blocks', t => {
   const str = prettifyMessage({
     log: { level: 30, req: { id: 'foo' } },
     context: {
@@ -168,10 +200,10 @@ tap.test('`messageFormat` supports conditional blocks', async t => {
       messageFormat: '{level} | {if req.id}({req.id}){end}{if msg}{msg}{end}'
     }
   })
-  t.equal(str, '30 | (foo)')
+  t.assert.strictEqual(str, '30 | (foo)')
 })
 
-tap.test('`messageFormat` supports function definition', async t => {
+test('`messageFormat` supports function definition', t => {
   const str = prettifyMessage({
     log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
     context: {
@@ -183,10 +215,10 @@ tap.test('`messageFormat` supports function definition', async t => {
       }
     }
   })
-  t.equal(str, '--> localhost/test')
+  t.assert.strictEqual(str, '--> localhost/test')
 })
 
-tap.test('`messageFormat` supports function definition with colorizer object', async t => {
+test('`messageFormat` supports function definition with colorizer object', t => {
   const colorizer = getColorizer(true)
   const str = prettifyMessage({
     log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
@@ -200,10 +232,10 @@ tap.test('`messageFormat` supports function definition with colorizer object', a
       }
     }
   })
-  t.equal(str, '\u001B[36m--> \u001B[31mlocalhost/test\u001B[36m\u001B[39m')
+  t.assert.strictEqual(str, '\u001B[36m--> \u001B[31mlocalhost/test\u001B[36m\u001B[39m')
 })
 
-tap.test('`messageFormat` supports function definition with colorizer object when using custom colors', async t => {
+test('`messageFormat` supports function definition with colorizer object when using custom colors', t => {
   const colorizer = getColorizer(true, [[30, 'brightGreen']], false)
   const str = prettifyMessage({
     log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
@@ -217,10 +249,10 @@ tap.test('`messageFormat` supports function definition with colorizer object whe
       }
     }
   })
-  t.equal(str, '\u001B[36m--> \u001B[31mlocalhost/test\u001B[36m\u001B[39m')
+  t.assert.strictEqual(str, '\u001B[36m--> \u001B[31mlocalhost/test\u001B[36m\u001B[39m')
 })
 
-tap.test('`messageFormat` supports function definition with colorizer object when no color is supported', async t => {
+test('`messageFormat` supports function definition with colorizer object when no color is supported', t => {
   const colorizer = getColorizer(false)
   const str = prettifyMessage({
     log: { level: 30, request: { url: 'localhost/test' }, msg: 'incoming request' },
@@ -234,5 +266,5 @@ tap.test('`messageFormat` supports function definition with colorizer object whe
       }
     }
   })
-  t.equal(str, '--> localhost/test')
+  t.assert.strictEqual(str, '--> localhost/test')
 })