fastify 5.3.3 → 5.5.0

package/test/route-shorthand.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { describe, test } = require('node:test')
-const sget = require('simple-get').concat
+const { Client } = require('undici')
 const Fastify = require('..')
 
 describe('route-shorthand', () => {
@@ -19,19 +19,10 @@ describe('route-shorthand', () => {
       await fastify.listen({ port: 0 })
       t.after(() => fastify.close())
 
-      await new Promise((resolve, reject) => {
-        sget({
-          method,
-          url: `http://localhost:${fastify.server.address().port}`
-        }, (err, response, body) => {
-          if (err) {
-            t.assert.ifError(err)
-            return reject(err)
-          }
-          t.assert.strictEqual(response.statusCode, 200)
-          resolve()
-        })
-      })
+      const instance = new Client(`http://localhost:${fastify.server.address().port}`)
+
+      const response = await instance.request({ path: '/', method })
+      t.assert.strictEqual(response.statusCode, 200)
     })
   }
 
@@ -48,19 +39,10 @@ describe('route-shorthand', () => {
 
     for (const method of supportedMethods) {
       currentMethod = method
-      await new Promise((resolve, reject) => {
-        sget({
-          method,
-          url: `http://localhost:${fastify.server.address().port}`
-        }, (err, response, body) => {
-          if (err) {
-            t.assert.ifError(err)
-            return reject(err)
-          }
-          t.assert.strictEqual(response.statusCode, 200)
-          resolve()
-        })
-      })
+      const instance = new Client(`http://localhost:${fastify.server.address().port}`)
+
+      const response = await instance.request({ path: '/', method })
+      t.assert.strictEqual(response.statusCode, 200)
     }
   })
 })

