fastify 5.2.0 → 5.2.2

package/test/listen.4.test.js

@@ -1,11 +1,12 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const dns = require('node:dns').promises
 const dnsCb = require('node:dns')
 const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const helper = require('./helper')
+const { waitForCb } = require('./toolkit')
 
 let localhostForURL
 
@@ -22,64 +23,69 @@ before(async function () {
   [, localhostForURL] = await helper.getLoopbackHost()
 })
 
-test('listen twice on the same port without callback rejects', t => {
+test('listen twice on the same port without callback rejects', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 })
     .then(() => {
-      const s2 = Fastify()
-      t.teardown(s2.close.bind(s2))
-      s2.listen({ port: fastify.server.address().port })
+      const server2 = Fastify()
+      t.after(() => server2.close())
+      server2.listen({ port: fastify.server.address().port })
         .catch(err => {
-          t.ok(err)
+          t.assert.ok(err)
+          done()
         })
     })
-    .catch(err => t.error(err))
+    .catch(err => {
+      t.assert.ifError(err)
+    })
 })
 
-test('listen twice on the same port without callback rejects with (address)', t => {
+test('listen twice on the same port without callback rejects with (address)', (t, done) => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 })
     .then(address => {
-      const s2 = Fastify()
-      t.teardown(s2.close.bind(s2))
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-      s2.listen({ port: fastify.server.address().port })
+      const server2 = Fastify()
+      t.after(() => server2.close())
+      t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+
+      server2.listen({ port: fastify.server.address().port })
         .catch(err => {
-          t.ok(err)
+          t.assert.ok(err)
+          done()
         })
     })
-    .catch(err => t.error(err))
+    .catch(err => {
+      t.assert.ifError(err)
+    })
 })
 
 test('listen on invalid port without callback rejects', t => {
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   return fastify.listen({ port: -1 })
     .catch(err => {
-      t.ok(err)
+      t.assert.ok(err)
       return true
     })
 })
 
-test('listen logs the port as info', t => {
+test('listen logs the port as info', async t => {
   t.plan(1)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   const msgs = []
   fastify.log.info = function (msg) {
     msgs.push(msg)
   }
 
-  fastify.listen({ port: 0 })
-    .then(() => {
-      t.ok(/http:\/\//.test(msgs[0]))
-    })
+  await fastify.listen({ port: 0 })
+  t.assert.ok(/http:\/\//.test(msgs[0]))
 })
 
 test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
@@ -88,7 +94,7 @@ test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
 
   const app = Fastify()
   app.get('/', async () => 'hello localhost')
-  t.teardown(app.close.bind(app))
+  t.after(() => app.close())
   await app.listen({ port: 0, host: 'localhost' })
 
   for (const lookup of localAddresses) {
@@ -98,34 +104,43 @@ test('listen on localhost binds IPv4 and IPv6 - promise interface', async t => {
         url: getUrl(app, lookup)
       }, (err, response, body) => {
         if (err) { return reject(err) }
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), 'hello localhost')
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body.toString(), 'hello localhost')
         resolve()
       })
     })
   }
 })
 
