fastify 5.2.2 → 5.3.1

package/test/logger/request.test.js

@@ -2,17 +2,16 @@
 
 const stream = require('node:stream')
 
-const t = require('tap')
+const t = require('node:test')
 const split = require('split2')
 
 const Fastify = require('../../fastify')
 const helper = require('../helper')
 const { on } = stream
 const { request } = require('./logger-test-utils')
+const { partialDeepStrictEqual } = require('../toolkit')
 
-t.test('request', (t) => {
-  t.setTimeout(60000)
-
+t.test('request', { timeout: 60000 }, async (t) => {
   let localhost
 
   t.plan(7)
@@ -20,7 +19,7 @@ t.test('request', (t) => {
     [localhost] = await helper.getLoopbackHost()
   })
 
-  t.test('The request id header key can be customized', async (t) => {
+  await t.test('The request id header key can be customized', async (t) => {
     const lines = ['incoming request', 'some log message', 'request completed']
     t.plan(lines.length * 2 + 2)
     const REQUEST_ID = '42'
@@ -30,26 +29,26 @@ t.test('request', (t) => {
       logger: { stream, level: 'info' },
       requestIdHeader: 'my-custom-request-id'
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', (req, reply) => {
-      t.equal(req.id, REQUEST_ID)
+      t.assert.strictEqual(req.id, REQUEST_ID)
       req.log.info('some log message')
       reply.send({ id: req.id })
     })
 
     const response = await fastify.inject({ method: 'GET', url: '/', headers: { 'my-custom-request-id': REQUEST_ID } })
     const body = await response.json()
-    t.equal(body.id, REQUEST_ID)
+    t.assert.strictEqual(body.id, REQUEST_ID)
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.reqId, REQUEST_ID)
-      t.equal(line.msg, lines.shift(), 'message is set')
+      t.assert.strictEqual(line.reqId, REQUEST_ID)
+      t.assert.strictEqual(line.msg, lines.shift(), 'message is set')
       if (lines.length === 0) break
     }
   })
 
-  t.test('The request id header key can be ignored', async (t) => {
+  await t.test('The request id header key can be ignored', async (t) => {
     const lines = ['incoming request', 'some log message', 'request completed']
     t.plan(lines.length * 2 + 2)
     const REQUEST_ID = 'ignore-me'
@@ -59,33 +58,33 @@ t.test('request', (t) => {
       logger: { stream, level: 'info' },
       requestIdHeader: false
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', (req, reply) => {
-      t.equal(req.id, 'req-1')
+      t.assert.strictEqual(req.id, 'req-1')
       req.log.info('some log message')
       reply.send({ id: req.id })
     })
     const response = await fastify.inject({ method: 'GET', url: '/', headers: { 'request-id': REQUEST_ID } })
     const body = await response.json()
-    t.equal(body.id, 'req-1')
+    t.assert.strictEqual(body.id, 'req-1')
 
     for await (const [line] of on(stream, 'data')) {
-      t.equal(line.reqId, 'req-1')
-      t.equal(line.msg, lines.shift(), 'message is set')
+      t.assert.strictEqual(line.reqId, 'req-1')
+      t.assert.strictEqual(line.msg, lines.shift(), 'message is set')
       if (lines.length === 0) break
     }
   })
 
-  t.test('The request id header key can be customized along with a custom id generator', async (t) => {
+  await t.test('The request id header key can be customized along with a custom id generator', async (t) => {
     const REQUEST_ID = '42'
     const matches = [
-      { reqId: REQUEST_ID, msg: /incoming request/ },
-      { reqId: REQUEST_ID, msg: /some log message/ },
-      { reqId: REQUEST_ID, msg: /request completed/ },
-      { reqId: 'foo', msg: /incoming request/ },
-      { reqId: 'foo', msg: /some log message 2/ },
-      { reqId: 'foo', msg: /request completed/ }
+      { reqId: REQUEST_ID, msg: 'incoming request' },
+      { reqId: REQUEST_ID, msg: 'some log message' },
+      { reqId: REQUEST_ID, msg: 'request completed' },
+      { reqId: 'foo', msg: 'incoming request' },
+      { reqId: 'foo', msg: 'some log message 2' },
+      { reqId: 'foo', msg: 'request completed' }
     ]
     t.plan(matches.length + 4)
 
@@ -97,16 +96,16 @@ t.test('request', (t) => {
         return 'foo'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/one', (req, reply) => {
-      t.equal(req.id, REQUEST_ID)
+      t.assert.strictEqual(req.id, REQUEST_ID)
       req.log.info('some log message')
       reply.send({ id: req.id })
     })
 
     fastify.get('/two', (req, reply) => {
-      t.equal(req.id, 'foo')
+      t.assert.strictEqual(req.id, 'foo')
       req.log.info('some log message 2')
       reply.send({ id: req.id })
     })
@@ -114,30 +113,30 @@ t.test('request', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
       const body = await response.json()
-      t.equal(body.id, REQUEST_ID)
+      t.assert.strictEqual(body.id, REQUEST_ID)
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/two' })
       const body = await response.json()
-      t.equal(body.id, 'foo')
+      t.assert.strictEqual(body.id, 'foo')
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, matches.shift())
+      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
       if (matches.length === 0) break
     }
   })
 
-  t.test('The request id header key can be ignored along with a custom id generator', async (t) => {
+  await t.test('The request id header key can be ignored along with a custom id generator', async (t) => {
     const REQUEST_ID = 'ignore-me'
     const matches = [
-      { reqId: 'foo', msg: /incoming request/ },
-      { reqId: 'foo', msg: /some log message/ },
-      { reqId: 'foo', msg: /request completed/ },
-      { reqId: 'foo', msg: /incoming request/ },
-      { reqId: 'foo', msg: /some log message 2/ },
-      { reqId: 'foo', msg: /request completed/ }
+      { reqId: 'foo', msg: 'incoming request' },
+      { reqId: 'foo', msg: 'some log message' },
+      { reqId: 'foo', msg: 'request completed' },
+      { reqId: 'foo', msg: 'incoming request' },
+      { reqId: 'foo', msg: 'some log message 2' },
+      { reqId: 'foo', msg: 'request completed' }
     ]
     t.plan(matches.length + 4)
 
@@ -149,16 +148,16 @@ t.test('request', (t) => {
         return 'foo'
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/one', (req, reply) => {
-      t.equal(req.id, 'foo')
+      t.assert.strictEqual(req.id, 'foo')
       req.log.info('some log message')
       reply.send({ id: req.id })
     })
 
     fastify.get('/two', (req, reply) => {
-      t.equal(req.id, 'foo')
+      t.assert.strictEqual(req.id, 'foo')
       req.log.info('some log message 2')
       reply.send({ id: req.id })
     })
@@ -166,27 +165,27 @@ t.test('request', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'request-id': REQUEST_ID } })
       const body = await response.json()
-      t.equal(body.id, 'foo')
+      t.assert.strictEqual(body.id, 'foo')
     }
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/two' })
       const body = await response.json()
-      t.equal(body.id, 'foo')
+      t.assert.strictEqual(body.id, 'foo')
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, matches.shift())
+      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
       if (matches.length === 0) break
     }
   })
 
-  t.test('The request id log label can be changed', async (t) => {
+  await t.test('The request id log label can be changed', async (t) => {
     const REQUEST_ID = '42'
     const matches = [
-      { traceId: REQUEST_ID, msg: /incoming request/ },
-      { traceId: REQUEST_ID, msg: /some log message/ },
-      { traceId: REQUEST_ID, msg: /request completed/ }
+      { traceId: REQUEST_ID, msg: 'incoming request' },
+      { traceId: REQUEST_ID, msg: 'some log message' },
+      { traceId: REQUEST_ID, msg: 'request completed' }
     ]
     t.plan(matches.length + 2)
 
@@ -196,10 +195,10 @@ t.test('request', (t) => {
       requestIdHeader: 'my-custom-request-id',
       requestIdLogLabel: 'traceId'
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/one', (req, reply) => {
-      t.equal(req.id, REQUEST_ID)
+      t.assert.strictEqual(req.id, REQUEST_ID)
       req.log.info('some log message')
       reply.send({ id: req.id })
     })
@@ -207,22 +206,16 @@ t.test('request', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/one', headers: { 'my-custom-request-id': REQUEST_ID } })
       const body = await response.json()
-      t.equal(body.id, REQUEST_ID)
+      t.assert.strictEqual(body.id, REQUEST_ID)
     }
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, matches.shift())
+      t.assert.ok(partialDeepStrictEqual(line, matches.shift()))
       if (matches.length === 0) break
     }
   })
 
-  t.test('should redact the authorization header if so specified', async (t) => {
-    const lines = [
-      { msg: /Server listening at/ },
-      { req: { headers: { authorization: '[Redacted]' } }, msg: 'incoming request' },
-      { res: { statusCode: 200 }, msg: 'request completed' }
-    ]
-    t.plan(lines.length + 3)
+  await t.test('should redact the authorization header if so specified', async (t) => {
     const stream = split(JSON.parse)
     const fastify = Fastify({
       logger: {
@@ -243,15 +236,22 @@ t.test('request', (t) => {
         }
       }
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', function (req, reply) {
-      t.same(req.headers.authorization, 'Bearer abcde')
+      t.assert.deepStrictEqual(req.headers.authorization, 'Bearer abcde')
       reply.send({ hello: 'world' })
     })
 
     await fastify.ready()
-    await fastify.listen({ port: 0, host: localhost })
+    const server = await fastify.listen({ port: 0, host: localhost })
+
+    const lines = [
+      { msg: `Server listening at ${server}` },
+      { req: { headers: { authorization: '[Redacted]' } }, msg: 'incoming request' },
+      { res: { statusCode: 200 }, msg: 'request completed' }
+    ]
+    t.plan(lines.length + 3)
 
     await request({
       method: 'GET',
@@ -262,17 +262,17 @@ t.test('request', (t) => {
         authorization: 'Bearer abcde'
       }
     }, function (response, body) {
-      t.equal(response.statusCode, 200)
-      t.same(body, JSON.stringify({ hello: 'world' }))
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body, JSON.stringify({ hello: 'world' }))
     })
 
     for await (const [line] of on(stream, 'data')) {
-      t.match(line, lines.shift())
+      t.assert.ok(partialDeepStrictEqual(line, lines.shift()))
       if (lines.length === 0) break
     }
   })
 
-  t.test('should not throw error when serializing custom req', (t) => {
+  await t.test('should not throw error when serializing custom req', (t) => {
     t.plan(1)
 
     const lines = []
@@ -283,10 +283,10 @@ t.test('request', (t) => {
       }
     })
     const fastify = Fastify({ logger: { level: 'info', stream: dest } })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.log.info({ req: {} })
 
-    t.same(lines[0].req, {})
+    t.assert.deepStrictEqual(lines[0].req, {})
   })
 })

package/test/schema-validation.test.js

@@ -1300,3 +1300,123 @@ test('Custom validator builder override by custom validator compiler in child in
   })
   t.equal(two.statusCode, 200)
 })
+
+test('Schema validation when no content type is provided', async t => {
+  // this case should not be happened in normal use-case,
+  // it is added for the completeness of code branch
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                foo: { type: 'string' }
+              },
+              required: ['foo'],
+              additionalProperties: false
+            }
+          }
+        }
+      }
+    },
+    preValidation: async (request) => {
+      request.headers['content-type'] = undefined
+    }
+  }, async () => 'ok')
+
+  await fastify.ready()
+
+  const invalid = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: { invalid: 'string' }
+  })
+  t.equal(invalid.statusCode, 200)
+})
+
+test('Schema validation will not be bypass by different content type', async t => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                foo: { type: 'string' }
+              },
+              required: ['foo'],
+              additionalProperties: false
+            }
+          }
+        }
+      }
+    }
+  }, async () => 'ok')
+
+  await fastify.ready()
+
+  const correct1 = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: { foo: 'string' }
+  })
+  t.equal(correct1.statusCode, 200)
+
+  const correct2 = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json; charset=utf-8'
+    },
+    body: { foo: 'string' }
+  })
+  t.equal(correct2.statusCode, 200)
+
+  const invalid1 = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json ;'
+    },
+    body: { invalid: 'string' }
+  })
+  t.equal(invalid1.statusCode, 400)
+  t.equal(invalid1.json().code, 'FST_ERR_VALIDATION')
+
+  const invalid2 = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn;'
+    },
+    body: { invalid: 'string' }
+  })
+  t.equal(invalid2.statusCode, 400)
+  t.equal(invalid2.json().code, 'FST_ERR_VALIDATION')
+
+  const invalid3 = await fastify.inject({
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn ;'
+    },
+    body: { invalid: 'string' }
+  })
+  t.equal(invalid3.statusCode, 400)
+  t.equal(invalid3.json().code, 'FST_ERR_VALIDATION')
+})

