fastify 5.0.0 → 5.2.0

package/test/case-insensitive.test.js

@@ -1,120 +1,123 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const sget = require('simple-get').concat
 
-test('case insensitive', t => {
+test('case insensitive', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({
     caseSensitive: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/foo', (req, reply) => {
     reply.send({ hello: 'world' })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/FOO'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         hello: 'world'
       })
+      done()
     })
   })
 })
 
-test('case insensitive inject', t => {
+test('case insensitive inject', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({
     caseSensitive: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/foo', (req, reply) => {
     reply.send({ hello: 'world' })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     fastify.inject({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/FOO'
     }, (err, response) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(response.payload), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(response.payload), {
         hello: 'world'
       })
+      done()
     })
   })
 })
 
-test('case insensitive (parametric)', t => {
+test('case insensitive (parametric)', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify({
     caseSensitive: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/foo/:param', (req, reply) => {
-    t.equal(req.params.param, 'bAr')
+    t.assert.strictEqual(req.params.param, 'bAr')
     reply.send({ hello: 'world' })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/FoO/bAr'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         hello: 'world'
       })
+      done()
     })
   })
 })
 
-test('case insensitive (wildcard)', t => {
+test('case insensitive (wildcard)', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify({
     caseSensitive: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/foo/*', (req, reply) => {
-    t.equal(req.params['*'], 'bAr/baZ')
+    t.assert.strictEqual(req.params['*'], 'bAr/baZ')
     reply.send({ hello: 'world' })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/FoO/bAr/baZ'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         hello: 'world'
       })
+      done()
     })
   })
 })

package/test/chainable.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const fastify = require('..')()
 
 const noop = () => {}
@@ -22,17 +21,17 @@ const opts = {
 
 test('chainable - get', t => {
   t.plan(1)
-  t.type(fastify.get('/', opts, noop), fastify)
+  t.assert.strictEqual(fastify.get('/', opts, noop), fastify)
 })
 
 test('chainable - post', t => {
   t.plan(1)
-  t.type(fastify.post('/', opts, noop), fastify)
+  t.assert.strictEqual(fastify.post('/', opts, noop), fastify)
 })
 
 test('chainable - route', t => {
   t.plan(1)
-  t.type(fastify.route({
+  t.assert.strictEqual(fastify.route({
     method: 'GET',
     url: '/other',
     schema: opts.schema,

package/test/check.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const { S } = require('fluent-json-schema')
 const Fastify = require('..')
 const sget = require('simple-get').concat
@@ -73,7 +72,6 @@ const options = {
 }
 
 const handler = (request, reply) => {
-  console.log('in handler')
   if (request.body.id === '400') {
     return reply.status(400).send({
       statusCode: 400,
@@ -107,15 +105,15 @@ const handler = (request, reply) => {
   })
 }
 
-test('serialize the response for a Bad Request error, as defined on the schema', t => {
+test('serialize the response for a Bad Request error, as defined on the schema', (t, done) => {
   const fastify = Fastify({})
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.post('/', options, handler)
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const url = `http://localhost:${fastify.server.address().port}/`
 
@@ -124,14 +122,14 @@ test('serialize the response for a Bad Request error, as defined on the schema',
       url,
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.same(body, {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.deepStrictEqual(body, {
         statusCode: 400,
         error: 'Bad Request',
         message: 'body must be object'
       })
-      t.end()
+      done()
     })
   })
 })

package/test/{childLoggerFactory.test.js → child-logger-factory.test.js}

@@ -1,15 +1,15 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 
-test('Should accept a custom childLoggerFactory function', t => {
+test('Should accept a custom childLoggerFactory function', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
   fastify.setChildLoggerFactory(function (logger, bindings, opts) {
-    t.ok(bindings.reqId)
-    t.ok(opts)
+    t.assert.ok(bindings.reqId)
+    t.assert.ok(opts)
     this.log.debug(bindings, 'created child logger')
     return logger.child(bindings, opts)
   })
@@ -19,19 +19,52 @@ test('Should accept a custom childLoggerFactory function', t => {
     reply.send()
   })
 
+  t.after(() => fastify.close())
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    fastify.inject({
+      method: 'GET',
+      url: 'http://localhost:' + fastify.server.address().port
+    }, (err, res) => {
+      t.assert.ifError(err)
+      done()
+    })
+  })
+})
+
+test('Should accept a custom childLoggerFactory function as option', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify({
+    childLoggerFactory: function (logger, bindings, opts) {
+      t.ok(bindings.reqId)
+      t.ok(opts)
+      this.log.debug(bindings, 'created child logger')
+      return logger.child(bindings, opts)
+    }
+  })
+
+  fastify.get('/', (req, reply) => {
+    req.log.info('log message')
+    reply.send()
+  })
+
+  t.after(() => fastify.close())
+
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
     fastify.inject({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, res) => {
-      t.error(err)
-      fastify.close()
+      t.assert.ifError(err)
+      done()
     })
   })
 })
 
-test('req.log should be the instance returned by the factory', t => {
+test('req.log should be the instance returned by the factory', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -41,24 +74,26 @@ test('req.log should be the instance returned by the factory', t => {
   })
 
   fastify.get('/', (req, reply) => {
-    t.equal(req.log, fastify.log)
+    t.assert.strictEqual(req.log, fastify.log)
     req.log.info('log message')
     reply.send()
   })
 
+  t.after(() => fastify.close())
+
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
     fastify.inject({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, res) => {
-      t.error(err)
-      fastify.close()
+      t.assert.ifError(err)
+      done()
     })
   })
 })
 
-test('should throw error if invalid logger is returned', t => {
+test('should throw error if invalid logger is returned', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -71,20 +106,22 @@ test('should throw error if invalid logger is returned', t => {
     reply.send()
   })
 
+  t.after(() => fastify.close())
+
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.throws(() => {
+    t.assert.ifError(err)
+    t.assert.throws(() => {
       try {
         fastify.inject({
           method: 'GET',
           url: 'http://localhost:' + fastify.server.address().port
         }, (err) => {
-          t.fail('request should have failed but did not')
-          t.error(err)
-          fastify.close()
+          t.assert.fail('request should have failed but did not')
+          t.assert.ifError(err)
+          done()
         })
       } finally {
-        fastify.close()
+        done()
       }
     }, { code: 'FST_ERR_LOG_INVALID_LOGGER' })
   })

package/test/client-timeout.test.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const fastify = require('..')({ requestTimeout: 5, http: { connectionsCheckingInterval: 1000 } })
 const { connect } = require('node:net')
 
-test('requestTimeout should return 408', t => {
+test('requestTimeout should return 408', (t, done) => {
   t.plan(1)
 
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
   })
 
@@ -28,11 +28,11 @@ test('requestTimeout should return 408', t => {
 
     socket.on('data', c => (data = Buffer.concat([data, c])))
     socket.on('end', () => {
-      t.equal(
+      t.assert.strictEqual(
         data.toString('utf-8'),
         'HTTP/1.1 408 Request Timeout\r\nContent-Length: 71\r\nContent-Type: application/json\r\n\r\n{"error":"Request Timeout","message":"Client Timeout","statusCode":408}'
       )
-      t.end()
+      done()
     })
   })
 })

package/test/close-pipelining.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const { Client } = require('undici')
 
@@ -29,8 +28,7 @@ test('Should return 503 while closing - pipelining', async t => {
     instance.request({ path: '/', method: 'GET' })
   ])
   const actual = responses.map(r => r.statusCode)
-
-  t.same(actual, codes)
+  t.assert.deepStrictEqual(actual, codes)
 
   await instance.close()
 })
@@ -61,10 +59,10 @@ test('Should close the socket abruptly - pipelining - return503OnClosing: false'
     instance.request({ path: '/', method: 'GET' })
   ])
 
-  t.equal(responses[0].status, 'fulfilled')
-  t.equal(responses[1].status, 'fulfilled')
-  t.equal(responses[2].status, 'rejected')
-  t.equal(responses[3].status, 'rejected')
+  t.assert.strictEqual(responses[0].status, 'fulfilled')
+  t.assert.strictEqual(responses[1].status, 'fulfilled')
+  t.assert.strictEqual(responses[2].status, 'rejected')
+  t.assert.strictEqual(responses[3].status, 'rejected')
 
   await instance.close()
 })

package/test/conditional-pino.test.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const { test } = require('node:test')
+
+test("pino is not require'd if logger is not passed", t => {
+  t.plan(1)
+
+  const fastify = require('..')
+
+  fastify()
+
+  t.assert.strictEqual(require.cache[require.resolve('pino')], undefined)
+})
+
+test("pino is require'd if logger is passed", t => {
+  t.plan(1)
+
+  const fastify = require('..')
+
+  fastify({
+    logger: true
+  })
+
+  t.assert.notStrictEqual(require.cache[require.resolve('pino')], undefined)
+})
+
+test("pino is require'd if loggerInstance is passed", t => {
+  t.plan(1)
+
+  const fastify = require('..')
+
+  const loggerInstance = {
+    fatal: (msg) => { },
+    error: (msg) => { },
+    warn: (msg) => { },
+    info: (msg) => { },
+    debug: (msg) => { },
+    trace: (msg) => { },
+    child: () => loggerInstance
+  }
+
+  fastify({
+    loggerInstance
+  })
+
+  t.assert.notStrictEqual(require.cache[require.resolve('pino')], undefined)
+})

package/test/{connectionTimeout.test.js → connection-timeout.test.js}

@@ -2,34 +2,33 @@
 
 const Fastify = require('..')
 const http = require('node:http')
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
-test('connectionTimeout', t => {
+test('connectionTimeout', async t => {
   t.plan(6)
 
   try {
     Fastify({ connectionTimeout: 1.3 })
-    t.fail('option must be an integer')
+    t.assert.fail('option must be an integer')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 
   try {
     Fastify({ connectionTimeout: [] })
-    t.fail('option must be an integer')
+    t.assert.fail('option must be an integer')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 
   const httpServer = Fastify({ connectionTimeout: 1 }).server
-  t.equal(httpServer.timeout, 1)
+  t.assert.strictEqual(httpServer.timeout, 1)
 
   const httpsServer = Fastify({ connectionTimeout: 2, https: {} }).server
-  t.equal(httpsServer.timeout, 2)
+  t.assert.strictEqual(httpsServer.timeout, 2)
 
   const http2Server = Fastify({ connectionTimeout: 3, http2: true }).server
-  t.equal(http2Server.timeout, 3)
+  t.assert.strictEqual(http2Server.timeout, 3)
 
   const serverFactory = (handler, _) => {
     const server = http.createServer((req, res) => {
@@ -39,5 +38,5 @@ test('connectionTimeout', t => {
     return server
   }
   const customServer = Fastify({ connectionTimeout: 4, serverFactory }).server
-  t.equal(customServer.timeout, 5)
+  t.assert.strictEqual(customServer.timeout, 5)
 })