-test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', t => {
+test('listen on localhost binds to all interfaces (both IPv4 and IPv6 if present) - callback interface', (t, done) => {
   dnsCb.lookup('localhost', { all: true }, (err, lookups) => {
     t.plan(2 + (3 * lookups.length))
-    t.error(err)
+    t.assert.ifError(err)
 
     const app = Fastify()
     app.get('/', async () => 'hello localhost')
     app.listen({ port: 0, host: 'localhost' }, (err) => {
-      t.error(err)
-      t.teardown(app.close.bind(app))
-
-      for (const lookup of lookups) {
-        sget({
-          method: 'GET',
-          url: getUrl(app, lookup)
-        }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
-          t.same(body.toString(), 'hello localhost')
-        })
+      t.assert.ifError(err)
+      t.after(() => app.close())
+
+      const { stepIn, patience } = waitForCb({ steps: lookups.length })
+
+      // Loop over each lookup and perform the assertions
+      if (lookups.length > 0) {
+        for (const lookup of lookups) {
+          sget({
+            method: 'GET',
+            url: getUrl(app, lookup)
+          }, (err, response, body) => {
+            t.assert.ifError(err)
+            t.assert.strictEqual(response.statusCode, 200)
+            t.assert.deepStrictEqual(body.toString(), 'hello localhost')
+            // Call stepIn to report that a request has been completed
+            stepIn()
+          })
+        }
+        // When all requests have been completed, call done
+        patience.then(() => done())
       }
     })
   })
@@ -137,11 +152,12 @@ test('addresses getter', async t => {
   t.plan(4)
   const app = Fastify()
   app.get('/', async () => 'hello localhost')
+  t.after(() => app.close())
 
-  t.same(app.addresses(), [], 'before ready')
+  t.assert.deepStrictEqual(app.addresses(), [], 'before ready')
   await app.ready()
 
-  t.same(app.addresses(), [], 'after ready')
+  t.assert.deepStrictEqual(app.addresses(), [], 'after ready')
   await app.listen({ port: 0, host: 'localhost' })
 
   // fix citgm
@@ -157,8 +173,8 @@ test('addresses getter', async t => {
     family: typeof a.family === 'number' ? 'IPv' + a.family : a.family
   })).sort()
 
-  t.same(appAddresses, localAddresses, 'after listen')
+  t.assert.deepStrictEqual(appAddresses, localAddresses, 'after listen')
 
   await app.close()
-  t.same(app.addresses(), [], 'after close')
+  t.assert.deepStrictEqual(app.addresses(), [], 'after close')
 })

package/test/listen.5.test.js

@@ -4,6 +4,7 @@ const { test } = require('node:test')
 const net = require('node:net')
 const Fastify = require('../fastify')
 const { once } = require('node:events')
+const { FSTWRN003 } = require('../lib/warnings.js')
 
 function createDeferredPromise () {
   const promise = {}
@@ -97,3 +98,25 @@ test('same port conflict and success should not fire callback multiple times - p
   await fastify.listen()
   await fastify.close()
 })
+
+test('should emit a warning when using async callback', (t, done) => {
+  t.plan(2)
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.assert.strictEqual(warning.name, 'FastifyWarning')
+    t.assert.strictEqual(warning.code, FSTWRN003.code)
+  }
+
+  const fastify = Fastify()
+
+  t.after(async () => {
+    await fastify.close()
+    process.removeListener('warning', onWarning)
+    FSTWRN003.emitted = false
+  })
+
+  fastify.listen({ port: 0 }, async function doNotUseAsyncCallback () {
+    done()
+  })
+})

package/test/nullable-validation.test.js

@@ -1,18 +1,17 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('..')
 
-test('nullable string', t => {
+test('nullable string', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
   fastify.route({
     method: 'POST',
     url: '/',
     handler: (req, reply) => {
-      t.same(req.body.hello, null)
+      t.assert.strictEqual(req.body.hello, null)
       reply.code(200).send(req.body)
     },
     schema: {
@@ -47,12 +46,13 @@ test('nullable string', t => {
       hello: null
     }
   }, (err, res) => {
-    t.error(err)
-    t.same(res.payload.hello, null)
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.json().hello, null)
+    done()
   })
 })
 
-test('object or null body', t => {
+test('object or null body', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -61,7 +61,7 @@ test('object or null body', t => {
     method: 'POST',
     url: '/',
     handler: (req, reply) => {
-      t.equal(req.body, undefined)
+      t.assert.strictEqual(req.body, undefined)
       reply.code(200).send({ isUndefinedBody: req.body === undefined })
     },
     schema: {
@@ -89,21 +89,22 @@ test('object or null body', t => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'POST',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), { isUndefinedBody: true })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), { isUndefinedBody: true })
+      done()
     })
   })
 })
 
-test('nullable body', t => {
+test('nullable body', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -112,7 +113,7 @@ test('nullable body', t => {
     method: 'POST',
     url: '/',
     handler: (req, reply) => {
-      t.equal(req.body, undefined)
+      t.assert.strictEqual(req.body, undefined)
       reply.code(200).send({ isUndefinedBody: req.body === undefined })
     },
     schema: {
@@ -141,21 +142,22 @@ test('nullable body', t => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     sget({
       method: 'POST',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), { isUndefinedBody: true })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), { isUndefinedBody: true })
+      done()
     })
   })
 })
 
-test('Nullable body with 204', t => {
+test('Nullable body with 204', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -164,7 +166,7 @@ test('Nullable body with 204', t => {
     method: 'POST',
     url: '/',
     handler: (req, reply) => {
-      t.equal(req.body, undefined)
+      t.assert.strictEqual(req.body, undefined)
       reply.code(204).send()
     },
     schema: {
@@ -182,16 +184,17 @@ test('Nullable body with 204', t => {
   })
 
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     sget({
       method: 'POST',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 204)
-      t.equal(body.length, 0)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 204)
+      t.assert.strictEqual(body.length, 0)
+      done()
     })
   })
 })

package/test/register.test.js

@@ -1,21 +1,20 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('..')
 
