node-fastify 5.8.3

package/test/https/custom-https-server.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../..')
+const https = require('node:https')
+const dns = require('node:dns').promises
+const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
+
+async function setup () {
+  await buildCertificate()
+
+  const localAddresses = await dns.lookup('localhost', { all: true })
+
+  test('Should support a custom https server', { skip: localAddresses.length < 1 }, async t => {
+    t.plan(5)
+
+    const fastify = Fastify({
+      serverFactory: (handler, opts) => {
+        t.assert.ok(opts.serverFactory, 'it is called once for localhost')
+
+        const options = {
+          key: global.context.key,
+          cert: global.context.cert
+        }
+
+        const server = https.createServer(options, (req, res) => {
+          req.custom = true
+          handler(req, res)
+        })
+
+        return server
+      }
+    })
+
+    t.after(() => { fastify.close() })
+
+    fastify.get('/', (req, reply) => {
+      t.assert.ok(req.raw.custom)
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.listen({ port: 0 })
+
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
+  })
+}
+
+setup()

package/test/https/https.test.js

@@ -0,0 +1,136 @@
+'use strict'
+
+const { test } = require('node:test')
+const { request } = require('undici')
+const Fastify = require('../..')
+
+const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
+test.before(buildCertificate)
+
+test('https', async (t) => {
+  t.plan(3)
+
+  let fastify
+  try {
+    fastify = Fastify({
+      https: {
+        key: global.context.key,
+        cert: global.context.cert
+      }
+    })
+    t.assert.ok('Key/cert successfully loaded')
+  } catch (e) {
+    t.assert.fail('Key/cert loading failed')
+  }
+
+  fastify.get('/', function (req, reply) {
+    reply.code(200).send({ hello: 'world' })
+  })
+
+  fastify.get('/proto', function (req, reply) {
+    reply.code(200).send({ proto: req.protocol })
+  })
+
+  await fastify.listen({ port: 0 })
+
+  t.after(() => { fastify.close() })
+
+  await t.test('https get request', async t => {
+    t.plan(4)
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  })
+
+  await t.test('https get request without trust proxy - protocol', async t => {
+    t.plan(3)
+    const result1 = await fetch(`${'https://localhost:' + fastify.server.address().port}/proto`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
+    })
+    t.assert.ok(result1.ok)
+    t.assert.deepStrictEqual(await result1.json(), { proto: 'https' })
+
+    const result2 = await fetch(`${'https://localhost:' + fastify.server.address().port}/proto`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      }),
+      headers: {
+        'x-forwarded-proto': 'lorem'
+      }
+    })
+    t.assert.deepStrictEqual(await result2.json(), { proto: 'https' })
+  })
+})
+
+test('https - headers', async (t) => {
+  t.plan(3)
+  let fastify
+  try {
+    fastify = Fastify({
+      https: {
+        key: global.context.key,
+        cert: global.context.cert
+      }
+    })
+    t.assert.ok('Key/cert successfully loaded')
+  } catch (e) {
+    t.assert.fail('Key/cert loading failed')
+  }
+
+  fastify.get('/', function (req, reply) {
+    reply.code(200).send({ hello: 'world', hostname: req.hostname, port: req.port })
+  })
+
+  t.after(async () => { await fastify.close() })
+
+  await fastify.listen({ port: 0 })
+
+  await t.test('https get request', async t => {
+    t.plan(3)
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hostname: 'localhost', port: fastify.server.address().port, hello: 'world' })
+  })
+
+  await t.test('https get request - test port fall back', async t => {
+    t.plan(2)
+
+    const result = await request('https://localhost:' + fastify.server.address().port, {
+      method: 'GET',
+      headers: {
+        host: 'fastify.test'
+      },
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
+    })
+
+    t.assert.strictEqual(result.statusCode, 200)
+    t.assert.deepStrictEqual(await result.body.json(), { hello: 'world', hostname: 'fastify.test', port: null })
+  })
+})

package/test/imports.test.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { test } = require('node:test')
+
+test('should import as default', t => {
+  t.plan(2)
+  const fastify = require('..')
+  t.assert.ok(fastify)
+  t.assert.strictEqual(typeof fastify, 'function')
+})
+
+test('should import as esm', t => {
+  t.plan(2)
+  const { fastify } = require('..')
+  t.assert.ok(fastify)
+  t.assert.strictEqual(typeof fastify, 'function')
+})

package/test/inject.test.js

