fastify 5.0.0 → 5.2.0

package/test/router-options.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const split = require('split2')
-const test = require('tap').test
+const { test } = require('node:test')
 const Fastify = require('../')
 const {
   FST_ERR_BAD_URL,
@@ -19,12 +19,12 @@ test('Should honor ignoreTrailingSlash option', async t => {
   })
 
   let res = await fastify.inject('/test')
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload.toString(), 'test')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload.toString(), 'test')
 
   res = await fastify.inject('/test/')
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload.toString(), 'test')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload.toString(), 'test')
 })
 
 test('Should honor ignoreDuplicateSlashes option', async t => {
@@ -38,12 +38,12 @@ test('Should honor ignoreDuplicateSlashes option', async t => {
   })
 
   let res = await fastify.inject('/test/test/test')
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload.toString(), 'test')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload.toString(), 'test')
 
   res = await fastify.inject('/test//test///test')
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload.toString(), 'test')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload.toString(), 'test')
 })
 
 test('Should honor ignoreTrailingSlash and ignoreDuplicateSlashes options', async t => {
@@ -58,40 +58,35 @@ test('Should honor ignoreTrailingSlash and ignoreDuplicateSlashes options', asyn
   })
 
   let res = await fastify.inject('/test/test/test/')
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload.toString(), 'test')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload.toString(), 'test')
 
   res = await fastify.inject('/test//test///test//')
-  t.equal(res.statusCode, 200)
-  t.equal(res.payload.toString(), 'test')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.payload.toString(), 'test')
 })
 
