fastify 5.3.3 → 5.5.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

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('..')
 const split = require('split2')
 const pino = require('pino')
@@ -43,8 +42,8 @@ const optsWithHostnameAndPort = {
     }
   }
 }
-test('async await', (t, done) => {
-  t.plan(16)
+test('async await', async t => {
+  t.plan(15)
   const fastify = Fastify()
   try {
     fastify.get('/', opts, async function awaitMyFunc (req, reply) {
@@ -75,46 +74,37 @@ test('async await', (t, done) => {
     t.assert.fail()
   }
 
-  fastify.listen({ port: 0 }, async err => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port
-    }, (err, response, body) => {
-      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' })
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/no-await'
-    }, (err, response, body) => {
-      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' })
-    })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/await/hostname_port'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      const parsedBody = JSON.parse(body)
-      t.assert.strictEqual(parsedBody.hostname, 'localhost')
-      t.assert.strictEqual(parseInt(parsedBody.port), fastify.server.address().port)
-      done()
-    })
-  })
+  const result = await fetch(fastifyServer)
+
+  const body = await result.text()
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+
+  const result1 = await fetch(`${fastifyServer}/no-await`)
+
+  const body1 = await result1.text()
+  t.assert.ok(result1.ok)
+  t.assert.strictEqual(result1.status, 200)
+  t.assert.strictEqual(result1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'world' })
+
+  const result2 = await fetch(`http://localhost:${fastify.server.address().port}/await/hostname_port`)
+
+  const parsedBody = await result2.json()
+  t.assert.ok(result2.ok)
+  t.assert.strictEqual(result2.status, 200)
+  t.assert.strictEqual(parsedBody.hostname, 'localhost')
+  t.assert.strictEqual(parseInt(parsedBody.port), fastify.server.address().port)
 })
 