-test('register', t => {
-  t.plan(17)
+test('register', async (t) => {
+  t.plan(14)
 
   const fastify = Fastify()
 
   fastify.register(function (instance, opts, done) {
-    t.not(instance, fastify)
-    t.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
+    t.assert.notStrictEqual(instance, fastify)
+    t.assert.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
 
-    t.equal(typeof opts, 'object')
-    t.equal(typeof done, 'function')
+    t.assert.strictEqual(typeof opts, 'object')
+    t.assert.strictEqual(typeof done, 'function')
 
     instance.get('/first', function (req, reply) {
       reply.send({ hello: 'world' })
@@ -24,11 +23,11 @@ test('register', t => {
   })
 
   fastify.register(function (instance, opts, done) {
-    t.not(instance, fastify)
-    t.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
+    t.assert.notStrictEqual(instance, fastify)
+    t.assert.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
 
-    t.equal(typeof opts, 'object')
-    t.equal(typeof done, 'function')
+    t.assert.strictEqual(typeof opts, 'object')
+    t.assert.strictEqual(typeof done, 'function')
 
     instance.get('/second', function (req, reply) {
       reply.send({ hello: 'world' })
@@ -36,28 +35,32 @@ test('register', t => {
     done()
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
-
-    makeRequest('first')
-    makeRequest('second')
-  })
-
-  function makeRequest (path) {
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/' + path
-    }, (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' })
+  await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  await makeRequest('first')
+  await makeRequest('second')
+
+  async function makeRequest (path) {
+    return new Promise((resolve, reject) => {
+      sget({
+        method: 'GET',
+        url: 'http://localhost:' + fastify.server.address().port + '/' + path
+      }, (err, response, body) => {
+        if (err) {
+          t.assert.ifError(err)
+          return reject(err)
+        }
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+        resolve()
+      })
     })
   }
 })
 
-test('internal route declaration should pass the error generated by the register to the done handler / 1', t => {
+test('internal route declaration should pass the error generated by the register to the done handler / 1', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -70,12 +73,13 @@ test('internal route declaration should pass the error generated by the register
   })
 
   fastify.listen({ port: 0 }, err => {
-    fastify.close()
-    t.equal(err.message, 'kaboom')
+    t.after(() => fastify.close())
+    t.assert.strictEqual(err.message, 'kaboom')
+    done()
   })
 })
 
-test('internal route declaration should pass the error generated by the register to the done handler / 2', t => {
+test('internal route declaration should pass the error generated by the register to the done handler / 2', (t, done) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -88,12 +92,13 @@ test('internal route declaration should pass the error generated by the register
   })
 
   fastify.after(err => {
-    t.equal(err.message, 'kaboom')
+    t.assert.strictEqual(err.message, 'kaboom')
   })
 
   fastify.listen({ port: 0 }, err => {
-    fastify.close()
-    t.error(err)
+    t.after(() => fastify.close())
+    t.assert.ifError(err)
+    done()
   })
 })
 
@@ -107,25 +112,25 @@ test('awaitable register and after', async t => {
     first = true
   })
 
-  t.equal(first, true)
+  t.assert.strictEqual(first, true)
 
   fastify.register(async (instance, opts) => {
     second = true
   })
 
   await fastify.after()
-  t.equal(second, true)
+  t.assert.strictEqual(second, true)
 
   fastify.register(async (instance, opts) => {
     third = true
   })
 
   await fastify.ready()
-  t.equal(third, true)
+  t.assert.strictEqual(third, true)
 })
 
 function thenableRejects (t, promise, error) {
-  return t.rejects(async () => { await promise }, error)
+  return t.assert.rejects(async () => { await promise }, error)
 }
 
 test('awaitable register error handling', async t => {
@@ -138,13 +143,13 @@ test('awaitable register error handling', async t => {
   }), e)
 
   fastify.register(async (instance, opts) => {
-    t.fail('should not be executed')
+    t.assert.fail('should not be executed')
   })
 
-  await t.rejects(fastify.after(), e)
+  await t.assert.rejects(fastify.after(), e)
 
   fastify.register(async (instance, opts) => {
-    t.fail('should not be executed')
+    t.assert.fail('should not be executed')
   })
 
   await thenableRejects(t, fastify.ready(), e)
@@ -160,16 +165,16 @@ test('awaitable after error handling', async t => {
   })
 
   fastify.register(async (instance, opts) => {
-    t.fail('should not be executed')
+    t.assert.fail('should not be executed')
   })
 
-  await t.rejects(fastify.after(), e)
+  await t.assert.rejects(fastify.after(), e)
 
   fastify.register(async (instance, opts) => {
-    t.fail('should not be executed')
+    t.assert.fail('should not be executed')
   })
 
-  await t.rejects(fastify.ready())
+  await t.assert.rejects(fastify.ready())
 })
 
 test('chainable register', async t => {
@@ -178,11 +183,11 @@ test('chainable register', async t => {
   const fastify = Fastify()
 
   fastify.register(async () => {
-    t.pass('first loaded')
+    t.assert.ok('first loaded')
   }).register(async () => {
-    t.pass('second loaded')
+    t.assert.ok('second loaded')
   }).register(async () => {
-    t.pass('third loaded')
+    t.assert.ok('third loaded')
   })
 
   await fastify.ready()