fastify 5.3.2 → 5.3.3

package/test/input-validation.js

@@ -4,6 +4,7 @@ const sget = require('simple-get').concat
 const Ajv = require('ajv')
 const Joi = require('joi')
 const yup = require('yup')
+const assert = require('node:assert')
 
 module.exports.payloadMethod = function (method, t) {
   const test = t.test
@@ -127,28 +128,27 @@ module.exports.payloadMethod = function (method, t) {
 
         done()
       })
-      t.pass()
+      t.assert.ok(true)
     } catch (e) {
-      t.fail()
+      t.assert.fail()
     }
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    if (err) {
-      t.error(err)
-    }
+    assert.ifError(err)
 
-    t.teardown(() => { fastify.close() })
+    t.after(() => { fastify.close() })
 
-    test(`${upMethod} - correctly replies`, t => {
+    test(`${upMethod} - correctly replies`, (t, testDone) => {
       if (upMethod === 'HEAD') {
         t.plan(2)
         sget({
           method: upMethod,
           url: 'http://localhost:' + fastify.server.address().port
         }, (err, response) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
+          t.assert.ifError(err)
+          t.assert.strictEqual(response.statusCode, 200)
+          testDone()
         })
       } else {
         t.plan(3)
@@ -160,14 +160,15 @@ module.exports.payloadMethod = function (method, t) {
           },
           json: true
         }, (err, response, body) => {
-          t.error(err)
-          t.equal(response.statusCode, 200)
-          t.same(body, { hello: 42 })
+          t.assert.ifError(err)
+          t.assert.strictEqual(response.statusCode, 200)
+          t.assert.deepStrictEqual(body, { hello: 42 })
+          testDone()
         })
       }
     })
 
