fastify 4.27.0 → 5.0.0-alpha.2

package/test/plugin.4.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
-/* eslint no-prototype-builtins: 0 */
-
 const t = require('tap')
 const test = t.test
 const Fastify = require('../fastify')
 const fp = require('fastify-plugin')
 const fakeTimer = require('@sinonjs/fake-timers')
+const { FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER } = require('../lib/errors')
 
 test('pluginTimeout', t => {
   t.plan(5)
@@ -133,6 +132,9 @@ test('plugin metadata - version not matching requirement', t => {
 test('plugin metadata - version not matching requirement 2', t => {
   t.plan(2)
   const fastify = Fastify()
+  Object.defineProperty(fastify, 'version', {
+    value: '99.0.0'
+  })
 
   plugin[Symbol.for('skip-override')] = true
   plugin[Symbol.for('plugin-meta')] = {
@@ -198,36 +200,75 @@ test('plugin metadata - release candidate', t => {
   }
 })
 
-test('fastify-rc loads prior version plugins', t => {
-  t.plan(2)
-  const fastify = Fastify()
-  Object.defineProperty(fastify, 'version', {
-    value: '99.0.0-rc.1'
+test('fastify-rc loads prior version plugins', async t => {
+  t.test('baseline (rc)', t => {
+    t.plan(2)
+
+    const fastify = Fastify()
+    Object.defineProperty(fastify, 'version', {
+      value: '99.0.0-rc.1'
+    })
+
+    plugin[Symbol.for('plugin-meta')] = {
+      name: 'plugin',
+      fastify: '^98.1.0'
+    }
+    plugin2[Symbol.for('plugin-meta')] = {
+      name: 'plugin2',
+      fastify: '98.x'
+    }
+
+    fastify.register(plugin)
+
+    fastify.ready((err) => {
+      t.error(err)
+      t.pass('everything right')
+    })
+
+    function plugin (instance, opts, done) {
+      done()
+    }
+
+    function plugin2 (instance, opts, done) {
+      done()
+    }
   })
 
-  plugin[Symbol.for('plugin-meta')] = {
-    name: 'plugin',
-    fastify: '^98.1.0'
-  }
-  plugin2[Symbol.for('plugin-meta')] = {
-    name: 'plugin2',
-    fastify: '98.x'
-  }
+  t.test('pre', t => {
+    t.plan(2)
 
-  fastify.register(plugin)
+    const fastify = Fastify()
+    Object.defineProperty(fastify, 'version', { value: '99.0.0-pre.1' })
 
-  fastify.ready((err) => {
-    t.error(err)
-    t.pass('everything right')
+    plugin[Symbol.for('plugin-meta')] = { name: 'plugin', fastify: '^98.x' }
+
+    fastify.register(plugin)
+
+    fastify.ready((err) => {
+      t.error(err)
+      t.pass()
+    })
+
+    function plugin (instance, opts, done) { done() }
   })
 
-  function plugin (instance, opts, done) {
-    done()
-  }
+  t.test('alpha', t => {
+    t.plan(2)
 
-  function plugin2 (instance, opts, done) {
-    done()
-  }
+    const fastify = Fastify()
+    Object.defineProperty(fastify, 'version', { value: '99.0.0-pre.1' })
+
+    plugin[Symbol.for('plugin-meta')] = { name: 'plugin', fastify: '^98.x' }
+
+    fastify.register(plugin)
+
+    fastify.ready((err) => {
+      t.error(err)
+      t.pass()
+    })
+
+    function plugin (instance, opts, done) { done() }
+  })
 })
 
 test('hasPlugin method exists as a function', t => {
@@ -415,49 +456,44 @@ test('hasPlugin returns true when using encapsulation', async t => {
   await fastify.ready()
 })
 
-test('registering plugins with mixed style should return a warning', async t => {
-  t.plan(12)
-
-  const pluginNames = ['error-plugin', 'anonymous', 'anotherPlugin', 'anotherPluginNamed']
-
-  const oldWarnings = process.listeners('warning')
-  process.removeAllListeners('warning')
-  process.on('warning', onWarning)
-  function onWarning (warning) {
-    t.match(warning.message, new RegExp(`.*${pluginNames.shift()} plugin being registered mixes async and callback styles.*`))
-    t.equal(warning.name, 'FastifyWarning')
-    t.equal(warning.code, 'FSTWRN002')
-  }
-  t.teardown(() => {
-    process.removeListener('warning', onWarning)
-    for (const warning of oldWarnings) {
-      process.on('warning', warning)
-    }
-  })
+test('registering anonymous plugin with mixed style should throw', async t => {
+  t.plan(2)
 
   const fastify = Fastify()
 
-  const pluginName = 'error-plugin'
-  const errorPlugin = async (app, opts, done) => {
+  const anonymousPlugin = async (app, opts, done) => {
     done()
   }
 
-  const namedPlugin = fp(errorPlugin, { name: pluginName })
+  fastify.register(anonymousPlugin)
 
-  async function anotherPlugin (app, opts, done) {
-    done()
+  try {
+    await fastify.ready()
+    t.fail('should throw')
+  } catch (error) {
+    t.type(error, FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER)
+    t.equal(error.message, 'The anonymousPlugin plugin being registered mixes async and callback styles. Async plugin should not mix async and callback style.')
   }
+})
+
+test('registering named plugin with mixed style should throw', async t => {
+  t.plan(2)
+
+  const fastify = Fastify()
 
-  const anotherPluginNamed = async function (app, opts, done) {
+  const pluginName = 'error-plugin'
+  const errorPlugin = async (app, opts, done) => {
     done()
   }
+  const namedPlugin = fp(errorPlugin, { name: pluginName })
 
   fastify.register(namedPlugin)
-  fastify.register(async (app, opts, done) => {
-    done()
-  })
-  fastify.register(anotherPlugin)
-  fastify.register(anotherPluginNamed)
 
-  await fastify.ready()
+  try {
+    await fastify.ready()
+    t.fail('should throw')
+  } catch (error) {
+    t.type(error, FST_ERR_PLUGIN_INVALID_ASYNC_HANDLER)
+    t.equal(error.message, 'The error-plugin plugin being registered mixes async and callback styles. Async plugin should not mix async and callback style.')
+  }
 })

package/test/register.test.js

@@ -1,7 +1,5 @@
 'use strict'
 
-/* eslint no-prototype-builtins: 0 */
-
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
@@ -14,7 +12,7 @@ test('register', t => {
 
   fastify.register(function (instance, opts, done) {
     t.not(instance, fastify)
-    t.ok(fastify.isPrototypeOf(instance))
+    t.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
 
     t.equal(typeof opts, 'object')
     t.equal(typeof done, 'function')
@@ -27,7 +25,7 @@ test('register', t => {
 
   fastify.register(function (instance, opts, done) {
     t.not(instance, fastify)
-    t.ok(fastify.isPrototypeOf(instance))
+    t.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
 
     t.equal(typeof opts, 'object')
     t.equal(typeof done, 'function')

package/test/reply-earlyHints.test.js

@@ -0,0 +1,98 @@
+'use strict'
+
+const Fastify = require('..')
+const { test } = require('tap')
+const http = require('http')
+const http2 = require('http2')
+
+const testResBody = 'Hello, world!'
+
+test('sends early hints', (t) => {
+  t.plan(6)
+
+  const fastify = Fastify({
+    logger: false
+  })
+
+  fastify.get('/', async (request, reply) => {
+    reply.writeEarlyHints({
+      link: '</styles.css>; rel=preload; as=style'
+    }, () => {
+      t.pass('callback called')
+    })
+
+    return testResBody
+  })
+
+  fastify.listen({ port: 0 }, (err, address) => {
+    t.error(err)
+
+    const req = http.get(address)
+
+    req.on('information', (res) => {
+      t.equal(res.statusCode, 103)
+      t.equal(res.headers.link, '</styles.css>; rel=preload; as=style')
+    })
+
+    req.on('response', (res) => {
+      t.equal(res.statusCode, 200)
+
+      let data = ''
+      res.on('data', (chunk) => {
+        data += chunk
+      })
+
+      res.on('end', () => {
+        t.equal(data, testResBody)
+        fastify.close(t.end)
+      })
+    })
+  })
+})
+
+test('sends early hints (http2)', (t) => {
+  t.plan(6)
+
+  const fastify = Fastify({
+    http2: true,
+    logger: false
+  })
+
+  fastify.get('/', async (request, reply) => {
+    reply.writeEarlyHints({
+      link: '</styles.css>; rel=preload; as=style'
+    })
+
+    return testResBody
+  })
+
+  fastify.listen({ port: 0 }, (err, address) => {
+    t.error(err)
+
+    const client = http2.connect(address)
+    const req = client.request()
+
+    req.on('headers', (headers) => {
+      t.not(headers, undefined)
+      t.equal(headers[':status'], 103)
+      t.equal(headers.link, '</styles.css>; rel=preload; as=style')
+    })
+
+    req.on('response', (headers) => {
+      t.equal(headers[':status'], 200)
+    })
+
+    let data = ''
+    req.on('data', (chunk) => {
+      data += chunk
+    })
+
+    req.on('end', () => {
+      t.equal(data, testResBody)
+      client.close()
+      fastify.close(t.end)
+    })
+
+    req.end()
+  })
+})

package/test/reply-error.test.js

@@ -603,7 +603,6 @@ test('error handler is triggered when a string is thrown from sync handler', t =
   const payload = 'error'
 
   fastify.get('/', function (req, reply) {
-    // eslint-disable-next-line no-throw-literal
     throw throwable
   })
 
@@ -666,7 +665,6 @@ test('should trigger error handlers if a sync route throws any non-error object'
   const payload = 'error'
 
   fastify.get('/', function async (req, reply) {
-    // eslint-disable-next-line no-throw-literal
     throw throwable
   })
 

package/test/route-hooks.test.js

@@ -255,7 +255,6 @@ function testBeforeHandlerHook (hook) {
 
     fastify.get('/', {
       [hook]: async () => {
-        // eslint-disable-next-line no-throw-literal
         throw myError
       }
     }, (req, reply) => {

package/test/route-shorthand.test.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const Fastify = require('../fastify')
+const supportedMethods = require('../lib/httpMethods').supportedMethods
+
+test('route-shorthand', t => {
+  t.plan(supportedMethods.length + 1)
+  const test = t.test
+
+  for (const method of supportedMethods) {
+    test(`route-shorthand - ${method.toLowerCase()}`, t => {
+      t.plan(3)
+      const fastify = new Fastify()
+      fastify[method.toLowerCase()]('/', function (req, reply) {
+        t.equal(req.method, method)
+        reply.send()
+      })
+      fastify.listen({ port: 0 }, function (err) {
+        if (err) t.error(err)
+        t.teardown(() => { fastify.close() })
+        sget({
+          method,
+          url: 'http://localhost:' + fastify.server.address().port
+        }, (err, response, body) => {
+          t.error(err)
+          t.equal(response.statusCode, 200)
+        })
+      })
+    })
+  }
+
+  test('route-shorthand - all', t => {
+    t.plan(3 * supportedMethods.length)
+    const fastify = new Fastify()
+    let currentMethod = ''
+    fastify.all('/', function (req, reply) {
+      t.equal(req.method, currentMethod)
+      reply.send()
+    })
+    fastify.listen({ port: 0 }, async function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      for (const method of supportedMethods) {
+        currentMethod = method
+        await new Promise(resolve => sget({
+          method,
+          url: 'http://localhost:' + fastify.server.address().port
+        }, (err, response, body) => {
+          t.error(err)
+          t.equal(response.statusCode, 200)
+          resolve()
+        })
+        )
+      }
+    })
+  })
+})

package/test/schema-special-usage.test.js

@@ -704,7 +704,7 @@ test('Custom schema object should not trigger FST_ERR_SCH_DUPLICATE', async t =>
 })
 
 test('The default schema compilers should not be called when overwritten by the user', async t => {
-  const Fastify = t.mock('../', {
+  const Fastify = t.mockRequire('../', {
     '@fastify/ajv-compiler': () => {
       t.fail('The default validator compiler should not be called')
     },

package/test/server.test.js

@@ -3,7 +3,7 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
-const semver = require('semver')
+const sget = require('simple-get').concat
 const undici = require('undici')
 
 test('listen should accept null port', t => {
@@ -72,7 +72,22 @@ test('listen should reject string port', async (t) => {
   }
 })
 
-test('abort signal', { skip: semver.lt(process.version, '16.0.0') }, t => {
+test('Test for hostname and port', t => {
+  const app = Fastify()
+  t.teardown(app.close.bind(app))
+  app.get('/host', (req, res) => {
+    const host = 'localhost:8000'
+    t.equal(req.host, host)
+    t.equal(req.hostname, req.host.split(':')[0])
+    t.equal(req.port, Number(req.host.split(':')[1]))
+    res.send('ok')
+  })
+  app.listen({ port: 8000 }, () => {
+    sget('http://localhost:8000/host', () => { t.end() })
+  })
+})
+
+test('abort signal', t => {
   t.test('listen should not start server', t => {
     t.plan(2)
     function onClose (instance, done) {

package/test/stream.2.test.js

@@ -68,7 +68,7 @@ test('onSend hook stream should work even if payload is not a proper stream', t
     child: () => { return spyLogger }
   }
 
-  const fastify = Fastify({ logger: spyLogger })
+  const fastify = Fastify({ loggerInstance: spyLogger })
   fastify.get('/', function (req, reply) {
     reply.send({ hello: 'world' })
   })

package/test/stream.4.test.js

@@ -3,16 +3,12 @@
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
-const fs = require('node:fs')
 const errors = require('http-errors')
 const JSONStream = require('JSONStream')
-const send = require('send')
 const Readable = require('node:stream').Readable
 const split = require('split2')
-const semver = require('semver')
 const Fastify = require('..')
 const { kDisableRequestLogging } = require('../lib/symbols.js')
-const { getServerUrl } = require('./helper')
 
 test('Destroying streams prematurely should call abort method', t => {
   t.plan(7)
@@ -183,41 +179,3 @@ test('return a 404 if the stream emits a 404 error', t => {
     })
   })
 })
-
-test('should support send module 200 and 404', { skip: semver.gte(process.versions.node, '17.0.0') }, t => {
-  t.plan(8)
-  const fastify = Fastify()
-
-  fastify.get('/', function (req, reply) {
-    const stream = send(req.raw, __filename)
-    reply.code(200).send(stream)
-  })
-
-  fastify.get('/error', function (req, reply) {
-    const stream = send(req.raw, 'non-existing-file')
-    reply.code(200).send(stream)
-  })
-
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
-
-    const url = getServerUrl(fastify)
-
-    sget(url, function (err, response, data) {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/javascript; charset=UTF-8')
-      t.equal(response.statusCode, 200)
-
-      fs.readFile(__filename, (err, expected) => {
-        t.error(err)
-        t.equal(expected.toString(), data.toString())
-      })
-    })
-
-    sget(url + '/error', function (err, response) {
-      t.error(err)
-      t.equal(response.statusCode, 404)
-    })
-  })
-})

package/test/stream.5.test.js

@@ -88,7 +88,7 @@ test('reply.send handles aborted requests', t => {
     child: () => { return spyLogger }
   }
   const fastify = Fastify({
-    logger: spyLogger
+    loggerInstance: spyLogger
   })
 
   fastify.get('/', (req, reply) => {
@@ -136,7 +136,7 @@ test('request terminated should not crash fastify', t => {
     child: () => { return spyLogger }
   }
   const fastify = Fastify({
-    logger: spyLogger
+    loggerInstance: spyLogger
   })
 
   fastify.get('/', async (req, reply) => {

package/test/trust-proxy.test.js

@@ -26,9 +26,11 @@ const testRequestValues = (t, req, options) => {
     t.ok(req.ip, 'ip is defined')
     t.equal(req.ip, options.ip, 'gets ip from x-forwarded-for')
   }
-  if (options.hostname) {
-    t.ok(req.hostname, 'hostname is defined')
-    t.equal(req.hostname, options.hostname, 'gets hostname from x-forwarded-host')
+  if (options.host) {
+    t.ok(req.host, 'host is defined')
+    t.equal(req.host, options.host, 'gets host from x-forwarded-host')
+    t.ok(req.hostname)
+    t.equal(req.hostname, options.host, 'gets hostname from x-forwarded-host')
   }
   if (options.ips) {
     t.same(req.ips, options.ips, 'gets ips from x-forwarded-for')
@@ -37,6 +39,10 @@ const testRequestValues = (t, req, options) => {
     t.ok(req.protocol, 'protocol is defined')
     t.equal(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
   }
+  if (options.port) {
+    t.ok(req.port, 'port is defined')
+    t.equal(req.port, options.port, 'port is taken from x-forwarded-for or host')
+  }
 }
 
 let localhost
@@ -45,18 +51,18 @@ before(async function () {
 })
 
 test('trust proxy, not add properties to node req', (t) => {
-  t.plan(8)
+  t.plan(14)
   const app = fastify({
     trustProxy: true
   })
   app.get('/trustproxy', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', hostname: 'example.com' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'] })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'], port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -70,14 +76,14 @@ test('trust proxy, not add properties to node req', (t) => {
 })
 
 test('trust proxy chain', (t) => {
-  t.plan(3)
+  t.plan(9)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -90,13 +96,13 @@ test('trust proxy chain', (t) => {
 })
 
 test('trust proxy function', (t) => {
-  t.plan(3)
+  t.plan(9)
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
   app.get('/trustproxyfunc', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -109,13 +115,13 @@ test('trust proxy function', (t) => {
 })
 
 test('trust proxy number', (t) => {
-  t.plan(4)
+  t.plan(10)
   const app = fastify({
     trustProxy: 1
   })
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -128,13 +134,13 @@ test('trust proxy number', (t) => {
 })
 
 test('trust proxy IP addresses', (t) => {
-  t.plan(4)
+  t.plan(10)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
   app.get('/trustproxyipaddrs', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -147,21 +153,21 @@ test('trust proxy IP addresses', (t) => {
 })
 
 test('trust proxy protocol', (t) => {
-  t.plan(13)
+  t.plan(31)
   const app = fastify({
     trustProxy: true
   })
   app.get('/trustproxyprotocol', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
   app.get('/trustproxynoprotocol', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
   app.get('/trustproxyprotocols', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))