fastify 5.3.3 → 5.5.0

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 => {

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 
 process.removeAllListeners('warning')
@@ -24,41 +23,37 @@ test('contentTypeParser should add a custom async parser', async t => {
   })
 
   t.after(() => fastify.close())
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-  await t.test('in POST', (t, done) => {
+  await t.test('in POST', async t => {
     t.plan(3)
 
-    sget({
+    const result = await fetch(fastifyServer, {
       method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
       headers: {
         'Content-Type': 'application/jsoff'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-      done()
+      },
+      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', (t, done) => {
+  await t.test('in OPTIONS', async t => {
     t.plan(3)
 
-    sget({
+    const result = await fetch(fastifyServer, {
       method: 'OPTIONS',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
       headers: {
         'Content-Type': 'application/jsoff'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-      done()
+      },
+      body: '{"hello":"world"}'
     })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
   })
 })