fastify 3.24.1 → 3.25.0

package/test/constrained-routes.test.js

@@ -182,3 +182,223 @@ test('Should allow registering custom constrained routes', t => {
     t.equal(res.statusCode, 404)
   })
 })
+
+test('Should allow registering an unconstrained route after a constrained route', t => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from fastify.io' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from fastify.io' })
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      host: 'example.com'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { hello: 'from any other domain' })
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should allow registering constrained routes in a prefixed plugin', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.register(async (scope, opts) => {
+    scope.route({
+      method: 'GET',
+      constraints: { host: 'fastify.io' },
+      path: '/route',
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+  }, { prefix: '/prefix' })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/prefix/route',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload), { ok: true })
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should allow registering a constrained GET route after a constrained HEAD route', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'HEAD',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.header('content-type', 'text/plain')
+      reply.send('custom HEAD response')
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'custom HEAD response')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Should allow registering a constrained GET route after an unconstrained HEAD route', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'HEAD',
+    url: '/',
+    handler: (req, reply) => {
+      reply.header('content-type', 'text/plain')
+      reply.send('custom HEAD response')
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { host: 'fastify.io' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from any other domain' })
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      host: 'fastify.io'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'custom HEAD response')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Will not try to re-createprefixed HEAD route if it already exists and exposeHeadRoutes is true for constrained routes', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify({ exposeHeadRoutes: true })
+
+  fastify.register((scope, opts, next) => {
+    scope.route({
+      method: 'HEAD',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.header('content-type', 'text/plain')
+        reply.send('custom HEAD response')
+      }
+    })
+    scope.route({
+      method: 'GET',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+
+    next()
+  }, { prefix: '/prefix' })
+
+  await fastify.ready()
+
+  t.ok(true)
+})
+
+test('allows separate constrained and unconstrained HEAD routes', async (t) => {
+  t.plan(1)
+
+  const fastify = Fastify({ exposeHeadRoutes: true })
+
+  fastify.register((scope, opts, next) => {
+    scope.route({
+      method: 'HEAD',
+      path: '/route',
+      handler: (req, reply) => {
+        reply.header('content-type', 'text/plain')
+        reply.send('unconstrained HEAD response')
+      }
+    })
+
+    scope.route({
+      method: 'HEAD',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.header('content-type', 'text/plain')
+        reply.send('constrained HEAD response')
+      }
+    })
+
+    scope.route({
+      method: 'GET',
+      path: '/route',
+      constraints: { host: 'fastify.io' },
+      handler: (req, reply) => {
+        reply.send({ ok: true })
+      }
+    })
+
+    next()
+  }, { prefix: '/prefix' })
+
+  await fastify.ready()
+
+  t.ok(true)
+})

package/test/custom-parser.test.js

@@ -25,6 +25,15 @@ function plainTextParser (request, callback) {
   }
 }
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 process.removeAllListeners('warning')
 
 test('contentTypeParser method should exist', t => {
@@ -61,7 +70,7 @@ test('contentTypeParser should add a custom parser', t => {
 
       sget({
         method: 'POST',
-        url: 'http://localhost:' + fastify.server.address().port,
+        url: getUrl(fastify),
         body: '{"hello":"world"}',
         headers: {
           'Content-Type': 'application/jsoff'
@@ -78,7 +87,7 @@ test('contentTypeParser should add a custom parser', t => {
 
       sget({
         method: 'OPTIONS',
-        url: 'http://localhost:' + fastify.server.address().port,
+        url: getUrl(fastify),
         body: '{"hello":"world"}',
         headers: {
           'Content-Type': 'application/jsoff'

package/test/decorator.test.js

@@ -1024,3 +1024,27 @@ test('decorateRequest/decorateReply is not set to a value', t => {
     })
   })
 })
+
+test('decorateRequest with dependencies', (t) => {
+  t.plan(2)
+  const app = Fastify()
+
+  const decorator1 = {
+    config: {},
+    app: {}
+  }
+  const decorator2 = {
+    stuff: {}
+  }
+
+  app.decorate('decorator1', decorator1)
+  app.decorateRequest('decorator1', decorator1)
+
+  if (
+    app.hasDecorator('decorator1') &&
+    app.hasRequestDecorator('decorator1')
+  ) {
+    t.doesNotThrow(() => app.decorateRequest('decorator2', decorator2, ['decorator1']))
+    t.ok(app.hasRequestDecorator('decorator2'))
+  }
+})

package/test/handler-context.test.js

@@ -4,6 +4,15 @@ const http = require('http')
 const test = require('tap').test
 const fastify = require('../')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('handlers receive correct `this` context', (t) => {
   t.plan(4)
 
@@ -29,8 +38,7 @@ test('handlers receive correct `this` context', (t) => {
     t.ok(instance.foo)
     t.equal(instance.foo, 'foo')
 
-    const address = `http://127.0.0.1:${instance.server.address().port}/`
-    http.get(address, () => {}).on('error', t.threw)
+    http.get(getUrl(instance), () => {}).on('error', t.threw)
   })
 })
 
@@ -50,7 +58,6 @@ test('handlers have access to the internal context', (t) => {
   instance.listen(0, (err) => {
     instance.server.unref()
     if (err) t.threw(err)
-    const address = `http://127.0.0.1:${instance.server.address().port}/`
-    http.get(address, () => {}).on('error', t.threw)
+    http.get(getUrl(instance), () => {}).on('error', t.threw)
   })
 })

package/test/http2/closing.test.js

@@ -11,6 +11,15 @@ const { once } = require('events')
 const { buildCertificate } = require('../build-certificate')
 t.before(buildCertificate)
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 t.test('http/2 request while fastify closing', t => {
   let fastify
   try {
@@ -30,7 +39,7 @@ t.test('http/2 request while fastify closing', t => {
 
     // Skipped because there is likely a bug on Node 8.
     t.test('return 200', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
-      const url = `http://127.0.0.1:${fastify.server.address().port}`
+      const url = getUrl(fastify)
       const session = http2.connect(url, function () {
         this.request({
           ':method': 'GET',
@@ -78,7 +87,7 @@ t.test('http/2 request while fastify closing - return503OnClosing: false', t =>
 
     // Skipped because there is likely a bug on Node 8.
     t.test('return 200', { skip: semver.lt(process.versions.node, '10.15.0') }, t => {
-      const url = `http://127.0.0.1:${fastify.server.address().port}`
+      const url = getUrl(fastify)
       const session = http2.connect(url, function () {
         this.request({
           ':method': 'GET',
@@ -115,7 +124,7 @@ t.test('http/2 closes successfully with async await', { skip: semver.lt(process.
 
   await fastify.listen(0)
 
-  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const url = getUrl(fastify)
   const session = await connect(url)
   // An error might or might not happen, as it's OS dependent.
   session.on('error', () => {})
@@ -135,7 +144,7 @@ t.test('https/2 closes successfully with async await', { skip: semver.lt(process
 
   await fastify.listen(0)
 
-  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const url = getUrl(fastify)
   const session = await connect(url)
   // An error might or might not happen, as it's OS dependent.
   session.on('error', () => {})
@@ -159,7 +168,7 @@ t.test('http/2 server side session emits a timeout event', { skip: semver.lt(pro
 
   await fastify.listen(0)
 
-  const url = `http://127.0.0.1:${fastify.server.address().port}`
+  const url = getUrl(fastify)
   const session = await connect(url)
   const req = session.request({
     ':method': 'GET',

package/test/listen.test.js

@@ -3,15 +3,29 @@
 const os = require('os')
 const path = require('path')
 const fs = require('fs')
-const test = require('tap').test
+const { test, before } = require('tap')
 const Fastify = require('..')
+const dns = require('dns').promises
+
+let localhost
+let localhostForURL
+
+before(async function () {
+  const lookup = await dns.lookup('localhost')
+  localhost = lookup.address
+  if (lookup.family === 6) {
+    localhostForURL = `[${lookup.address}]`
+  } else {
+    localhostForURL = localhost
+  }
+})
 
 test('listen accepts a callback', t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen((err) => {
-    t.equal(fastify.server.address().address, '127.0.0.1')
+    t.equal(fastify.server.address().address, localhost)
     t.error(err)
   })
 })
@@ -21,7 +35,7 @@ test('listen accepts a port and a callback', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err) => {
-    t.equal(fastify.server.address().address, '127.0.0.1')
+    t.equal(fastify.server.address().address, localhost)
     t.error(err)
   })
 })
@@ -31,7 +45,7 @@ test('listen accepts a port and a callback with (err, address)', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err, address) => {
-    t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err)
   })
 })
@@ -40,7 +54,7 @@ test('listen accepts a port, address, and callback', t => {
   t.plan(1)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', (err) => {
+  fastify.listen(0, localhost, (err) => {
     t.error(err)
   })
 })
@@ -78,8 +92,8 @@ test('listen accepts a port, address and a callback with (err, address)', t => {
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', (err, address) => {
-    t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+  fastify.listen(0, localhost, (err, address) => {
+    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err)
   })
 })
@@ -88,7 +102,7 @@ test('listen accepts a port, address, backlog and callback', t => {
   t.plan(1)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', 511, (err) => {
+  fastify.listen(0, localhost, 511, (err) => {
     t.error(err)
   })
 })
@@ -97,8 +111,8 @@ test('listen accepts a port, address, backlog and callback with (err, address)',
   t.plan(2)
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
-  fastify.listen(0, '127.0.0.1', 511, (err, address) => {
-    t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+  fastify.listen(0, localhost, 511, (err, address) => {
+    t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err)
   })
 })
@@ -111,7 +125,7 @@ test('listen after Promise.resolve()', t => {
     .then(() => {
       f.listen(0, (err, address) => {
         f.server.unref()
-        t.equal(address, 'http://127.0.0.1:' + f.server.address().port)
+        t.equal(address, `http://${localhostForURL}:${f.server.address().port}`)
         t.error(err)
       })
     })
@@ -153,7 +167,7 @@ test('double listen errors callback with (err, address)', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err1, address1) => {
-    t.equal(address1, 'http://127.0.0.1:' + fastify.server.address().port)
+    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err1)
     fastify.listen(fastify.server.address().port, (err2, address2) => {
       t.equal(address2, null)
@@ -167,7 +181,7 @@ test('listen twice on the same port', t => {
   const fastify = Fastify()
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err1, address1) => {
-    t.equal(address1, 'http://127.0.0.1:' + fastify.server.address().port)
+    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
     t.error(err1)
     const s2 = Fastify()
     t.teardown(s2.close.bind(s2))
@@ -184,7 +198,7 @@ test('listen twice on the same port callback with (err, address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0, (err1, address1) => {
     const _port = fastify.server.address().port
-    t.equal(address1, 'http://127.0.0.1:' + _port)
+    t.equal(address1, `http://${localhostForURL}:${_port}`)
     t.error(err1)
     const s2 = Fastify()
     t.teardown(s2.close.bind(s2))
@@ -221,7 +235,7 @@ test('listen without callback (port zero)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0)
     .then(() => {
-      t.equal(fastify.server.address().address, '127.0.0.1')
+      t.equal(fastify.server.address().address, localhost)
     })
 })
 
@@ -231,7 +245,7 @@ test('listen without callback (port not given)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen()
     .then(() => {
-      t.equal(fastify.server.address().address, '127.0.0.1')
+      t.equal(fastify.server.address().address, localhost)
     })
 })
 
@@ -241,7 +255,7 @@ test('listen null without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(null)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -251,7 +265,7 @@ test('listen without port without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen()
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -261,7 +275,7 @@ test('listen with undefined without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(undefined)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -271,7 +285,7 @@ test('listen without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
     })
 })
 
@@ -295,7 +309,7 @@ test('double listen without callback with (address)', t => {
   t.teardown(fastify.close.bind(fastify))
   fastify.listen(0)
     .then(address => {
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
       fastify.listen(0)
         .catch(err => {
           t.ok(err)
@@ -329,7 +343,7 @@ test('listen twice on the same port without callback rejects with (address)', t
     .then(address => {
       const s2 = Fastify()
       t.teardown(s2.close.bind(s2))
-      t.equal(address, 'http://127.0.0.1:' + fastify.server.address().port)
+      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
       s2.listen(fastify.server.address().port)
         .catch(err => {
           t.ok(err)

package/test/request-error.test.js

@@ -157,10 +157,7 @@ test('default clientError handler destroys sockets in writable state', t => {
 
   const fastify = Fastify({
     bodyLimit: 1,
-    keepAliveTimeout: 100,
-    logger: {
-      level: 'trace'
-    }
+    keepAliveTimeout: 100
   })
 
   fastify.server.emit('clientError', new Error(), {
@@ -181,10 +178,7 @@ test('default clientError handler destroys http sockets in non-writable state',
 
   const fastify = Fastify({
     bodyLimit: 1,
-    keepAliveTimeout: 100,
-    logger: {
-      level: 'trace'
-    }
+    keepAliveTimeout: 100
   })
 
   fastify.server.emit('clientError', new Error(), {

package/test/router-options.test.js

@@ -5,6 +5,15 @@ const sget = require('simple-get')
 const Fastify = require('../')
 const { FST_ERR_BAD_URL } = require('../lib/errors')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('Should honor ignoreTrailingSlash option', t => {
   t.plan(4)
   const fastify = Fastify({
@@ -19,7 +28,7 @@ test('Should honor ignoreTrailingSlash option', t => {
     fastify.server.unref()
     if (err) t.threw(err)
 
-    const baseUrl = 'http://127.0.0.1:' + fastify.server.address().port
+    const baseUrl = getUrl(fastify)
 
     sget.concat(baseUrl + '/test', (err, res, data) => {
       if (err) t.threw(err)

package/test/stream.test.js

@@ -16,6 +16,15 @@ const Readable = require('stream').Readable
 const split = require('split2')
 const { kDisableRequestLogging, kReplySent } = require('../lib/symbols.js')
 
+function getUrl (app) {
+  const { address, port } = app.server.address()
+  if (address === '::1') {
+    return `http://[${address}]:${port}`
+  } else {
+    return `http://${address}:${port}`
+  }
+}
+
 test('should respond with a stream', t => {
   t.plan(8)
   const fastify = Fastify()
@@ -573,7 +582,7 @@ test('return a 404 if the stream emits a 404 error', t => {
   })
 })
 
-test('should support send module 200 and 404', t => {
+test('should support send module 200 and 404', { only: true }, t => {
   t.plan(8)
   const fastify = Fastify()
 
@@ -591,7 +600,9 @@ test('should support send module 200 and 404', t => {
     t.error(err)
     fastify.server.unref()
 
-    sget(`http://localhost:${fastify.server.address().port}`, function (err, response, data) {
+    const url = getUrl(fastify)
+
+    sget(url, function (err, response, data) {
       t.error(err)
       t.equal(response.headers['content-type'], 'application/octet-stream')
       t.equal(response.statusCode, 200)
@@ -602,7 +613,7 @@ test('should support send module 200 and 404', t => {
       })
     })
 
-    sget(`http://localhost:${fastify.server.address().port}/error`, function (err, response) {
+    sget(url + '/error', function (err, response) {
       t.error(err)
       t.equal(response.statusCode, 404)
     })