fastify 5.4.0 → 5.5.0

package/test/check.test.js

@@ -3,7 +3,6 @@
 const { test } = require('node:test')
 const { S } = require('fluent-json-schema')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
 const BadRequestSchema = S.object()
   .prop('statusCode', S.number())
@@ -105,32 +104,29 @@ const handler = (request, reply) => {
   })
 }
 
-test('serialize the response for a Bad Request error, as defined on the schema', (t, done) => {
+test('serialize the response for a Bad Request error, as defined on the schema', async t => {
   const fastify = Fastify({})
 
   t.after(() => fastify.close())
 
   fastify.post('/', options, handler)
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    const url = `http://localhost:${fastify.server.address().port}/`
-
-    sget({
-      method: 'POST',
-      url,
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 400)
-      t.assert.deepStrictEqual(body, {
-        statusCode: 400,
-        error: 'Bad Request',
-        message: 'body must be object'
-      })
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: '12'
+  })
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 400)
+  t.assert.deepStrictEqual(await result.json(), {
+    statusCode: 400,
+    error: 'Bad Request',
+    message: 'body must be object'
   })
 })
 

package/test/close-pipelining.test.js

@@ -11,8 +11,10 @@ test('Should return 503 while closing - pipelining', async t => {
   })
 
   fastify.get('/', async (req, reply) => {
+    // Simulate a delay to allow pipelining to kick in
+    await new Promise(resolve => setTimeout(resolve, 5))
+    reply.send({ hello: 'world' })
     fastify.close()
-    return { hello: 'world' }
   })
 
   await fastify.listen({ port: 0 })
@@ -21,14 +23,19 @@ test('Should return 503 while closing - pipelining', async t => {
     pipelining: 2
   })
 
-  const codes = [200, 200, 503]
-  const responses = await Promise.all([
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' })
+  const [firstRequest, secondRequest, thirdRequest] = await Promise.allSettled([
+    instance.request({ path: '/', method: 'GET', blocking: false }),
+    instance.request({ path: '/', method: 'GET', blocking: false }),
+    instance.request({ path: '/', method: 'GET', blocking: false })
   ])
-  const actual = responses.map(r => r.statusCode)
-  t.assert.deepStrictEqual(actual, codes)
+  t.assert.strictEqual(firstRequest.status, 'fulfilled')
+  t.assert.strictEqual(secondRequest.status, 'fulfilled')
+
+  t.assert.strictEqual(firstRequest.value.statusCode, 200)
+  t.assert.strictEqual(secondRequest.value.statusCode, 200)
+
+  t.assert.strictEqual(thirdRequest.status, 'fulfilled')
+  t.assert.strictEqual(thirdRequest.value.statusCode, 503)
 
   await instance.close()
 })
@@ -42,6 +49,8 @@ test('Should close the socket abruptly - pipelining - return503OnClosing: false'
   })
 
   fastify.get('/', async (req, reply) => {
+    // Simulate a delay to allow pipelining to kick in
+    await new Promise(resolve => setTimeout(resolve, 5))
     reply.send({ hello: 'world' })
     fastify.close()
   })
@@ -49,21 +58,21 @@ test('Should close the socket abruptly - pipelining - return503OnClosing: false'
   await fastify.listen({ port: 0 })
 
   const instance = new Client('http://localhost:' + fastify.server.address().port, {
-    pipelining: 2
+    pipelining: 1
   })
 
   const responses = await Promise.allSettled([
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' }),
-    instance.request({ path: '/', method: 'GET' })
+    instance.request({ path: '/', method: 'GET', blocking: false }),
+    instance.request({ path: '/', method: 'GET', blocking: false }),
+    instance.request({ path: '/', method: 'GET', blocking: false }),
+    instance.request({ path: '/', method: 'GET', blocking: false })
   ])
 
   const fulfilled = responses.filter(r => r.status === 'fulfilled')
   const rejected = responses.filter(r => r.status === 'rejected')
 
-  t.assert.strictEqual(fulfilled.length, 2)
-  t.assert.strictEqual(rejected.length, 2)
+  t.assert.strictEqual(fulfilled.length, 1)
+  t.assert.strictEqual(rejected.length, 3)
 
   await instance.close()
 })

package/test/constrained-routes.test.js

@@ -905,3 +905,234 @@ test('Allow regex constraints in routes', async t => {
     t.assert.strictEqual(res.statusCode, 404)
   }
 })
