fastify 5.3.0 → 5.3.2

package/test/logger/options.test.js

@@ -2,47 +2,45 @@
 
 const stream = require('node:stream')
 
-const t = require('tap')
+const t = require('node:test')
 const split = require('split2')
 const pino = require('pino')
 
 const Fastify = require('../../fastify')
 const { on } = stream
 
-t.test('logger options', (t) => {
-  t.setTimeout(60000)
-
+t.test('logger options', { timeout: 60000 }, async (t) => {
   t.plan(16)
 
-  t.test('logger can be silenced', (t) => {
+  await t.test('logger can be silenced', (t) => {
     t.plan(17)
     const fastify = Fastify({
       logger: false
     })
-    t.teardown(fastify.close.bind(fastify))
-    t.ok(fastify.log)
-    t.equal(typeof fastify.log, 'object')
-    t.equal(typeof fastify.log.fatal, 'function')
-    t.equal(typeof fastify.log.error, 'function')
-    t.equal(typeof fastify.log.warn, 'function')
-    t.equal(typeof fastify.log.info, 'function')
-    t.equal(typeof fastify.log.debug, 'function')
-    t.equal(typeof fastify.log.trace, 'function')
-    t.equal(typeof fastify.log.child, 'function')
+    t.after(() => fastify.close())
+    t.assert.ok(fastify.log)
+    t.assert.deepEqual(typeof fastify.log, 'object')
+    t.assert.deepEqual(typeof fastify.log.fatal, 'function')
+    t.assert.deepEqual(typeof fastify.log.error, 'function')
+    t.assert.deepEqual(typeof fastify.log.warn, 'function')
+    t.assert.deepEqual(typeof fastify.log.info, 'function')
+    t.assert.deepEqual(typeof fastify.log.debug, 'function')
+    t.assert.deepEqual(typeof fastify.log.trace, 'function')
+    t.assert.deepEqual(typeof fastify.log.child, 'function')
 
     const childLog = fastify.log.child()
 
-    t.equal(typeof childLog, 'object')
-    t.equal(typeof childLog.fatal, 'function')
-    t.equal(typeof childLog.error, 'function')
-    t.equal(typeof childLog.warn, 'function')
-    t.equal(typeof childLog.info, 'function')
-    t.equal(typeof childLog.debug, 'function')
-    t.equal(typeof childLog.trace, 'function')
-    t.equal(typeof childLog.child, 'function')
+    t.assert.deepEqual(typeof childLog, 'object')
+    t.assert.deepEqual(typeof childLog.fatal, 'function')
+    t.assert.deepEqual(typeof childLog.error, 'function')
+    t.assert.deepEqual(typeof childLog.warn, 'function')
+    t.assert.deepEqual(typeof childLog.info, 'function')
+    t.assert.deepEqual(typeof childLog.debug, 'function')
+    t.assert.deepEqual(typeof childLog.trace, 'function')
+    t.assert.deepEqual(typeof childLog.child, 'function')
   })
 
-  t.test('Should set a custom logLevel for a plugin', async (t) => {
+  await t.test('Should set a custom logLevel for a plugin', async (t) => {
     const lines = ['incoming request', 'Hello', 'request completed']
     t.plan(lines.length + 2)
 
@@ -53,7 +51,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', (req, reply) => {
       req.log.info('Not Exist') // we should not see this log
@@ -73,22 +71,22 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body.hello, 'world')
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/plugin' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body.hello, 'world')
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.same(line.msg, lines.shift())
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should set a custom logSerializers for a plugin', async (t) => {
+  await t.test('Should set a custom logSerializers for a plugin', async (t) => {
     const lines = ['incoming request', 'XHello', 'request completed']
     t.plan(lines.length + 1)
 
@@ -99,7 +97,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(function (instance, opts, done) {
       instance.get('/plugin', (req, reply) => {
@@ -114,17 +112,17 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/plugin' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body.hello, 'world')
     }
 
     for await (const [line] of on(stream, 'data')) {
       // either test or msg
-      t.equal(line.test || line.msg, lines.shift())
+      t.assert.deepEqual(line.test || line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should set a custom logLevel for every plugin', async (t) => {
+  await t.test('Should set a custom logLevel for every plugin', async (t) => {
     const lines = ['incoming request', 'info', 'request completed', 'incoming request', 'debug', 'request completed']
     t.plan(lines.length * 2 + 3)
 
@@ -135,7 +133,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', (req, reply) => {
       req.log.warn('Hello') // we should not see this log
@@ -165,29 +163,29 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/info' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/debug' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.ok(line.level === 30 || line.level === 20)
-      t.equal(line.msg, lines.shift())
+      t.assert.ok(line.level === 30 || line.level === 20)
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should set a custom logSerializers for every plugin', async (t) => {
+  await t.test('Should set a custom logSerializers for every plugin', async (t) => {
     const lines = ['incoming request', 'Hello', 'request completed', 'incoming request', 'XHello', 'request completed', 'incoming request', 'ZHello', 'request completed']
     t.plan(lines.length + 3)
 
@@ -197,7 +195,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', (req, reply) => {
       req.log.warn({ test: 'Hello' })
@@ -225,28 +223,28 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/test1' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/test2' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.test || line.msg, lines.shift())
+      t.assert.deepEqual(line.test || line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should override serializers from route', async (t) => {
+  await t.test('Should override serializers from route', async (t) => {
     const lines = ['incoming request', 'ZHello', 'request completed']
     t.plan(lines.length + 1)
 
@@ -256,7 +254,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(function (instance, opts, done) {
       instance.get('/', {
@@ -275,16 +273,16 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.test || line.msg, lines.shift())
+      t.assert.deepEqual(line.test || line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should override serializers from plugin', async (t) => {
+  await t.test('Should override serializers from plugin', async (t) => {
     const lines = ['incoming request', 'ZHello', 'request completed']
     t.plan(lines.length + 1)
 
@@ -294,7 +292,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(function (instance, opts, done) {
       instance.register(context1, {
@@ -318,16 +316,16 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.test || line.msg, lines.shift())
+      t.assert.deepEqual(line.test || line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should increase the log level for a specific plugin', async (t) => {
+  await t.test('Should increase the log level for a specific plugin', async (t) => {
     const lines = ['Hello']
     t.plan(lines.length * 2 + 1)
 
@@ -338,7 +336,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(function (instance, opts, done) {
       instance.get('/', (req, reply) => {
@@ -353,17 +351,17 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.level, 50)
-      t.equal(line.msg, lines.shift())
+      t.assert.deepEqual(line.level, 50)
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should set the log level for the customized 404 handler', async (t) => {
+  await t.test('Should set the log level for the customized 404 handler', async (t) => {
     const lines = ['Hello']
     t.plan(lines.length * 2 + 1)
 
@@ -374,7 +372,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(function (instance, opts, done) {
       instance.setNotFoundHandler(function (req, reply) {
@@ -388,17 +386,17 @@ t.test('logger options', (t) => {
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
-      t.equal(response.statusCode, 404)
+      t.assert.deepEqual(response.statusCode, 404)
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.level, 50)
-      t.equal(line.msg, lines.shift())
+      t.assert.deepEqual(line.level, 50)
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should set the log level for the customized 500 handler', async (t) => {
+  await t.test('Should set the log level for the customized 500 handler', async (t) => {
     const lines = ['Hello']
     t.plan(lines.length * 2 + 1)
 
@@ -409,7 +407,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(function (instance, opts, done) {
       instance.get('/', (req, reply) => {
@@ -428,17 +426,17 @@ t.test('logger options', (t) => {
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
-      t.equal(response.statusCode, 500)
+      t.assert.deepEqual(response.statusCode, 500)
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.level, 60)
-      t.equal(line.msg, lines.shift())
+      t.assert.deepEqual(line.level, 60)
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('Should set a custom log level for a specific route', async (t) => {
+  await t.test('Should set a custom log level for a specific route', async (t) => {
     const lines = ['incoming request', 'Hello', 'request completed']
     t.plan(lines.length + 2)
 
@@ -449,7 +447,7 @@ t.test('logger options', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/log', { logLevel: 'info' }, (req, reply) => {
       req.log.info('Hello')
@@ -466,39 +464,39 @@ t.test('logger options', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/log' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/no-log' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepEqual(body, { hello: 'world' })
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.msg, lines.shift())
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('should pass when using unWritable props in the logger option', (t) => {
+  await t.test('should pass when using unWritable props in the logger option', (t) => {
     t.plan(8)
     const fastify = Fastify({
       logger: Object.defineProperty({}, 'level', { value: 'info' })
     })
-    t.teardown(fastify.close.bind(fastify))
-
-    t.equal(typeof fastify.log, 'object')
-    t.equal(typeof fastify.log.fatal, 'function')
-    t.equal(typeof fastify.log.error, 'function')
-    t.equal(typeof fastify.log.warn, 'function')
-    t.equal(typeof fastify.log.info, 'function')
-    t.equal(typeof fastify.log.debug, 'function')
-    t.equal(typeof fastify.log.trace, 'function')
-    t.equal(typeof fastify.log.child, 'function')
+    t.after(() => fastify.close())
+
+    t.assert.deepEqual(typeof fastify.log, 'object')
+    t.assert.deepEqual(typeof fastify.log.fatal, 'function')
+    t.assert.deepEqual(typeof fastify.log.error, 'function')
+    t.assert.deepEqual(typeof fastify.log.warn, 'function')
+    t.assert.deepEqual(typeof fastify.log.info, 'function')
+    t.assert.deepEqual(typeof fastify.log.debug, 'function')
+    t.assert.deepEqual(typeof fastify.log.trace, 'function')
+    t.assert.deepEqual(typeof fastify.log.child, 'function')
   })
 
-  t.test('Should throw an error if logger instance is passed to `logger`', async (t) => {
+  await t.test('Should throw an error if logger instance is passed to `logger`', async (t) => {
     t.plan(2)
     const stream = split(JSON.parse)
 
@@ -507,22 +505,22 @@ t.test('logger options', (t) => {
     try {
       Fastify({ logger })
     } catch (err) {
-      t.ok(err)
-      t.equal(err.code, 'FST_ERR_LOG_INVALID_LOGGER_CONFIG')
+      t.assert.ok(err)
+      t.assert.deepEqual(err.code, 'FST_ERR_LOG_INVALID_LOGGER_CONFIG')
     }
   })
 
-  t.test('Should throw an error if options are passed to `loggerInstance`', async (t) => {
+  await t.test('Should throw an error if options are passed to `loggerInstance`', async (t) => {
     t.plan(2)
     try {
       Fastify({ loggerInstance: { level: 'log' } })
     } catch (err) {
-      t.ok(err)
-      t.equal(err.code, 'FST_ERR_LOG_INVALID_LOGGER_INSTANCE')
+      t.assert.ok(err)
+      t.assert.strictEqual(err.code, 'FST_ERR_LOG_INVALID_LOGGER_INSTANCE')
     }
   })
 
-  t.test('If both `loggerInstance` and `logger` are provided, an error should be thrown', async (t) => {
+  await t.test('If both `loggerInstance` and `logger` are provided, an error should be thrown', async (t) => {
     t.plan(2)
     const loggerInstanceStream = split(JSON.parse)
     const loggerInstance = pino({ level: 'error' }, loggerInstanceStream)
@@ -536,12 +534,12 @@ t.test('logger options', (t) => {
         loggerInstance
       })
     } catch (err) {
-      t.ok(err)
-      t.equal(err.code, 'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED')
+      t.assert.ok(err)
+      t.assert.deepEqual(err.code, 'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED')
     }
   })
 
-  t.test('`logger` should take pino configuration and create a pino logger', async (t) => {
+  await t.test('`logger` should take pino configuration and create a pino logger', async (t) => {
     const lines = ['hello', 'world']
     t.plan(2 * lines.length + 2)
     const loggerStream = split(JSON.parse)
@@ -551,7 +549,7 @@ t.test('logger options', (t) => {
         level: 'error'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.get('/hello', (req, reply) => {
       req.log.error('hello')
       reply.code(404).send()
@@ -565,16 +563,16 @@ t.test('logger options', (t) => {
     await fastify.ready()
     {
       const response = await fastify.inject({ method: 'GET', url: '/hello' })
-      t.equal(response.statusCode, 404)
+      t.assert.deepEqual(response.statusCode, 404)
     }
     {
       const response = await fastify.inject({ method: 'GET', url: '/world' })
-      t.equal(response.statusCode, 201)
+      t.assert.deepEqual(response.statusCode, 201)
     }
 
     for await (const [line] of on(loggerStream, 'data')) {
-      t.equal(line.level, 50)
-      t.equal(line.msg, lines.shift())
+      t.assert.deepEqual(line.level, 50)
+      t.assert.deepEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })