fastify 4.0.0-rc.3 → 4.0.0

package/test/plugin.test.js

@@ -184,11 +184,11 @@ test('fastify.register with fastify-plugin should provide access to external fas
   })
 })
 
-test('fastify.register with fastify-plugin registers root level plugins', t => {
+test('fastify.register with fastify-plugin registers fastify level plugins', t => {
   t.plan(15)
   const fastify = Fastify()
 
-  function rootPlugin (instance, opts, done) {
+  function fastifyPlugin (instance, opts, done) {
     instance.decorate('test', 'first')
     t.ok(instance.test)
     done()
@@ -199,7 +199,7 @@ test('fastify.register with fastify-plugin registers root level plugins', t => {
     done()
   }
 
-  fastify.register(fp(rootPlugin))
+  fastify.register(fp(fastifyPlugin))
 
   fastify.register((instance, opts, done) => {
     t.ok(instance.test)
@@ -354,27 +354,29 @@ test('check dependencies - should throw', t => {
 })
 
 test('set the plugin name based on the plugin displayName symbol', t => {
-  t.plan(5)
+  t.plan(6)
   const fastify = Fastify()
 
   fastify.register(fp((fastify, opts, done) => {
-    t.equal(fastify.pluginName, 'plugin-A')
+    t.equal(fastify.pluginName, 'fastify -> plugin-A')
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'plugin-A -> plugin-AB')
+      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
       done()
     }, { name: 'plugin-AB' }))
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC')
+      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
       done()
     }, { name: 'plugin-AC' }))
     done()
   }, { name: 'plugin-A' }))
 
   fastify.register(fp((fastify, opts, done) => {
-    t.equal(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC -> plugin-B')
+    t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC -> plugin-B')
     done()
   }, { name: 'plugin-B' }))
 
+  t.equal(fastify.pluginName, 'fastify')
+
   fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.close()
@@ -382,29 +384,31 @@ test('set the plugin name based on the plugin displayName symbol', t => {
 })
 
 test('plugin name will change when using no encapsulation', t => {
-  t.plan(5)
+  t.plan(6)
   const fastify = Fastify()
 
   fastify.register(fp((fastify, opts, done) => {
     // store it in a different variable will hold the correct name
     const pluginName = fastify.pluginName
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'plugin-A -> plugin-AB')
+      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
       done()
     }, { name: 'plugin-AB' }))
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC')
+      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
       done()
     }, { name: 'plugin-AC' }))
     setImmediate(() => {
       // normally we would expect the name plugin-A
       // but we operate on the same instance in each plugin
-      t.equal(fastify.pluginName, 'plugin-A -> plugin-AB -> plugin-AC')
-      t.equal(pluginName, 'plugin-A')
+      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      t.equal(pluginName, 'fastify -> plugin-A')
     })
     done()
   }, { name: 'plugin-A' }))
 
