fastify 5.3.2 → 5.4.0

package/test/allow-unsafe-regex.test.js

@@ -2,10 +2,9 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
-test('allow unsafe regex', (t, done) => {
-  t.plan(4)
+test('allow unsafe regex', async t => {
+  t.plan(2)
 
   const fastify = Fastify({
     allowUnsafeRegex: false
@@ -16,25 +15,15 @@ test('allow unsafe regex', (t, done) => {
     reply.send({ foo: req.params.foo })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/1234'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), {
-        foo: '1234'
-      })
-      done()
-    })
-  })
+  await fastify.listen({ port: 0 })
+
+  const result = await fetch(`http://localhost:${fastify.server.address().port}/1234`)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { foo: '1234' })
 })
 
-test('allow unsafe regex not match', (t, done) => {
-  t.plan(3)
+test('allow unsafe regex not match', async t => {
+  t.plan(1)
 
   const fastify = Fastify({
     allowUnsafeRegex: false
@@ -45,18 +34,10 @@ test('allow unsafe regex not match', (t, done) => {
     reply.send({ foo: req.params.foo })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
+  await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/a1234'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 404)
-      done()
-    })
-  })
+  const result = await fetch(`http://localhost:${fastify.server.address().port}/a1234`)
+  t.assert.strictEqual(result.status, 404)
 })
 
 test('allow unsafe regex not safe', (t, done) => {
@@ -89,8 +70,8 @@ test('allow unsafe regex not safe by default', (t, done) => {
   done()
 })
 
-test('allow unsafe regex allow unsafe', (t, done) => {
-  t.plan(5)
+test('allow unsafe regex allow unsafe', async t => {
+  t.plan(3)
 
   const fastify = Fastify({
     allowUnsafeRegex: true
@@ -103,19 +84,9 @@ test('allow unsafe regex allow unsafe', (t, done) => {
     })
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/1234'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), {
-        foo: '1234'
-      })
-      done()
-    })
-  })
+  await fastify.listen({ port: 0 })
+
+  const result = await fetch(`http://localhost:${fastify.server.address().port}/1234`)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { foo: '1234' })
 })

package/test/als.test.js

@@ -3,10 +3,9 @@
 const { AsyncLocalStorage } = require('node:async_hooks')
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
-test('Async Local Storage test', (t, done) => {
-  t.plan(13)
+test('Async Local Storage test', async (t) => {
+  t.plan(12)
   if (!AsyncLocalStorage) {
     t.skip('AsyncLocalStorage not available, skipping test')
     process.exit(0)
@@ -15,6 +14,8 @@ test('Async Local Storage test', (t, done) => {
   const storage = new AsyncLocalStorage()
   const app = Fastify({ logger: false })
 
+  t.after(() => app.close())
+
   let counter = 0
   app.addHook('onRequest', (req, reply, next) => {
     const id = counter++
@@ -33,45 +34,32 @@ test('Async Local Storage test', (t, done) => {
     reply.send({ id })
   })
 
-  app.listen({ port: 0 }, function (err, address) {
-    t.assert.ifError(err)
+  const fastifyServer = await app.listen({ port: 0 })
 
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + app.server.address().port,
-      body: {
-        hello: 'world'
-      },
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(body, { id: 0 })
+  // First POST request
+  const result1 = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ hello: 'world' })
+  })
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  t.assert.deepStrictEqual(await result1.json(), { id: 0 })
 
-      sget({
-        method: 'POST',
-        url: 'http://localhost:' + app.server.address().port,
-        body: {
-          hello: 'world'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { id: 1 })
+  const result2 = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ hello: 'world' })
+  })
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  t.assert.deepStrictEqual(await result2.json(), { id: 1 })
 
-        sget({
-          method: 'GET',
-          url: 'http://localhost:' + app.server.address().port,
-          json: true
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.strictEqual(response.statusCode, 200)
-          t.assert.deepStrictEqual(body, { id: 2 })
-          app.close()
-          done()
-        })
-      })
-    })
+  // GET request
+  const result3 = await fetch(fastifyServer, {
+    method: 'GET'
   })
+  t.assert.ok(result3.ok)
+  t.assert.strictEqual(result3.status, 200)
+  t.assert.deepStrictEqual(await result3.json(), { id: 2 })
 })

