fastify 5.2.2 → 5.3.1

package/test/custom-querystring-parser.test.js

@@ -1,49 +1,55 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const querystring = require('node:querystring')
 const sget = require('simple-get').concat
 const Fastify = require('..')
+const { waitForCb } = require('./toolkit')
 
 test('Custom querystring parser', t => {
   t.plan(9)
 
   const fastify = Fastify({
     querystringParser: function (str) {
-      t.equal(str, 'foo=bar&baz=faz')
+      t.assert.strictEqual(str, 'foo=bar&baz=faz')
       return querystring.parse(str)
     }
   })
 
   fastify.get('/', (req, reply) => {
-    t.same(req.query, {
+    t.assert.deepEqual(req.query, {
       foo: 'bar',
       baz: 'faz'
     })
     reply.send({ hello: 'world' })
   })
 
+  const completion = waitForCb({ steps: 2 })
+
   fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
-    t.teardown(() => fastify.close())
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     sget({
       method: 'GET',
       url: `${address}?foo=bar&baz=faz`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      completion.stepIn()
     })
 
     fastify.inject({
       method: 'GET',
       url: `${address}?foo=bar&baz=faz`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      completion.stepIn()
     })
   })
+
+  return completion.patience
 })
 
 test('Custom querystring parser should be called also if there is nothing to parse', t => {
@@ -51,36 +57,42 @@ test('Custom querystring parser should be called also if there is nothing to par
 
   const fastify = Fastify({
     querystringParser: function (str) {
-      t.equal(str, '')
+      t.assert.strictEqual(str, '')
       return querystring.parse(str)
     }
   })
 
   fastify.get('/', (req, reply) => {
-    t.same(req.query, {})
+    t.assert.deepEqual(req.query, {})
     reply.send({ hello: 'world' })
   })
 
+  const completion = waitForCb({ steps: 2 })
+
   fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
-    t.teardown(() => fastify.close())
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     sget({
       method: 'GET',
       url: address
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      completion.stepIn()
     })
 
     fastify.inject({
       method: 'GET',
       url: address
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      completion.stepIn()
     })
   })
+
+  return completion.patience
 })
 
 test('Querystring without value', t => {
@@ -88,36 +100,42 @@ test('Querystring without value', t => {
 
   const fastify = Fastify({
     querystringParser: function (str) {
-      t.equal(str, 'foo')
+      t.assert.strictEqual(str, 'foo')
       return querystring.parse(str)
     }
   })
 
   fastify.get('/', (req, reply) => {
-    t.same(req.query, { foo: '' })
+    t.assert.deepEqual(req.query, { foo: '' })
     reply.send({ hello: 'world' })
   })
 
+  const completion = waitForCb({ steps: 2 })
+
   fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
-    t.teardown(() => fastify.close())
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
 
     sget({
       method: 'GET',
       url: `${address}?foo`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      completion.stepIn()
     })
 
     fastify.inject({
       method: 'GET',
       url: `${address}?foo`
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      completion.stepIn()
     })
   })
+
+  return completion.patience
 })
 
 test('Custom querystring parser should be a function', t => {
@@ -127,9 +145,9 @@ test('Custom querystring parser should be a function', t => {
     Fastify({
       querystringParser: 10
     })
-    t.fail('Should throw')
+    t.assert.fail('Should throw')
   } catch (err) {
-    t.equal(
+    t.assert.strictEqual(
       err.message,
       "querystringParser option should be a function, instead got 'number'"
     )

package/test/decorator.test.js

@@ -925,9 +925,9 @@ test('Request/reply decorators should be able to access the server instance', as
   server.decorateRequest('assert', rootAssert)
   server.decorateReply('assert', rootAssert)
 
-  server.get('/root-assert', async (req, rep) => {
+  server.get('/root-assert', async (req, res) => {
     req.assert()
-    rep.assert()
+    res.assert()
     return 'done'
   })
 
@@ -936,9 +936,9 @@ test('Request/reply decorators should be able to access the server instance', as
     instance.decorateReply('assert', nestedAssert)
     instance.decorate('foo', 'bar')
 
-    instance.get('/nested-assert', async (req, rep) => {
+    instance.get('/nested-assert', async (req, res) => {
       req.assert()
-      rep.assert()
+      res.assert()
       return 'done'
     })
   })
@@ -1260,3 +1260,173 @@ test('chain of decorators on Reply', async (t) => {
     t.equal(response.body, 'tata')
   }
 })
+
+test('getDecorator should return the decorator', t => {
+  t.plan(12)
+  const fastify = Fastify()
+
+  fastify.decorate('root', 'from_root')
+  fastify.decorateRequest('root', 'from_root_request')
+  fastify.decorateReply('root', 'from_root_reply')
+
+  t.equal(fastify.getDecorator('root'), 'from_root')
+  fastify.get('/', async (req, res) => {
+    t.equal(req.getDecorator('root'), 'from_root_request')
+    t.equal(res.getDecorator('root'), 'from_root_reply')
+
+    res.send()
+  })
+
+  fastify.register((child) => {
+    child.decorate('child', 'from_child')
+
+    t.equal(child.getDecorator('child'), 'from_child')
+    t.equal(child.getDecorator('root'), 'from_root')
+
+    child.get('/child', async (req, res) => {
+      t.equal(req.getDecorator('root'), 'from_root_request')
+      t.equal(res.getDecorator('root'), 'from_root_reply')
+
+      res.send()
+    })
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+
+    fastify.inject({ url: '/child' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+  })
+})
+
+test('getDecorator should return function decorators with expected binded context', t => {
+  t.plan(12)
+  const fastify = Fastify()
+
+  fastify.decorate('a', function () {
+    return this
+  })
+  fastify.decorateRequest('b', function () {
+    return this
+  })
+  fastify.decorateReply('c', function () {
+    return this
+  })
+
+  fastify.register((child) => {
+    child.decorate('a', function () {
+      return this
+    })
+
+    t.same(child.getDecorator('a')(), child)
+    child.get('/child', async (req, res) => {
+      t.same(req.getDecorator('b')(), req)
+      t.same(res.getDecorator('c')(), res)
+
+      res.send()
+    })
+  })
+
+  t.same(fastify.getDecorator('a')(), fastify)
+  fastify.get('/', async (req, res) => {
+    t.same(req.getDecorator('b')(), req)
+    t.same(res.getDecorator('c')(), res)
+
+    res.send()
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+
+    fastify.inject({ url: '/child' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+
+    t.pass()
+  })
+})
+
+test('getDecorator should only return decorators existing in the scope', t => {
+  t.plan(9)
+
+  function assertsThrowOnUndeclaredDecorator (notDecorated, instanceType) {
+    try {
+      notDecorated.getDecorator('foo')
+      t.fail()
+    } catch (e) {
+      t.same(e.code, 'FST_ERR_DEC_UNDECLARED')
+      t.same(e.message, `No decorator 'foo' has been declared on ${instanceType}.`)
+    }
+  }
+
+  const fastify = Fastify()
+  fastify.register(child => {
+    child.decorate('foo', true)
+    child.decorateRequest('foo', true)
+    child.decorateReply('foo', true)
+  })
+
+  fastify.get('/', async (req, res) => {
+    assertsThrowOnUndeclaredDecorator(req, 'request')
+    assertsThrowOnUndeclaredDecorator(res, 'reply')
+
+    return { hello: 'world' }
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+
+    assertsThrowOnUndeclaredDecorator(fastify, 'instance')
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+  })
+})
+
+test('Request.setDecorator should update an existing decorator', t => {
+  t.plan(7)
+  const fastify = Fastify()
+
+  fastify.decorateRequest('session', null)
+  fastify.decorateRequest('utility', null)
+  fastify.addHook('onRequest', async (req, reply) => {
+    req.setDecorator('session', { user: 'Jean' })
+    req.setDecorator('utility', function () {
+      return this
+    })
+    try {
+      req.setDecorator('foo', { user: 'Jean' })
+      t.fail()
+    } catch (e) {
+      t.same(e.code, 'FST_ERR_DEC_UNDECLARED')
+      t.same(e.message, "No decorator 'foo' has been declared on request.")
+    }
+  })
+
+  fastify.get('/', async (req, res) => {
+    t.strictSame(req.getDecorator('session'), { user: 'Jean' })
+    t.same(req.getDecorator('utility')(), req)
+
+    res.send()
+  })
+
+  fastify.ready((err) => {
+    t.error(err)
+    fastify.inject({ url: '/' }, (err, res) => {
+      t.error(err)
+      t.pass()
+    })
+  })
+})

package/test/fastify-instance.test.js

@@ -7,9 +7,12 @@ const os = require('node:os')
 const {
   kOptions,
   kErrorHandler,
-  kChildLoggerFactory
+  kChildLoggerFactory,
+  kState
 } = require('../lib/symbols')
 
+const isIPv6Missing = !Object.values(os.networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
+
 test('root fastify instance is an object', t => {
   t.plan(1)
   t.assert.strictEqual(typeof Fastify(), 'object')
@@ -279,7 +282,7 @@ test('fastify instance should contains listeningOrigin property (unix socket)',
   await fastify.close()
 })
 
-test('fastify instance should contains listeningOrigin property (IPv6)', async t => {
+test('fastify instance should contains listeningOrigin property (IPv6)', { skip: isIPv6Missing }, async t => {
   t.plan(1)
   const port = 3000
   const host = '::1'
@@ -288,3 +291,10 @@ test('fastify instance should contains listeningOrigin property (IPv6)', async t
   t.assert.deepStrictEqual(fastify.listeningOrigin, `http://[::1]:${port}`)
   await fastify.close()
 })
+
+test('fastify instance should ensure ready promise cleanup on ready', async t => {
+  t.plan(1)
+  const fastify = Fastify()
+  await fastify.ready()
+  t.assert.strictEqual(fastify[kState].readyPromise, null)
+})

package/test/hooks.on-listen.test.js

@@ -6,6 +6,9 @@ const fp = require('fastify-plugin')
 const split = require('split2')
 const helper = require('./helper')
 const { kState } = require('../lib/symbols')
+const { networkInterfaces } = require('node:os')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
 
 let localhost
 before(async function () {
@@ -405,7 +408,7 @@ test('localhost onListen encapsulation should be called in order and should log
   })
 })
 
-test('non-localhost onListen should be called in order', t => {
+test('non-localhost onListen should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(2)
 
   const fastify = Fastify()
@@ -428,7 +431,7 @@ test('non-localhost onListen should be called in order', t => {
   })
 })
 
-test('non-localhost async onListen should be called in order', async t => {
+test('non-localhost async onListen should be called in order', { skip: isIPv6Missing }, async t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -448,7 +451,7 @@ test('non-localhost async onListen should be called in order', async t => {
   })
 })
 
-test('non-localhost sync onListen should log errors as warnings and continue', t => {
+test('non-localhost sync onListen should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -488,7 +491,7 @@ test('non-localhost sync onListen should log errors as warnings and continue', t
   })
 })
 
-test('non-localhost async onListen should log errors as warnings and continue', async t => {
+test('non-localhost async onListen should log errors as warnings and continue', { skip: isIPv6Missing }, async t => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -529,7 +532,7 @@ test('non-localhost async onListen should log errors as warnings and continue',
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin', t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
   t.plan(3)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -562,7 +565,7 @@ test('non-localhost Register onListen hook after a plugin inside a plugin', t =>
   })
 })
 
-test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', t => {
+test('non-localhost Register onListen hook after a plugin inside a plugin should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(6)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -608,7 +611,7 @@ test('non-localhost Register onListen hook after a plugin inside a plugin should
   })
 })
 
-test('non-localhost onListen encapsulation should be called in order', t => {
+test('non-localhost onListen encapsulation should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(6)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -640,7 +643,7 @@ test('non-localhost onListen encapsulation should be called in order', t => {
   })
 })
 
-test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', t => {
+test('non-localhost onListen encapsulation should be called in order and should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(7)
   const stream = split(JSON.parse)
   const fastify = Fastify({
@@ -874,7 +877,7 @@ test('onListen localhost with callback encapsulation should be called in order',
   })
 })
 
-test('onListen non-localhost should work in order with callback in sync', t => {
+test('onListen non-localhost should work in order with callback in sync', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -896,7 +899,7 @@ test('onListen non-localhost should work in order with callback in sync', t => {
   })
 })
 
-test('onListen non-localhost should work in order with callback in async', t => {
+test('onListen non-localhost should work in order with callback in async', { skip: isIPv6Missing }, t => {
   t.plan(4)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -916,7 +919,7 @@ test('onListen non-localhost should work in order with callback in async', t =>
   })
 })
 
-test('onListen non-localhost sync with callback should log errors as warnings and continue', t => {
+test('onListen non-localhost sync with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -960,7 +963,7 @@ test('onListen non-localhost sync with callback should log errors as warnings an
   })
 })
 
-test('onListen non-localhost async with callback should log errors as warnings and continue', t => {
+test('onListen non-localhost async with callback should log errors as warnings and continue', { skip: isIPv6Missing }, t => {
   t.plan(8)
 
   const stream = split(JSON.parse)
@@ -1002,7 +1005,7 @@ test('onListen non-localhost async with callback should log errors as warnings a
   })
 })
 
-test('Register onListen hook non-localhost with callback after a plugin inside a plugin', t => {
+test('Register onListen hook non-localhost with callback after a plugin inside a plugin', { skip: isIPv6Missing }, t => {
   t.plan(5)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
@@ -1035,7 +1038,7 @@ test('Register onListen hook non-localhost with callback after a plugin inside a
   })
 })
 
-test('onListen non-localhost with callback encapsulation should be called in order', t => {
+test('onListen non-localhost with callback encapsulation should be called in order', { skip: isIPv6Missing }, t => {
   t.plan(8)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 84
+const expectedErrors = 85
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -21,6 +21,7 @@ test(`should expose ${expectedErrors} errors`, t => {
 
 test('ensure name and codes of Errors are identical', t => {
   t.plan(expectedErrors)
+
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -249,6 +250,16 @@ test('FST_ERR_DEC_REFERENCE_TYPE', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_DEC_UNDECLARED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_DEC_UNDECLARED('myDecorator', 'request')
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_DEC_UNDECLARED')
+  t.assert.strictEqual(error.message, "No decorator 'myDecorator' has been declared on request.")
+  t.assert.strictEqual(error.statusCode, 500)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_HOOK_INVALID_TYPE', t => {
   t.plan(5)
   const error = new errors.FST_ERR_HOOK_INVALID_TYPE()
@@ -881,6 +892,7 @@ test('FST_ERR_ERROR_HANDLER_NOT_FN', t => {
 
 test('Ensure that all errors are in Errors.md TOC', t => {
   t.plan(expectedErrors)
+
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -918,6 +930,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
 
 test('Ensure that non-existing errors are not in Errors.md documented', t => {
   t.plan(expectedErrors)
+
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g

package/test/listen.2.test.js

@@ -3,6 +3,9 @@
 const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
+const { networkInterfaces } = require('node:os')
+
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
 
 let localhostForURL
 
@@ -59,7 +62,7 @@ test('double listen errors callback with (err, address)', (t, done) => {
   })
 })
 
-test('nonlocalhost double listen errors callback with (err, address)', (t, done) => {
+test('nonlocalhost double listen errors callback with (err, address)', { skip: isIPv6Missing }, (t, done) => {
   t.plan(4)
   const fastify = Fastify()
   t.after(() => fastify.close())