+  t.equal(fastify.pluginName, 'fastify')
+
   fastify.listen({ port: 0 }, err => {
     t.error(err)
     fastify.close()
@@ -415,7 +419,7 @@ test('plugin name is undefined when accessing in no plugin context', t => {
   t.plan(2)
   const fastify = Fastify()
 
-  t.equal(fastify.pluginName, undefined)
+  t.equal(fastify.pluginName, 'fastify')
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
@@ -1052,3 +1056,162 @@ test('plugin metadata - release candidate', t => {
     done()
   }
 })
+
+test('hasPlugin method exists as a function', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  t.equal(typeof fastify.hasPlugin, 'function')
+})
+
+test('hasPlugin returns true if the specified plugin has been registered', async t => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  function pluginA (fastify, opts, done) {
+    t.ok(fastify.hasPlugin('plugin-A'))
+    done()
+  }
+  pluginA[Symbol.for('fastify.display-name')] = 'plugin-A'
+  fastify.register(pluginA)
+
+  fastify.register(function pluginB (fastify, opts, done) {
+    t.ok(fastify.hasPlugin('pluginB'))
+    done()
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    // one line
+    t.ok(fastify.hasPlugin('function (fastify, opts, done) { -- // one line'))
+    done()
+  })
+
+  await fastify.ready()
+
+  t.ok(fastify.hasPlugin('fastify'))
+})
+
+test('hasPlugin returns false if the specified plugin has not been registered', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  t.notOk(fastify.hasPlugin('pluginFoo'))
+})
+
+test('hasPlugin returns false when using encapsulation', async t => {
+  t.plan(25)
+
+  const fastify = Fastify()
+
+  fastify.register(function pluginA (fastify, opts, done) {
+    t.ok(fastify.hasPlugin('pluginA'))
+    t.notOk(fastify.hasPlugin('pluginAA'))
+    t.notOk(fastify.hasPlugin('pluginAAA'))
+    t.notOk(fastify.hasPlugin('pluginAB'))
+    t.notOk(fastify.hasPlugin('pluginB'))
+
+    fastify.register(function pluginAA (fastify, opts, done) {
+      t.notOk(fastify.hasPlugin('pluginA'))
+      t.ok(fastify.hasPlugin('pluginAA'))
+      t.notOk(fastify.hasPlugin('pluginAAA'))
+      t.notOk(fastify.hasPlugin('pluginAB'))
+      t.notOk(fastify.hasPlugin('pluginB'))
+
+      fastify.register(function pluginAAA (fastify, opts, done) {
+        t.notOk(fastify.hasPlugin('pluginA'))
+        t.notOk(fastify.hasPlugin('pluginAA'))
+        t.ok(fastify.hasPlugin('pluginAAA'))
+        t.notOk(fastify.hasPlugin('pluginAB'))
+        t.notOk(fastify.hasPlugin('pluginB'))
+
+        done()
+      })
+
+      done()
+    })
+
+    fastify.register(function pluginAB (fastify, opts, done) {
+      t.notOk(fastify.hasPlugin('pluginA'))
+      t.notOk(fastify.hasPlugin('pluginAA'))
+      t.notOk(fastify.hasPlugin('pluginAAA'))
+      t.ok(fastify.hasPlugin('pluginAB'))
+      t.notOk(fastify.hasPlugin('pluginB'))
+
+      done()
+    })
+
+    done()
+  })
+
+  fastify.register(function pluginB (fastify, opts, done) {
+    t.notOk(fastify.hasPlugin('pluginA'))
+    t.notOk(fastify.hasPlugin('pluginAA'))
+    t.notOk(fastify.hasPlugin('pluginAAA'))
+    t.notOk(fastify.hasPlugin('pluginAB'))
+    t.ok(fastify.hasPlugin('pluginB'))
+
+    done()
+  })
+
+  await fastify.ready()
+})
+
+test('hasPlugin returns true when using no encapsulation', async t => {
+  t.plan(26)
+
+  const fastify = Fastify()
+
+  fastify.register(fp((fastify, opts, done) => {
+    t.equal(fastify.pluginName, 'fastify -> plugin-AA')
+    t.ok(fastify.hasPlugin('plugin-AA'))
+    t.notOk(fastify.hasPlugin('plugin-A'))
+    t.notOk(fastify.hasPlugin('plugin-AAA'))
+    t.notOk(fastify.hasPlugin('plugin-AB'))
+    t.notOk(fastify.hasPlugin('plugin-B'))
+
+    fastify.register(fp((fastify, opts, done) => {
+      t.ok(fastify.hasPlugin('plugin-AA'))
+      t.ok(fastify.hasPlugin('plugin-A'))
+      t.notOk(fastify.hasPlugin('plugin-AAA'))
+      t.notOk(fastify.hasPlugin('plugin-AB'))
+      t.notOk(fastify.hasPlugin('plugin-B'))
+
+      fastify.register(fp((fastify, opts, done) => {
+        t.ok(fastify.hasPlugin('plugin-AA'))
+        t.ok(fastify.hasPlugin('plugin-A'))
+        t.ok(fastify.hasPlugin('plugin-AAA'))
+        t.notOk(fastify.hasPlugin('plugin-AB'))
+        t.notOk(fastify.hasPlugin('plugin-B'))
+
+        done()
+      }, { name: 'plugin-AAA' }))
+
+      done()
+    }, { name: 'plugin-A' }))
+
+    fastify.register(fp((fastify, opts, done) => {
+      t.ok(fastify.hasPlugin('plugin-AA'))
+      t.ok(fastify.hasPlugin('plugin-A'))
+      t.ok(fastify.hasPlugin('plugin-AAA'))
+      t.ok(fastify.hasPlugin('plugin-AB'))
+      t.notOk(fastify.hasPlugin('plugin-B'))
+
+      done()
+    }, { name: 'plugin-AB' }))
+
+    done()
+  }, { name: 'plugin-AA' }))
+
+  fastify.register(fp((fastify, opts, done) => {
+    t.ok(fastify.hasPlugin('plugin-AA'))
+    t.ok(fastify.hasPlugin('plugin-A'))
+    t.ok(fastify.hasPlugin('plugin-AAA'))
+    t.ok(fastify.hasPlugin('plugin-AB'))
+    t.ok(fastify.hasPlugin('plugin-B'))
+
+    done()
+  }, { name: 'plugin-B' }))
+
+  await fastify.ready()
+})