package/test/async-await.test.js

@@ -6,6 +6,7 @@ const Fastify = require('..')
 const split = require('split2')
 const pino = require('pino')
 const { sleep } = require('./helper')
+const { waitForCb } = require('./toolkit')
 const statusCodes = require('node:http').STATUS_CODES
 
 const opts = {
@@ -43,7 +44,7 @@ const optsWithHostnameAndPort = {
     }
   }
 }
-test('async await', (t, done) => {
+test('async await', (t, testDone) => {
   t.plan(16)
   const fastify = Fastify()
   try {
@@ -79,6 +80,10 @@ test('async await', (t, done) => {
     t.assert.ifError(err)
     t.after(() => { fastify.close() })
 
+    const completion = waitForCb({
+      steps: 3
+    })
+
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
@@ -87,6 +92,7 @@ test('async await', (t, done) => {
       t.assert.strictEqual(response.statusCode, 200)
       t.assert.strictEqual(response.headers['content-length'], '' + body.length)
       t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      completion.stepIn()
     })
 
     sget({
@@ -97,6 +103,7 @@ test('async await', (t, done) => {
       t.assert.strictEqual(response.statusCode, 200)
       t.assert.strictEqual(response.headers['content-length'], '' + body.length)
       t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+      completion.stepIn()
     })
 
     sget({
@@ -108,8 +115,10 @@ test('async await', (t, done) => {
       const parsedBody = JSON.parse(body)
       t.assert.strictEqual(parsedBody.hostname, 'localhost')
       t.assert.strictEqual(parseInt(parsedBody.port), fastify.server.address().port)
-      done()
+      completion.stepIn()
     })
+
+    completion.patience.then(testDone)
   })
 })
 

package/test/body-limit.test.js

@@ -1,12 +1,11 @@
 'use strict'
 
 const Fastify = require('../fastify')
-const sget = require('simple-get').concat
 const zlib = require('node:zlib')
 const { test } = require('node:test')
 
-test('bodyLimit', (t, done) => {
-  t.plan(5)
+test('bodyLimit', async t => {
+  t.plan(4)
 
   try {
     Fastify({ bodyLimit: 1.3 })
@@ -28,22 +27,17 @@ test('bodyLimit', (t, done) => {
     reply.send({ error: 'handler should not be called' })
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: { 'Content-Type': 'application/json' },
-      body: [],
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 413)
-      done()
-    })
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify([])
   })
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 413)
 })
 
 test('bodyLimit is applied to decoded content', async (t) => {
@@ -114,8 +108,8 @@ test('bodyLimit is applied to decoded content', async (t) => {
   })
 })
 
-test('default request.routeOptions.bodyLimit should be 1048576', (t, done) => {
-  t.plan(4)
+test('default request.routeOptions.bodyLimit should be 1048576', async t => {
+  t.plan(3)
   const fastify = Fastify()
   fastify.post('/default-bodylimit', {
     handler (request, reply) {
@@ -123,26 +117,20 @@ test('default request.routeOptions.bodyLimit should be 1048576', (t, done) => {
       reply.send({ })
     }
   })
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port + '/default-bodylimit',
-      headers: { 'Content-Type': 'application/json' },
-      body: [],
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
+  const result = await fetch(fastifyServer + '/default-bodylimit', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify([])
   })
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
 })
 
-test('request.routeOptions.bodyLimit should be equal to route limit', (t, done) => {
-  t.plan(4)
+test('request.routeOptions.bodyLimit should be equal to route limit', async t => {
+  t.plan(3)
   const fastify = Fastify({ bodyLimit: 1 })
   fastify.post('/route-limit', {
     bodyLimit: 1000,
@@ -151,26 +139,20 @@ test('request.routeOptions.bodyLimit should be equal to route limit', (t, done)
       reply.send({})
     }
   })
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port + '/route-limit',
-      headers: { 'Content-Type': 'application/json' },
-      body: [],
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
+  const result = await fetch(fastifyServer + '/route-limit', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify([])
   })
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
 })
 
-test('request.routeOptions.bodyLimit should be equal to server limit', (t, done) => {
-  t.plan(4)
+test('request.routeOptions.bodyLimit should be equal to server limit', async t => {
+  t.plan(3)
   const fastify = Fastify({ bodyLimit: 100 })
   fastify.post('/server-limit', {
     handler (request, reply) {
@@ -178,20 +160,14 @@ test('request.routeOptions.bodyLimit should be equal to server limit', (t, done)
       reply.send({})
     }
   })
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port + '/server-limit',
-      headers: { 'Content-Type': 'application/json' },
-      body: [],
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      done()
-    })
+  const result = await fetch(fastifyServer + '/server-limit', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify([])
   })
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
 })

package/test/build-certificate.js

@@ -91,7 +91,7 @@ function selfCert (opts) {
   }
 }
 
-async function buildCertificate () {
+function buildCertificate () {
   // "global" is used in here because "t.context" is only supported by "t.beforeEach" and "t.afterEach"
   // For the test case which execute this code which will be using `t.before` and it can reduce the
   // number of times executing it.

package/test/close-pipelining.test.js

@@ -59,10 +59,11 @@ test('Should close the socket abruptly - pipelining - return503OnClosing: false'
     instance.request({ path: '/', method: 'GET' })
   ])
 
-  t.assert.strictEqual(responses[0].status, 'fulfilled')
-  t.assert.strictEqual(responses[1].status, 'fulfilled')
-  t.assert.strictEqual(responses[2].status, 'rejected')
-  t.assert.strictEqual(responses[3].status, 'rejected')
+  const fulfilled = responses.filter(r => r.status === 'fulfilled')
+  const rejected = responses.filter(r => r.status === 'rejected')
+
+  t.assert.strictEqual(fulfilled.length, 2)
+  t.assert.strictEqual(rejected.length, 2)
 
   await instance.close()
 })

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 
 process.removeAllListeners('warning')
@@ -24,41 +23,37 @@ test('contentTypeParser should add a custom async parser', async t => {
   })
 
   t.after(() => fastify.close())
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-  await t.test('in POST', (t, done) => {
+  await t.test('in POST', async t => {
     t.plan(3)
 
-    sget({
+    const result = await fetch(fastifyServer, {
       method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
       headers: {
         'Content-Type': 'application/jsoff'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-      done()
+      },
+      body: '{"hello":"world"}'
     })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
   })
 
-  await t.test('in OPTIONS', (t, done) => {
+  await t.test('in OPTIONS', async t => {
     t.plan(3)
 
-    sget({
+    const result = await fetch(fastifyServer, {
       method: 'OPTIONS',
-      url: 'http://localhost:' + fastify.server.address().port,
-      body: '{"hello":"world"}',
       headers: {
         'Content-Type': 'application/jsoff'
-      }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-      done()
+      },
+      body: '{"hello":"world"}'
     })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
   })
 })

package/test/decorator-namespace.test._js_

@@ -2,8 +2,7 @@
 
 /* eslint no-prototype-builtins: 0 */
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const fp = require('fastify-plugin')
 
@@ -24,8 +23,8 @@ test('plugin namespace', async t => {
   }, { namepace: 'foo' })
 
   // ! but outside the plugin the decorator would be app.foo.utility()
-  t.ok(app.foo.utility)
+  t.assert.ok(app.foo.utility)
 
   const res = await app.inject('/')
-  t.same(res.json(), { utility: 'utility' })
+  t.assert.deepStrictEqual(res.json(), { utility: 'utility' })
 })