fastify 5.3.0 → 5.3.2

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

@@ -2,6 +2,7 @@
 
 const { test } = require('tap')
 const Fastify = require('..')
+const { request } = require('undici')
 
 const AJV = require('ajv')
 const Schema = require('fluent-json-schema')
@@ -1300,3 +1301,138 @@ 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(10)
+
+  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.listen({ port: 0 })
+  t.teardown(() => fastify.close())
+  const address = fastify.listeningOrigin
+
+  const correct1 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({ foo: 'string' })
+  })
+  t.equal(correct1.statusCode, 200)
+  await correct1.body.dump()
+
+  const correct2 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json; charset=utf-8'
+    },
+    body: JSON.stringify({ foo: 'string' })
+  })
+  t.equal(correct2.statusCode, 200)
+  await correct2.body.dump()
+
+  const invalid1 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'application/json ;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid1.statusCode, 400)
+  t.equal((await invalid1.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid2 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid2.statusCode, 400)
+  t.equal((await invalid2.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid3 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn ;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid3.statusCode, 400)
+  t.equal((await invalid3.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid4 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn foo;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid4.statusCode, 400)
+  t.equal((await invalid4.body.json()).code, 'FST_ERR_VALIDATION')
+})

package/test/stream.4.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const errors = require('http-errors')
 const JSONStream = require('JSONStream')
@@ -10,7 +9,7 @@ const split = require('split2')
 const Fastify = require('..')
 const { kDisableRequestLogging } = require('../lib/symbols.js')
 
-test('Destroying streams prematurely should call abort method', t => {
+test('Destroying streams prematurely should call abort method', (t, testDone) => {
   t.plan(7)
 
   let fastify = null
@@ -23,7 +22,7 @@ test('Destroying streams prematurely should call abort method', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -31,13 +30,14 @@ test('Destroying streams prematurely should call abort method', t => {
   // Test that "premature close" errors are logged with level warn
   logStream.on('data', line => {
     if (line.res) {
-      t.equal(line.msg, 'stream closed prematurely')
-      t.equal(line.level, 30)
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
+      testDone()
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -50,30 +50,30 @@ test('Destroying streams prematurely should call abort method', t => {
     })
     reallyLongStream.destroy = undefined
     reallyLongStream.close = undefined
-    reallyLongStream.abort = () => t.ok('called')
+    reallyLongStream.abort = () => t.assert.ok('called')
     reply.send(reallyLongStream)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     const port = fastify.server.address().port
 
     http.get(`http://localhost:${port}`, function (response) {
-      t.equal(response.statusCode, 200)
+      t.assert.strictEqual(response.statusCode, 200)
       response.on('readable', function () {
         response.destroy()
       })
       // Node bug? Node never emits 'close' here.
       response.on('aborted', function () {
-        t.pass('Response closed')
+        t.assert.ok('Response closed')
       })
     })
   })
 })
 
-test('Destroying streams prematurely, log is disabled', t => {
+test('Destroying streams prematurely, log is disabled', (t, testDone) => {
   t.plan(4)
 
   let fastify = null
@@ -82,7 +82,7 @@ test('Destroying streams prematurely, log is disabled', t => {
       logger: false
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -100,30 +100,33 @@ test('Destroying streams prematurely, log is disabled', t => {
       }
     })
     reallyLongStream.destroy = true
-    reallyLongStream.close = () => t.ok('called')
+    reallyLongStream.close = () => {
+      t.assert.ok('called')
+      testDone()
+    }
     reply.send(reallyLongStream)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     const port = fastify.server.address().port
 
     http.get(`http://localhost:${port}`, function (response) {
-      t.equal(response.statusCode, 200)
+      t.assert.strictEqual(response.statusCode, 200)
       response.on('readable', function () {
         response.destroy()
       })
       // Node bug? Node never emits 'close' here.
       response.on('aborted', function () {
-        t.pass('Response closed')
+        t.assert.ok('Response closed')
       })
     })
   })
 })
 
-test('should respond with a stream1', t => {
+test('should respond with a stream1', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -135,25 +138,26 @@ test('should respond with a stream1', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget(`http://localhost:${fastify.server.address().port}`, function (err, response, body) {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/json')
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json')
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
+      testDone()
     })
   })
 })
 
-test('return a 404 if the stream emits a 404 error', t => {
+test('return a 404 if the stream emits a 404 error', (t, testDone) => {
   t.plan(5)
 
   const fastify = Fastify()
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     const reallyLongStream = new Readable({
       read: function () {
@@ -167,15 +171,16 @@ test('return a 404 if the stream emits a 404 error', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     const port = fastify.server.address().port
 
     sget(`http://localhost:${port}`, function (err, response) {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+      t.assert.strictEqual(response.statusCode, 404)
+      testDone()
     })
   })
 })

package/test/toolkit.js

@@ -30,3 +30,34 @@ exports.waitForCb = function (options) {
 
   return { stepIn, patience }
 }
+
+exports.partialDeepStrictEqual = function partialDeepStrictEqual (actual, expected) {
+  if (typeof expected !== 'object' || expected === null) {
+    return actual === expected
+  }
+
+  if (typeof actual !== 'object' || actual === null) {
+    return false
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) return false
+    if (expected.length > actual.length) return false
+
+    for (let i = 0; i < expected.length; i++) {
+      if (!partialDeepStrictEqual(actual[i], expected[i])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  for (const key of Object.keys(expected)) {
+    if (!(key in actual)) return false
+    if (!partialDeepStrictEqual(actual[key], expected[key])) {
+      return false
+    }
+  }
+
+  return true
+}