fastify 5.3.0 → 5.3.2

package/test/logger/logging.test.js

@@ -2,7 +2,7 @@
 
 const stream = require('node:stream')
 
-const t = require('tap')
+const t = require('node:test')
 const split = require('split2')
 const pino = require('pino')
 
@@ -10,10 +10,9 @@ const Fastify = require('../../fastify')
 const helper = require('../helper')
 const { once, on } = stream
 const { request } = require('./logger-test-utils')
+const { partialDeepStrictEqual } = require('../toolkit')
 
-t.test('logging', (t) => {
-  t.setTimeout(60000)
-
+t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
@@ -23,7 +22,7 @@ t.test('logging', (t) => {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
   })
 
-  t.test('The default 404 handler logs the incoming request', async (t) => {
+  await t.test('The default 404 handler logs the incoming request', async (t) => {
     const lines = ['incoming request', 'Route GET:/not-found not found', 'request completed']
     t.plan(lines.length + 1)
 
@@ -34,29 +33,22 @@ t.test('logging', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     await fastify.ready()
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/not-found' })
-      t.equal(response.statusCode, 404)
+      t.assert.strictEqual(response.statusCode, 404)
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.msg, lines.shift())
+      t.assert.strictEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('should not rely on raw request to log errors', async (t) => {
-    const lines = [
-      { msg: /Server listening at/ },
-      { level: 30, msg: 'incoming request' },
-      { res: { statusCode: 415 }, msg: 'something happened' },
-      { res: { statusCode: 415 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 1)
+  await t.test('should not rely on raw request to log errors', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -64,32 +56,31 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.get('/error', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.status(415).send(new Error('something happened'))
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { level: 30, msg: 'incoming request' },
+      { res: { statusCode: 415 }, msg: 'something happened' },
+      { res: { statusCode: 415 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port + '/error')
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, lines.shift())
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('should log the error if no error handler is defined', async (t) => {
-    const lines = [
-      { msg: /Server listening at/ },
-      { msg: 'incoming request' },
-      { level: 50, msg: 'a generic error' },
-      { res: { statusCode: 500 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 1)
-
+  await t.test('should log the error if no error handler is defined', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -97,32 +88,32 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/error', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(new Error('a generic error'))
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { msg: 'incoming request' },
+      { level: 50, msg: 'a generic error' },
+      { res: { statusCode: 500 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port + '/error')
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, lines.shift())
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('should log as info if error status code >= 400 and < 500 if no error handler is defined', async (t) => {
-    const lines = [
-      { msg: /Server listening at/ },
-      { msg: 'incoming request' },
-      { level: 30, msg: 'a 400 error' },
-      { res: { statusCode: 400 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 1)
+  await t.test('should log as info if error status code >= 400 and < 500 if no error handler is defined', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -130,36 +121,36 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/400', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(Object.assign(new Error('a 400 error'), { statusCode: 400 }))
     })
     fastify.get('/503', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(Object.assign(new Error('a 503 error'), { statusCode: 503 }))
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { msg: 'incoming request' },
+      { level: 30, msg: 'a 400 error' },
+      { res: { statusCode: 400 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port + '/400')
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, lines.shift())
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('should log as error if error status code >= 500 if no error handler is defined', async (t) => {
-    const lines = [
-      { msg: /Server listening at/ },
-      { msg: 'incoming request' },
-      { level: 50, msg: 'a 503 error' },
-      { res: { statusCode: 503 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 1)
+  await t.test('should log as error if error status code >= 500 if no error handler is defined', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -167,30 +158,31 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.get('/503', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(Object.assign(new Error('a 503 error'), { statusCode: 503 }))
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { msg: 'incoming request' },
+      { level: 50, msg: 'a 503 error' },
+      { res: { statusCode: 503 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 1)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port + '/503')
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, lines.shift())
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('should not log the error if error handler is defined and it does not error', async (t) => {
-    const lines = [
-      { msg: /Server listening at/ },
-      { level: 30, msg: 'incoming request' },
-      { res: { statusCode: 200 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 2)
+  await t.test('should not log the error if error handler is defined and it does not error', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -198,28 +190,34 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
     fastify.get('/error', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(new Error('something happened'))
     })
     fastify.setErrorHandler((err, req, reply) => {
-      t.ok(err)
+      t.assert.ok(err)
       reply.send('something bad happened')
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { level: 30, msg: 'incoming request' },
+      { res: { statusCode: 200 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 2)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port + '/error')
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, lines.shift())
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('reply.send logs an error if called twice in a row', async (t) => {
+  await t.test('reply.send logs an error if called twice in a row', async (t) => {
     const lines = [
       'incoming request',
       'request completed',
@@ -234,7 +232,7 @@ t.test('logging', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', (req, reply) => {
       reply.send({ hello: 'world' })
@@ -244,19 +242,19 @@ t.test('logging', (t) => {
 
     const response = await fastify.inject({ method: 'GET', url: '/' })
     const body = await response.json()
-    t.same(body, { hello: 'world' })
+    t.assert.ok(partialDeepStrictEqual(body, { hello: 'world' }))
 
     for await (const [line] of on(stream, 'data')) {
-      t.same(line.msg, lines.shift())
+      t.assert.strictEqual(line.msg, lines.shift())
       if (lines.length === 0) break
     }
   })
 
-  t.test('should not log incoming request and outgoing response when disabled', async (t) => {
+  await t.test('should not log incoming request and outgoing response when disabled', async (t) => {
     t.plan(1)
     const stream = split(JSON.parse)
     const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream } })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/500', (req, reply) => {
       reply.code(500).send(Error('500 error'))
@@ -267,27 +265,27 @@ t.test('logging', (t) => {
     await fastify.inject({ method: 'GET', url: '/500' })
 
     // no more readable data
-    t.equal(stream.readableLength, 0)
+    t.assert.strictEqual(stream.readableLength, 0)
   })
 
-  t.test('should not log incoming request, outgoing response  and route not found for 404 onBadUrl when disabled', async (t) => {
+  await t.test('should not log incoming request, outgoing response  and route not found for 404 onBadUrl when disabled', async (t) => {
     t.plan(1)
     const stream = split(JSON.parse)
     const fastify = Fastify({ disableRequestLogging: true, logger: { level: 'info', stream } })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     await fastify.ready()
 
     await fastify.inject({ method: 'GET', url: '/%c0' })
 
     // no more readable data
-    t.equal(stream.readableLength, 0)
+    t.assert.strictEqual(stream.readableLength, 0)
   })
 
-  t.test('defaults to info level', async (t) => {
+  await t.test('defaults to info level', async (t) => {
     const lines = [
-      { reqId: /req-/, req: { method: 'GET' }, msg: 'incoming request' },
-      { reqId: /req-/, res: { statusCode: 200 }, msg: 'request completed' }
+      { req: { method: 'GET' }, msg: 'incoming request' },
+      { res: { statusCode: 200 }, msg: 'request completed' }
     ]
     t.plan(lines.length * 2 + 1)
     const stream = split(JSON.parse)
@@ -296,10 +294,10 @@ t.test('logging', (t) => {
         stream
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send({ hello: 'world' })
     })
 
@@ -313,20 +311,13 @@ t.test('logging', (t) => {
       // we skip the non-request log
       if (typeof line.reqId !== 'string') continue
       if (id === undefined && line.reqId) id = line.reqId
-      if (id !== undefined && line.reqId) t.equal(line.reqId, id)
-      t.match(line, lines.shift())
+      if (id !== undefined && line.reqId) t.assert.strictEqual(line.reqId, id)
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('test log stream', async (t) => {
-    const lines = [
-      { msg: /^Server listening at / },
-      { reqId: /req-/, req: { method: 'GET' }, msg: 'incoming request' },
-      { reqId: /req-/, res: { statusCode: 200 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 3)
-
+  await t.test('test log stream', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -334,36 +325,34 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send({ hello: 'world' })
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { req: { method: 'GET' }, msg: 'incoming request' },
+      { res: { statusCode: 200 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 3)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port)
 
     let id
     for await (const [line] of on(stream, 'data')) {
       if (id === undefined && line.reqId) id = line.reqId
-      if (id !== undefined && line.reqId) t.equal(line.reqId, id)
-      t.match(line, lines.shift())
+      if (id !== undefined && line.reqId) t.assert.strictEqual(line.reqId, id)
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('test error log stream', async (t) => {
-    const lines = [
-      { msg: /^Server listening at / },
-      { reqId: /req-/, req: { method: 'GET' }, msg: 'incoming request' },
-      { reqId: /req-/, res: { statusCode: 500 }, msg: 'kaboom' },
-      { reqId: /req-/, res: { statusCode: 500 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 4)
-
+  await t.test('test error log stream', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -371,28 +360,35 @@ t.test('logging', (t) => {
         level: 'info'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/error', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(new Error('kaboom'))
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { req: { method: 'GET' }, msg: 'incoming request' },
+      { res: { statusCode: 500 }, msg: 'kaboom' },
+      { res: { statusCode: 500 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 4)
 
     await request(`http://${localhostForURL}:` + fastify.server.address().port + '/error')
 
     let id
     for await (const [line] of on(stream, 'data')) {
       if (id === undefined && line.reqId) id = line.reqId
-      if (id !== undefined && line.reqId) t.equal(line.reqId, id)
-      t.match(line, lines.shift())
+      if (id !== undefined && line.reqId) t.assert.strictEqual(line.reqId, id)
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('should not log the error if request logging is disabled', async (t) => {
+  await t.test('should not log the error if request logging is disabled', async (t) => {
     t.plan(4)
 
     const stream = split(JSON.parse)
@@ -403,10 +399,10 @@ t.test('logging', (t) => {
       },
       disableRequestLogging: true
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/error', function (req, reply) {
-      t.ok(req.log)
+      t.assert.ok(req.log)
       reply.send(new Error('a generic error'))
     })
 
@@ -417,11 +413,11 @@ t.test('logging', (t) => {
 
     {
       const [line] = await once(stream, 'data')
-      t.type(line.msg, 'string')
-      t.ok(line.msg.startsWith('Server listening at'), 'message is set')
+      t.assert.ok(typeof line.msg === 'string')
+      t.assert.ok(line.msg.startsWith('Server listening at'), 'message is set')
     }
 
     // no more readable data
-    t.equal(stream.readableLength, 0)
+    t.assert.strictEqual(stream.readableLength, 0)
   })
 })