fastify 5.0.0 → 5.2.0

package/test/url-rewriting.test.js

@@ -1,15 +1,14 @@
 '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('Should rewrite url', t => {
+test('Should rewrite url', (t, done) => {
   t.plan(5)
   const fastify = Fastify({
     rewriteUrl (req) {
-      t.equal(req.url, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
       this.log.info('rewriting url')
       return '/'
     }
@@ -24,26 +23,26 @@ test('Should rewrite url', t => {
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
     }, (err, response, body) => {
-      t.error(err)
-      t.same(JSON.parse(body), { hello: 'world' })
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      t.assert.strictEqual(response.statusCode, 200)
+      done()
     })
   })
-
-  t.teardown(() => fastify.close())
 })
 
-test('Should not rewrite if the url is the same', t => {
+test('Should not rewrite if the url is the same', (t, done) => {
   t.plan(4)
   const fastify = Fastify({
     rewriteUrl (req) {
-      t.equal(req.url, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
       this.log.info('rewriting url')
       return req.url
     }
@@ -58,24 +57,24 @@ test('Should not rewrite if the url is the same', t => {
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 404)
+      done()
     })
   })
-
-  t.teardown(() => fastify.close())
 })
-test('Should throw an error', t => {
+
+test('Should throw an error', (t, done) => {
   t.plan(5)
   const fastify = Fastify({
     rewriteUrl (req) {
-      t.equal(req.url, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
       this.log.info('rewriting url')
       return undefined
     }
@@ -90,27 +89,26 @@ test('Should throw an error', t => {
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
     }, (err, response, body) => {
-      t.equal(err.code, 'ECONNRESET')
-      t.equal(response, undefined)
-      t.equal(body, undefined)
+      t.assert.strictEqual(err.code, 'ECONNRESET')
+      t.assert.strictEqual(response, undefined)
+      t.assert.strictEqual(body, undefined)
+      done()
     })
   })
-
-  t.teardown(() => fastify.close())
 })
 
-test('Should rewrite url but keep originalUrl unchanged', t => {
+test('Should rewrite url but keep originalUrl unchanged', (t, done) => {
   t.plan(7)
   const fastify = Fastify({
     rewriteUrl (req) {
-      t.equal(req.url, '/this-would-404-without-url-rewrite')
-      t.equal(req.originalUrl, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.url, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.originalUrl, '/this-would-404-without-url-rewrite')
       return '/'
     }
   })
@@ -120,23 +118,22 @@ test('Should rewrite url but keep originalUrl unchanged', t => {
     url: '/',
     handler: (req, reply) => {
       reply.send({ hello: 'world', hostname: req.hostname, port: req.port })
-      t.equal(req.originalUrl, '/this-would-404-without-url-rewrite')
+      t.assert.strictEqual(req.originalUrl, '/this-would-404-without-url-rewrite')
     }
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
-
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
     }, (err, response, body) => {
-      t.error(err)
+      t.assert.ifError(err)
       const parsedBody = JSON.parse(body)
-      t.same(parsedBody, { hello: 'world', hostname: 'localhost', port: fastify.server.address().port })
-      t.equal(response.statusCode, 200)
+      t.assert.deepStrictEqual(parsedBody, { hello: 'world', hostname: 'localhost', port: fastify.server.address().port })
+      t.assert.strictEqual(response.statusCode, 200)
+      done()
     })
   })
-
-  t.teardown(() => fastify.close())
 })

package/test/{useSemicolonDelimiter.test.js → use-semicolon-delimiter.test.js}

@@ -1,110 +1,110 @@
 '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('use semicolon delimiter default false', t => {
+test('use semicolon delimiter default false', (t, done) => {
   t.plan(4)
 
-  const fastify = Fastify({})
-
-  t.teardown(fastify.close.bind(fastify))
+  const fastify = Fastify()
 
   fastify.get('/1234;foo=bar', (req, reply) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-
+  fastify.listen({ port: 0, }, err => {
+    t.assert.ifError(err)
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234;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), {})
+      fastify.close()
+      done()
     })
   })
 })
 
-test('use semicolon delimiter set to true', t => {
+test('use semicolon delimiter set to true', (t, done) => {
   t.plan(4)
-
   const fastify = Fastify({
     useSemicolonDelimiter: true
   })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/1234', (req, reply) => {
     reply.send(req.query)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234;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), {
         foo: 'bar'
       })
+      fastify.close()
+      done()
     })
   })
 })
 
-test('use semicolon delimiter set to false', t => {
+test('use semicolon delimiter set to false', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({
     useSemicolonDelimiter: false
   })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/1234;foo=bar', (req, reply) => {
     reply.send(req.query)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234;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), {})
+      fastify.close()
+      done()
     })
   })
 })
 
-test('use semicolon delimiter set to false return 404', t => {
+test('use semicolon delimiter set to false return 404', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify({
     useSemicolonDelimiter: false
   })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.get('/1234', (req, reply) => {
     reply.send(req.query)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 404)
+      fastify.close()
+      done()
     })
   })
 })