fastify 4.14.1 → 4.16.0

package/test/pretty-print.test.js

@@ -15,7 +15,8 @@ test('pretty print - static routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /
+    const expected = `\
+└── /
     ├── test (GET)
     │   └── /hello (GET)
     └── hello/world (GET)
@@ -26,6 +27,41 @@ test('pretty print - static routes', t => {
   })
 })
 
+test('pretty print - internal tree - static routes', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/hello', () => {})
+  fastify.get('/hello/world', () => {})
+
+  fastify.put('/test', () => {})
+  fastify.put('/test/foo', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /hello (GET)
+    └── hello/world (GET)
+`
+
+    t.equal(typeof getTree, 'string')
+    t.equal(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    └── test (PUT)
+        └── /foo (PUT)
+`
+
+    t.equal(typeof putTree, 'string')
+    t.equal(putTree, expectedPutTree)
+  })
+})
+
 test('pretty print - parametric routes', t => {
   t.plan(2)
 
@@ -37,10 +73,13 @@ test('pretty print - parametric routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /
+    const expected = `\
+└── /
     ├── test (GET)
-    │   └── /:hello (GET)
-    └── hello/:world (GET)
+    │   └── /
+    │       └── :hello (GET)
+    └── hello/
+        └── :world (GET)
 `
 
     t.equal(typeof tree, 'string')
@@ -48,6 +87,44 @@ test('pretty print - parametric routes', t => {
   })
 })
 
+test('pretty print - internal tree - parametric routes', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/:hello', () => {})
+  fastify.get('/hello/:world', () => {})
+
+  fastify.put('/test', () => {})
+  fastify.put('/test/:hello', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── :hello (GET)
+    └── hello/
+        └── :world (GET)
+`
+
+    t.equal(typeof getTree, 'string')
+    t.equal(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    └── test (PUT)
+        └── /
+            └── :hello (PUT)
+`
+
+    t.equal(typeof putTree, 'string')
+    t.equal(putTree, expectedPutTree)
+  })
+})
+
 test('pretty print - mixed parametric routes', t => {
   t.plan(2)
 
@@ -60,11 +137,12 @@ test('pretty print - mixed parametric routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /test (GET)
-    └── /
-        └── :hello (GET)
-            :hello (POST)
-            └── /world (GET)
+    const expected = `\
+└── /
+    └── test (GET)
+        └── /
+            └── :hello (GET, POST)
+                └── /world (GET)
 `
 
     t.equal(typeof tree, 'string')
@@ -83,10 +161,13 @@ test('pretty print - wildcard routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /
+    const expected = `\
+└── /
     ├── test (GET)
-    │   └── /* (GET)
-    └── hello/* (GET)
+    │   └── /
+    │       └── * (GET)
+    └── hello/
+        └── * (GET)
 `
 
     t.equal(typeof tree, 'string')
@@ -94,6 +175,44 @@ test('pretty print - wildcard routes', t => {
   })
 })
 
+test('pretty print - internal tree - wildcard routes', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/*', () => {})
+  fastify.get('/hello/*', () => {})
+
+  fastify.put('/*', () => {})
+  fastify.put('/test/*', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── * (GET)
+    └── hello/
+        └── * (GET)
+`
+
+    t.equal(typeof getTree, 'string')
+    t.equal(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    ├── test/
+    │   └── * (PUT)
+    └── * (PUT)
+`
+
+    t.equal(typeof putTree, 'string')
+    t.equal(putTree, expectedPutTree)
+  })
+})
+
 test('pretty print - empty plugins', t => {
   t.plan(2)
 
@@ -134,17 +253,15 @@ test('pretty print - commonPrefix', t => {
     const radixTree = fastify.printRoutes()
     const flatTree = fastify.printRoutes({ commonPrefix: false })
 
-    const radixExpected = `└── /
-    ├── hel
-    │   ├── lo (GET)
-    │   │   lo (HEAD)
-    │   └── icopter (GET)
-    │       icopter (HEAD)
-    └── hello (PUT)
+    const radixExpected = `\
+└── /
+    └── hel
+        ├── lo (GET, HEAD, PUT)
+        └── icopter (GET, HEAD)
 `
-    const flatExpected = `└── / (-)
-    ├── helicopter (GET, HEAD)
-    └── hello (GET, HEAD, PUT)
+    const flatExpected = `\
+├── /hello (GET, HEAD, PUT)
+└── /helicopter (GET, HEAD)
 `
     t.equal(typeof radixTree, 'string')
     t.equal(typeof flatTree, 'string')
@@ -170,49 +287,64 @@ test('pretty print - includeMeta, includeHooks', t => {
     const flatTree = fastify.printRoutes({ commonPrefix: false, includeHooks: true, includeMeta: ['errorHandler'] })
     const hooksOnly = fastify.printRoutes({ commonPrefix: false, includeHooks: true })
 
-    const radixExpected = `└── /
-    ├── hel
-    │   ├── lo (GET)
-    │   │   • (onTimeout) ["onTimeout()"]
-    │   │   • (onRequest) ["anonymous()"]
-    │   │   • (errorHandler) "defaultErrorHandler()"
-    │   │   lo (HEAD)
-    │   │   • (onTimeout) ["onTimeout()"]
-    │   │   • (onRequest) ["anonymous()"]
-    │   │   • (onSend) ["headRouteOnSendHandler()"]
-    │   │   • (errorHandler) "defaultErrorHandler()"
-    │   └── icopter (GET)
-    │       • (onTimeout) ["onTimeout()"]
-    │       • (onRequest) ["anonymous()"]
-    │       • (errorHandler) "defaultErrorHandler()"
-    │       icopter (HEAD)
-    │       • (onTimeout) ["onTimeout()"]
-    │       • (onRequest) ["anonymous()"]
-    │       • (onSend) ["headRouteOnSendHandler()"]
-    │       • (errorHandler) "defaultErrorHandler()"
-    └── hello (PUT)
-        • (onTimeout) ["onTimeout()"]
-        • (onRequest) ["anonymous()"]
-        • (errorHandler) "defaultErrorHandler()"
+    const radixExpected = `\
+└── /
+    └── hel
+        ├── lo (GET, PUT)
+        │   • (onTimeout) ["onTimeout()"]
+        │   • (onRequest) ["anonymous()"]
+        │   • (errorHandler) "defaultErrorHandler()"
+        │   lo (HEAD)
+        │   • (onTimeout) ["onTimeout()"]
+        │   • (onRequest) ["anonymous()"]
+        │   • (onSend) ["headRouteOnSendHandler()"]
+        │   • (errorHandler) "defaultErrorHandler()"
+        └── icopter (GET)
+            • (onTimeout) ["onTimeout()"]
+            • (onRequest) ["anonymous()"]
+            • (errorHandler) "defaultErrorHandler()"
+            icopter (HEAD)
+            • (onTimeout) ["onTimeout()"]
+            • (onRequest) ["anonymous()"]
+            • (onSend) ["headRouteOnSendHandler()"]
+            • (errorHandler) "defaultErrorHandler()"
 `
-    const flatExpected = `└── / (-)
-    ├── helicopter (GET, HEAD)
-    │   • (onTimeout) ["onTimeout()"]
-    │   • (onRequest) ["anonymous()"]
-    │   • (errorHandler) "defaultErrorHandler()"
-    └── hello (GET, HEAD, PUT)
-        • (onTimeout) ["onTimeout()"]
-        • (onRequest) ["anonymous()"]
-        • (errorHandler) "defaultErrorHandler()"
+    const flatExpected = `\
+├── /hello (GET, PUT)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (errorHandler) "defaultErrorHandler()"
+│   /hello (HEAD)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (onSend) ["headRouteOnSendHandler()"]
+│   • (errorHandler) "defaultErrorHandler()"
+└── /helicopter (GET)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (errorHandler) "defaultErrorHandler()"
+    /helicopter (HEAD)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (onSend) ["headRouteOnSendHandler()"]
+    • (errorHandler) "defaultErrorHandler()"
 `
 
-    const hooksOnlyExpected = `└── / (-)
-    ├── helicopter (GET, HEAD)
-    │   • (onTimeout) ["onTimeout()"]
-    │   • (onRequest) ["anonymous()"]
-    └── hello (GET, HEAD, PUT)
-        • (onTimeout) ["onTimeout()"]
-        • (onRequest) ["anonymous()"]
+    const hooksOnlyExpected = `\
+├── /hello (GET, PUT)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   /hello (HEAD)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (onSend) ["headRouteOnSendHandler()"]
+└── /helicopter (GET)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    /helicopter (HEAD)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (onSend) ["headRouteOnSendHandler()"]
 `
     t.equal(typeof radixTree, 'string')
     t.equal(typeof flatTree, 'string')

package/test/route-hooks.test.js

@@ -101,6 +101,35 @@ function testExecutionHook (hook) {
     })
   })
 
+  test(`${hook} option could accept an array of async functions`, t => {
+    t.plan(3)
+    const fastify = Fastify()
+    const checker = Object.defineProperty({ calledTimes: 0 }, 'check', {
+      get: function () { return ++this.calledTimes }
+    })
+
+    fastify.post('/', {
+      [hook]: [
+        async (req, reply) => {
+          t.equal(checker.check, 1)
+        },
+        async (req, reply) => {
+          t.equal(checker.check, 2)
+        }
+      ]
+    }, (req, reply) => {
+      reply.send({})
+    })
+
+    fastify.inject({
+      method: 'POST',
+      url: '/',
+      payload: { hello: 'world' }
+    }, (err, res) => {
+      t.error(err)
+    })
+  })
+
   test(`${hook} option does not interfere with ${hook} hook`, t => {
     t.plan(7)
     const fastify = Fastify()

package/test/route.test.js

@@ -1494,7 +1494,7 @@ test('exposeHeadRoute should not reuse the same route option', async t => {
   })
 })
 
-test('using fastify.all when a catchall is defined does not degrade performance', { timeout: 5000 }, async t => {
+test('using fastify.all when a catchall is defined does not degrade performance', { timeout: 30000 }, async t => {
   t.plan(1)
 
   const fastify = Fastify()

package/test/schema-feature.test.js

@@ -6,6 +6,7 @@ const fp = require('fastify-plugin')
 const deepClone = require('rfdc')({ circles: true, proto: false })
 const Ajv = require('ajv')
 const { kSchemaController } = require('../lib/symbols.js')
+const warning = require('../lib/warnings')
 
 const echoParams = (req, reply) => { reply.send(req.params) }
 const echoBody = (req, reply) => { reply.send(req.body) }
@@ -253,6 +254,183 @@ test('Should not change the input schemas', t => {
   })
 })
 
+test('Should emit warning if the schema headers is undefined', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyWarning')
+    t.equal(warning.code, 'FSTWRN001')
+  }
+
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTWRN001', false)
+  })
+
+  fastify.post('/:id', {
+    handler: echoParams,
+    schema: {
+      headers: undefined
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/123'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should emit warning if the schema body is undefined', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyWarning')
+    t.equal(warning.code, 'FSTWRN001')
+  }
+
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTWRN001', false)
+  })
+
+  fastify.post('/:id', {
+    handler: echoParams,
+    schema: {
+      body: undefined
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/123'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should emit warning if the schema query is undefined', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyWarning')
+    t.equal(warning.code, 'FSTWRN001')
+  }
+
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTWRN001', false)
+  })
+
+  fastify.post('/:id', {
+    handler: echoParams,
+    schema: {
+      querystring: undefined
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/123'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should emit warning if the schema params is undefined', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyWarning')
+    t.equal(warning.code, 'FSTWRN001')
+  }
+
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTWRN001', false)
+  })
+
+  fastify.post('/:id', {
+    handler: echoParams,
+    schema: {
+      params: undefined
+    }
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/123'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should emit a warning for every route with undefined schema', t => {
+  t.plan(16)
+  const fastify = Fastify()
+
+  let runs = 0
+  const expectedWarningEmitted = [0, 1, 2, 3]
+  // It emits 4 warnings:
+  // - 2 - GET and HEAD for /undefinedParams/:id
+  // - 2 - GET and HEAD for /undefinedBody/:id
+  // => 3 x 4 assertions = 12 assertions
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyWarning')
+    t.equal(warning.code, 'FSTWRN001')
+    t.equal(runs++, expectedWarningEmitted.shift())
+  }
+
+  process.on('warning', onWarning)
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTWRN001', false)
+  })
+
+  fastify.get('/undefinedParams/:id', {
+    handler: echoParams,
+    schema: {
+      params: undefined
+    }
+  })
+
+  fastify.get('/undefinedBody/:id', {
+    handler: echoParams,
+    schema: {
+      body: undefined
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefinedParams/123'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefinedBody/123'
+  }, (error, res) => {
+    t.error(error)
+    t.equal(res.statusCode, 200)
+  })
+})
+
 test('First level $ref', t => {
   t.plan(2)
   const fastify = Fastify()