package/test/route-prefix.test.js

@@ -423,6 +423,37 @@ test('matches both /prefix and /prefix/ with a / route - ignoreTrailingSlash: tr
   })
 })
 
+test('matches both /prefix and /prefix/ with a / route - ignoreDuplicateSlashes: true', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.get('/', (req, reply) => {
+      reply.send({ hello: 'world' })
+    })
+
+    done()
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
 test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreTrailingSlash: false', t => {
   t.plan(4)
   const fastify = Fastify({
@@ -459,6 +490,106 @@ test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "
   })
 })
 
+test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreDuplicateSlashes: false', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreDuplicateSlashes: false
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.route({
+      method: 'GET',
+      url: '/',
+      prefixTrailingSlash: 'both',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    done()
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
+test('matches both /prefix and /prefix/ with a / route - ignoreTrailingSlash: true, ignoreDuplicateSlashes: true', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.get('/', (req, reply) => {
+      reply.send({ hello: 'world' })
+    })
+
+    done()
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
+test('matches both /prefix and /prefix/ with a / route - ignoreTrailingSlash: true, ignoreDuplicateSlashes: false', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: false
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.get('/', (req, reply) => {
+      reply.send({ hello: 'world' })
+    })
+
+    done()
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
 test('returns 404 status code with /prefix/ and / route - prefixTrailingSlash: "both" (default), ignoreTrailingSlash: true', t => {
   t.plan(2)
   const fastify = Fastify({
@@ -490,6 +621,89 @@ test('returns 404 status code with /prefix/ and / route - prefixTrailingSlash: "
   })
 })
 
+test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreDuplicateSlashes: true', t => {
+  t.plan(2)
+  const fastify = Fastify({
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.route({
+      method: 'GET',
+      url: '/',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    done()
+  }, { prefix: '/prefix/' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix//'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
+test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreTrailingSlash: true, ignoreDuplicateSlashes: true', t => {
+  t.plan(2)
+  const fastify = Fastify({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.route({
+      method: 'GET',
+      url: '/',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    done()
+  }, { prefix: '/prefix/' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix//'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
+test('matches both /prefix and /prefix/  with a / route - prefixTrailingSlash: "both", ignoreDuplicateSlashes: true', t => {
+  t.plan(2)
+  const fastify = Fastify({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.route({
+      method: 'GET',
+      url: '/',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    done()
+  }, { prefix: '/prefix/' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix//'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+})
+
 test('matches only /prefix  with a / route - prefixTrailingSlash: "no-slash", ignoreTrailingSlash: false', t => {
   t.plan(4)
   const fastify = Fastify({
@@ -526,6 +740,42 @@ test('matches only /prefix  with a / route - prefixTrailingSlash: "no-slash", ig
   })
 })
 
+test('matches only /prefix  with a / route - prefixTrailingSlash: "no-slash", ignoreDuplicateSlashes: false', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreDuplicateSlashes: false
+  })
+
+  fastify.register(function (fastify, opts, done) {
+    fastify.route({
+      method: 'GET',
+      url: '/',
+      prefixTrailingSlash: 'no-slash',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+
+    done()
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix'
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'world' })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(JSON.parse(res.payload).statusCode, 404)
+  })
+})
+
 test('matches only /prefix/  with a / route - prefixTrailingSlash: "slash", ignoreTrailingSlash: false', t => {
   t.plan(4)
   const fastify = Fastify({

package/test/router-options.test.js

@@ -44,6 +44,67 @@ test('Should honor ignoreTrailingSlash option', t => {
   })
 })
 
+test('Should honor ignoreDuplicateSlashes option', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.get('/test//test///test', (req, res) => {
+    res.send('test')
+  })
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.teardown(() => { fastify.close() })
+    if (err) t.threw(err)
+
+    const baseUrl = getUrl(fastify)
+
+    sget.concat(baseUrl + '/test/test/test', (err, res, data) => {
+      if (err) t.threw(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'test')
+    })
+
+    sget.concat(baseUrl + '/test//test///test', (err, res, data) => {
+      if (err) t.threw(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'test')
+    })
+  })
+})
+
+test('Should honor ignoreTrailingSlash and ignoreDuplicateSlashes options', t => {
+  t.plan(4)
+  const fastify = Fastify({
+    ignoreTrailingSlash: true,
+    ignoreDuplicateSlashes: true
+  })
+
+  fastify.get('/test//test///test', (req, res) => {
+    res.send('test')
+  })
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.teardown(() => { fastify.close() })
+    if (err) t.threw(err)
+
+    const baseUrl = getUrl(fastify)
+
+    sget.concat(baseUrl + '/test/test/test/', (err, res, data) => {
+      if (err) t.threw(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'test')
+    })
+
+    sget.concat(baseUrl + '/test//test///test//', (err, res, data) => {
+      if (err) t.threw(err)
+      t.equal(res.statusCode, 200)
+      t.equal(data.toString(), 'test')
+    })
+  })
+})
+
 test('Should honor maxParamLength option', t => {
   t.plan(4)
   const fastify = Fastify({ maxParamLength: 10 })

package/test/schema-feature.test.js

@@ -1755,3 +1755,27 @@ test('Should coerce the array if the default validator is used', async t => {
     t.error(err)
   }
 })
+
+test('Should return a human-friendly error if response status codes are not specified', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.route({
+    url: '/',
+    method: 'GET',
+    schema: {
+      response: {
+        // This should be nested under a status code key, e.g { 200: { type: 'array' } }
+        type: 'array'
+      }
+    },
+    handler: (req, reply) => {
+      reply.send([])
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
+    t.match(err.message, 'Failed building the serialization schema for GET: /, due to error response schemas should be nested under a valid status code, e.g { 2xx: { type: "object" } }')
+  })
+})

package/test/schema-serialization.test.js

@@ -711,3 +711,60 @@ test('Errors in searilizer sended to errorHandler', async t => {
   t.ok(savedError.serialization, 'Serialization sign presents')
   t.end()
 })
+
+test('capital X', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.get('/', {
+    schema: {
+      response: {
+        '2XX': {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            work: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, function (req, reply) {
+    reply.code(200).send({ name: 'Foo', work: 'Bar', nick: 'Boo' })
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.same(res.json(), { name: 'Foo', work: 'Bar' })
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('allow default as status code and used as last fallback', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.route({
+    url: '/',
+    method: 'GET',
+    schema: {
+      response: {
+        default: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            work: { type: 'string' }
+          }
+        }
+      }
+    },
+    handler: (req, reply) => {
+      reply.code(200).send({ name: 'Foo', work: 'Bar', nick: 'Boo' })
+    }
+  })
+
+  fastify.inject('/', (err, res) => {
+    t.error(err)
+    t.same(res.json(), { name: 'Foo', work: 'Bar' })
+    t.equal(res.statusCode, 200)
+  })
+})

package/test/types/fastify.test-d.ts

@@ -58,6 +58,7 @@ fastify({ http2: true, https: {} }).inject({}, lightMyRequestCallback)
 // server options
 expectAssignable<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>(fastify({ http2: true }))
 expectAssignable<FastifyInstance>(fastify({ ignoreTrailingSlash: true }))
+expectAssignable<FastifyInstance>(fastify({ ignoreDuplicateSlashes: true }))
 expectAssignable<FastifyInstance>(fastify({ connectionTimeout: 1000 }))
 expectAssignable<FastifyInstance>(fastify({ forceCloseConnections: true }))
 expectAssignable<FastifyInstance>(fastify({ keepAliveTimeout: 1000 }))