fastify 5.2.0 → 5.2.1

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

@@ -1,18 +1,17 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const sget = require('simple-get').concat
-const Fastify = require('../fastify')
+const Fastify = require('..')
 const jsonParser = require('fast-json-body')
 const { getServerUrl } = require('./helper')
 
 process.removeAllListeners('warning')
 
-test('should be able to use default parser for extra content type', t => {
+test('should be able to use default parser for extra content type', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(() => fastify.close())
+  t.after(() => fastify.close())
 
   fastify.post('/', (request, reply) => {
     reply.send(request.body)
@@ -21,7 +20,7 @@ test('should be able to use default parser for extra content type', t => {
   fastify.addContentTypeParser('text/json', { parseAs: 'string' }, fastify.getDefaultJsonParser('ignore', 'ignore'))
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -31,18 +30,17 @@ test('should be able to use default parser for extra content type', t => {
         'Content-Type': 'text/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.strictSame(JSON.parse(body.toString()), { hello: 'world' })
-      fastify.close()
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body.toString()), { hello: 'world' })
+      done()
     })
   })
 })
 
-test('contentTypeParser should add a custom parser with RegExp value', t => {
-  t.plan(3)
-
+test('contentTypeParser should add a custom parser with RegExp value', async (t) => {
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.post('/', (req, reply) => {
     reply.send(req.body)
@@ -58,13 +56,12 @@ test('contentTypeParser should add a custom parser with RegExp value', t => {
     })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-
-    t.teardown(() => fastify.close())
+  fastify.listen({ port: 0 }, async err => {
+    t.assert.ifError(err)
 
-    t.test('in POST', t => {
+    await t.test('in POST', (t, done) => {
       t.plan(3)
+      t.after(() => fastify.close())
 
       sget({
         method: 'POST',
@@ -74,14 +71,16 @@ test('contentTypeParser should add a custom parser with RegExp value', t => {
           'Content-Type': 'application/vnd.test+json'
         }
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
+        done()
       })
     })
 
-    t.test('in OPTIONS', t => {
+    await t.test('in OPTIONS', (t, done) => {
       t.plan(3)
+      t.after(() => fastify.close())
 
       sget({
         method: 'OPTIONS',
@@ -91,9 +90,10 @@ test('contentTypeParser should add a custom parser with RegExp value', t => {
           'Content-Type': 'weird/content-type+json'
         }
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body.toString(), JSON.stringify({ hello: 'world' }))
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
+        done()
       })
     })
   })
@@ -102,7 +102,7 @@ test('contentTypeParser should add a custom parser with RegExp value', t => {
 test('contentTypeParser should add multiple custom parsers with RegExp values', async t => {
   t.plan(6)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.post('/', (req, reply) => {
     reply.send(req.body)
@@ -137,8 +137,8 @@ test('contentTypeParser should add multiple custom parsers with RegExp values',
         'Content-Type': 'application/vnd.hello+json'
       }
     })
-    t.equal(response.statusCode, 200)
-    t.same(response.payload.toString(), '{"hello":"world"}')
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), '{"hello":"world"}')
   }
 
   {
@@ -150,8 +150,8 @@ test('contentTypeParser should add multiple custom parsers with RegExp values',
         'Content-Type': 'application/test+xml'
       }
     })
-    t.equal(response.statusCode, 200)
-    t.same(response.payload.toString(), 'xml')
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), 'xml')
   }
 
   await fastify.inject({
@@ -162,17 +162,17 @@ test('contentTypeParser should add multiple custom parsers with RegExp values',
       'Content-Type': 'application/+myExtension'
     }
   }).then((response) => {
-    t.equal(response.statusCode, 200)
-    t.same(response.payload.toString(), 'abcdefgmyExtension')
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.deepStrictEqual(response.payload.toString(), 'abcdefgmyExtension')
   }).catch((err) => {
-    t.error(err)
+    t.assert.ifError(err)
   })
 })
 
-test('catch all content type parser should not interfere with content type parser', t => {
+test('catch all content type parser should not interfere with content type parser', (t, done) => {
   t.plan(10)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.post('/', (req, reply) => {
     reply.send(req.body)
@@ -201,7 +201,15 @@ test('catch all content type parser should not interfere with content type parse
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+
+    let pending = 3
+
+    function completed () {
+      if (--pending === 0) {
+        done()
+      }
+    }
 
     sget({
       method: 'POST',
@@ -211,9 +219,10 @@ test('catch all content type parser should not interfere with content type parse
         'Content-Type': 'application/json'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), JSON.stringify({ myKey: 'myValue' }))
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ myKey: 'myValue' }))
+      completed()
     })
 
     sget({
@@ -224,9 +233,10 @@ test('catch all content type parser should not interfere with content type parse
         'Content-Type': 'very-weird-content-type'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'body')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), 'body')
+      completed()
     })
 
     sget({
@@ -237,9 +247,10 @@ test('catch all content type parser should not interfere with content type parse
         'Content-Type': 'text/html'
       }
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body.toString(), 'my texthtml')
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body.toString(), 'my texthtml')
+      completed()
     })
   })
 })

package/test/delete.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const assert = require('node:assert')
+const { test } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('..')()
 
@@ -85,15 +85,17 @@ const bodySchema = {
   }
 }
 
-test('shorthand - delete', t => {
+test('shorthand - delete', (t, done) => {
   t.plan(1)
   try {
     fastify.delete('/', schema, function (req, reply) {
       reply.code(200).send({ hello: 'world' })
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
+  } finally {
+    done()
   }
 })
 
@@ -103,9 +105,9 @@ test('shorthand - delete params', t => {
     fastify.delete('/params/:foo/:test', paramsSchema, function (req, reply) {
       reply.code(200).send(req.params)
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -115,9 +117,9 @@ test('shorthand - delete, querystring schema', t => {
     fastify.delete('/query', querySchema, function (req, reply) {
       reply.send(req.query)
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -127,9 +129,9 @@ test('shorthand - get, headers schema', t => {
     fastify.delete('/headers', headersSchema, function (req, reply) {
       reply.code(200).send(req.headers)
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -139,9 +141,9 @@ test('missing schema - delete', t => {
     fastify.delete('/missing', function (req, reply) {
       reply.code(200).send({ hello: 'world' })
     })
-    t.pass()
+    t.assert.ok(true)
   } catch (e) {
-    t.fail()
+    t.assert.fail()
   }
 })
 
@@ -151,60 +153,63 @@ test('body - delete', t => {
     fastify.delete('/body', bodySchema, function (req, reply) {
       reply.send(req.body)
     })
-    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() })
+  assert.ifError(err)
+  test.after(() => { fastify.close() })
 
-  test('shorthand - request delete', t => {
+  test('shorthand - request delete', (t, done) => {
     t.plan(4)
     sget({
       method: 'DELETE',
       url: 'http://localhost:' + fastify.server.address().port
     }, (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' })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      done()
     })
   })
 
-  test('shorthand - request delete params schema', t => {
+  test('shorthand - request delete params schema', (t, done) => {
     t.plan(4)
     sget({
       method: 'DELETE',
       url: 'http://localhost:' + fastify.server.address().port + '/params/world/123'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { foo: 'world', test: 123 })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { foo: 'world', test: 123 })
+      done()
     })
   })
 
-  test('shorthand - request delete params schema error', t => {
+  test('shorthand - request delete params schema error', (t, done) => {
     t.plan(3)
     sget({
       method: 'DELETE',
       url: 'http://localhost:' + fastify.server.address().port + '/params/world/string'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         error: 'Bad Request',
         code: 'FST_ERR_VALIDATION',
         message: 'params/test must be integer',
         statusCode: 400
       })
+      done()
     })
   })
 
-  test('shorthand - request delete headers schema', t => {
+  test('shorthand - request delete headers schema', (t, done) => {
     t.plan(4)
     sget({
       method: 'DELETE',
@@ -213,14 +218,15 @@ fastify.listen({ port: 0 }, err => {
       },
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.equal(JSON.parse(body)['x-test'], 1)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.strictEqual(JSON.parse(body)['x-test'], 1)
+      done()
     })
   })
 
-  test('shorthand - request delete headers schema error', t => {
+  test('shorthand - request delete headers schema error', (t, done) => {
     t.plan(3)
     sget({
       method: 'DELETE',
@@ -229,61 +235,65 @@ fastify.listen({ port: 0 }, err => {
       },
       url: 'http://localhost:' + fastify.server.address().port + '/headers'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         error: 'Bad Request',
         code: 'FST_ERR_VALIDATION',
         message: 'headers/x-test must be number',
         statusCode: 400
       })
+      done()
     })
   })
 
-  test('shorthand - request delete querystring schema', t => {
+  test('shorthand - request delete querystring schema', (t, done) => {
     t.plan(4)
     sget({
       method: 'DELETE',
       url: 'http://localhost:' + fastify.server.address().port + '/query?hello=123'
     }, (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: 123 })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 123 })
+      done()
     })
   })
 
-  test('shorthand - request delete querystring schema error', t => {
+  test('shorthand - request delete querystring schema error', (t, done) => {
     t.plan(3)
     sget({
       method: 'DELETE',
       url: 'http://localhost:' + fastify.server.address().port + '/query?hello=world'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         error: 'Bad Request',
         code: 'FST_ERR_VALIDATION',
         message: 'querystring/hello must be integer',
         statusCode: 400
       })
+      done()
     })
   })
 
-  test('shorthand - request delete missing schema', t => {
+  test('shorthand - request delete missing schema', (t, done) => {
     t.plan(4)
     sget({
       method: 'DELETE',
       url: 'http://localhost:' + fastify.server.address().port + '/missing'
     }, (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' })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      done()
     })
   })
 
-  test('shorthand - delete with body', t => {
+  test('shorthand - delete with body', (t, done) => {
     t.plan(3)
     sget({
       method: 'DELETE',
@@ -293,18 +303,19 @@ fastify.listen({ port: 0 }, err => {
       },
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body, { hello: 'world' })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body, { hello: 'world' })
+      done()
     })
   })
 })
 
-test('shorthand - delete with application/json Content-Type header and null body', t => {
+test('shorthand - delete with application/json Content-Type header and null body', (t, done) => {
   t.plan(4)
   const fastify = require('..')()
   fastify.delete('/', {}, (req, reply) => {
-    t.equal(req.body, null)
+    t.assert.strictEqual(req.body, null)
     reply.send(req.body)
   })
   fastify.inject({
@@ -313,9 +324,10 @@ test('shorthand - delete with application/json Content-Type header and null body
     headers: { 'Content-Type': 'application/json' },
     body: 'null'
   }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(response.payload.toString(), 'null')
+    t.assert.ifError(err)
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.strictEqual(response.payload.toString(), 'null')
+    done()
   })
 })
 
@@ -325,7 +337,7 @@ test('shorthand - delete with application/json Content-Type header and without b
   t.plan(4)
   const fastify = require('..')()
   fastify.delete('/', {}, (req, reply) => {
-    t.equal(req.body, undefined)
+    t.assert.strictEqual(req.body, undefined)
     reply.send(req.body)
   })
   fastify.inject({
@@ -334,8 +346,8 @@ test('shorthand - delete with application/json Content-Type header and without b
     headers: { 'Content-Type': 'application/json' },
     body: null
   }, (err, response) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(response.payload.toString(), '')
+    t.assert.ifError(err)
+    t.assert.strictEqual(response.statusCode, 200)
+    t.assert.strictEqual(response.payload.toString(), '')
   })
 })

package/test/internals/errors.test.js

@@ -5,7 +5,9 @@ const errors = require('../../lib/errors')
 const { readFileSync } = require('node:fs')
 const { resolve } = require('node:path')
 
-test('should expose 83 errors', t => {
+const expectedErrors = 84
+
+test(`should expose ${expectedErrors} errors`, t => {
   t.plan(1)
   const exportedKeys = Object.keys(errors)
   let counter = 0
@@ -14,11 +16,11 @@ test('should expose 83 errors', t => {
       counter++
     }
   }
-  t.assert.strictEqual(counter, 83)
+  t.assert.strictEqual(counter, expectedErrors)
 })
 
 test('ensure name and codes of Errors are identical', t => {
-  t.plan(83)
+  t.plan(expectedErrors)
   const exportedKeys = Object.keys(errors)
   for (const key of exportedKeys) {
     if (errors[key].name === 'FastifyError') {
@@ -377,6 +379,16 @@ test('FST_ERR_REP_RESPONSE_BODY_CONSUMED', t => {
   t.assert.ok(error instanceof Error)
 })
 
+test('FST_ERR_REP_READABLE_STREAM_LOCKED', t => {
+  t.plan(5)
+  const error = new errors.FST_ERR_REP_READABLE_STREAM_LOCKED()
+  t.assert.strictEqual(error.name, 'FastifyError')
+  t.assert.strictEqual(error.code, 'FST_ERR_REP_READABLE_STREAM_LOCKED')
+  t.assert.strictEqual(error.message, 'ReadableStream was locked. You should call releaseLock() method on reader before sending.')
+  t.assert.strictEqual(error.statusCode, 500)
+  t.assert.ok(error instanceof Error)
+})
+
 test('FST_ERR_REP_ALREADY_SENT', t => {
   t.plan(5)
   const error = new errors.FST_ERR_REP_ALREADY_SENT('/hello', 'GET')
@@ -868,7 +880,7 @@ test('FST_ERR_ERROR_HANDLER_NOT_FN', t => {
 })
 
 test('Ensure that all errors are in Errors.md TOC', t => {
-  t.plan(83)
+  t.plan(expectedErrors)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -880,7 +892,7 @@ test('Ensure that all errors are in Errors.md TOC', t => {
 })
 
 test('Ensure that non-existing errors are not in Errors.md TOC', t => {
-  t.plan(83)
+  t.plan(expectedErrors)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = / {4}- \[([A-Z0-9_]+)\]\(#[a-z0-9_]+\)/g
@@ -893,7 +905,7 @@ test('Ensure that non-existing errors are not in Errors.md TOC', t => {
 })
 
 test('Ensure that all errors are in Errors.md documented', t => {
-  t.plan(83)
+  t.plan(expectedErrors)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const exportedKeys = Object.keys(errors)
@@ -905,7 +917,7 @@ test('Ensure that all errors are in Errors.md documented', t => {
 })
 
 test('Ensure that non-existing errors are not in Errors.md documented', t => {
-  t.plan(83)
+  t.plan(expectedErrors)
   const errorsMd = readFileSync(resolve(__dirname, '../../docs/Reference/Errors.md'), 'utf8')
 
   const matchRE = /<a id="[0-9a-zA-Z_]+">([0-9a-zA-Z_]+)<\/a>/g