node-fastify 5.8.3

package/test/content-type.test.js

@@ -0,0 +1,181 @@
+'use strict'
+
+const { describe, test } = require('node:test')
+const ContentType = require('../lib/content-type')
+const Fastify = require('..')
+
+test('should remove content-type for setErrorHandler', async t => {
+  t.plan(8)
+  let count = 0
+
+  const fastify = Fastify()
+  fastify.setErrorHandler(function (error, request, reply) {
+    t.assert.strictEqual(error.message, 'kaboom')
+    t.assert.strictEqual(reply.hasHeader('content-type'), false)
+    reply.code(400).send({ foo: 'bar' })
+  })
+  fastify.addHook('onSend', async function (request, reply, payload) {
+    count++
+    t.assert.strictEqual(typeof payload, 'string')
+    switch (count) {
+      case 1: {
+        // should guess the correct content-type based on payload
+        t.assert.strictEqual(reply.getHeader('content-type'), 'text/plain; charset=utf-8')
+        throw Error('kaboom')
+      }
+      case 2: {
+        // should guess the correct content-type based on payload
+        t.assert.strictEqual(reply.getHeader('content-type'), 'application/json; charset=utf-8')
+        return payload
+      }
+      default: {
+        t.fail('should not reach')
+      }
+    }
+  })
+  fastify.get('/', function (request, reply) {
+    reply.send('plain-text')
+  })
+
+  const { statusCode, body } = await fastify.inject({ method: 'GET', path: '/' })
+  t.assert.strictEqual(statusCode, 400)
+  t.assert.strictEqual(body, JSON.stringify({ foo: 'bar' }))
+})
+
+describe('ContentType class', () => {
+  test('returns empty instance for empty value', (t) => {
+    let found = new ContentType('')
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType('undefined')
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType()
+    t.assert.equal(found.isEmpty, true)
+  })
+
+  test('indicates media type is not correct format', (t) => {
+    let found = new ContentType('foo')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo /bar')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo/ bar')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo; param=1')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('foo/π; param=1')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('application/json<script>alert(1)</script>')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('application/json/extra/slashes')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('application/json(garbage)')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('application/json@evil')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+
+    found = new ContentType('application/json\x00garbage')
+    t.assert.equal(found.isEmpty, true)
+    t.assert.equal(found.isValid, false)
+  })
+
+  test('subtype with multiple fields validates as incorrect', (t) => {
+    let found = new ContentType('application/json whatever')
+    t.assert.equal(found.isValid, false)
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType('application/    json whatever')
+    t.assert.equal(found.isValid, false)
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType('application/json whatever; foo=bar')
+    t.assert.equal(found.isValid, false)
+    t.assert.equal(found.isEmpty, true)
+
+    found = new ContentType('application/    json whatever; foo=bar')
+    t.assert.equal(found.isValid, false)
+    t.assert.equal(found.isEmpty, true)
+  })
+
+  test('returns a plain media type instance', (t) => {
+    const found = new ContentType('Application/JSON')
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 0)
+  })
+
+  test('handles empty parameters list', (t) => {
+    const found = new ContentType('Application/JSON ;')
+    t.assert.equal(found.isEmpty, false)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 0)
+  })
+
+  test('returns a media type instance with parameters', (t) => {
+    const found = new ContentType('Application/JSON ; charset=utf-8; foo=BaR;baz=" 42"')
+    t.assert.equal(found.isEmpty, false)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 3)
+
+    const expected = [
+      ['charset', 'utf-8'],
+      ['foo', 'BaR'],
+      ['baz', ' 42']
+    ]
+    t.assert.deepStrictEqual(
+      Array.from(found.parameters.entries()),
+      expected
+    )
+
+    t.assert.equal(
+      found.toString(),
+      'application/json; charset="utf-8"; foo="BaR"; baz=" 42"'
+    )
+  })
+
+  test('skips invalid quoted string parameters', (t) => {
+    const found = new ContentType('Application/JSON ; charset=utf-8; foo=BaR;baz=" 42')
+    t.assert.equal(found.isEmpty, false)
+    t.assert.equal(found.mediaType, 'application/json')
+    t.assert.equal(found.type, 'application')
+    t.assert.equal(found.subtype, 'json')
+    t.assert.equal(found.parameters.size, 3)
+
+    const expected = [
+      ['charset', 'utf-8'],
+      ['foo', 'BaR'],
+      ['baz', 'invalid quoted string']
+    ]
+    t.assert.deepStrictEqual(
+      Array.from(found.parameters.entries()),
+      expected
+    )
+
+    t.assert.equal(
+      found.toString(),
+      'application/json; charset="utf-8"; foo="BaR"; baz="invalid quoted string"'
+    )
+  })
+})