package/test/route.1.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('..')
 const {
   FST_ERR_INSTANCE_ALREADY_LISTENING,
@@ -12,7 +11,7 @@ const { getServerUrl } = require('./helper')
 test('route', async t => {
   t.plan(10)
 
-  await t.test('route - get', (t, done) => {
+  await t.test('route - get', async (t) => {
     t.plan(4)
 
     const fastify = Fastify()
@@ -38,22 +37,16 @@ test('route', async t => {
       })
     )
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-      sget({
-        method: 'GET',
-        url: getServerUrl(fastify) + '/'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        done()
-      })
-    })
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
+
+    const response = await fetch(getServerUrl(fastify) + '/')
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
-  await t.test('missing schema - route', (t, done) => {
+  await t.test('missing schema - route', async (t) => {
     t.plan(4)
 
     const fastify = Fastify()
@@ -67,19 +60,13 @@ test('route', async t => {
       })
     )
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-      sget({
-        method: 'GET',
-        url: getServerUrl(fastify) + '/missing'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        done()
-      })
-    })
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
+
+    const response = await fetch(getServerUrl(fastify) + '/missing')
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    t.assert.deepStrictEqual(await response.json(), { hello: 'world' })
   })
 
   await t.test('invalid handler attribute - route', t => {
@@ -89,7 +76,7 @@ test('route', async t => {
     t.assert.throws(() => fastify.get('/', { handler: 'not a function' }, () => { }))
   })
 
-  await t.test('Add Multiple methods per route all uppercase', (t, done) => {
+  await t.test('Add Multiple methods per route all uppercase', async (t) => {
     t.plan(7)
 
     const fastify = Fastify()
@@ -102,31 +89,21 @@ test('route', async t => {
         }
       }))
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-      sget({
-        method: 'GET',
-        url: getServerUrl(fastify) + '/multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
 
-      sget({
-        method: 'DELETE',
-        url: getServerUrl(fastify) + '/multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        done()
-      })
-    })
+    const getResponse = await fetch(getServerUrl(fastify) + '/multiple')
+    t.assert.ok(getResponse.ok)
+    t.assert.strictEqual(getResponse.status, 200)
+    t.assert.deepStrictEqual(await getResponse.json(), { hello: 'world' })
+
+    const deleteResponse = await fetch(getServerUrl(fastify) + '/multiple', { method: 'DELETE' })
+    t.assert.ok(deleteResponse.ok)
+    t.assert.strictEqual(deleteResponse.status, 200)
+    t.assert.deepStrictEqual(await deleteResponse.json(), { hello: 'world' })
   })
 
-  await t.test('Add Multiple methods per route all lowercase', (t, done) => {
+  await t.test('Add Multiple methods per route all lowercase', async (t) => {
     t.plan(7)
 
     const fastify = Fastify()
@@ -139,31 +116,21 @@ test('route', async t => {
         }
       }))
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-      sget({
-        method: 'GET',
-        url: getServerUrl(fastify) + '/multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
 
-      sget({
-        method: 'DELETE',
-        url: getServerUrl(fastify) + '/multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        done()
-      })
-    })
+    const getResponse = await fetch(getServerUrl(fastify) + '/multiple')
+    t.assert.ok(getResponse.ok)
+    t.assert.strictEqual(getResponse.status, 200)
+    t.assert.deepStrictEqual(await getResponse.json(), { hello: 'world' })
+
+    const deleteResponse = await fetch(getServerUrl(fastify) + '/multiple', { method: 'DELETE' })
+    t.assert.ok(deleteResponse.ok)
+    t.assert.strictEqual(deleteResponse.status, 200)
+    t.assert.deepStrictEqual(await deleteResponse.json(), { hello: 'world' })
   })
 
-  await t.test('Add Multiple methods per route mixed uppercase and lowercase', (t, done) => {
+  await t.test('Add Multiple methods per route mixed uppercase and lowercase', async (t) => {
     t.plan(7)
 
     const fastify = Fastify()
@@ -176,28 +143,18 @@ test('route', async t => {
         }
       }))
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-      sget({
-        method: 'GET',
-        url: getServerUrl(fastify) + '/multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
 
-      sget({
-        method: 'DELETE',
-        url: getServerUrl(fastify) + '/multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        done()
-      })
-    })
+    const getResponse = await fetch(getServerUrl(fastify) + '/multiple')
+    t.assert.ok(getResponse.ok)
+    t.assert.strictEqual(getResponse.status, 200)
+    t.assert.deepStrictEqual(await getResponse.json(), { hello: 'world' })
+
+    const deleteResponse = await fetch(getServerUrl(fastify) + '/multiple', { method: 'DELETE' })
+    t.assert.ok(deleteResponse.ok)
+    t.assert.strictEqual(deleteResponse.status, 200)
+    t.assert.deepStrictEqual(await deleteResponse.json(), { hello: 'world' })
   })
 
   t.test('Add invalid Multiple methods per route', t => {
@@ -228,7 +185,7 @@ test('route', async t => {
       }), new FST_ERR_ROUTE_METHOD_INVALID())
   })
 
-  await t.test('Add additional multiple methods to existing route', (t, done) => {
+  await t.test('Add additional multiple methods to existing route', async (t) => {
     t.plan(7)
 
     const fastify = Fastify()
@@ -245,49 +202,35 @@ test('route', async t => {
       })
     })
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-      sget({
-        method: 'PUT',
-        url: getServerUrl(fastify) + '/add-multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      })
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
 
-      sget({
-        method: 'DELETE',
-        url: getServerUrl(fastify) + '/add-multiple'
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        done()
-      })
-    })
+    const putResponse = await fetch(getServerUrl(fastify) + '/add-multiple', { method: 'PUT' })
+    t.assert.ok(putResponse.ok)
+    t.assert.strictEqual(putResponse.status, 200)
+    t.assert.deepStrictEqual(await putResponse.json(), { hello: 'world' })
+
+    const deleteResponse = await fetch(getServerUrl(fastify) + '/add-multiple', { method: 'DELETE' })
+    t.assert.ok(deleteResponse.ok)
+    t.assert.strictEqual(deleteResponse.status, 200)
+    t.assert.deepStrictEqual(await deleteResponse.json(), { hello: 'world' })
   })
 
-  await t.test('cannot add another route after binding', (t, done) => {
+  await t.test('cannot add another route after binding', async (t) => {
     t.plan(1)
 
     const fastify = Fastify()
 
-    fastify.listen({ port: 0 }, function (err) {
-      if (err) t.assert.ifError(err)
-      t.after(() => { fastify.close() })
-
-      t.assert.throws(() => fastify.route({
-        method: 'GET',
-        url: '/another-get-route',
-        handler: function (req, reply) {
-          reply.send({ hello: 'world' })
-        }
-      }), new FST_ERR_INSTANCE_ALREADY_LISTENING('Cannot add route!'))
+    await fastify.listen({ port: 0 })
+    t.after(() => { fastify.close() })
 
-      done()
-    })
+    t.assert.throws(() => fastify.route({
+      method: 'GET',
+      url: '/another-get-route',
+      handler: function (req, reply) {
+        reply.send({ hello: 'world' })
+      }
+    }), new FST_ERR_INSTANCE_ALREADY_LISTENING('Cannot add route!'))
   })
 })
 

package/test/route.8.test.js

@@ -1,12 +1,10 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('..')
 const {
   FST_ERR_INVALID_URL
 } = require('../lib/errors')
-const { getServerUrl } = require('./helper')
 
 test('Request and Reply share the route options', async t => {
   t.plan(3)
@@ -64,8 +62,8 @@ test('Will not try to re-createprefixed HEAD route if it already exists and expo
   t.assert.ok(true)
 })
 
-test('route with non-english characters', (t, done) => {
-  t.plan(4)
+test('route with non-english characters', async (t) => {
+  t.plan(3)
 
   const fastify = Fastify()
 
@@ -73,20 +71,14 @@ test('route with non-english characters', (t, done) => {
     reply.send('here /föö')
   })
 
-  fastify.listen({ port: 0 }, err => {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
 
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + encodeURI('/föö')
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.strictEqual(body.toString(), 'here /föö')
-      done()
-    })
-  })
+  const response = await fetch(fastifyServer + encodeURI('/föö'))
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.strictEqual(body, 'here /föö')
 })
 
 test('invalid url attribute - non string URL', t => {