-    test(`${upMethod} - 400 on bad parameters`, t => {
+    test(`${upMethod} - 400 on bad parameters`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -177,18 +178,19 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: 'body/hello must be integer',
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation coerce`, t => {
+    test(`${upMethod} - input-validation coerce`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -198,13 +200,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: 42 })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation custom schema compiler`, t => {
+    test(`${upMethod} - input-validation custom schema compiler`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -215,13 +218,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: 42 })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation joi schema compiler ok`, t => {
+    test(`${upMethod} - input-validation joi schema compiler ok`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -231,13 +235,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: '42' })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation joi schema compiler ko`, t => {
+    test(`${upMethod} - input-validation joi schema compiler ko`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -247,18 +252,19 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: '"hello" must be a string',
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation yup schema compiler ok`, t => {
+    test(`${upMethod} - input-validation yup schema compiler ok`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -268,13 +274,14 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { hello: 42 })
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { hello: '42' })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation yup schema compiler ko`, t => {
+    test(`${upMethod} - input-validation yup schema compiler ko`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
@@ -284,52 +291,55 @@ module.exports.payloadMethod = function (method, t) {
         },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.match(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
-          message: /body hello must be a `string` type, but the final value was: `44`./,
+          message: 'body hello must be a `string` type, but the final value was: `44`.',
           statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, t => {
+    test(`${upMethod} - input-validation instance custom schema compiler encapsulated`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
         url: 'http://localhost:' + fastify.server.address().port + '/plugin',
-        body: { },
+        body: {},
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: 'From custom schema compiler!',
-          statusCode: '400',
+          statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
 
-    test(`${upMethod} - input-validation custom schema compiler encapsulated`, t => {
+    test(`${upMethod} - input-validation custom schema compiler encapsulated`, (t, testDone) => {
       t.plan(3)
       sget({
         method: upMethod,
         url: 'http://localhost:' + fastify.server.address().port + '/plugin/custom',
-        body: { },
+        body: {},
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 400)
-        t.same(body, {
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 400)
+        t.assert.deepStrictEqual(body, {
           error: 'Bad Request',
           message: 'Always fail!',
-          statusCode: '400',
+          statusCode: 400,
           code: 'FST_ERR_VALIDATION'
         })
+        testDone()
       })
     })
   })

package/test/internals/errors.test.js

@@ -5,7 +5,7 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-const expectedErrors = 85
+const expectedErrors = 84
 
 test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
@@ -580,16 +580,6 @@ test('FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX', t => {
   t.assert.ok(error instanceof Error)
 })
 
-test('FST_ERR_HTTP2_INVALID_VERSION', t => {
-  t.plan(5)
-  const error = new errors.FST_ERR_HTTP2_INVALID_VERSION()
-  t.assert.strictEqual(error.name, 'FastifyError')
-  t.assert.strictEqual(error.code, 'FST_ERR_HTTP2_INVALID_VERSION')
-  t.assert.strictEqual(error.message, 'HTTP2 is available only from node >= 8.8.1')
-  t.assert.strictEqual(error.statusCode, 500)
-  t.assert.ok(error instanceof Error)
-})
-
 test('FST_ERR_INIT_OPTS_INVALID', t => {
   t.plan(5)
   const error = new errors.FST_ERR_INIT_OPTS_INVALID()

package/test/internals/hooks.test.js

@@ -2,6 +2,7 @@
 
 const { test } = require('node:test')
 const { Hooks } = require('../../lib/hooks')
+const { default: fastify } = require('../../fastify')
 const noop = () => {}
 
 test('hooks should have 4 array with the registered hooks', t => {
@@ -77,3 +78,19 @@ test('should throw on wrong parameters', t => {
     t.assert.strictEqual(e.message, 'onSend hook should be a function, instead got [object Null]')
   }
 })
+
+test('Integration test: internal function _addHook should be turned into app.ready() rejection', async (t) => {
+  const app = fastify()
+
+  app.register(async function () {
+    app.addHook('notRealHook', async () => {})
+  })
+
+  try {
+    await app.ready()
+    t.assert.fail('Expected ready() to throw')
+  } catch (err) {
+    t.assert.strictEqual(err.code, 'FST_ERR_HOOK_NOT_SUPPORTED')
+    t.assert.match(err.message, /hook not supported/i)
+  }
+})

package/test/issue-4959.test.js

@@ -17,7 +17,7 @@ function runBadClientCall (reqOptions, payload) {
     ...reqOptions,
     headers: {
       'Content-Type': 'application/json',
-      'Content-Length': Buffer.byteLength(postData),
+      'Content-Length': Buffer.byteLength(postData)
     }
   }, () => {
     innerReject(new Error('Request should have failed'))
@@ -78,7 +78,7 @@ test('should handle a soket error', async (t) => {
     hostname: 'localhost',
     port: fastify.server.address().port,
     path: '/',
-    method: 'PUT',
+    method: 'PUT'
   }, { test: 'me' })
   t.assert.equal(err.code, 'ECONNRESET')
 })

package/test/logger/response.test.js

@@ -2,19 +2,18 @@
 
 const stream = require('node:stream')
 
-const t = require('tap')
+const t = require('node:test')
 const split = require('split2')
 const pino = require('pino')
 
 const Fastify = require('../../fastify')
+const { partialDeepStrictEqual } = require('../toolkit')
 const { on } = stream
 
-t.test('response serialization', (t) => {
-  t.setTimeout(60000)
-
+t.test('response serialization', { timeout: 60000 }, async (t) => {
   t.plan(4)
 
-  t.test('Should use serializers from plugin and route', async (t) => {
+  await t.test('Should use serializers from plugin and route', async (t) => {
     const lines = [
       { msg: 'incoming request' },
       { test: 'XHello', test2: 'ZHello' },
@@ -28,7 +27,7 @@ t.test('response serialization', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(context1, {
       logSerializers: { test: value => 'X' + value }
@@ -51,16 +50,16 @@ t.test('response serialization', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepStrictEqual(body, { 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 use serializers from instance fastify and route', async (t) => {
+  await t.test('Should use serializers from instance fastify and route', async (t) => {
     const lines = [
       { msg: 'incoming request' },
       { test: 'XHello', test2: 'ZHello' },
@@ -80,7 +79,7 @@ t.test('response serialization', (t) => {
     const fastify = Fastify({
       loggerInstance
     })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/', {
       logSerializers: {
@@ -96,16 +95,16 @@ t.test('response serialization', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepStrictEqual(body, { 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 use serializers inherit from contexts', async (t) => {
+  await t.test('Should use serializers inherit from contexts', async (t) => {
     const lines = [
       { msg: 'incoming request' },
       { test: 'XHello', test2: 'YHello', test3: 'ZHello' },
@@ -123,7 +122,7 @@ t.test('response serialization', (t) => {
     }, stream)
 
     const fastify = Fastify({ loggerInstance })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.register(context1, { logSerializers: { test2: value => 'Y' + value } })
 
@@ -144,16 +143,16 @@ t.test('response serialization', (t) => {
     {
       const response = await fastify.inject({ method: 'GET', url: '/' })
       const body = await response.json()
-      t.same(body, { hello: 'world' })
+      t.assert.deepStrictEqual(body, { 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 serialize request and response', async (t) => {
+  await t.test('should serialize request and response', async (t) => {
     const lines = [
       { req: { method: 'GET', url: '/500' }, msg: 'incoming request' },
       { req: { method: 'GET', url: '/500' }, msg: '500 error' },
@@ -163,7 +162,7 @@ t.test('response serialization', (t) => {
 
     const stream = split(JSON.parse)
     const fastify = Fastify({ logger: { level: 'info', stream } })
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     fastify.get('/500', (req, reply) => {
       reply.code(500).send(Error('500 error'))
@@ -173,11 +172,11 @@ t.test('response serialization', (t) => {
 
     {
       const response = await fastify.inject({ method: 'GET', url: '/500' })
-      t.equal(response.statusCode, 500)
+      t.assert.strictEqual(response.statusCode, 500)
     }
 
     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
     }
   })

package/test/options.error-handler.test.js

@@ -1,5 +1,5 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 require('./helper').payloadMethod('options', t, true)
 require('./input-validation').payloadMethod('options', t)

package/test/options.test.js

@@ -1,5 +1,5 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 require('./helper').payloadMethod('options', t)
 require('./input-validation').payloadMethod('options', t)

package/test/output-validation.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 fastify = require('..')()
 
@@ -34,9 +33,9 @@ test('shorthand - output string', t => {
     fastify.get('/string', opts, function (req, reply) {
       reply.code(200).send({ hello: 'world' })
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -46,9 +45,9 @@ test('shorthand - output number', t => {
     fastify.get('/number', opts, function (req, reply) {
       reply.code(201).send({ hello: 55 })
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -59,9 +58,9 @@ test('wrong object for schema - output', t => {
       // will send { }
       reply.code(201).send({ hello: 'world' })
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -72,9 +71,9 @@ test('empty response', t => {
     fastify.get('/empty', opts, function (req, reply) {
       reply.code(204).send()
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -84,80 +83,60 @@ test('unlisted response code', t => {
     fastify.get('/400', opts, function (req, reply) {
       reply.code(400).send({ hello: 'DOOM' })
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
-fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => { fastify.close() })
+test('start server and run tests', async (t) => {
+  await fastify.listen({ port: 0 })
+  const baseUrl = 'http://localhost:' + fastify.server.address().port
+  t.after(() => fastify.close())
 
-  test('shorthand - string get ok', t => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/string'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
+  function sgetAsync (opts) {
+    return new Promise((resolve, reject) => {
+      sget(opts, (err, res, body) => {
+        if (err) return reject(err)
+        resolve({ res, body })
+      })
     })
+  }
+
+  await test('shorthand - string get ok', async (t) => {
+    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/string` })
+    t.assert.strictEqual(res.statusCode, 200)
+    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  test('shorthand - number get ok', t => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/number'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 201)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 55 })
-    })
+  await test('shorthand - number get ok', async (t) => {
+    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/number` })
+    t.assert.strictEqual(res.statusCode, 201)
+    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 55 })
   })
 
-  test('shorthand - wrong-object-for-schema', t => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/wrong-object-for-schema'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), {
-        statusCode: 500,
-        error: 'Internal Server Error',
-        message: 'The value "world" cannot be converted to a number.'
-      })
+  await test('shorthand - wrong-object-for-schema', async (t) => {
+    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/wrong-object-for-schema` })
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      statusCode: 500,
+      error: 'Internal Server Error',
+      message: 'The value "world" cannot be converted to a number.'
     })
   })
 
-  test('shorthand - empty', t => {
-    t.plan(2)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/empty'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 204)
-    })
+  await test('shorthand - empty', async (t) => {
+    const { res } = await sgetAsync({ method: 'GET', url: `${baseUrl}/empty` })
+    t.assert.strictEqual(res.statusCode, 204)
   })
 
-  test('shorthand - 400', t => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/400'
-    }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'DOOM' })
-    })
+  await test('shorthand - 400', async (t) => {
+    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/400` })
+    t.assert.strictEqual(res.statusCode, 400)
+    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'DOOM' })
   })
 })

package/test/patch.error-handler.test.js

@@ -1,5 +1,5 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 require('./helper').payloadMethod('patch', t, true)
 require('./input-validation').payloadMethod('patch', t)

package/test/patch.test.js

@@ -1,5 +1,5 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 require('./helper').payloadMethod('patch', t)
 require('./input-validation').payloadMethod('patch', t)