@@ -0,0 +1,502 @@
+'use strict'
+
+const { test } = require('node:test')
+const Stream = require('node:stream')
+const util = require('node:util')
+const Fastify = require('..')
+const { Readable } = require('node:stream')
+
+test('inject should exist', t => {
+  t.plan(2)
+  const fastify = Fastify()
+  t.assert.ok(fastify.inject)
+  t.assert.strictEqual(typeof fastify.inject, 'function')
+})
+
+test('should wait for the ready event', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.register((instance, opts, done) => {
+    instance.get('/', (req, reply) => {
+      reply.send(payload)
+    })
+    setTimeout(done, 500)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(payload, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject get request', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(payload, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject get request - code check', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.code(201).send(payload)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(payload, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 201)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject get request - headers check', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.header('content-type', 'text/plain').send('')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual('', res.payload)
+    t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+    t.assert.strictEqual(res.headers['content-length'], '0')
+    done()
+  })
+})
+
+test('inject get request - querystring', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.send(req.query)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/?hello=world'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual({ hello: 'world' }, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject get request - params', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/:hello', (req, reply) => {
+    reply.send(req.params)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/world'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual({ hello: 'world' }, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject get request - wildcard', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/test/*', (req, reply) => {
+    reply.send(req.params)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/test/wildcard'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual({ '*': 'wildcard' }, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '16')
+    done()
+  })
+})
+
+test('inject get request - headers', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.send(req.headers)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: { hello: 'world' }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.strictEqual('world', JSON.parse(res.payload).hello)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '69')
+    done()
+  })
+})
+
+test('inject post request', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(payload, JSON.parse(res.payload))
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject post request - send stream', (t, done) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: { 'content-type': 'application/json' },
+    payload: getStream()
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual('{"hello":"world"}', res.payload)
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '17')
+    done()
+  })
+})
+
+test('inject get request - reply stream', (t, done) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.get('/', (req, reply) => {
+    reply.send(getStream())
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual('{"hello":"world"}', res.payload)
+    t.assert.strictEqual(res.statusCode, 200)
+    done()
+  })
+})
+
+test('inject promisify - waiting for ready event', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  const injectParams = {
+    method: 'GET',
+    url: '/'
+  }
+  fastify.inject(injectParams)
+    .then(res => {
+      t.assert.strictEqual(res.statusCode, 200)
+      done()
+    })
+    .catch(t.assert.fail)
+})
+
+test('inject promisify - after the ready event', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  fastify.ready(err => {
+    t.assert.ifError(err)
+
+    const injectParams = {
+      method: 'GET',
+      url: '/'
+    }
+    fastify.inject(injectParams)
+      .then(res => {
+        t.assert.strictEqual(res.statusCode, 200)
+        done()
+      })
+      .catch(t.assert.fail)
+  })
+})
+
+test('inject promisify - when the server is up', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  fastify.ready(err => {
+    t.assert.ifError(err)
+
+    // setTimeout because the ready event don't set "started" flag
+    // in this iteration of the 'event loop'
+    setTimeout(() => {
+      const injectParams = {
+        method: 'GET',
+        url: '/'
+      }
+      fastify.inject(injectParams)
+        .then(res => {
+          t.assert.strictEqual(res.statusCode, 200)
+          done()
+        })
+        .catch(t.assert.fail)
+    }, 10)
+  })
+})
+
+test('should reject in error case', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  const error = new Error('DOOM!')
+  fastify.register((instance, opts, done) => {
+    setTimeout(done, 500, error)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  })
+    .catch(e => {
+      t.assert.strictEqual(e, error)
+      done()
+    })
+})
+
+test('inject a multipart request using form-body', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.addContentTypeParser('*', function (req, payload, done) {
+    let body = ''
+    payload.on('data', d => {
+      body += d
+    })
+    payload.on('end', () => {
+      done(null, body)
+    })
+  })
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  const form = new FormData()
+  form.set('my_field', 'my value')
+
+  fastify.inject({
+    method: 'POST',
+    url: '/',
+    payload: form
+  })
+    .then(response => {
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.ok(/Content-Disposition: form-data; name="my_field"/.test(response.payload))
+      done()
+    })
+})
+
+// https://github.com/hapijs/shot/blob/master/test/index.js#L836
+function getStream () {
+  const Read = function () {
+    Stream.Readable.call(this)
+  }
+  util.inherits(Read, Stream.Readable)
+  const word = '{"hello":"world"}'
+  let i = 0
+
+  Read.prototype._read = function (size) {
+    this.push(word[i] ? word[i++] : null)
+  }
+
+  return new Read()
+}
+
+test('should error the promise if ready errors', (t, done) => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts) => {
+    return Promise.reject(new Error('kaboom'))
+  }).after(function () {
+    t.assert.ok('after is called')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }).then(() => {
+    t.assert.fail('this should not be called')
+  }).catch(err => {
+    t.assert.ok(err)
+    t.assert.strictEqual(err.message, 'kaboom')
+    done()
+  })
+})
+
+test('should throw error if callback specified and if ready errors', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+  const error = new Error('kaboom')
+
+  fastify.register((instance, opts) => {
+    return Promise.reject(error)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/'
+  }, err => {
+    t.assert.ok(err)
+    t.assert.strictEqual(err, error)
+    done()
+  })
+})
+
+test('should support builder-style injection with ready app', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  await fastify.ready()
+  const res = await fastify.inject().get('/').end()
+  t.assert.deepStrictEqual(payload, JSON.parse(res.payload))
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['content-length'], '17')
+})
+
+test('should support builder-style injection with non-ready app', async (t) => {
+  t.plan(3)
+  const fastify = Fastify()
+  const payload = { hello: 'world' }
+
+  fastify.get('/', (req, reply) => {
+    reply.send(payload)
+  })
+
+  const res = await fastify.inject().get('/').end()
+  t.assert.deepStrictEqual(payload, JSON.parse(res.payload))
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['content-length'], '17')
+})
+
+test('should handle errors in builder-style injection correctly', async (t) => {
+  t.plan(2)
+  const fastify = Fastify()
+  fastify.register((instance, opts, done) => {
+    done(new Error('Kaboom'))
+  })
+
+  try {
+    await fastify.inject().get('/')
+  } catch (err) {
+    t.assert.ok(err)
+    t.assert.strictEqual(err.message, 'Kaboom')
+  }
+})
+
+test('Should not throw on access to routeConfig frameworkErrors handler - FST_ERR_BAD_URL', (t, done) => {
+  t.plan(5)
+
+  const fastify = Fastify({
+    frameworkErrors: function (err, req, res) {
+      t.assert.ok(typeof req.id === 'string')
+      t.assert.ok(req.raw instanceof Readable)
+      t.assert.deepStrictEqual(req.routeOptions.url, undefined)
+      res.send(`${err.message} - ${err.code}`)
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/%world'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+      done()
+    }
+  )
+})