-test('ignore the result of the promise if reply.send is called beforehand (undefined)', (t, done) => {
-  t.plan(4)
+test('ignore the result of the promise if reply.send is called beforehand (undefined)', async (t) => {
+  t.plan(3)
 
   const server = Fastify()
   const payload = { hello: 'world' }
@@ -125,22 +115,17 @@ test('ignore the result of the promise if reply.send is called beforehand (undef
 
   t.after(() => { server.close() })
 
-  server.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + server.server.address().port + '/'
-    }, (err, res, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(payload, JSON.parse(body))
-      t.assert.strictEqual(res.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await server.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+
+  t.assert.ok(result.ok)
+  t.assert.deepStrictEqual(payload, await result.json())
+  t.assert.strictEqual(result.status, 200)
 })
 
-test('ignore the result of the promise if reply.send is called beforehand (object)', (t, done) => {
-  t.plan(4)
+test('ignore the result of the promise if reply.send is called beforehand (object)', async (t) => {
+  t.plan(3)
 
   const server = Fastify()
   const payload = { hello: 'world2' }
@@ -152,18 +137,13 @@ test('ignore the result of the promise if reply.send is called beforehand (objec
 
   t.after(() => { server.close() })
 
-  server.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + server.server.address().port + '/'
-    }, (err, res, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(payload, JSON.parse(body))
-      t.assert.strictEqual(res.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await server.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+
+  t.assert.ok(result.ok)
+  t.assert.deepStrictEqual(payload, await result.json())
+  t.assert.strictEqual(result.status, 200)
 })
 
 test('server logs an error if reply.send is called and a value is returned via async/await', (t, done) => {
@@ -197,8 +177,8 @@ test('server logs an error if reply.send is called and a value is returned via a
   })
 })
 
-test('ignore the result of the promise if reply.send is called beforehand (undefined)', (t, done) => {
-  t.plan(4)
+test('ignore the result of the promise if reply.send is called beforehand (undefined)', async (t) => {
+  t.plan(3)
 
   const server = Fastify()
   const payload = { hello: 'world' }
@@ -209,22 +189,17 @@ test('ignore the result of the promise if reply.send is called beforehand (undef
 
   t.after(() => { server.close() })
 
-  server.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + server.server.address().port + '/'
-    }, (err, res, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(payload, JSON.parse(body))
-      t.assert.strictEqual(res.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await server.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+
+  t.assert.ok(result.ok)
+  t.assert.deepStrictEqual(payload, await result.json())
+  t.assert.strictEqual(result.status, 200)
 })
 
-test('ignore the result of the promise if reply.send is called beforehand (object)', (t, done) => {
-  t.plan(4)
+test('ignore the result of the promise if reply.send is called beforehand (object)', async (t) => {
+  t.plan(3)
 
   const server = Fastify()
   const payload = { hello: 'world2' }
@@ -236,18 +211,13 @@ test('ignore the result of the promise if reply.send is called beforehand (objec
 
   t.after(() => { server.close() })
 
-  server.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + server.server.address().port + '/'
-    }, (err, res, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(payload, JSON.parse(body))
-      t.assert.strictEqual(res.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await server.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+
+  t.assert.ok(result.ok)
+  t.assert.deepStrictEqual(payload, await result.json())
+  t.assert.strictEqual(result.status, 200)
 })
 
 test('await reply if we will be calling reply.send in the future', (t, done) => {
@@ -433,8 +403,8 @@ test('does not call reply.send() twice if 204 response equal already sent', (t,
   })
 })
 
-test('promise was fulfilled with undefined', (t, done) => {
-  t.plan(4)
+test('promise was fulfilled with undefined', async (t) => {
+  t.plan(3)
 
   let fastify = null
   const stream = split(JSON.parse)
@@ -458,20 +428,13 @@ test('promise was fulfilled with undefined', (t, done) => {
     t.assert.fail('should not log an error')
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/'
-    }, (err, res, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(res.body, undefined)
-      t.assert.strictEqual(res.statusCode, 200)
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(await result.text(), '')
+  t.assert.strictEqual(result.status, 200)
 })
 
 test('promise was fulfilled with undefined using inject', async (t) => {
@@ -496,8 +459,8 @@ test('promise was fulfilled with undefined using inject', async (t) => {
   t.assert.strictEqual(res.statusCode, 200)
 })
 
-test('error is not logged because promise was fulfilled with undefined but response was sent before promise resolution', (t, done) => {
-  t.plan(4)
+test('error is not logged because promise was fulfilled with undefined but response was sent before promise resolution', async (t) => {
+  t.plan(3)
 
   let fastify = null
   const stream = split(JSON.parse)
@@ -523,23 +486,16 @@ test('error is not logged because promise was fulfilled with undefined but respo
     t.assert.fail('should not log an error')
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + '/'
-    }, (err, res, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(res.statusCode, 200)
-      t.assert.deepStrictEqual(
-        payload,
-        JSON.parse(body)
-      )
-      done()
-    })
-  })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer)
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(
+    payload,
+    await result.json()
+  )
 })
 
 test('Thrown Error instance sets HTTP status code', (t, done) => {

package/test/async_hooks.test.js

@@ -3,7 +3,6 @@
 const { createHook } = require('node:async_hooks')
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
 const remainingIds = new Set()
 
@@ -20,7 +19,7 @@ createHook({
 
 const app = Fastify({ logger: false })
 
-test('test async hooks', (t, done) => {
+test('test async hooks', async (t) => {
   app.get('/', function (request, reply) {
     reply.send({ id: 42 })
   })
@@ -29,43 +28,25 @@ test('test async hooks', (t, done) => {
     reply.send({ id: 42 })
   })
 
-  app.listen({ port: 0 }, function (err, address) {
-    t.assert.ifError(err)
+  t.after(() => app.close())
 
-    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)
+  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)
+  const result1 = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ hello: 'world' })
+  })
+  t.assert.strictEqual(result1.status, 200)
 
-        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)
-          app.close()
-          t.assert.strictEqual(remainingIds.size, 0)
-          done()
-        })
-      })
-    })
+  const result2 = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ hello: 'world' })
   })
+  t.assert.strictEqual(result2.status, 200)
+
+  const result3 = await fetch(fastifyServer)
+  t.assert.strictEqual(result3.status, 200)
+  t.assert.strictEqual(remainingIds.size, 0)
 })