package/test/server.test.js

@@ -2,6 +2,8 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
+const sget = require('simple-get').concat
+const undici = require('undici')
 
 test('listen should accept null port', async t => {
   const fastify = Fastify()
@@ -11,3 +13,176 @@ test('listen should accept null port', async t => {
     fastify.listen({ port: null })
   )
 })
+
+test('listen should accept undefined port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: undefined })
+  )
+})
+
+test('listen should accept stringified number port', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({ port: '1234' })
+  )
+})
+
+test('listen should accept log text resolution function', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  await t.assert.doesNotReject(
+    fastify.listen({
+      host: '127.0.0.1',
+      port: '1234',
+      listenTextResolver: (address) => {
+        t.assert.strictEqual(address, 'http://127.0.0.1:1234')
+        return 'hardcoded text'
+      }
+    })
+  )
+})
+
+test('listen should reject string port', async (t) => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  try {
+    await fastify.listen({ port: 'hello-world' })
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'ERR_SOCKET_BAD_PORT')
+  }
+
+  try {
+    await fastify.listen({ port: '1234hello' })
+  } catch (error) {
+    t.assert.strictEqual(error.code, 'ERR_SOCKET_BAD_PORT')
+  }
+})
+
+test('Test for hostname and port', (t, end) => {
+  const app = Fastify()
+  t.after(() => app.close())
+  app.get('/host', (req, res) => {
+    const host = 'localhost:8000'
+    t.assert.strictEqual(req.host, host)
+    t.assert.strictEqual(req.hostname, req.host.split(':')[0])
+    t.assert.strictEqual(req.port, Number(req.host.split(':')[1]))
+    res.send('ok')
+  })
+
+  app.listen({ port: 8000 }, () => {
+    sget('http://localhost:8000/host', () => { end() })
+  })
+})
+
+test('abort signal', async t => {
+  await t.test('listen should not start server', (t, end) => {
+    t.plan(2)
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      end()
+    }
+    const controller = new AbortController()
+
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    fastify.listen({ port: 1234, signal: controller.signal }, (err) => {
+      t.assert.ifError(err)
+    })
+    controller.abort()
+    t.assert.strictEqual(fastify.server.listening, false)
+  })
+
+  await t.test('listen should not start server if already aborted', (t, end) => {
+    t.plan(2)
+    function onClose (instance, done) {
+      t.assert.strictEqual(instance, fastify)
+      done()
+      end()
+    }
+
+    const controller = new AbortController()
+    controller.abort()
+    const fastify = Fastify()
+    fastify.addHook('onClose', onClose)
+    fastify.listen({ port: 1234, signal: controller.signal }, (err) => {
+      t.assert.ifError(err)
+    })
+    t.assert.strictEqual(fastify.server.listening, false)
+  })
+
+  await t.test('listen should throw if received invalid signal', t => {
+    t.plan(2)
+    const fastify = Fastify()
+
+    try {
+      fastify.listen({ port: 1234, signal: {} }, (err) => {
+        t.assert.ifError(err)
+      })
+      t.assert.fail('should throw')
+    } catch (e) {
+      t.assert.strictEqual(e.code, 'FST_ERR_LISTEN_OPTIONS_INVALID')
+      t.assert.strictEqual(e.message, 'Invalid listen options: \'Invalid options.signal\'')
+    }
+  })
+})
+
+test('#5180 - preClose should be called before closing secondary server', async (t) => {
+  t.plan(2)
+  const fastify = Fastify({ forceCloseConnections: true })
+  let flag = false
+  t.after(() => fastify.close())
+
+  fastify.addHook('preClose', () => {
+    flag = true
+  })
+
+  fastify.get('/', async (req, reply) => {
+    // request will be pending for 1 second to simulate a slow request
+    await new Promise((resolve) => { setTimeout(resolve, 1000) })
+    return { hello: 'world' }
+  })
+
+  fastify.listen({ port: 0 }, (err) => {
+    t.assert.ifError(err)
+    const addresses = fastify.addresses()
+    const mainServerAddress = fastify.server.address()
+    let secondaryAddress
+    for (const addr of addresses) {
+      if (addr.family !== mainServerAddress.family) {
+        secondaryAddress = addr
+        secondaryAddress.address = secondaryAddress.family === 'IPv6'
+          ? `[${secondaryAddress.address}]`
+          : secondaryAddress.address
+        break
+      }
+    }
+
+    if (!secondaryAddress) {
+      t.assert.ok(true, 'Secondary address not found')
+      return
+    }
+
+    undici.request(`http://${secondaryAddress.address}:${secondaryAddress.port}/`)
+      .then(
+        () => { t.assert.fail('Request should not succeed') },
+        () => {
+          t.assert.ok(flag)
+        }
+      )
+
+    // Close the server while the slow request is pending
+    setTimeout(fastify.close, 250)
+  })
+
+  // Wait 1000ms to ensure that the test is finished and async operations are
+  // completed
+  await new Promise((resolve) => { setTimeout(resolve, 1000) })
+})