package/test/context-config.test.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const { test } = require('node:test')
+
+const { kRouteContext } = require('../lib/symbols')
+const Fastify = require('..')
+
+const schema = {
+  schema: { },
+  config: {
+    value1: 'foo',
+    value2: true
+  }
+}
+
+function handler (req, reply) {
+  reply.send(reply[kRouteContext].config)
+}
+
+test('config', async t => {
+  t.plan(6)
+  const fastify = Fastify()
+
+  fastify.get('/get', {
+    schema: schema.schema,
+    config: Object.assign({}, schema.config)
+  }, handler)
+
+  fastify.route({
+    method: 'GET',
+    url: '/route',
+    schema: schema.schema,
+    handler,
+    config: Object.assign({}, schema.config)
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/no-config',
+    schema: schema.schema,
+    handler
+  })
+
+  let response = await fastify.inject({
+    method: 'GET',
+    url: '/route'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
+    method: 'GET',
+    url: '/route'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
+    method: 'GET',
+    url: '/no-config'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { url: '/no-config', method: 'GET' })
+})
+
+test('config with exposeHeadRoutes', async t => {
+  t.plan(6)
+  const fastify = Fastify({ exposeHeadRoutes: true })
+
+  fastify.get('/get', {
+    schema: schema.schema,
+    config: Object.assign({}, schema.config)
+  }, handler)
+
+  fastify.route({
+    method: 'GET',
+    url: '/route',
+    schema: schema.schema,
+    handler,
+    config: Object.assign({}, schema.config)
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/no-config',
+    schema: schema.schema,
+    handler
+  })
+
+  let response = await fastify.inject({
+    method: 'GET',
+    url: '/get'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/get', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
+    method: 'GET',
+    url: '/route'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
+    method: 'GET',
+    url: '/no-config'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { url: '/no-config', method: 'GET' })
+})
+
+test('config without exposeHeadRoutes', async t => {
+  t.plan(6)
+  const fastify = Fastify({ exposeHeadRoutes: false })
+
+  fastify.get('/get', {
+    schema: schema.schema,
+    config: Object.assign({}, schema.config)
+  }, handler)
+
+  fastify.route({
+    method: 'GET',
+    url: '/route',
+    schema: schema.schema,
+    handler,
+    config: Object.assign({}, schema.config)
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/no-config',
+    schema: schema.schema,
+    handler
+  })
+
+  let response = await fastify.inject({
+    method: 'GET',
+    url: '/get'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/get', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
+    method: 'GET',
+    url: '/route'
+  })
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), Object.assign({ url: '/route', method: 'GET' }, schema.config))
+
+  response = await fastify.inject({
+    method: 'GET',
+    url: '/no-config'
+  })
+
+  t.assert.strictEqual(response.statusCode, 200)
+  t.assert.deepStrictEqual(response.json(), { url: '/no-config', method: 'GET' })
+})

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

@@ -0,0 +1,118 @@
+'use strict'
+
+const { test } = require('node:test')
+const http = require('node:http')
+const dns = require('node:dns').promises
+const Fastify = require('..')
+const { FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE } = require('../lib/errors')
+
+async function setup () {
+  const localAddresses = await dns.lookup('localhost', { all: true })
+
+  test('Should support a custom http 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 server = http.createServer((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 response = await fetch('http://localhost:' + fastify.server.address().port, {
+      method: 'GET'
+    })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  })
+
+  test('Should not allow forceCloseConnection=idle if the server does not support closeIdleConnections', t => {
+    t.plan(1)
+
+    t.assert.throws(
+      () => {
+        Fastify({
+          forceCloseConnections: 'idle',
+          serverFactory (handler, opts) {
+            return {
+              on () {
+
+              }
+            }
+          }
+        })
+      },
+      FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE,
+      "Cannot set forceCloseConnections to 'idle' as your HTTP server does not support closeIdleConnections method"
+    )
+  })
+
+  test('Should accept user defined serverFactory and ignore secondary server creation', async t => {
+    const server = http.createServer(() => { })
+    t.after(() => new Promise(resolve => server.close(resolve)))
+    const app = Fastify({
+      serverFactory: () => server
+    })
+    await t.assert.doesNotReject(async () => { await app.listen({ port: 0 }) })
+  })
+
+  test('Should not call close on the server if it has not created it', async t => {
+    const server = http.createServer()
+
+    const serverFactory = (handler, opts) => {
+      server.on('request', handler)
+      return server
+    }
+
+    const fastify = Fastify({ serverFactory })
+
+    fastify.get('/', (req, reply) => {
+      reply.send({ hello: 'world' })
+    })
+
+    await fastify.ready()
+
+    await new Promise((resolve, reject) => {
+      server.listen(0)
+      server.on('listening', resolve)
+      server.on('error', reject)
+    })
+
+    const address = server.address()
+    t.assert.strictEqual(server.listening, true)
+    await fastify.close()
+
+    t.assert.strictEqual(server.listening, true)
+    t.assert.deepStrictEqual(server.address(), address)
+    t.assert.deepStrictEqual(fastify.addresses(), [address])
+
+    await new Promise((resolve, reject) => {
+      server.close((err) => {
+        if (err) {
+          return reject(err)
+        }
+        resolve()
+      })
+    })
+    t.assert.strictEqual(server.listening, false)
+    t.assert.deepStrictEqual(server.address(), null)
+  })
+}
+
+setup()

package/test/custom-parser-async.test.js

@@ -0,0 +1,59 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('../fastify')
+
+process.removeAllListeners('warning')
+
+test('contentTypeParser should add a custom async parser', async t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.post('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.options('/', (req, reply) => {
+    reply.send(req.body)
+  })
+
+  fastify.addContentTypeParser('application/jsoff', async function (req, payload) {
+    const res = await new Promise((resolve, reject) => resolve(payload))
+    return res
+  })
+
+  t.after(() => fastify.close())
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  await t.test('in POST', async t => {
+    t.plan(3)
+
+    const result = await fetch(fastifyServer, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/jsoff'
+      },
+      body: '{"hello":"world"}'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
+  })
+
+  await t.test('in OPTIONS', async t => {
+    t.plan(3)
+
+    const result = await fetch(fastifyServer, {
+      method: 'OPTIONS',
+      headers: {
+        'Content-Type': 'application/jsoff'
+      },
+      body: '{"hello":"world"}'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
+  })
+})