-test('Should honor maxParamLength option', t => {
-  t.plan(4)
+test('Should honor maxParamLength option', async (t) => {
   const fastify = Fastify({ maxParamLength: 10 })
 
   fastify.get('/test/:id', (req, reply) => {
     reply.send({ hello: 'world' })
   })
 
-  fastify.inject({
+  const res = await fastify.inject({
     method: 'GET',
     url: '/test/123456789'
-  }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
   })
+  t.assert.strictEqual(res.statusCode, 200)
 
-  fastify.inject({
+  const resError = await fastify.inject({
     method: 'GET',
     url: '/test/123456789abcd'
-  }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 404)
   })
+  t.assert.strictEqual(resError.statusCode, 404)
 })
 
-test('Should expose router options via getters on request and reply', t => {
+test('Should expose router options via getters on request and reply', (t, done) => {
   t.plan(9)
   const fastify = Fastify()
   const expectedSchema = {
@@ -106,13 +101,13 @@ test('Should expose router options via getters on request and reply', t => {
   fastify.get('/test/:id', {
     schema: expectedSchema
   }, (req, reply) => {
-    t.equal(reply.routeOptions.config.url, '/test/:id')
-    t.equal(reply.routeOptions.config.method, 'GET')
-    t.same(req.routeOptions.schema, expectedSchema)
-    t.equal(typeof req.routeOptions.handler, 'function')
-    t.equal(req.routeOptions.config.url, '/test/:id')
-    t.equal(req.routeOptions.config.method, 'GET')
-    t.equal(req.is404, false)
+    t.assert.strictEqual(reply.routeOptions.config.url, '/test/:id')
+    t.assert.strictEqual(reply.routeOptions.config.method, 'GET')
+    t.assert.deepStrictEqual(req.routeOptions.schema, expectedSchema)
+    t.assert.strictEqual(typeof req.routeOptions.handler, 'function')
+    t.assert.strictEqual(req.routeOptions.config.url, '/test/:id')
+    t.assert.strictEqual(req.routeOptions.config.method, 'GET')
+    t.assert.strictEqual(req.is404, false)
     reply.send({ hello: 'world' })
   })
 
@@ -120,17 +115,18 @@ test('Should expose router options via getters on request and reply', t => {
     method: 'GET',
     url: '/test/123456789'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 200)
+    done()
   })
 })
 
-test('Should set is404 flag for unmatched paths', t => {
+test('Should set is404 flag for unmatched paths', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
 
   fastify.setNotFoundHandler((req, reply) => {
-    t.equal(req.is404, true)
+    t.assert.strictEqual(req.is404, true)
     reply.code(404).send({ error: 'Not Found', message: 'Four oh for', statusCode: 404 })
   })
 
@@ -138,19 +134,20 @@ test('Should set is404 flag for unmatched paths', t => {
     method: 'GET',
     url: '/nonexist/123456789'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('Should honor frameworkErrors option - FST_ERR_BAD_URL', t => {
+test('Should honor frameworkErrors option - FST_ERR_BAD_URL', (t, done) => {
   t.plan(3)
   const fastify = Fastify({
     frameworkErrors: function (err, req, res) {
       if (err instanceof FST_ERR_BAD_URL) {
-        t.ok(true)
+        t.assert.ok(true)
       } else {
-        t.fail()
+        t.assert.fail()
       }
       res.send(`${err.message} - ${err.code}`)
     }
@@ -166,13 +163,14 @@ test('Should honor frameworkErrors option - FST_ERR_BAD_URL', t => {
       url: '/test/%world'
     },
     (err, res) => {
-      t.error(err)
-      t.equal(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      done()
     }
   )
 })
 
-test('Should supply Fastify request to the logger in frameworkErrors wrapper - FST_ERR_BAD_URL', t => {
+test('Should supply Fastify request to the logger in frameworkErrors wrapper - FST_ERR_BAD_URL', (t, done) => {
   t.plan(8)
 
   const REQ_ID = 'REQ-1234'
@@ -180,15 +178,15 @@ test('Should supply Fastify request to the logger in frameworkErrors wrapper - F
 
   const fastify = Fastify({
     frameworkErrors: function (err, req, res) {
-      t.same(req.id, REQ_ID)
-      t.same(req.raw.httpVersion, '1.1')
+      t.assert.deepStrictEqual(req.id, REQ_ID)
+      t.assert.deepStrictEqual(req.raw.httpVersion, '1.1')
       res.send(`${err.message} - ${err.code}`)
     },
     logger: {
       stream: logStream,
       serializers: {
         req (request) {
-          t.same(request.id, REQ_ID)
+          t.assert.deepStrictEqual(request.id, REQ_ID)
           return { httpVersion: request.raw.httpVersion }
         }
       }
@@ -201,9 +199,9 @@ test('Should supply Fastify request to the logger in frameworkErrors wrapper - F
   })
 
   logStream.on('data', (json) => {
-    t.same(json.msg, 'incoming request')
-    t.same(json.reqId, REQ_ID)
-    t.same(json.req.httpVersion, '1.1')
+    t.assert.deepStrictEqual(json.msg, 'incoming request')
+    t.assert.deepStrictEqual(json.reqId, REQ_ID)
+    t.assert.deepStrictEqual(json.req.httpVersion, '1.1')
   })
 
   fastify.inject(
@@ -212,13 +210,14 @@ test('Should supply Fastify request to the logger in frameworkErrors wrapper - F
       url: '/test/%world'
     },
     (err, res) => {
-      t.error(err)
-      t.equal(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      done()
     }
   )
 })
 
-test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST_ERR_BAD_URL', t => {
+test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST_ERR_BAD_URL', (t, done) => {
   t.plan(2)
 
   const logStream = split(JSON.parse)
@@ -232,10 +231,10 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
       stream: logStream,
       serializers: {
         req () {
-          t.fail('should not be called')
+          t.assert.fail('should not be called')
         },
         res () {
-          t.fail('should not be called')
+          t.assert.fail('should not be called')
         }
       }
     }
@@ -246,7 +245,7 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
   })
 
   logStream.on('data', (json) => {
-    t.fail('should not be called')
+    t.assert.fail('should not be called')
   })
 
   fastify.inject(
@@ -255,13 +254,14 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
       url: '/test/%world'
     },
     (err, res) => {
-      t.error(err)
-      t.equal(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      done()
     }
   )
 })
 
-test('Should honor frameworkErrors option - FST_ERR_ASYNC_CONSTRAINT', t => {
+test('Should honor frameworkErrors option - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
   t.plan(3)
 
   const constraint = {
@@ -282,9 +282,9 @@ test('Should honor frameworkErrors option - FST_ERR_ASYNC_CONSTRAINT', t => {
   const fastify = Fastify({
     frameworkErrors: function (err, req, res) {
       if (err instanceof FST_ERR_ASYNC_CONSTRAINT) {
-        t.ok(true)
+        t.assert.ok(true)
       } else {
-        t.fail()
+        t.assert.fail()
       }
       res.send(`${err.message} - ${err.code}`)
     },
@@ -306,13 +306,14 @@ test('Should honor frameworkErrors option - FST_ERR_ASYNC_CONSTRAINT', t => {
       url: '/'
     },
     (err, res) => {
-      t.error(err)
-      t.equal(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+      done()
     }
   )
 })
 
-test('Should supply Fastify request to the logger in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', t => {
+test('Should supply Fastify request to the logger in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
   t.plan(8)
 
   const constraint = {
@@ -336,15 +337,15 @@ test('Should supply Fastify request to the logger in frameworkErrors wrapper - F
   const fastify = Fastify({
     constraints: { secret: constraint },
     frameworkErrors: function (err, req, res) {
-      t.same(req.id, REQ_ID)
-      t.same(req.raw.httpVersion, '1.1')
+      t.assert.deepStrictEqual(req.id, REQ_ID)
+      t.assert.deepStrictEqual(req.raw.httpVersion, '1.1')
       res.send(`${err.message} - ${err.code}`)
     },
     logger: {
       stream: logStream,
       serializers: {
         req (request) {
-          t.same(request.id, REQ_ID)
+          t.assert.deepStrictEqual(request.id, REQ_ID)
           return { httpVersion: request.raw.httpVersion }
         }
       }
@@ -362,9 +363,9 @@ test('Should supply Fastify request to the logger in frameworkErrors wrapper - F
   })
 
   logStream.on('data', (json) => {
-    t.same(json.msg, 'incoming request')
-    t.same(json.reqId, REQ_ID)
-    t.same(json.req.httpVersion, '1.1')
+    t.assert.deepStrictEqual(json.msg, 'incoming request')
+    t.assert.deepStrictEqual(json.reqId, REQ_ID)
+    t.assert.deepStrictEqual(json.req.httpVersion, '1.1')
   })
 
   fastify.inject(
@@ -373,13 +374,14 @@ test('Should supply Fastify request to the logger in frameworkErrors wrapper - F
       url: '/'
     },
     (err, res) => {
-      t.error(err)
-      t.equal(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+      done()
     }
   )
 })
 
-test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', t => {
+test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
   t.plan(2)
 
   const constraint = {
@@ -409,10 +411,10 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
       stream: logStream,
       serializers: {
         req () {
-          t.fail('should not be called')
+          t.assert.fail('should not be called')
         },
         res () {
-          t.fail('should not be called')
+          t.assert.fail('should not be called')
         }
       }
     }
@@ -428,7 +430,7 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
   })
 
   logStream.on('data', (json) => {
-    t.fail('should not be called')
+    t.assert.fail('should not be called')
   })
 
   fastify.inject(
@@ -437,8 +439,9 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
       url: '/'
     },
     (err, res) => {
-      t.error(err)
-      t.equal(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+      done()
     }
   )
 })

package/test/same-shape.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const fastify = require('..')
 
 test('same shape on Request', async (t) => {
@@ -21,7 +21,7 @@ test('same shape on Request', async (t) => {
 
   app.get('/', (req, reply) => {
     if (request) {
-      t.equal(%HaveSameMap(request, req), true)
+      t.assert.deepStrictEqual(request, req)
     }
 
     request = req
@@ -51,7 +51,7 @@ test('same shape on Request when object', async (t) => {
 
   app.get('/', (req, reply) => {
     if (request) {
-      t.equal(%HaveSameMap(request, req), true)
+      t.assert.deepStrictEqual(request, req)
     }
 
     request = req
@@ -81,7 +81,7 @@ test('same shape on Reply', async (t) => {
 
   app.get('/', (req, reply) => {
     if (_reply) {
-      t.equal(%HaveSameMap(_reply, reply), true)
+      t.assert.deepStrictEqual(_reply, reply)
     }
 
     _reply = reply
@@ -111,7 +111,7 @@ test('same shape on Reply when object', async (t) => {
 
   app.get('/', (req, reply) => {
     if (_reply) {
-      t.equal(%HaveSameMap(_reply, reply), true)
+      t.assert.deepStrictEqual(_reply, reply)
     }
 
     _reply = reply

package/test/schema-examples.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const localize = require('ajv-i18n')
 const Fastify = require('..')
 
-test('Example - URI $id', t => {
+test('Example - URI $id', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   fastify.addSchema({
@@ -25,10 +25,13 @@ test('Example - URI $id', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - string $id', t => {
+test('Example - string $id', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   fastify.addSchema({
@@ -47,10 +50,13 @@ test('Example - string $id', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - get schema', t => {
+test('Example - get schema', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   fastify.addSchema({
@@ -63,7 +69,8 @@ test('Example - get schema', t => {
 
   const mySchemas = fastify.getSchemas()
   const mySchema = fastify.getSchema('schemaId')
-  t.same(mySchemas.schemaId, mySchema)
+  t.assert.deepStrictEqual(mySchemas.schemaId, mySchema)
+  done()
 })
 
 test('Example - get schema encapsulated', async t => {
@@ -91,12 +98,12 @@ test('Example - get schema encapsulated', async t => {
   const r2 = await fastify.inject('/sub')
   const r3 = await fastify.inject('/deep')
 
-  t.same(Object.keys(r1.json()), ['one'])
-  t.same(Object.keys(r2.json()), ['one', 'two'])
-  t.same(Object.keys(r3.json()), ['one', 'two', 'three'])
+  t.assert.deepStrictEqual(Object.keys(r1.json()), ['one'])
+  t.assert.deepStrictEqual(Object.keys(r2.json()), ['one', 'two'])
+  t.assert.deepStrictEqual(Object.keys(r3.json()), ['one', 'two', 'three'])
 })
 
-test('Example - validation', t => {
+test('Example - validation', (t, done) => {
   t.plan(1)
   const fastify = Fastify({
     ajv: {
@@ -168,10 +175,13 @@ test('Example - validation', t => {
   }
 
   fastify.post('/the/url', { schema }, handler)
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - ajv config', t => {
+test('Example - ajv config', (t, done) => {
   t.plan(1)
 
   const fastify = Fastify({
@@ -228,10 +238,13 @@ test('Example - ajv config', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example Joi', t => {
+test('Example Joi', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   const handler = () => { }
@@ -248,10 +261,13 @@ test('Example Joi', t => {
     }
   }, handler)
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example yup', t => {
+test('Example yup', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   const handler = () => { }
@@ -287,10 +303,13 @@ test('Example yup', t => {
     }
   }, handler)
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - serialization', t => {
+test('Example - serialization', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   const handler = () => { }
@@ -308,10 +327,13 @@ test('Example - serialization', t => {
   }
 
   fastify.post('/the/url', { schema }, handler)
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - serialization 2', t => {
+test('Example - serialization 2', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   const handler = () => { }
@@ -333,10 +355,13 @@ test('Example - serialization 2', t => {
   }
 
   fastify.post('/the/url', { schema }, handler)
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - serializator', t => {
+test('Example - serializator', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -361,10 +386,13 @@ test('Example - serializator', t => {
     }
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('Example - schemas examples', t => {
+test('Example - schemas examples', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
   const handler = () => { }
@@ -457,10 +485,13 @@ test('Example - schemas examples', t => {
 
   })
 
-  fastify.ready(err => t.error(err))
+  fastify.ready(err => {
+    t.assert.ifError(err)
+    done()
+  })
 })
 
-test('should return custom error messages with ajv-errors', t => {
+test('should return custom error messages with ajv-errors', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify({
@@ -508,18 +539,19 @@ test('should return custom error messages with ajv-errors', t => {
     },
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       statusCode: 400,
       code: 'FST_ERR_VALIDATION',
       error: 'Bad Request',
       message: 'body/age bad age - should be num, body name please, body work please'
     })
-    t.equal(res.statusCode, 400)
+    t.assert.strictEqual(res.statusCode, 400)
+    done()
   })
 })
 
-test('should be able to handle formats of ajv-formats when added by plugins option', t => {
+test('should be able to handle formats of ajv-formats when added by plugins option', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify({
@@ -553,8 +585,8 @@ test('should be able to handle formats of ajv-formats when added by plugins opti
     },
     url: '/'
   }, (_err, res) => {
-    t.equal(res.body, '254381a5-888c-4b41-8116-e3b1a54980bd')
-    t.equal(res.statusCode, 200)
+    t.assert.strictEqual(res.body, '254381a5-888c-4b41-8116-e3b1a54980bd')
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -565,16 +597,17 @@ test('should be able to handle formats of ajv-formats when added by plugins opti
     },
     url: '/'
   }, (_err, res) => {
-    t.same(JSON.parse(res.payload), {
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       statusCode: 400,
       code: 'FST_ERR_VALIDATION',
       error: 'Bad Request',
       message: 'body/id must match format "uuid"'
     })
+    done()
   })
 })
 
-test('should return localized error messages with ajv-i18n', t => {
+test('should return localized error messages with ajv-i18n', (t, done) => {
   t.plan(3)
 
   const schema = {
@@ -614,14 +647,15 @@ test('should return localized error messages with ajv-i18n', t => {
     },
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), [{
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), [{
       instancePath: '',
       keyword: 'required',
       message: 'должно иметь обязательное поле work',
       params: { missingProperty: 'work' },
       schemaPath: '#/required'
     }])
-    t.equal(res.statusCode, 400)
+    t.assert.strictEqual(res.statusCode, 400)
+    done()
   })
 })