+
+test('Should allow registering custom rotuerOptions constrained routes', async t => {
+  t.plan(5)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify({ routerOptions: { constraints: { secret: constraint } } })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'beta' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from beta' })
+    }
+  })
+
+  {
+    const res = await fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: {
+        'X-Secret': 'alpha'
+      }
+    })
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'from alpha' })
+    t.assert.strictEqual(res.statusCode, 200)
+  }
+
+  {
+    const res = await fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: {
+        'X-Secret': 'beta'
+      }
+    })
+    t.assert.deepStrictEqual(JSON.parse(res.payload), { hello: 'from beta' })
+    t.assert.strictEqual(res.statusCode, 200)
+  }
+
+  {
+    const res = await fastify.inject({
+      method: 'GET',
+      url: '/',
+      headers: {
+        'X-Secret': 'gamma'
+      }
+    })
+    t.assert.strictEqual(res.statusCode, 404)
+  }
+})
+
+test('Custom rotuerOptions constrained routes registered also for HEAD method generated by fastify', (t, done) => {
+  t.plan(3)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx) => {
+      return req.headers['x-secret']
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify({ routerOptions: { constraints: { secret: constraint } } })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'mySecret' },
+    handler: (req, reply) => {
+      reply.send('from mySecret - my length is 31')
+    }
+  })
+
+  fastify.inject({
+    method: 'HEAD',
+    url: '/',
+    headers: {
+      'X-Secret': 'mySecret'
+    }
+  }, (err, res) => {
+    t.assert.ifError(err)
+    t.assert.deepStrictEqual(res.headers['content-length'], '31')
+    t.assert.strictEqual(res.statusCode, 200)
+    done()
+  })
+})
+
+test('allow async rotuerOptions constraints', async (t) => {
+  t.plan(5)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx, done) => {
+      done(null, req.headers['x-secret'])
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify({ routerOptions: { constraints: { secret: constraint } } })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'beta' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from beta' })
+    }
+  })
+
+  {
+    const { statusCode, payload } = await fastify.inject({ method: 'GET', path: '/', headers: { 'X-Secret': 'alpha' } })
+    t.assert.deepStrictEqual(JSON.parse(payload), { hello: 'from alpha' })
+    t.assert.strictEqual(statusCode, 200)
+  }
+  {
+    const { statusCode, payload } = await fastify.inject({ method: 'GET', path: '/', headers: { 'X-Secret': 'beta' } })
+    t.assert.deepStrictEqual(JSON.parse(payload), { hello: 'from beta' })
+    t.assert.strictEqual(statusCode, 200)
+  }
+  {
+    const { statusCode } = await fastify.inject({ method: 'GET', path: '/', headers: { 'X-Secret': 'gamma' } })
+    t.assert.strictEqual(statusCode, 404)
+  }
+})
+
+test('error in async rotuerOptions constraints', async (t) => {
+  t.plan(8)
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx, done) => {
+      done(Error('kaboom'))
+    },
+    validate () { return true }
+  }
+
+  const fastify = Fastify({ routerOptions: { constraints: { secret: constraint } } })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'beta' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from beta' })
+    }
+  })
+
+  {
+    const { statusCode, payload } = await fastify.inject({ method: 'GET', path: '/', headers: { 'X-Secret': 'alpha' } })
+    t.assert.deepStrictEqual(JSON.parse(payload), { error: 'Internal Server Error', message: 'Unexpected error from async constraint', statusCode: 500 })
+    t.assert.strictEqual(statusCode, 500)
+  }
+  {
+    const { statusCode, payload } = await fastify.inject({ method: 'GET', path: '/', headers: { 'X-Secret': 'beta' } })
+    t.assert.deepStrictEqual(JSON.parse(payload), { error: 'Internal Server Error', message: 'Unexpected error from async constraint', statusCode: 500 })
+    t.assert.strictEqual(statusCode, 500)
+  }
+  {
+    const { statusCode, payload } = await fastify.inject({ method: 'GET', path: '/', headers: { 'X-Secret': 'gamma' } })
+    t.assert.deepStrictEqual(JSON.parse(payload), { error: 'Internal Server Error', message: 'Unexpected error from async constraint', statusCode: 500 })
+    t.assert.strictEqual(statusCode, 500)
+  }
+  {
+    const { statusCode, payload } = await fastify.inject({ method: 'GET', path: '/' })
+    t.assert.deepStrictEqual(JSON.parse(payload), { error: 'Internal Server Error', message: 'Unexpected error from async constraint', statusCode: 500 })
+    t.assert.strictEqual(statusCode, 500)
+  }
+})

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

@@ -3,7 +3,6 @@
 const { test } = require('node:test')
 const http = require('node:http')
 const dns = require('node:dns').promises
-const sget = require('simple-get').concat
 const Fastify = require('..')
 const { FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE } = require('../lib/errors')
 
@@ -11,7 +10,7 @@ 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(4)
+    t.plan(5)
 
     const fastify = Fastify({
       serverFactory: (handler, opts) => {
@@ -34,20 +33,13 @@ async function setup () {
 
     await fastify.listen({ port: 0 })
 
-    await new Promise((resolve, reject) => {
-      sget({
-        method: 'GET',
-        url: 'http://localhost:' + fastify.server.address().port,
-        rejectUnauthorized: false
-      }, (err, response, body) => {
-        if (err) {
-          return reject(err)
-        }
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        resolve()
-      })
+    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 => {