fastify 5.3.1 → 5.3.3

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')
@@ -1342,8 +1343,6 @@ test('Schema validation when no content type is provided', async t => {
 })
 
 test('Schema validation will not be bypass by different content type', async t => {
-  t.plan(8)
-
   const fastify = Fastify()
 
   fastify.post('/', {
@@ -1365,58 +1364,117 @@ test('Schema validation will not be bypass by different content type', async t =
     }
   }, async () => 'ok')
 
-  await fastify.ready()
+  await fastify.listen({ port: 0 })
+  t.teardown(() => fastify.close())
+  const address = fastify.listeningOrigin
 
-  const correct1 = await fastify.inject({
+  const correct1 = await request(address, {
     method: 'POST',
     url: '/',
     headers: {
       'content-type': 'application/json'
     },
-    body: { foo: 'string' }
+    body: JSON.stringify({ foo: 'string' })
   })
   t.equal(correct1.statusCode, 200)
+  await correct1.body.dump()
 
-  const correct2 = await fastify.inject({
+  const correct2 = await request(address, {
     method: 'POST',
     url: '/',
     headers: {
       'content-type': 'application/json; charset=utf-8'
     },
-    body: { foo: 'string' }
+    body: JSON.stringify({ foo: 'string' })
   })
   t.equal(correct2.statusCode, 200)
+  await correct2.body.dump()
 
-  const invalid1 = await fastify.inject({
+  const invalid1 = await request(address, {
     method: 'POST',
     url: '/',
     headers: {
       'content-type': 'application/json ;'
     },
-    body: { invalid: 'string' }
+    body: JSON.stringify({ invalid: 'string' })
   })
   t.equal(invalid1.statusCode, 400)
-  t.equal(invalid1.json().code, 'FST_ERR_VALIDATION')
+  t.equal((await invalid1.body.json()).code, 'FST_ERR_VALIDATION')
 
-  const invalid2 = await fastify.inject({
+  const invalid2 = await request(address, {
     method: 'POST',
     url: '/',
     headers: {
       'content-type': 'ApPlIcAtIoN/JsOn;'
     },
-    body: { invalid: 'string' }
+    body: JSON.stringify({ invalid: 'string' })
   })
   t.equal(invalid2.statusCode, 400)
-  t.equal(invalid2.json().code, 'FST_ERR_VALIDATION')
+  t.equal((await invalid2.body.json()).code, 'FST_ERR_VALIDATION')
 
-  const invalid3 = await fastify.inject({
+  const invalid3 = await request(address, {
     method: 'POST',
     url: '/',
     headers: {
       'content-type': 'ApPlIcAtIoN/JsOn ;'
     },
-    body: { invalid: 'string' }
+    body: JSON.stringify({ invalid: 'string' })
   })
   t.equal(invalid3.statusCode, 400)
-  t.equal(invalid3.json().code, 'FST_ERR_VALIDATION')
+  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')
+
+  const invalid5 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn \tfoo;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid5.statusCode, 400)
+  t.equal((await invalid5.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid6 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn\t foo;'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid6.statusCode, 415)
+  t.equal((await invalid6.body.json()).code, 'FST_ERR_CTP_INVALID_MEDIA_TYPE')
+
+  const invalid7 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn \t'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid7.statusCode, 400)
+  t.equal((await invalid7.body.json()).code, 'FST_ERR_VALIDATION')
+
+  const invalid8 = await request(address, {
+    method: 'POST',
+    url: '/',
+    headers: {
+      'content-type': 'ApPlIcAtIoN/JsOn\t'
+    },
+    body: JSON.stringify({ invalid: 'string' })
+  })
+  t.equal(invalid8.statusCode, 400)
+  t.equal((await invalid8.body.json()).code, 'FST_ERR_VALIDATION')
 })

package/test/stream.1.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fs = require('node:fs')
 const Fastify = require('../fastify')
 
-test('should respond with a stream', t => {
+test('should respond with a stream', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
 
@@ -16,23 +15,24 @@ test('should respond with a stream', 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, data) {
-      t.error(err)
-      t.equal(response.headers['content-type'], undefined)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.headers['content-type'], undefined)
+      t.assert.strictEqual(response.statusCode, 200)
 
       fs.readFile(__filename, (err, expected) => {
-        t.error(err)
-        t.equal(expected.toString(), data.toString())
+        t.assert.ifError(err)
+        t.assert.strictEqual(expected.toString(), data.toString())
+        testDone()
       })
     })
   })
 })
 
-test('should respond with a stream (error)', t => {
+test('should respond with a stream (error)', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
 
@@ -42,17 +42,18 @@ test('should respond with a stream (error)', 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}/error`, function (err, response) {
-      t.error(err)
-      t.equal(response.statusCode, 500)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 500)
+      testDone()
     })
   })
 })
 
-test('should trigger the onSend hook', t => {
+test('should trigger the onSend hook', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
 
@@ -61,7 +62,7 @@ test('should trigger the onSend hook', t => {
   })
 
   fastify.addHook('onSend', (req, reply, payload, done) => {
-    t.ok(payload._readableState)
+    t.assert.ok(payload._readableState)
     reply.header('Content-Type', 'application/javascript')
     done()
   })
@@ -69,14 +70,15 @@ test('should trigger the onSend hook', t => {
   fastify.inject({
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-type'], 'application/javascript')
-    t.equal(res.payload, fs.readFileSync(__filename, 'utf8'))
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-type'], 'application/javascript')
+    t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
     fastify.close()
+    testDone()
   })
 })
 
-test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', t => {
+test('should trigger the onSend hook only twice if pumping the stream fails, first with the stream, second with the serialized error', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
 
@@ -87,22 +89,23 @@ test('should trigger the onSend hook only twice if pumping the stream fails, fir
   let counter = 0
   fastify.addHook('onSend', (req, reply, payload, done) => {
     if (counter === 0) {
-      t.ok(payload._readableState)
+      t.assert.ok(payload._readableState)
     } else if (counter === 1) {
       const error = JSON.parse(payload)
-      t.equal(error.statusCode, 500)
+      t.assert.strictEqual(error.statusCode, 500)
     }
     counter++
     done()
   })
 
   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) {
-      t.error(err)
-      t.equal(response.statusCode, 500)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 500)
+      testDone()
     })
   })
 })

package/test/stream.2.test.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const proxyquire = require('proxyquire')
 const fs = require('node:fs')
 const resolve = require('node:path').resolve
 const zlib = require('node:zlib')
 const pipeline = require('node:stream').pipeline
 const Fastify = require('..')
+const { waitForCb } = require('./toolkit')
 
 test('onSend hook stream', t => {
   t.plan(4)
@@ -17,6 +17,8 @@ test('onSend hook stream', t => {
     reply.send({ hello: 'world' })
   })
 
+  const { stepIn, patience } = waitForCb({ steps: 2 })
+
   fastify.addHook('onSend', (req, reply, payload, done) => {
     const gzStream = zlib.createGzip()
 
@@ -24,7 +26,10 @@ test('onSend hook stream', t => {
     pipeline(
       fs.createReadStream(resolve(__filename), 'utf8'),
       gzStream,
-      t.error
+      (err) => {
+        t.assert.ifError(err)
+        stepIn()
+      }
     )
     done(null, gzStream)
   })
@@ -33,16 +38,19 @@ test('onSend hook stream', t => {
     url: '/',
     method: 'GET'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.headers['content-encoding'], 'gzip')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.headers['content-encoding'], 'gzip')
     const file = fs.readFileSync(resolve(__filename), 'utf8')
     const payload = zlib.gunzipSync(res.rawPayload)
-    t.equal(payload.toString('utf-8'), file)
+    t.assert.strictEqual(payload.toString('utf-8'), file)
     fastify.close()
+    stepIn()
   })
+
+  return patience
 })
 
-test('onSend hook stream should work even if payload is not a proper stream', t => {
+test('onSend hook stream should work even if payload is not a proper stream', (t, testDone) => {
   t.plan(1)
 
   const reply = proxyquire('../lib/reply', {
@@ -59,8 +67,9 @@ test('onSend hook stream should work even if payload is not a proper stream', t
     fatal: () => { },
     error: () => { },
     warn: (message) => {
-      t.equal(message, 'stream payload does not end properly')
+      t.assert.strictEqual(message, 'stream payload does not end properly')
       fastify.close()
+      testDone()
     },
     info: () => { },
     debug: () => { },
@@ -83,7 +92,7 @@ test('onSend hook stream should work even if payload is not a proper stream', t
   })
 })
 
-test('onSend hook stream should work on payload with "close" ending function', t => {
+test('onSend hook stream should work on payload with "close" ending function', (t, testDone) => {
   t.plan(1)
 
   const reply = proxyquire('../lib/reply', {
@@ -106,7 +115,8 @@ test('onSend hook stream should work on payload with "close" ending function', t
       pipe: () => { },
       close: (cb) => {
         cb()
-        t.pass()
+        t.assert.ok('close callback called')
+        testDone()
       }
     }
     done(null, fakeStream)

package/test/stream.3.test.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const split = require('split2')
 const Fastify = require('..')
 
-test('Destroying streams prematurely', t => {
+test('Destroying streams prematurely', (t, testDone) => {
   t.plan(6)
 
   let fastify = null
@@ -18,7 +17,7 @@ test('Destroying streams prematurely', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -26,13 +25,14 @@ test('Destroying streams prematurely', 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({
@@ -48,26 +48,26 @@ test('Destroying streams prematurely', 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
 
     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 should call close method', t => {
+test('Destroying streams prematurely should call close method', (t, testDone) => {
   t.plan(7)
 
   let fastify = null
@@ -80,7 +80,7 @@ test('Destroying streams prematurely should call close method', t => {
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -88,13 +88,13 @@ test('Destroying streams prematurely should call close 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)
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -106,30 +106,33 @@ test('Destroying streams prematurely should call close method', t => {
       }
     })
     reallyLongStream.destroy = undefined
-    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('Destroying streams prematurely should call close method when destroy is not a function', t => {
+test('Destroying streams prematurely should call close method when destroy is not a function', (t, testDone) => {
   t.plan(7)
 
   let fastify = null
@@ -142,7 +145,7 @@ test('Destroying streams prematurely should call close method when destroy is no
       }
     })
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
   const stream = require('node:stream')
   const http = require('node:http')
@@ -150,13 +153,13 @@ test('Destroying streams prematurely should call close method when destroy is no
   // 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)
     }
   })
 
   fastify.get('/', function (request, reply) {
-    t.pass('Received request')
+    t.assert.ok('Received request')
 
     let sent = false
     const reallyLongStream = new stream.Readable({
@@ -168,24 +171,27 @@ test('Destroying streams prematurely should call close method when destroy is no
       }
     })
     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')
       })
     })
   })

package/test/types/errors.test-d.ts

@@ -52,7 +52,6 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_DUPLICATE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_VALIDATION_BUILD)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_SERIALIZATION_BUILD)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_HTTP2_INVALID_VERSION)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INIT_OPTS_INVALID)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DUPLICATED_ROUTE)

package/test/types/plugin.test-d.ts

@@ -12,7 +12,7 @@ interface TestOptions extends FastifyPluginOptions {
 }
 const testOptions: TestOptions = {
   option1: 'a',
-  option2: false,
+  option2: false
 }
 const testPluginOpts: FastifyPluginCallback<TestOptions> = function (instance, opts, done) {
   expectType<TestOptions>(opts)

package/test/types/register.test-d.ts

@@ -50,7 +50,7 @@ const testPluginWithHttp2WithType = (instance: ServerWithHttp2, opts: FastifyPlu
 const testPluginWithHttp2WithTypeAsync = async (instance: ServerWithHttp2, opts: FastifyPluginOptions) => { }
 const testOptions: TestOptions = {
   option1: 'a',
-  option2: false,
+  option2: false
 }
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginCallback))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginAsync))

package/test/use-semicolon-delimiter.test.js

@@ -13,7 +13,7 @@ test('use semicolon delimiter default false', (t, done) => {
     reply.send(req.query)
   })
 
-  fastify.listen({ port: 0, }, err => {
+  fastify.listen({ port: 0 }, err => {
     t.assert.ifError(err)
     sget({
       method: 'GET',

package/types/errors.d.ts

@@ -51,7 +51,6 @@ export type FastifyErrorCodes = Record<
   'FST_ERR_SCH_VALIDATION_BUILD' |
   'FST_ERR_SCH_SERIALIZATION_BUILD' |
   'FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX' |
-  'FST_ERR_HTTP2_INVALID_VERSION' |
   'FST_ERR_INIT_OPTS_INVALID' |
   'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE' |
   'FST_ERR_DUPLICATED_ROUTE' |

package/test/http2/missing-http2-module.test.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { test } = require('node:test')
-const proxyquire = require('proxyquire')
-const server = proxyquire('../../lib/server', { 'node:http2': null })
-const Fastify = proxyquire('../..', { './lib/server.js': server })
-
-test('should throw when http2 module cannot be found', t => {
-  t.plan(2)
-  try {
-    Fastify({ http2: true })
-    t.assert.fail('fastify did not throw expected error')
-  } catch (err) {
-    t.assert.strictEqual(err.code, 'FST_ERR_HTTP2_INVALID_VERSION')
-    t.assert.strictEqual(err.message, 'HTTP2 is available only from node >= 8.8.1')
-  }
-})