fastify 5.0.0 → 5.2.0

package/test/versioned-routes.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const helper = require('./helper')
 const Fastify = require('..')
 const sget = require('simple-get').concat
@@ -15,7 +15,7 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('Should register a versioned route', t => {
+test('Should register a versioned route (inject)', (t, done) => {
   t.plan(11)
   const fastify = Fastify()
 
@@ -35,9 +35,9 @@ test('Should register a versioned route', t => {
       'Accept-Version': '1.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -47,9 +47,9 @@ test('Should register a versioned route', t => {
       'Accept-Version': '1.2.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -59,9 +59,9 @@ test('Should register a versioned route', t => {
       'Accept-Version': '1.2.0'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -71,12 +71,13 @@ test('Should register a versioned route', t => {
       'Accept-Version': '1.2.1'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('Should register a versioned route via route constraints', t => {
+test('Should register a versioned route via route constraints', (t, done) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -96,9 +97,9 @@ test('Should register a versioned route via route constraints', t => {
       'Accept-Version': '1.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -108,13 +109,14 @@ test('Should register a versioned route via route constraints', t => {
       'Accept-Version': '1.2.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
+    done()
   })
 })
 
-test('Should register the same route with different versions', t => {
+test('Should register the same route with different versions', (t, done) => {
   t.plan(8)
   const fastify = Fastify()
 
@@ -143,9 +145,9 @@ test('Should register the same route with different versions', t => {
       'Accept-Version': '1.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, '1.3.0')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, '1.3.0')
   })
 
   fastify.inject({
@@ -155,9 +157,9 @@ test('Should register the same route with different versions', t => {
       'Accept-Version': '1.2.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 200)
-    t.equal(res.payload, '1.2.0')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.payload, '1.2.0')
   })
 
   fastify.inject({
@@ -167,12 +169,13 @@ test('Should register the same route with different versions', t => {
       'Accept-Version': '2.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('The versioned route should take precedence', t => {
+test('The versioned route should take precedence', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -200,13 +203,14 @@ test('The versioned route should take precedence', t => {
       'Accept-Version': '1.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
+    done()
   })
 })
 
-test('Versioned route but not version header should return a 404', t => {
+test('Versioned route but not version header should return a 404', (t, done) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -223,12 +227,13 @@ test('Versioned route but not version header should return a 404', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('Should register a versioned route', t => {
+test('Should register a versioned route (server)', (t, done) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -242,8 +247,8 @@ test('Should register a versioned route', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'GET',
@@ -252,25 +257,26 @@ test('Should register a versioned route', t => {
         'Accept-Version': '1.x'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), { hello: 'world' })
-    })
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'Accept-Version': '2.x'
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port,
+        headers: {
+          'Accept-Version': '2.x'
+        }
+      }, (err, response, body) => {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 404)
+        done()
+      })
     })
   })
 })
 
-test('Shorthand route declaration', t => {
+test('Shorthand route declaration', (t, done) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -285,9 +291,9 @@ test('Shorthand route declaration', t => {
       'Accept-Version': '1.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -297,27 +303,28 @@ test('Shorthand route declaration', t => {
       'Accept-Version': '1.2.1'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('The not found handler should not erase the Accept-Version header', t => {
+test('The not found handler should not erase the Accept-Version header', (t, done) => {
   t.plan(13)
   const fastify = Fastify()
 
   fastify.addHook('onRequest', function (req, reply, done) {
-    t.same(req.headers['accept-version'], '2.x')
+    t.assert.deepStrictEqual(req.headers['accept-version'], '2.x')
     done()
   })
 
   fastify.addHook('preValidation', function (req, reply, done) {
-    t.same(req.headers['accept-version'], '2.x')
+    t.assert.deepStrictEqual(req.headers['accept-version'], '2.x')
     done()
   })
 
   fastify.addHook('preHandler', function (req, reply, done) {
-    t.same(req.headers['accept-version'], '2.x')
+    t.assert.deepStrictEqual(req.headers['accept-version'], '2.x')
     done()
   })
 
@@ -331,14 +338,14 @@ test('The not found handler should not erase the Accept-Version header', t => {
   })
 
   fastify.setNotFoundHandler(function (req, reply) {
-    t.same(req.headers['accept-version'], '2.x')
+    t.assert.deepStrictEqual(req.headers['accept-version'], '2.x')
     // we check if the symbol is exposed on key or not
     for (const key in req.headers) {
-      t.same(typeof key, 'string')
+      t.assert.deepStrictEqual(typeof key, 'string')
     }
 
     for (const key of Object.keys(req.headers)) {
-      t.same(typeof key, 'string')
+      t.assert.deepStrictEqual(typeof key, 'string')
     }
 
     reply.code(404).send('not found handler')
@@ -351,13 +358,14 @@ test('The not found handler should not erase the Accept-Version header', t => {
       'Accept-Version': '2.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload, 'not found handler')
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.payload, 'not found handler')
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('Bad accept version (inject)', t => {
+test('Bad accept version (inject)', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -377,8 +385,8 @@ test('Bad accept version (inject)', t => {
       'Accept-Version': 'a.b.c'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
   })
 
   fastify.inject({
@@ -388,12 +396,13 @@ test('Bad accept version (inject)', t => {
       'Accept-Version': 12
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('Bad accept version (server)', t => {
+test('Bad accept version (server)', (t, done) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -407,8 +416,8 @@ test('Bad accept version (server)', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'GET',
@@ -417,24 +426,25 @@ test('Bad accept version (server)', t => {
         'Accept-Version': 'a.b.c'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
-    })
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'Accept-Version': 12
-      }
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 404)
+
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port,
+        headers: {
+          'Accept-Version': 12
+        }
+      }, (err, response, body) => {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 404)
+        done()
+      })
     })
   })
 })
 
-test('test log stream', t => {
+test('test log stream', (t, done) => {
   t.plan(3)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -449,8 +459,8 @@ test('test log stream', t => {
   })
 
   fastify.listen({ port: 0, host: localhost }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     http.get({
       host: fastify.server.address().hostname,
@@ -464,16 +474,17 @@ test('test log stream', t => {
 
     stream.once('data', listenAtLogLine => {
       stream.once('data', line => {
-        t.equal(line.req.version, '1.x')
+        t.assert.strictEqual(line.req.version, '1.x')
         stream.once('data', line => {
-          t.equal(line.req.version, '1.x')
+          t.assert.strictEqual(line.req.version, '1.x')
+          done()
         })
       })
     })
   })
 })
 
-test('Should register a versioned route with custom versioning strategy', t => {
+test('Should register a versioned route with custom versioning strategy', (t, done) => {
   t.plan(8)
 
   const customVersioning = {
@@ -523,9 +534,9 @@ test('Should register a versioned route with custom versioning strategy', t => {
       Accept: 'application/vnd.example.api+json;version=2'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'from route v2' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'from route v2' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -535,9 +546,9 @@ test('Should register a versioned route with custom versioning strategy', t => {
       Accept: 'application/vnd.example.api+json;version=3'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'from route v3' })
-    t.equal(res.statusCode, 200)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'from route v3' })
+    t.assert.strictEqual(res.statusCode, 200)
   })
 
   fastify.inject({
@@ -547,12 +558,13 @@ test('Should register a versioned route with custom versioning strategy', t => {
       Accept: 'application/vnd.example.api+json;version=4'
     }
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('Vary header check (for documentation example)', t => {
+test('Vary header check (for documentation example)', (t, done) => {
   t.plan(8)
   const fastify = Fastify()
   fastify.addHook('onSend', async (req, reply) => {
@@ -589,19 +601,20 @@ test('Vary header check (for documentation example)', t => {
       'Accept-Version': '1.x'
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
-    t.equal(res.headers.vary, 'Accept-Version')
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers.vary, 'Accept-Version')
   })
 
   fastify.inject({
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.same(JSON.parse(res.payload), { hello: 'world' })
-    t.equal(res.statusCode, 200)
-    t.equal(res.headers.vary, undefined)
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'world' })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers.vary, undefined)
+    done()
   })
 })