fastify 5.0.0 → 5.2.0

package/test/http2/secure.test.js

@@ -1,16 +1,15 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../..')
 const h2url = require('h2url')
 const msg = { hello: 'world' }
 
 const { buildCertificate } = require('../build-certificate')
-t.before(buildCertificate)
+test.before(buildCertificate)
 
-test('secure', (t) => {
-  t.plan(5)
+test('secure', async (t) => {
+  t.plan(4)
 
   let fastify
   try {
@@ -21,9 +20,9 @@ test('secure', (t) => {
         cert: global.context.cert
       }
     })
-    t.pass('Key/cert successfully loaded')
+    t.assert.ok(true, 'Key/cert successfully loaded')
   } catch (e) {
-    t.fail('Key/cert loading failed', e)
+    t.assert.fail('Key/cert loading failed')
   }
 
   fastify.get('/', function (req, reply) {
@@ -36,35 +35,33 @@ test('secure', (t) => {
     reply.code(200).send({ hostname: req.hostname, port: req.port })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
+  await fastify.listen({ port: 0 })
 
-    t.test('https get request', async (t) => {
-      t.plan(3)
+  await t.test('https get request', async (t) => {
+    t.plan(3)
 
-      const url = `https://localhost:${fastify.server.address().port}`
-      const res = await h2url.concat({ url })
+    const url = `https://localhost:${fastify.server.address().port}`
+    const res = await h2url.concat({ url })
 
-      t.equal(res.headers[':status'], 200)
-      t.equal(res.headers['content-length'], '' + JSON.stringify(msg).length)
-      t.same(JSON.parse(res.body), msg)
-    })
+    t.assert.strictEqual(res.headers[':status'], 200)
+    t.assert.strictEqual(res.headers['content-length'], '' + JSON.stringify(msg).length)
+    t.assert.deepStrictEqual(JSON.parse(res.body), msg)
+  })
 
-    t.test('https get request without trust proxy - protocol', async (t) => {
-      t.plan(2)
+  await t.test('https get request without trust proxy - protocol', async (t) => {
+    t.plan(2)
 
-      const url = `https://localhost:${fastify.server.address().port}/proto`
-      t.same(JSON.parse((await h2url.concat({ url })).body), { proto: 'https' })
-      t.same(JSON.parse((await h2url.concat({ url, headers: { 'X-Forwarded-Proto': 'lorem' } })).body), { proto: 'https' })
-    })
-    t.test('https get request - test hostname and port', async (t) => {
-      t.plan(2)
+    const url = `https://localhost:${fastify.server.address().port}/proto`
+    t.assert.deepStrictEqual(JSON.parse((await h2url.concat({ url })).body), { proto: 'https' })
+    t.assert.deepStrictEqual(JSON.parse((await h2url.concat({ url, headers: { 'X-Forwarded-Proto': 'lorem' } })).body), { proto: 'https' })
+  })
+  await t.test('https get request - test hostname and port', async (t) => {
+    t.plan(2)
 
-      const url = `https://localhost:${fastify.server.address().port}/hostname_port`
-      const parsedbody = JSON.parse((await h2url.concat({ url })).body)
-      t.equal(parsedbody.hostname, 'localhost')
-      t.equal(parsedbody.port, fastify.server.address().port)
-    })
+    const url = `https://localhost:${fastify.server.address().port}/hostname_port`
+    const parsedbody = JSON.parse((await h2url.concat({ url })).body)
+    t.assert.strictEqual(parsedbody.hostname, 'localhost')
+    t.assert.strictEqual(parsedbody.port, fastify.server.address().port)
   })
 })

package/test/http2/unknown-http-method.test.js

@@ -1,31 +1,30 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../..')
 const h2url = require('h2url')
 const msg = { hello: 'world' }
 
-const fastify = Fastify({
-  http2: true
-})
+test('http2 unknown http method', async t => {
+  const fastify = Fastify({
+    http2: true
+  })
 
-fastify.get('/', function (req, reply) {
-  reply.code(200).send(msg)
-})
+  fastify.get('/', function (req, reply) {
+    reply.code(200).send(msg)
+  })
 
-fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => { fastify.close() })
+  t.after(() => { fastify.close() })
+  await fastify.listen({ port: 0 })
 
-  test('http UNKNOWN_METHOD request', async (t) => {
+  await t.test('http UNKNOWN_METHOD request', async (t) => {
     t.plan(2)
 
     const url = `http://localhost:${fastify.server.address().port}`
     const res = await h2url.concat({ url, method: 'UNKNOWN_METHOD' })
 
-    t.equal(res.headers[':status'], 404)
-    t.same(JSON.parse(res.body), {
+    t.assert.strictEqual(res.headers[':status'], 404)
+    t.assert.deepStrictEqual(JSON.parse(res.body), {
       statusCode: 404,
       code: 'FST_ERR_NOT_FOUND',
       error: 'Not Found',

package/test/https/custom-https-server.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 https = require('node:https')
 const dns = require('node:dns').promises
@@ -18,7 +17,7 @@ async function setup () {
 
     const fastify = Fastify({
       serverFactory: (handler, opts) => {
-        t.ok(opts.serverFactory, 'it is called once for localhost')
+        t.assert.ok(opts.serverFactory, 'it is called once for localhost')
 
         const options = {
           key: global.context.key,
@@ -34,10 +33,10 @@ async function setup () {
       }
     })
 
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => { fastify.close() })
 
     fastify.get('/', (req, reply) => {
-      t.ok(req.raw.custom)
+      t.assert.ok(req.raw.custom)
       reply.send({ hello: 'world' })
     })
 
@@ -52,8 +51,8 @@ async function setup () {
         if (err) {
           return reject(err)
         }
-        t.equal(response.statusCode, 200)
-        t.same(JSON.parse(body), { hello: 'world' })
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
         resolve()
       })
     })

package/test/https/https.test.js

@@ -1,15 +1,14 @@
 '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 { buildCertificate } = require('../build-certificate')
-t.before(buildCertificate)
+test.before(buildCertificate)
 
-test('https', (t) => {
-  t.plan(4)
+test('https', async (t) => {
+  t.plan(3)
 
   let fastify
   try {
@@ -19,9 +18,9 @@ test('https', (t) => {
         cert: global.context.cert
       }
     })
-    t.pass('Key/cert successfully loaded')
+    t.assert.ok('Key/cert successfully loaded')
   } catch (e) {
-    t.fail('Key/cert loading failed', e)
+    t.assert.fail('Key/cert loading failed')
   }
 
   fastify.get('/', function (req, reply) {
@@ -32,51 +31,52 @@ test('https', (t) => {
     reply.code(200).send({ proto: req.protocol })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+  await fastify.listen({ port: 0 })
 
-    t.test('https get request', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'https://localhost:' + fastify.server.address().port,
-        rejectUnauthorized: false
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.equal(response.headers['content-length'], '' + body.length)
-        t.same(JSON.parse(body), { hello: 'world' })
-      })
+  t.after(() => { fastify.close() })
+
+  await t.test('https get request', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'https://localhost:' + fastify.server.address().port,
+      rejectUnauthorized: false
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      done()
     })
+  })
 
-    t.test('https get request without trust proxy - protocol', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'https://localhost:' + fastify.server.address().port + '/proto',
-        rejectUnauthorized: false
-      }, (err, response, body) => {
-        t.error(err)
-        t.same(JSON.parse(body), { proto: 'https' })
-      })
-      sget({
-        method: 'GET',
-        url: 'https://localhost:' + fastify.server.address().port + '/proto',
-        rejectUnauthorized: false,
-        headers: {
-          'x-forwarded-proto': 'lorem'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.same(JSON.parse(body), { proto: 'https' })
-      })
+  await t.test('https get request without trust proxy - protocol', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'https://localhost:' + fastify.server.address().port + '/proto',
+      rejectUnauthorized: false
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(JSON.parse(body), { proto: 'https' })
+    })
+    sget({
+      method: 'GET',
+      url: 'https://localhost:' + fastify.server.address().port + '/proto',
+      rejectUnauthorized: false,
+      headers: {
+        'x-forwarded-proto': 'lorem'
+      }
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(JSON.parse(body), { proto: 'https' })
+      done()
     })
   })
 })
 
-test('https - headers', (t) => {
-  t.plan(4)
+test('https - headers', async (t) => {
+  t.plan(3)
   let fastify
   try {
     fastify = Fastify({
@@ -85,49 +85,49 @@ test('https - headers', (t) => {
         cert: global.context.cert
       }
     })
-    t.pass('Key/cert successfully loaded')
+    t.assert.ok('Key/cert successfully loaded')
   } catch (e) {
-    t.fail('Key/cert loading failed', e)
+    t.assert.fail('Key/cert loading failed')
   }
 
   fastify.get('/', function (req, reply) {
     reply.code(200).send({ hello: 'world', hostname: req.hostname, port: req.port })
   })
 
-  t.teardown(async () => { await fastify.close() })
+  t.after(async () => { await fastify.close() })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  await fastify.listen({ port: 0 })
 
-    t.test('https get request', t => {
-      t.plan(4)
-      sget({
-        method: 'GET',
-        url: 'https://localhost:' + fastify.server.address().port,
-        rejectUnauthorized: false
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        const parsedBody = JSON.parse(body)
-        t.equal(parsedBody.hostname, 'localhost')
-        t.equal(parsedBody.port, fastify.server.address().port)
-      })
+  await t.test('https get request', (t, done) => {
+    t.plan(4)
+    sget({
+      method: 'GET',
+      url: 'https://localhost:' + fastify.server.address().port,
+      rejectUnauthorized: false
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      const parsedBody = JSON.parse(body)
+      t.assert.strictEqual(parsedBody.hostname, 'localhost')
+      t.assert.strictEqual(parsedBody.port, fastify.server.address().port)
+      done()
     })
-    t.test('https get request - test port fall back', t => {
-      t.plan(3)
-      sget({
-        method: 'GET',
-        headers: {
-          host: 'example.com'
-        },
-        url: 'https://localhost:' + fastify.server.address().port,
-        rejectUnauthorized: false
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        const parsedBody = JSON.parse(body)
-        t.equal(parsedBody.port, null)
-      })
+  })
+  await t.test('https get request - test port fall back', (t, done) => {
+    t.plan(3)
+    sget({
+      method: 'GET',
+      headers: {
+        host: 'example.com'
+      },
+      url: 'https://localhost:' + fastify.server.address().port,
+      rejectUnauthorized: false
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      const parsedBody = JSON.parse(body)
+      t.assert.strictEqual(parsedBody.port, null)
+      done()
     })
   })
 })

package/test/imports.test.js

@@ -1,18 +1,17 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
 test('should import as default', t => {
   t.plan(2)
   const fastify = require('..')
-  t.ok(fastify)
-  t.equal(typeof fastify, 'function')
+  t.assert.ok(fastify)
+  t.assert.strictEqual(typeof fastify, 'function')
 })
 
 test('should import as esm', t => {
   t.plan(2)
   const { fastify } = require('..')
-  t.ok(fastify)
-  t.equal(typeof fastify, 'function')
+  t.assert.ok(fastify)
+  t.assert.strictEqual(typeof fastify, 'function')
 })

package/test/internals/all.test.js

@@ -1,10 +1,9 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../..')
 
-test('fastify.all should add all the methods to the same url', t => {
+test('fastify.all should add all the methods to the same url', async t => {
   const fastify = Fastify()
 
   const requirePayload = [
@@ -14,15 +13,15 @@ test('fastify.all should add all the methods to the same url', t => {
   ]
 
   const supportedMethods = fastify.supportedMethods
-  t.plan(supportedMethods.length * 2)
+  t.plan(supportedMethods.length)
 
   fastify.all('/', (req, reply) => {
     reply.send({ method: req.raw.method })
   })
 
-  supportedMethods.forEach(injectRequest)
+  await Promise.all(supportedMethods.map(async method => injectRequest(method)))
 
-  function injectRequest (method) {
+  async function injectRequest (method) {
     const options = {
       url: '/',
       method
@@ -32,10 +31,8 @@ test('fastify.all should add all the methods to the same url', t => {
       options.payload = { hello: 'world' }
     }
 
-    fastify.inject(options, (err, res) => {
-      t.error(err)
-      const payload = JSON.parse(res.payload)
-      t.same(payload, { method })
-    })
+    const res = await fastify.inject(options)
+    const payload = JSON.parse(res.payload)
+    t.assert.deepStrictEqual(payload, { method })
   }
 })

package/test/internals/{contentTypeParser.test.js → content-type-parser.test.js}

@@ -1,8 +1,7 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const proxyquire = require('proxyquire')
-const test = t.test
 const { Readable } = require('node:stream')
 const { kTestInternals, kRouteContext } = require('../../lib/symbols')
 const Request = require('../../lib/request')
@@ -17,8 +16,8 @@ test('rawBody function', t => {
     asString: true,
     asBuffer: false,
     fn (req, bodyInString, done) {
-      t.equal(bodyInString, body.toString())
-      t.equal(typeof done, 'function')
+      t.assert.strictEqual(bodyInString, body.toString())
+      t.assert.strictEqual(typeof done, 'function')
       return {
         then (cb) {
           cb()
@@ -70,8 +69,8 @@ test('Should support Webpack and faux modules', t => {
     asString: true,
     asBuffer: false,
     fn (req, bodyInString, done) {
-      t.equal(bodyInString, body.toString())
-      t.equal(typeof done, 'function')
+      t.assert.strictEqual(bodyInString, body.toString())
+      t.assert.strictEqual(typeof done, 'function')
       return {
         then (cb) {
           cb()

package/test/internals/context.test.js

@@ -1,23 +1,23 @@
 'use strict'
 
-const { test } = require('tap')
-
+const { test } = require('node:test')
 const { kRouteContext } = require('../../lib/symbols')
 const Context = require('../../lib/context')
 
 const Fastify = require('../..')
 
-test('context', context => {
+test('context', async context => {
   context.plan(1)
 
-  context.test('Should not contain undefined as key prop', async t => {
+  await context.test('Should not contain undefined as key prop', async t => {
+    t.plan(4)
     const app = Fastify()
 
     app.get('/', (req, reply) => {
-      t.type(req[kRouteContext], Context)
-      t.type(reply[kRouteContext], Context)
-      t.notOk('undefined' in reply[kRouteContext])
-      t.notOk('undefined' in req[kRouteContext])
+      t.assert.ok(req[kRouteContext] instanceof Context)
+      t.assert.ok(reply[kRouteContext] instanceof Context)
+      t.assert.ok(!('undefined' in reply[kRouteContext]))
+      t.assert.ok(!('undefined' in req[kRouteContext]))
 
       reply.send('hello world!')
     })
@@ -25,9 +25,7 @@ test('context', context => {
     try {
       await app.inject('/')
     } catch (e) {
-      t.fail(e)
+      t.assert.fail(e)
     }
-
-    t.plan(4)
   })
 })

package/test/internals/decorator.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const decorator = require('../../lib/decorate')
 const {
   kState
@@ -22,7 +21,7 @@ test('decorate should add the given method to its instance', t => {
 
   const server = build()
   server.add('test', () => {})
-  t.ok(server.test)
+  t.assert.ok(server.test)
 })
 
 test('decorate is chainable', t => {
@@ -44,15 +43,15 @@ test('decorate is chainable', t => {
     .add('test2', () => {})
     .add('test3', () => {})
 
-  t.ok(server.test1)
-  t.ok(server.test2)
-  t.ok(server.test3)
+  t.assert.ok(server.test1)
+  t.assert.ok(server.test2)
+  t.assert.ok(server.test3)
 })
 
 test('checkExistence should check if a property is part of the given instance', t => {
   t.plan(1)
   const instance = { test: () => {} }
-  t.ok(decorator.exist(instance, 'test'))
+  t.assert.ok(decorator.exist(instance, 'test'))
 })
 
 test('checkExistence should find the instance if not given', t => {
@@ -71,7 +70,7 @@ test('checkExistence should find the instance if not given', t => {
 
   const server = build()
   server.add('test', () => {})
-  t.ok(server.check('test'))
+  t.assert.ok(server.check('test'))
 })
 
 test('checkExistence should check the prototype as well', t => {
@@ -80,7 +79,7 @@ test('checkExistence should check the prototype as well', t => {
   Instance.prototype.test = () => {}
 
   const instance = new Instance()
-  t.ok(decorator.exist(instance, 'test'))
+  t.assert.ok(decorator.exist(instance, 'test'))
 })
 
 test('checkDependencies should throw if a dependency is not present', t => {
@@ -88,10 +87,10 @@ test('checkDependencies should throw if a dependency is not present', t => {
   const instance = {}
   try {
     decorator.dependencies(instance, 'foo', ['test'])
-    t.fail()
+    t.assert.fail()
   } catch (e) {
-    t.equal(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
-    t.equal(e.message, 'The decorator is missing dependency \'test\'.')
+    t.assert.strictEqual(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
+    t.assert.strictEqual(e.message, 'The decorator is missing dependency \'test\'.')
   }
 })
 
@@ -112,10 +111,10 @@ test('decorate should internally call checkDependencies', t => {
 
   try {
     server.add('method', () => {}, ['test'])
-    t.fail()
+    t.assert.fail()
   } catch (e) {
-    t.equal(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
-    t.equal(e.message, 'The decorator is missing dependency \'test\'.')
+    t.assert.strictEqual(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
+    t.assert.strictEqual(e.message, 'The decorator is missing dependency \'test\'.')
   }
 })
 
@@ -132,14 +131,14 @@ test('decorate should recognize getter/setter objects', t => {
   decorator.add.call(one, 'foo', {
     getter: () => this._a,
     setter: (val) => {
-      t.pass()
+      t.assert.ok(true)
       this._a = val
     }
   })
-  t.equal(Object.hasOwn(one, 'foo'), true)
-  t.equal(one.foo, undefined)
+  t.assert.strictEqual(Object.hasOwn(one, 'foo'), true)
+  t.assert.strictEqual(one.foo, undefined)
   one.foo = 'a'
-  t.equal(one.foo, 'a')
+  t.assert.strictEqual(one.foo, 'a')
 
   // getter only
   const two = {
@@ -152,6 +151,6 @@ test('decorate should recognize getter/setter objects', t => {
   decorator.add.call(two, 'foo', {
     getter: () => 'a getter'
   })
-  t.equal(Object.hasOwn(two, 'foo'), true)
-  t.equal(two.foo, 'a getter')
+  t.assert.strictEqual(Object.hasOwn(two, 'foo'), true)
+  t.assert.strictEqual(two.foo, 'a getter')
 })