fastify 5.0.0 → 5.2.0

package/test/route.1.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('..')
 const {
@@ -10,15 +9,14 @@ const {
 } = require('../lib/errors')
 const { getServerUrl } = require('./helper')
 
-test('route', t => {
+test('route', async t => {
   t.plan(10)
-  const test = t.test
 
-  test('route - get', t => {
+  await t.test('route - get', (t, done) => {
     t.plan(4)
 
     const fastify = Fastify()
-    t.doesNotThrow(() =>
+    t.assert.doesNotThrow(() =>
       fastify.route({
         method: 'GET',
         url: '/',
@@ -41,24 +39,25 @@ test('route', t => {
     )
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
       sget({
         method: 'GET',
         url: getServerUrl(fastify) + '/'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        done()
       })
     })
   })
 
-  test('missing schema - route', t => {
+  await t.test('missing schema - route', (t, done) => {
     t.plan(4)
 
     const fastify = Fastify()
-    t.doesNotThrow(() =>
+    t.assert.doesNotThrow(() =>
       fastify.route({
         method: 'GET',
         url: '/missing',
@@ -69,31 +68,32 @@ test('route', t => {
     )
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
       sget({
         method: 'GET',
         url: getServerUrl(fastify) + '/missing'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        done()
       })
     })
   })
 
-  test('invalid handler attribute - route', t => {
+  await t.test('invalid handler attribute - route', t => {
     t.plan(1)
 
     const fastify = Fastify()
-    t.throws(() => fastify.get('/', { handler: 'not a function' }, () => { }))
+    t.assert.throws(() => fastify.get('/', { handler: 'not a function' }, () => { }))
   })
 
-  test('Add Multiple methods per route all uppercase', t => {
+  await t.test('Add Multiple methods per route all uppercase', (t, done) => {
     t.plan(7)
 
     const fastify = Fastify()
-    t.doesNotThrow(() =>
+    t.assert.doesNotThrow(() =>
       fastify.route({
         method: ['GET', 'DELETE'],
         url: '/multiple',
@@ -103,33 +103,34 @@ test('route', t => {
       }))
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
       sget({
         method: 'GET',
         url: getServerUrl(fastify) + '/multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
 
       sget({
         method: 'DELETE',
         url: getServerUrl(fastify) + '/multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        done()
       })
     })
   })
 
-  test('Add Multiple methods per route all lowercase', t => {
+  await t.test('Add Multiple methods per route all lowercase', (t, done) => {
     t.plan(7)
 
     const fastify = Fastify()
-    t.doesNotThrow(() =>
+    t.assert.doesNotThrow(() =>
       fastify.route({
         method: ['get', 'delete'],
         url: '/multiple',
@@ -139,33 +140,34 @@ test('route', t => {
       }))
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
       sget({
         method: 'GET',
         url: getServerUrl(fastify) + '/multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
 
       sget({
         method: 'DELETE',
         url: getServerUrl(fastify) + '/multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        done()
       })
     })
   })
 
-  test('Add Multiple methods per route mixed uppercase and lowercase', t => {
+  await t.test('Add Multiple methods per route mixed uppercase and lowercase', (t, done) => {
     t.plan(7)
 
     const fastify = Fastify()
-    t.doesNotThrow(() =>
+    t.assert.doesNotThrow(() =>
       fastify.route({
         method: ['GET', 'delete'],
         url: '/multiple',
@@ -175,33 +177,34 @@ test('route', t => {
       }))
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
       sget({
         method: 'GET',
         url: getServerUrl(fastify) + '/multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
 
       sget({
         method: 'DELETE',
         url: getServerUrl(fastify) + '/multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        done()
       })
     })
   })
 
-  test('Add invalid Multiple methods per route', t => {
+  t.test('Add invalid Multiple methods per route', t => {
     t.plan(1)
 
     const fastify = Fastify()
-    t.throws(() =>
+    t.assert.throws(() =>
       fastify.route({
         method: ['GET', 1],
         url: '/invalid-method',
@@ -211,11 +214,11 @@ test('route', t => {
       }), new FST_ERR_ROUTE_METHOD_INVALID())
   })
 
-  test('Add method', t => {
+  await t.test('Add method', t => {
     t.plan(1)
 
     const fastify = Fastify()
-    t.throws(() =>
+    t.assert.throws(() =>
       fastify.route({
         method: 1,
         url: '/invalid-method',
@@ -225,11 +228,11 @@ test('route', t => {
       }), new FST_ERR_ROUTE_METHOD_INVALID())
   })
 
-  test('Add additional multiple methods to existing route', t => {
+  await t.test('Add additional multiple methods to existing route', (t, done) => {
     t.plan(7)
 
     const fastify = Fastify()
-    t.doesNotThrow(() => {
+    t.assert.doesNotThrow(() => {
       fastify.get('/add-multiple', function (req, reply) {
         reply.send({ hello: 'Bob!' })
       })
@@ -243,49 +246,52 @@ test('route', t => {
     })
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
       sget({
         method: 'PUT',
         url: getServerUrl(fastify) + '/add-multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
       })
 
       sget({
         method: 'DELETE',
         url: getServerUrl(fastify) + '/add-multiple'
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        done()
       })
     })
   })
 
-  test('cannot add another route after binding', t => {
+  await t.test('cannot add another route after binding', (t, done) => {
     t.plan(1)
 
     const fastify = Fastify()
 
     fastify.listen({ port: 0 }, function (err) {
-      if (err) t.error(err)
-      t.teardown(() => { fastify.close() })
+      if (err) t.assert.ifError(err)
+      t.after(() => { fastify.close() })
 
-      t.throws(() => fastify.route({
+      t.assert.throws(() => fastify.route({
         method: 'GET',
         url: '/another-get-route',
         handler: function (req, reply) {
           reply.send({ hello: 'world' })
         }
       }), new FST_ERR_INSTANCE_ALREADY_LISTENING('Cannot add route!'))
+
+      done()
     })
   })
 })
 
-test('invalid schema - route', t => {
+test('invalid schema - route', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -300,10 +306,11 @@ test('invalid schema - route', t => {
     }
   })
   fastify.after(err => {
-    t.notOk(err, 'the error is throw on preReady')
+    t.assert.ok(!err, 'the error is throw on preReady')
   })
   fastify.ready(err => {
-    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
-    t.match(err.message, /Failed building the validation schema for GET: \/invalid/)
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.assert.match(err.message, /Failed building the validation schema for GET: \/invalid/)
+    done()
   })
 })

package/test/route.2.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../fastify')
 
 test('same route definition object on multiple prefixes', async t => {
@@ -17,13 +16,13 @@ test('same route definition object on multiple prefixes', async t => {
 
   fastify.register(async function (f) {
     f.addHook('onRoute', (routeOptions) => {
-      t.equal(routeOptions.url, '/v1/simple')
+      t.assert.strictEqual(routeOptions.url, '/v1/simple')
     })
     f.route(routeObject)
   }, { prefix: '/v1' })
   fastify.register(async function (f) {
     f.addHook('onRoute', (routeOptions) => {
-      t.equal(routeOptions.url, '/v2/simple')
+      t.assert.strictEqual(routeOptions.url, '/v2/simple')
     })
     f.route(routeObject)
   }, { prefix: '/v2' })
@@ -31,7 +30,7 @@ test('same route definition object on multiple prefixes', async t => {
   await fastify.ready()
 })
 
-test('path can be specified in place of uri', t => {
+test('path can be specified in place of uri', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -49,9 +48,10 @@ test('path can be specified in place of uri', t => {
   }
 
   fastify.inject(reqOpts, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    done()
   })
 })
 
@@ -65,20 +65,20 @@ test('invalid bodyLimit option - route', t => {
       method: 'PUT',
       handler: () => null
     })
-    t.fail('bodyLimit must be an integer')
+    t.assert.fail('bodyLimit must be an integer')
   } catch (err) {
-    t.equal(err.message, "'bodyLimit' option must be an integer > 0. Got 'false'")
+    t.assert.strictEqual(err.message, "'bodyLimit' option must be an integer > 0. Got 'false'")
   }
 
   try {
     fastify.post('/url', { bodyLimit: 10000.1 }, () => null)
-    t.fail('bodyLimit must be an integer')
+    t.assert.fail('bodyLimit must be an integer')
   } catch (err) {
-    t.equal(err.message, "'bodyLimit' option must be an integer > 0. Got '10000.1'")
+    t.assert.strictEqual(err.message, "'bodyLimit' option must be an integer > 0. Got '10000.1'")
   }
 })
 
-test('handler function in options of shorthand route should works correctly', t => {
+test('handler function in options of shorthand route should works correctly', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
@@ -92,8 +92,9 @@ test('handler function in options of shorthand route should works correctly', t
     method: 'GET',
     url: '/foo'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    done()
   })
 })

package/test/route.3.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const joi = require('joi')
 const Fastify = require('..')
 
-test('does not mutate joi schemas', t => {
-  t.plan(4)
+test('does not mutate joi schemas', (t, done) => {
+  t.plan(5)
 
   const fastify = Fastify()
   function validatorCompiler ({ schema, method, url, httpPart }) {
@@ -32,7 +31,8 @@ test('does not mutate joi schemas', t => {
       params: { an_id: joi.number() }
     },
     handler (req, res) {
-      t.same(req.params, { an_id: 42 })
+      t.assert.strictEqual(Object.keys(req.params).length, 1)
+      t.assert.strictEqual(req.params.an_id, '42')
       res.send({ hello: 'world' })
     }
   })
@@ -40,14 +40,15 @@ test('does not mutate joi schemas', t => {
   fastify.inject({
     method: 'GET',
     url: '/foo/42'
-  }, (err, result) => {
-    t.error(err)
-    t.equal(result.statusCode, 200)
-    t.same(JSON.parse(result.payload), { hello: 'world' })
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.deepStrictEqual(res.json(), { hello: 'world' })
+    done()
   })
 })
 
-test('multiple routes with one schema', t => {
+test('multiple routes with one schema', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -80,18 +81,19 @@ test('multiple routes with one schema', t => {
   })
 
   fastify.ready(error => {
-    t.error(error)
-    t.same(schema, schema)
+    t.assert.ifError(error)
+    t.assert.deepStrictEqual(schema, schema)
+    done()
   })
 })
 
-test('route error handler overrides default error handler', t => {
+test('route error handler overrides default error handler', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
 
   const customRouteErrorHandler = (error, request, reply) => {
-    t.equal(error.message, 'Wrong Pot Error')
+    t.assert.strictEqual(error.message, 'Wrong Pot Error')
 
     reply.code(418).send({
       message: 'Make a brew',
@@ -113,23 +115,24 @@ test('route error handler overrides default error handler', t => {
     method: 'GET',
     url: '/coffee'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 418)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 418)
+    t.assert.deepStrictEqual(res.json(), {
       message: 'Make a brew',
       statusCode: 418,
       error: 'Wrong Pot Error'
     })
+    done()
   })
 })
 
-test('route error handler does not affect other routes', t => {
+test('route error handler does not affect other routes', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
 
   const customRouteErrorHandler = (error, request, reply) => {
-    t.equal(error.message, 'Wrong Pot Error')
+    t.assert.strictEqual(error.message, 'Wrong Pot Error')
 
     reply.code(418).send({
       message: 'Make a brew',
@@ -159,23 +162,24 @@ test('route error handler does not affect other routes', t => {
     method: 'GET',
     url: '/tea'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 500)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
       message: 'No tea today',
       statusCode: 500,
       error: 'Internal Server Error'
     })
+    done()
   })
 })
 
-test('async error handler for a route', t => {
+test('async error handler for a route', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
 
   const customRouteErrorHandler = async (error, request, reply) => {
-    t.equal(error.message, 'Delayed Pot Error')
+    t.assert.strictEqual(error.message, 'Delayed Pot Error')
     reply.code(418)
     return {
       message: 'Make a brew sometime later',
@@ -197,12 +201,13 @@ test('async error handler for a route', t => {
     method: 'GET',
     url: '/late-coffee'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 418)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 418)
+    t.assert.deepStrictEqual(res.json(), {
       message: 'Make a brew sometime later',
       statusCode: 418,
       error: 'Delayed Pot Error'
     })
+    done()
   })
 })

package/test/route.4.test.js

@@ -1,21 +1,20 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 
-test('route error handler overrides global custom error handler', t => {
-  t.plan(4)
+test('route error handler overrides global custom error handler', async t => {
+  t.plan(3)
 
   const fastify = Fastify()
 
   const customGlobalErrorHandler = (error, request, reply) => {
-    t.error(error)
+    t.assert.ifError(error)
     reply.code(429).send({ message: 'Too much coffee' })
   }
 
   const customRouteErrorHandler = (error, request, reply) => {
-    t.equal(error.message, 'Wrong Pot Error')
+    t.assert.strictEqual(error.message, 'Wrong Pot Error')
     reply.code(418).send({
       message: 'Make a brew',
       statusCode: 418,
@@ -34,17 +33,15 @@ test('route error handler overrides global custom error handler', t => {
     errorHandler: customRouteErrorHandler
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/more-coffee'
-  }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 418)
-    t.same(JSON.parse(res.payload), {
-      message: 'Make a brew',
-      statusCode: 418,
-      error: 'Wrong Pot Error'
-    })
+  })
+  t.assert.strictEqual(res.statusCode, 418)
+  t.assert.deepStrictEqual(JSON.parse(res.payload), {
+    message: 'Make a brew',
+    statusCode: 418,
+    error: 'Wrong Pot Error'
   })
 })
 
@@ -61,7 +58,7 @@ test('throws when route with empty url', async t => {
       }
     })
   } catch (err) {
-    t.equal(err.message, 'The path could not be empty')
+    t.assert.strictEqual(err.message, 'The path could not be empty')
   }
 })
 
@@ -75,7 +72,7 @@ test('throws when route with empty url in shorthand declaration', async t => {
       async function handler () { return {} }
     )
   } catch (err) {
-    t.equal(err.message, 'The path could not be empty')
+    t.assert.strictEqual(err.message, 'The path could not be empty')
   }
 })
 
@@ -94,19 +91,19 @@ test('throws when route-level error handler is not a function', t => {
       errorHandler: 'teapot'
     })
   } catch (err) {
-    t.equal(err.message, 'Error Handler for GET:/tea route, if defined, must be a function')
+    t.assert.strictEqual(err.message, 'Error Handler for GET:/tea route, if defined, must be a function')
   }
 })
 
-test('route child logger factory overrides default child logger factory', t => {
-  t.plan(3)
+test('route child logger factory overrides default child logger factory', async t => {
+  t.plan(2)
 
   const fastify = Fastify()
 
   const customRouteChildLogger = (logger, bindings, opts, req) => {
     const child = logger.child(bindings, opts)
     child.customLog = function (message) {
-      t.equal(message, 'custom')
+      t.assert.strictEqual(message, 'custom')
     }
     return child
   }
@@ -121,11 +118,10 @@ test('route child logger factory overrides default child logger factory', t => {
     childLoggerFactory: customRouteChildLogger
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/coffee'
-  }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
   })
+
+  t.assert.strictEqual(res.statusCode, 200)
 })