fastify 5.4.0 → 5.5.0

package/test/helper.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const sget = require('simple-get').concat
 const dns = require('node:dns').promises
 const stream = require('node:stream')
 const { promisify } = require('node:util')
@@ -105,89 +104,85 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
 
     t.after(() => { fastify.close() })
 
-    test(`${upMethod} - correctly replies`, (t, testDone) => {
+    test(`${upMethod} - correctly replies`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.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, { hello: 'world' })
-        testDone()
+        body: JSON.stringify({ hello: 'world' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
     })
 
-    test(`${upMethod} - correctly replies with very large body`, (t, testDone) => {
+    test(`${upMethod} - correctly replies with very large body`, async (t) => {
       t.plan(3)
 
       const largeString = 'world'.repeat(13200)
-      sget({
+      const result = await fetch('http://localhost:' + fastify.server.address().port, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
-        body: { hello: largeString },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: largeString })
-        testDone()
+        body: JSON.stringify({ hello: largeString }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: largeString })
     })
 
-    test(`${upMethod} - correctly replies if the content type has the charset`, (t, testDone) => {
+    test(`${upMethod} - correctly replies if the content type has the charset`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
         body: JSON.stringify({ hello: 'world' }),
         headers: {
           'content-type': 'application/json; charset=utf-8'
         }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body.toString(), JSON.stringify({ hello: 'world' }))
-        testDone()
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.text(), JSON.stringify({ hello: 'world' }))
     })
 
-    test(`${upMethod} without schema - correctly replies`, (t, testDone) => {
+    test(`${upMethod} without schema - correctly replies`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/missing', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/missing',
-        body: {
-          hello: 'world'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: 'world' })
-        testDone()
+        body: JSON.stringify({ hello: 'world' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
     })
 
-    test(`${upMethod} with body and querystring - correctly replies`, (t, testDone) => {
+    test(`${upMethod} with body and querystring - correctly replies`, async (t) => {
       t.plan(3)
-      sget({
+
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/with-query?foo=hello', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/with-query?foo=hello',
-        body: {
-          hello: 'world'
-        },
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(body, { hello: 'worldhello' })
-        testDone()
+        body: JSON.stringify({ hello: 'world' }),
+        headers: {
+          'Content-Type': 'application/json'
+        }
       })
+
+      t.assert.ok(result.ok)
+      t.assert.strictEqual(result.status, 200)
+      t.assert.deepStrictEqual(await result.json(), { hello: 'worldhello' })
     })
 
     test(`${upMethod} with no body - correctly replies`, t => {
@@ -195,14 +190,13 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
 
       const { stepIn, patience } = waitForCb({ steps: 2 })
 
-      sget({
+      fetch('http://localhost:' + fastify.server.address().port + '/missing', {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/missing',
         headers: { 'Content-Length': '0' }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.strictEqual(body.toString(), '')
+      }).then(async (response) => {
+        t.assert.ok(response.ok)
+        t.assert.strictEqual(response.status, 200)
+        t.assert.strictEqual(await response.text(), '')
         stepIn()
       })
 
@@ -220,88 +214,95 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
       return patience
     })
 
-    test(`${upMethod} returns 415 - incorrect media type if body is not json`, (t, testDone) => {
+    test(`${upMethod} returns 415 - incorrect media type if body is not json`, async (t) => {
       t.plan(2)
-      sget({
-        method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port + '/missing',
-        body: 'hello world'
 
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 415)
-        testDone()
+      const result = await fetch('http://localhost:' + fastify.server.address().port + '/missing', {
+        method: upMethod,
+        body: 'hello world',
+        headers: {
+          'Content-Type': undefined
+        }
       })
+
+      t.assert.ok(!result.ok)
+      t.assert.strictEqual(result.status, 415)
     })
 
     if (loMethod === 'options') {
-      test('OPTIONS returns 415 - should return 415 if Content-Type is not json or plain text', (t, testDone) => {
+      test('OPTIONS returns 415 - should return 415 if Content-Type is not json or plain text', async (t) => {
         t.plan(2)
-        sget({
+
+        const result = await fetch('http://localhost:' + fastify.server.address().port + '/missing', {
           method: upMethod,
-          url: 'http://localhost:' + fastify.server.address().port + '/missing',
           body: 'hello world',
           headers: {
             'Content-Type': 'text/xml'
           }
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.strictEqual(response.statusCode, 415)
-          testDone()
         })
+
+        t.assert.ok(!result.ok)
+        t.assert.strictEqual(result.status, 415)
       })
     }
 
     test(`${upMethod} returns 400 - Bad Request`, t => {
-      t.plan(4)
+      const isOptions = upMethod === 'OPTIONS'
+      t.plan(isOptions ? 2 : 4)
 
-      const { stepIn, patience } = waitForCb({ steps: 2 })
+      const { stepIn, patience } = waitForCb({ steps: isOptions ? 1 : 2 })
 
-      sget({
+      fetch('http://localhost:' + fastify.server.address().port, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
         body: 'hello world',
         headers: {
           'Content-Type': 'application/json'
         }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
+      }).then((response) => {
+        t.assert.ok(!response.ok)
+        t.assert.strictEqual(response.status, 400)
         stepIn()
       })
 
-      sget({
-        method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': '0'
-        }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 400)
-        stepIn()
-      })
+      if (!isOptions) {
+        fetch(`http://localhost:${fastify.server.address().port}`, {
+          method: upMethod,
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': '0'
+          }
+        }).then((response) => {
+          t.assert.ok(!response.ok)
+          t.assert.strictEqual(response.status, 400)
+          stepIn()
+        })
+      }
 
       return patience
     })
 
     test(`${upMethod} returns 413 - Payload Too Large`, t => {
       const isOptions = upMethod === 'OPTIONS'
-      t.plan(isOptions ? 4 : 6)
+      t.plan(isOptions ? 3 : 5)
 
       const { stepIn, patience } = waitForCb({ steps: isOptions ? 2 : 3 })
 
-      sget({
+      fetch(`http://localhost:${fastify.server.address().port}`, {
         method: upMethod,
-        url: 'http://localhost:' + fastify.server.address().port,
+        body: JSON.stringify({ w: 'w'.repeat(1024 * 1024 + 1) }),
         headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': 1024 * 1024 + 1
+          'Content-Type': 'application/json'
+        }
+      }).then((response) => {
+        t.assert.strictEqual(response.status, 413)
+        stepIn()
+      }).catch((err) => {
+        // Handle EPIPE error - server closed connection after sending 413
+        if (err.cause?.code === 'EPIPE' || err.message.includes('fetch failed')) {
+          t.assert.ok(true, 'Expected EPIPE error due to server closing connection on 413')
+        } else {
+          throw err
         }
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 413)
         stepIn()
       })
 
@@ -314,27 +315,33 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
             chunk = null
           }
         })
-        sget({
+        fetch('http://localhost:' + fastify.server.address().port, {
           method: upMethod,
-          url: 'http://localhost:' + fastify.server.address().port,
           headers: { 'Content-Type': 'application/json' },
-          body: largeStream
-        }, (err, response, body) => {
-          t.assert.ifError(err)
-          t.assert.strictEqual(response.statusCode, 413)
+          body: largeStream,
+          duplex: 'half'
+        }).then((response) => {
+          t.assert.ok(!response.ok)
+          t.assert.strictEqual(response.status, 413)
+          stepIn()
+        }).catch((err) => {
+          // Handle EPIPE error - server closed connection after sending 413
+          if (err.cause?.code === 'EPIPE' || err.message.includes('fetch failed')) {
+            t.assert.ok(true, 'Expected EPIPE error due to server closing connection on 413')
+          } else {
+            throw err
+          }
           stepIn()
         })
       }
 
-      sget({
+      fetch(`http://localhost:${fastify.server.address().port}/with-limit`, {
         method: upMethod,
-        url: `http://localhost:${fastify.server.address().port}/with-limit`,
         headers: { 'Content-Type': 'application/json' },
-        body: {},
-        json: true
-      }, (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 413)
+        body: JSON.stringify({})
+      }).then((response) => {
+        t.assert.ok(!response.ok)
+        t.assert.strictEqual(response.status, 413)
         stepIn()
       })
 
@@ -364,15 +371,14 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         })
       })
 
-      sget({
+      fetch(`http://localhost:${fastify.server.address().port}`, {
         method: upMethod,
-        url: `http://localhost:${fastify.server.address().port}`,
         headers: {
           'Content-Type': 'application/json'
         }
-      }, (err, res, body) => {
-        t.assert.ifError(err)
-        t.assert.deepStrictEqual(JSON.parse(body.toString()), {
+      }).then(async (res) => {
+        t.assert.ok(!res.ok)
+        t.assert.deepStrictEqual(await res.json(), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
           message: 'Body cannot be empty when content-type is set to \'application/json\'',
@@ -399,16 +405,15 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         stepIn()
       })
 
-      sget({
+      fetch(`http://localhost:${fastify.server.address().port}`, {
         method: upMethod,
-        url: `http://localhost:${fastify.server.address().port}`,
         headers: {
           'Content-Type': 'application/json'
         },
-        payload: null
-      }, (err, res, body) => {
-        t.assert.ifError(err)
-        t.assert.deepStrictEqual(JSON.parse(body.toString()), {
+        body: null
+      }).then(async (res) => {
+        t.assert.ok(!res.ok)
+        t.assert.deepStrictEqual(await res.json(), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
           message: 'Body cannot be empty when content-type is set to \'application/json\'',
@@ -435,16 +440,15 @@ module.exports.payloadMethod = function (method, t, isSetErrorHandler = false) {
         stepIn()
       })
 
-      sget({
+      fetch(`http://localhost:${fastify.server.address().port}`, {
         method: upMethod,
-        url: `http://localhost:${fastify.server.address().port}`,
         headers: {
           'Content-Type': 'application/json'
         },
-        payload: undefined
-      }, (err, res, body) => {
-        t.assert.ifError(err)
-        t.assert.deepStrictEqual(JSON.parse(body.toString()), {
+        body: undefined
+      }).then(async (res) => {
+        t.assert.ok(!res.ok)
+        t.assert.deepStrictEqual(await res.json(), {
           error: 'Bad Request',
           code: 'FST_ERR_CTP_EMPTY_JSON_BODY',
           message: 'Body cannot be empty when content-type is set to \'application/json\'',

package/test/hooks-async.test.js

@@ -2,7 +2,6 @@
 
 const { Readable } = require('node:stream')
 const { test, describe } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('../fastify')
 const fs = require('node:fs')
 const { sleep } = require('./helper')
@@ -10,8 +9,8 @@ const { waitForCb } = require('./toolkit')
 
 process.removeAllListeners('warning')
 
-test('async hooks', t => {
-  t.plan(21)
+test('async hooks', async t => {
+  t.plan(20)
   const fastify = Fastify({ exposeHeadRoutes: false })
   fastify.addHook('onRequest', async function (request, reply) {
     await sleep(1)
@@ -59,37 +58,32 @@ test('async hooks', t => {
     reply.code(200).send({ hello: 'world' })
   })
 
-  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: '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' })
-      completion.stepIn()
-    })
-    sget({
-      method: 'HEAD',
-      url: 'http://localhost:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      completion.stepIn()
-    })
-    sget({
-      method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      completion.stepIn()
-    })
+  const response1 = await fetch(fastifyServer, {
+    method: 'GET'
+  })
+  t.assert.ok(response1.ok)
+  t.assert.strictEqual(response1.status, 200)
+  const body1 = await response1.text()
+  t.assert.strictEqual(response1.headers.get('content-length'), '' + body1.length)
+  t.assert.deepStrictEqual(JSON.parse(body1), { hello: 'world' })
+  completion.stepIn()
+
+  const response2 = await fetch(fastifyServer, {
+    method: 'HEAD'
+  })
+  t.assert.ok(!response2.ok)
+  t.assert.strictEqual(response2.status, 500)
+  completion.stepIn()
+
+  const response3 = await fetch(fastifyServer, {
+    method: 'DELETE'
   })
+  t.assert.ok(!response3.ok)
+  t.assert.strictEqual(response3.status, 500)
+  completion.stepIn()
 
   return completion.patience
 })