fastify 5.2.1 → 5.3.0

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

@@ -1,14 +1,13 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 
 process.removeAllListeners('warning')
 
-test('contentTypeParser should add a custom async parser', t => {
-  t.plan(3)
+test('contentTypeParser should add a custom async parser', async t => {
+  t.plan(2)
   const fastify = Fastify()
 
   fastify.post('/', (req, reply) => {
@@ -24,43 +23,42 @@ test('contentTypeParser should add a custom async parser', t => {
     return res
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
+  t.after(() => fastify.close())
+  await fastify.listen({ port: 0 })
 
-    t.teardown(() => fastify.close())
+  await t.test('in POST', (t, done) => {
+    t.plan(3)
 
-    t.test('in POST', t => {
-      t.plan(3)
-
-      sget({
-        method: 'POST',
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: '{"hello":"world"}',
-        headers: {
-          'Content-Type': 'application/jsoff'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), JSON.stringify({ hello: 'world' }))
-      })
+    sget({
+      method: 'POST',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/jsoff'
+      }
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
+      done()
     })
+  })
 
-    t.test('in OPTIONS', t => {
-      t.plan(3)
+  await t.test('in OPTIONS', (t, done) => {
+    t.plan(3)
 
-      sget({
-        method: 'OPTIONS',
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: '{"hello":"world"}',
-        headers: {
-          'Content-Type': 'application/jsoff'
-        }
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), JSON.stringify({ hello: 'world' }))
-      })
+    sget({
+      method: 'OPTIONS',
+      url: 'http://localhost:' + fastify.server.address().port,
+      body: '{"hello":"world"}',
+      headers: {
+        'Content-Type': 'application/jsoff'
+      }
+    }, (err, response, body) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
+      done()
     })
   })
 })

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

@@ -1,19 +1,18 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const jsonParser = require('fast-json-body')
 const { getServerUrl } = require('./helper')
+const { waitForCb } = require('./toolkit')
 
 process.removeAllListeners('warning')
 
-test('should prefer string content types over RegExp ones', t => {
+test('should prefer string content types over RegExp ones', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-
+  t.after(() => { fastify.close() })
   fastify.post('/', (req, reply) => {
     reply.send(req.body)
   })
@@ -33,7 +32,8 @@ test('should prefer string content types over RegExp ones', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+    const completion = waitForCb({ steps: 2 })
 
     sget({
       method: 'POST',
@@ -43,9 +43,10 @@ test('should prefer string content types over RegExp ones', t => {
         'Content-Type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), JSON.stringify({ k1: 'myValue', k2: 'myValue' }))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.equal(body.toString(), JSON.stringify({ k1: 'myValue', k2: 'myValue' }))
+      completion.stepIn()
     })
 
     sget({
@@ -56,18 +57,21 @@ test('should prefer string content types over RegExp ones', t => {
         'Content-Type': 'application/javascript'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'javascript')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.equal(body.toString(), 'javascript')
+      completion.stepIn()
     })
+
+    completion.patience.then(testDone)
   })
 })
 
-test('removeContentTypeParser should support arrays of content types to remove', t => {
+test('removeContentTypeParser should support arrays of content types to remove', (t, testDone) => {
   t.plan(8)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.addContentTypeParser('application/xml', function (req, payload, done) {
     payload.on('data', () => {})
@@ -90,7 +94,8 @@ test('removeContentTypeParser should support arrays of content types to remove',
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+    const completion = waitForCb({ steps: 3 })
 
     sget({
       method: 'POST',
@@ -100,9 +105,10 @@ test('removeContentTypeParser should support arrays of content types to remove',
         'Content-Type': 'application/xml'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'xml')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.equal(body.toString(), 'xml')
+      completion.stepIn()
     })
 
     sget({
@@ -113,8 +119,9 @@ test('removeContentTypeParser should support arrays of content types to remove',
         'Content-Type': 'image/png'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 415)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 415)
+      completion.stepIn()
     })
 
     sget({
@@ -125,16 +132,19 @@ test('removeContentTypeParser should support arrays of content types to remove',
         'Content-Type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 415)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 415)
+      completion.stepIn()
     })
+    completion.patience.then(testDone)
   })
 })
 
-test('removeContentTypeParser should support encapsulation', t => {
+test('removeContentTypeParser should support encapsulation', (t, testDone) => {
   t.plan(6)
 
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.addContentTypeParser('application/xml', function (req, payload, done) {
     payload.on('data', () => {})
@@ -158,7 +168,8 @@ test('removeContentTypeParser should support encapsulation', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+    const completion = waitForCb({ steps: 2 })
 
     sget({
       method: 'POST',
@@ -168,8 +179,9 @@ test('removeContentTypeParser should support encapsulation', t => {
         'Content-Type': 'application/xml'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 415)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 415)
+      completion.stepIn()
     })
 
     sget({
@@ -180,18 +192,20 @@ test('removeContentTypeParser should support encapsulation', t => {
         'Content-Type': 'application/xml'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'xml')
-      fastify.close()
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.equal(body.toString(), 'xml')
+      completion.stepIn()
     })
+    completion.patience.then(testDone)
   })
 })
 
-test('removeAllContentTypeParsers should support encapsulation', t => {
+test('removeAllContentTypeParsers should support encapsulation', (t, testDone) => {
   t.plan(6)
 
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.post('/', (req, reply) => {
     reply.send(req.body)
@@ -208,7 +222,8 @@ test('removeAllContentTypeParsers should support encapsulation', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+    const completion = waitForCb({ steps: 2 })
 
     sget({
       method: 'POST',
@@ -218,8 +233,9 @@ test('removeAllContentTypeParsers should support encapsulation', t => {
         'Content-Type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 415)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 415)
+      completion.stepIn()
     })
 
     sget({
@@ -230,10 +246,11 @@ test('removeAllContentTypeParsers should support encapsulation', t => {
         'Content-Type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body.toString()).test, 1)
-      fastify.close()
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.equal(JSON.parse(body.toString()).test, 1)
+      completion.stepIn()
     })
+    completion.patience.then(testDone)
   })
 })

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)
+})