fastify 5.0.0 → 5.2.0

package/test/pretty-print.test.js

@@ -1,10 +1,9 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 
-test('pretty print - static routes', t => {
+test('pretty print - static routes', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -22,12 +21,13 @@ test('pretty print - static routes', t => {
     └── hello/world (GET)
 `
 
-    t.equal(typeof tree, 'string')
-    t.equal(tree, expected)
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
   })
 })
 
-test('pretty print - internal tree - static routes', t => {
+test('pretty print - internal tree - static routes', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -47,8 +47,8 @@ test('pretty print - internal tree - static routes', t => {
     └── hello/world (GET)
 `
 
-    t.equal(typeof getTree, 'string')
-    t.equal(getTree, expectedGetTree)
+    t.assert.strictEqual(typeof getTree, 'string')
+    t.assert.strictEqual(getTree, expectedGetTree)
 
     const putTree = fastify.printRoutes({ method: 'PUT' })
     const expectedPutTree = `\
@@ -57,12 +57,13 @@ test('pretty print - internal tree - static routes', t => {
         └── /foo (PUT)
 `
 
-    t.equal(typeof putTree, 'string')
-    t.equal(putTree, expectedPutTree)
+    t.assert.strictEqual(typeof putTree, 'string')
+    t.assert.strictEqual(putTree, expectedPutTree)
+    done()
   })
 })
 
-test('pretty print - parametric routes', t => {
+test('pretty print - parametric routes', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -82,12 +83,13 @@ test('pretty print - parametric routes', t => {
         └── :world (GET)
 `
 
-    t.equal(typeof tree, 'string')
-    t.equal(tree, expected)
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
   })
 })
 
-test('pretty print - internal tree - parametric routes', t => {
+test('pretty print - internal tree - parametric routes', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -109,8 +111,8 @@ test('pretty print - internal tree - parametric routes', t => {
         └── :world (GET)
 `
 
-    t.equal(typeof getTree, 'string')
-    t.equal(getTree, expectedGetTree)
+    t.assert.strictEqual(typeof getTree, 'string')
+    t.assert.strictEqual(getTree, expectedGetTree)
 
     const putTree = fastify.printRoutes({ method: 'PUT' })
     const expectedPutTree = `\
@@ -120,12 +122,13 @@ test('pretty print - internal tree - parametric routes', t => {
             └── :hello (PUT)
 `
 
-    t.equal(typeof putTree, 'string')
-    t.equal(putTree, expectedPutTree)
+    t.assert.strictEqual(typeof putTree, 'string')
+    t.assert.strictEqual(putTree, expectedPutTree)
+    done()
   })
 })
 
-test('pretty print - mixed parametric routes', t => {
+test('pretty print - mixed parametric routes', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -145,12 +148,13 @@ test('pretty print - mixed parametric routes', t => {
                 └── /world (GET)
 `
 
-    t.equal(typeof tree, 'string')
-    t.equal(tree, expected)
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
   })
 })
 
-test('pretty print - wildcard routes', t => {
+test('pretty print - wildcard routes', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -170,12 +174,13 @@ test('pretty print - wildcard routes', t => {
         └── * (GET)
 `
 
-    t.equal(typeof tree, 'string')
-    t.equal(tree, expected)
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
   })
 })
 
-test('pretty print - internal tree - wildcard routes', t => {
+test('pretty print - internal tree - wildcard routes', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({ exposeHeadRoutes: false })
@@ -197,8 +202,8 @@ test('pretty print - internal tree - wildcard routes', t => {
         └── * (GET)
 `
 
-    t.equal(typeof getTree, 'string')
-    t.equal(getTree, expectedGetTree)
+    t.assert.strictEqual(typeof getTree, 'string')
+    t.assert.strictEqual(getTree, expectedGetTree)
 
     const putTree = fastify.printRoutes({ method: 'PUT' })
     const expectedPutTree = `\
@@ -208,23 +213,25 @@ test('pretty print - internal tree - wildcard routes', t => {
     └── * (PUT)
 `
 
-    t.equal(typeof putTree, 'string')
-    t.equal(putTree, expectedPutTree)
+    t.assert.strictEqual(typeof putTree, 'string')
+    t.assert.strictEqual(putTree, expectedPutTree)
+    done()
   })
 })
 
-test('pretty print - empty plugins', t => {
+test('pretty print - empty plugins', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
   fastify.ready(() => {
     const tree = fastify.printPlugins()
-    t.equal(typeof tree, 'string')
-    t.match(tree, /root \d+ ms\n└── bound _after \d+ ms/m)
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.match(tree, /root \d+ ms\n└── bound _after \d+ ms/m)
+    done()
   })
 })
 
-test('pretty print - nested plugins', t => {
+test('pretty print - nested plugins', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -234,14 +241,15 @@ test('pretty print - nested plugins', t => {
   })
   fastify.ready(() => {
     const tree = fastify.printPlugins()
-    t.equal(typeof tree, 'string')
-    t.match(tree, 'foo')
-    t.match(tree, 'bar')
-    t.match(tree, 'baz')
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.match(tree, /foo/)
+    t.assert.match(tree, /bar/)
+    t.assert.match(tree, /baz/)
+    done()
   })
 })
 
-test('pretty print - commonPrefix', t => {
+test('pretty print - commonPrefix', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
@@ -263,14 +271,15 @@ test('pretty print - commonPrefix', t => {
 ├── /hello (GET, HEAD, PUT)
 └── /helicopter (GET, HEAD)
 `
-    t.equal(typeof radixTree, 'string')
-    t.equal(typeof flatTree, 'string')
-    t.equal(radixTree, radixExpected)
-    t.equal(flatTree, flatExpected)
+    t.assert.strictEqual(typeof radixTree, 'string')
+    t.assert.strictEqual(typeof flatTree, 'string')
+    t.assert.strictEqual(radixTree, radixExpected)
+    t.assert.strictEqual(flatTree, flatExpected)
+    done()
   })
 })
 
-test('pretty print - includeMeta, includeHooks', t => {
+test('pretty print - includeMeta, includeHooks', (t, done) => {
   t.plan(6)
 
   const fastify = Fastify()
@@ -346,11 +355,12 @@ test('pretty print - includeMeta, includeHooks', t => {
     • (onRequest) ["anonymous()"]
     • (onSend) ["headRouteOnSendHandler()"]
 `
-    t.equal(typeof radixTree, 'string')
-    t.equal(typeof flatTree, 'string')
-    t.equal(typeof hooksOnlyExpected, 'string')
-    t.equal(radixTree, radixExpected)
-    t.equal(flatTree, flatExpected)
-    t.equal(hooksOnly, hooksOnlyExpected)
+    t.assert.strictEqual(typeof radixTree, 'string')
+    t.assert.strictEqual(typeof flatTree, 'string')
+    t.assert.strictEqual(typeof hooksOnlyExpected, 'string')
+    t.assert.strictEqual(radixTree, radixExpected)
+    t.assert.strictEqual(flatTree, flatExpected)
+    t.assert.strictEqual(hooksOnly, hooksOnlyExpected)
+    done()
   })
 })

package/test/proto-poisoning.test.js

@@ -2,21 +2,19 @@
 
 const Fastify = require('..')
 const sget = require('simple-get').concat
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
-test('proto-poisoning error', t => {
+test('proto-poisoning error', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (request, reply) => {
-    t.fail('handler should not be called')
+    t.assert.fail('handler should not be called')
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -24,25 +22,26 @@ test('proto-poisoning error', t => {
       headers: { 'Content-Type': 'application/json' },
       body: '{ "__proto__": { "a": 42 } }'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      fastify.close()
+      done()
     })
   })
 })
 
-test('proto-poisoning remove', t => {
+test('proto-poisoning remove', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({ onProtoPoisoning: 'remove' })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (request, reply) => {
-    t.equal(undefined, Object.assign({}, request.body).a)
+    t.assert.strictEqual(undefined, Object.assign({}, request.body).a)
     reply.send({ ok: true })
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -50,25 +49,26 @@ test('proto-poisoning remove', t => {
       headers: { 'Content-Type': 'application/json' },
       body: '{ "__proto__": { "a": 42 }, "b": 42 }'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      fastify.close()
+      done()
     })
   })
 })
 
-test('proto-poisoning ignore', t => {
+test('proto-poisoning ignore', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({ onProtoPoisoning: 'ignore' })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (request, reply) => {
-    t.equal(42, Object.assign({}, request.body).a)
+    t.assert.strictEqual(42, Object.assign({}, request.body).a)
     reply.send({ ok: true })
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -76,24 +76,25 @@ test('proto-poisoning ignore', t => {
       headers: { 'Content-Type': 'application/json' },
       body: '{ "__proto__": { "a": 42 }, "b": 42 }'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      fastify.close()
+      done()
     })
   })
 })
 
-test('constructor-poisoning error (default in v3)', t => {
+test('constructor-poisoning error (default in v3)', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (request, reply) => {
     reply.send('ok')
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -101,24 +102,25 @@ test('constructor-poisoning error (default in v3)', t => {
       headers: { 'Content-Type': 'application/json' },
       body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      fastify.close()
+      done()
     })
   })
 })
 
-test('constructor-poisoning error', t => {
+test('constructor-poisoning error', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify({ onConstructorPoisoning: 'error' })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (request, reply) => {
-    t.fail('handler should not be called')
+    t.assert.fail('handler should not be called')
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -126,25 +128,26 @@ test('constructor-poisoning error', t => {
       headers: { 'Content-Type': 'application/json' },
       body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 400)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 400)
+      fastify.close()
+      done()
     })
   })
 })
 
-test('constructor-poisoning remove', t => {
+test('constructor-poisoning remove', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({ onConstructorPoisoning: 'remove' })
-  t.teardown(fastify.close.bind(fastify))
 
   fastify.post('/', (request, reply) => {
-    t.equal(undefined, Object.assign({}, request.body).foo)
+    t.assert.strictEqual(undefined, Object.assign({}, request.body).foo)
     reply.send({ ok: true })
   })
 
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -152,8 +155,10 @@ test('constructor-poisoning remove', t => {
       headers: { 'Content-Type': 'application/json' },
       body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      fastify.close()
+      done()
     })
   })
 })

package/test/reply-code.test.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const t = require('tap')
-const { Readable } = require('stream')
-const test = t.test
+const { test } = require('node:test')
+const { Readable } = require('node:stream')
 const Fastify = require('..')
 
-test('code should handle null/undefined/float', t => {
+test('code should handle null/undefined/float', (t, done) => {
   t.plan(8)
 
   const fastify = Fastify()
@@ -26,9 +25,9 @@ test('code should handle null/undefined/float', t => {
     method: 'GET',
     url: '/null'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 500)
-    t.same(res.json(), {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
       statusCode: 500,
       code: 'FST_ERR_BAD_STATUS_CODE',
       error: 'Internal Server Error',
@@ -40,9 +39,9 @@ test('code should handle null/undefined/float', t => {
     method: 'GET',
     url: '/undefined'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 500)
-    t.same(res.json(), {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
       statusCode: 500,
       code: 'FST_ERR_BAD_STATUS_CODE',
       error: 'Internal Server Error',
@@ -54,12 +53,13 @@ test('code should handle null/undefined/float', t => {
     method: 'GET',
     url: '/404.5'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 404)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
   })
 })
 
-test('code should handle 204', t => {
+test('code should handle 204', (t, done) => {
   t.plan(13)
 
   const fastify = Fastify()
@@ -80,7 +80,7 @@ test('code should handle 204', t => {
       }
     })
     stream.on('end', () => {
-      t.pass('stream ended')
+      t.assert.ok('stream ended')
     })
     reply.status(204).send(stream)
   })
@@ -89,34 +89,35 @@ test('code should handle 204', t => {
     method: 'GET',
     url: '/204'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 204)
-    t.equal(res.payload, '')
-    t.equal(res.headers['content-length'], undefined)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
   })
 
   fastify.inject({
     method: 'GET',
     url: '/undefined/204'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 204)
-    t.equal(res.payload, '')
-    t.equal(res.headers['content-length'], undefined)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
   })
 
   fastify.inject({
     method: 'GET',
     url: '/stream/204'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 204)
-    t.equal(res.payload, '')
-    t.equal(res.headers['content-length'], undefined)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+    done()
   })
 })
 
-test('code should handle onSend hook on 204', t => {
+test('code should handle onSend hook on 204', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify()
@@ -137,10 +138,11 @@ test('code should handle onSend hook on 204', t => {
     method: 'GET',
     url: '/204'
   }, (error, res) => {
-    t.error(error)
-    t.equal(res.statusCode, 204)
-    t.equal(res.payload, '')
-    t.equal(res.headers['content-length'], undefined)
-    t.equal(res.headers['content-type'], undefined)
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+    t.assert.strictEqual(res.headers['content-type'], undefined)
+    done()
   })
 })

package/test/{reply-earlyHints.test.js → reply-early-hints.test.js}

@@ -1,13 +1,13 @@
 'use strict'
 
 const Fastify = require('..')
-const { test } = require('tap')
-const http = require('http')
-const http2 = require('http2')
+const { test } = require('node:test')
+const http = require('node:http')
+const http2 = require('node:http2')
 
 const testResBody = 'Hello, world!'
 
-test('sends early hints', (t) => {
+test('sends early hints', (t, done) => {
   t.plan(6)
 
   const fastify = Fastify({
@@ -18,24 +18,24 @@ test('sends early hints', (t) => {
     reply.writeEarlyHints({
       link: '</styles.css>; rel=preload; as=style'
     }, () => {
-      t.pass('callback called')
+      t.assert.ok('callback called')
     })
 
     return testResBody
   })
 
   fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const req = http.get(address)
 
     req.on('information', (res) => {
-      t.equal(res.statusCode, 103)
-      t.equal(res.headers.link, '</styles.css>; rel=preload; as=style')
+      t.assert.strictEqual(res.statusCode, 103)
+      t.assert.strictEqual(res.headers.link, '</styles.css>; rel=preload; as=style')
     })
 
     req.on('response', (res) => {
-      t.equal(res.statusCode, 200)
+      t.assert.strictEqual(res.statusCode, 200)
 
       let data = ''
       res.on('data', (chunk) => {
@@ -43,14 +43,15 @@ test('sends early hints', (t) => {
       })
 
       res.on('end', () => {
-        t.equal(data, testResBody)
-        fastify.close(t.end)
+        t.assert.strictEqual(data, testResBody)
+        fastify.close()
+        done()
       })
     })
   })
 })
 
-test('sends early hints (http2)', (t) => {
+test('sends early hints (http2)', (t, done) => {
   t.plan(6)
 
   const fastify = Fastify({
@@ -67,19 +68,19 @@ test('sends early hints (http2)', (t) => {
   })
 
   fastify.listen({ port: 0 }, (err, address) => {
-    t.error(err)
+    t.assert.ifError(err)
 
     const client = http2.connect(address)
     const req = client.request()
 
     req.on('headers', (headers) => {
-      t.not(headers, undefined)
-      t.equal(headers[':status'], 103)
-      t.equal(headers.link, '</styles.css>; rel=preload; as=style')
+      t.assert.notStrictEqual(headers, undefined)
+      t.assert.strictEqual(headers[':status'], 103)
+      t.assert.strictEqual(headers.link, '</styles.css>; rel=preload; as=style')
     })
 
     req.on('response', (headers) => {
-      t.equal(headers[':status'], 200)
+      t.assert.strictEqual(headers[':status'], 200)
     })
 
     let data = ''
@@ -88,9 +89,10 @@ test('sends early hints (http2)', (t) => {
     })
 
     req.on('end', () => {
-      t.equal(data, testResBody)
+      t.assert.strictEqual(data, testResBody)
       client.close()
-      fastify.close(t.end)
+      fastify.close()
+      done()
     })
 
     req.end()