fastify 5.3.2 → 5.4.0

package/test/http-methods/lock.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('LOCK', { hasBody: true })
 
@@ -57,52 +56,53 @@ test('can be created - lock', t => {
 })
 
 test('lock test', async t => {
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
   t.after(() => {
     fastify.close()
   })
   // the body test uses a text/plain content type instead of application/xml because it requires
   // a specific content type parser
-  await t.test('request with body - lock', (t, done) => {
+  await t.test('request with body - lock', async (t) => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'LOCK',
       headers: { 'content-type': 'text/plain' },
-      body: bodySample,
-      method: 'LOCK'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      done()
+      body: bodySample
     })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
   })
 
-  await t.test('request with body and no content type (415 error) - lock', (t, done) => {
+  await t.test('request with body and no content type (415 error) - lock', async (t) => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'LOCK',
       body: bodySample,
-      method: 'LOCK'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 415)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      done()
+      headers: { 'content-type': undefined }
     })
+
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 415)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
   })
 
-  await t.test('request without body - lock', (t, done) => {
+  await t.test('request without body - lock', async (t) => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
-      headers: { 'content-type': 'text/plain' },
-      method: 'LOCK'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      done()
+
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'LOCK',
+      headers: { 'content-type': 'text/plain' }
     })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
   })
 })

package/test/http-methods/mkcol.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../')()
 fastify.addHttpMethod('MKCOL')
 
@@ -22,18 +21,15 @@ test('can be created - mkcol', t => {
 })
 
 test('mkcol test', async t => {
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
   t.after(() => { fastify.close() })
 
-  await t.test('request - mkcol', (t, done) => {
+  await t.test('request - mkcol', async t => {
     t.plan(2)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/`,
+    const result = await fetch(`${fastifyServer}/test/`, {
       method: 'MKCOL'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 201)
-      done()
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 201)
   })
 })

package/test/http-methods/proppatch.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../')()
 fastify.addHttpMethod('PROPPATCH', { hasBody: true })
 
@@ -62,50 +61,45 @@ test('shorthand - proppatch', t => {
 })
 
 test('proppatch test', async t => {
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
   t.after(() => { fastify.close() })
   // the body test uses a text/plain content type instead of application/xml because it requires
   // a specific content type parser
-  await t.test('request with body - proppatch', (t, done) => {
+  await t.test('request with body - proppatch', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'PROPPATCH',
       headers: { 'content-type': 'text/plain' },
-      body: bodySample,
-      method: 'PROPPATCH'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 207)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      done()
+      body: bodySample
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
   })
 
-  await t.test('request with body and no content type (415 error) - proppatch', (t, done) => {
+  await t.test('request with body and no content type (415 error) - proppatch', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'PROPPATCH',
       body: bodySample,
-      method: 'PROPPATCH'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 415)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      done()
+      headers: { 'content-type': undefined }
     })
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 415)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
   })
 
-  await t.test('request without body - proppatch', (t, done) => {
+  await t.test('request without body - proppatch', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
       method: 'PROPPATCH'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 207)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      done()
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
   })
 })

package/test/http-methods/report.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('REPORT', { hasBody: true })
 
@@ -80,88 +79,64 @@ test('report test', async t => {
     fastify.close()
   })
 
-  await t.test('request - report', (t, done) => {
+  await t.test('request - report', async (t) => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/`,
-        method: 'REPORT'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 207)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/`, {
+      method: 'REPORT'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
   })
 
-  await t.test('request with other path - report', (t, done) => {
+  await t.test('request with other path - report', async (t) => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        method: 'REPORT'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 207)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
   })
 
   // the body test uses a text/plain content type instead of application/xml because it requires
   // a specific content type parser
-  await t.test('request with body - report', (t, done) => {
+  await t.test('request with body - report', async (t) => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        headers: { 'content-type': 'text/plain' },
-        body: bodySample,
-        method: 'REPORT'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 207)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT',
+      headers: { 'content-type': 'text/plain' },
+      body: bodySample
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
   })
 
-  await t.test('request with body and no content type (415 error) - report', (t, done) => {
+  await t.test('request with body and no content type (415 error) - report', async (t) => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        body: bodySample,
-        method: 'REPORT'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 415)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT',
+      body: bodySample,
+      headers: { 'content-type': '' }
+    })
+
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 415)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
   })
 
-  await t.test('request without body - report', (t, done) => {
+  await t.test('request without body - report', async (t) => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        method: 'REPORT'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 207)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
   })
 })

package/test/http-methods/search.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../fastify')()
 fastify.addHttpMethod('SEARCH', { hasBody: true })
 
@@ -130,119 +129,105 @@ test('search test', async t => {
   t.after(() => { fastify.close() })
   const url = `http://localhost:${fastify.server.address().port}`
 
-  await t.test('request - search', (t, done) => {
+  await t.test('request - search', async t => {
     t.plan(4)
-    sget({
-      method: 'SEARCH',
-      url
-    }, (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' })
-      done()
+    const result = await fetch(url, {
+      method: 'SEARCH'
     })
+    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' })
   })
 
-  await t.test('request search params schema', (t, done) => {
+  await t.test('request search params schema', async t => {
     t.plan(4)
-    sget({
-      method: 'SEARCH',
-      url: `${url}/params/world/123`
-    }, (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), { foo: 'world', test: 123 })
-      done()
+    const result = await fetch(`${url}/params/world/123`, {
+      method: 'SEARCH'
     })
+    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), { foo: 'world', test: 123 })
   })
 
-  await t.test('request search params schema error', (t, done) => {
+  await t.test('request search params schema error', async t => {
     t.plan(3)
-    sget({
-      method: 'SEARCH',
-      url: `${url}/params/world/string`
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 400)
-      t.assert.deepStrictEqual(JSON.parse(body), {
-        error: 'Bad Request',
-        code: 'FST_ERR_VALIDATION',
-        message: 'params/test must be integer',
-        statusCode: 400
-      })
-      done()
+    const result = await fetch(`${url}/params/world/string`, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.strictEqual(result.status, 400)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'params/test must be integer',
+      statusCode: 400
     })
   })
 
-  await t.test('request search querystring schema', (t, done) => {
+  await t.test('request search querystring schema', async t => {
     t.plan(4)
-    sget({
-      method: 'SEARCH',
-      url: `${url}/query?hello=123`
-    }, (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: 123 })
-      done()
+    const result = await fetch(`${url}/query?hello=123`, {
+      method: 'SEARCH'
     })
+    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: 123 })
   })
 
-  await t.test('request search querystring schema error', (t, done) => {
+  await t.test('request search querystring schema error', async t => {
     t.plan(3)
-    sget({
-      method: 'SEARCH',
-      url: `${url}/query?hello=world`
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 400)
-      t.assert.deepStrictEqual(JSON.parse(body), {
-        error: 'Bad Request',
-        code: 'FST_ERR_VALIDATION',
-        message: 'querystring/hello must be integer',
-        statusCode: 400
-      })
-      done()
+    const result = await fetch(`${url}/query?hello=world`, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.strictEqual(result.status, 400)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'querystring/hello must be integer',
+      statusCode: 400
     })
   })
 
-  await t.test('request search body schema', (t, done) => {
+  await t.test('request search body schema', async t => {
     t.plan(4)
     const replyBody = { foo: 'bar', test: 5 }
-    sget({
+    const result = await fetch(`${url}/body`, {
       method: 'SEARCH',
-      url: `${url}/body`,
       body: JSON.stringify(replyBody),
       headers: { 'content-type': 'application/json' }
-    }, (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), replyBody)
-      done()
     })
+    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), replyBody)
   })
 
-  await t.test('request search body schema error', (t, done) => {
+  await t.test('request search body schema error', async t => {
     t.plan(4)
-    sget({
+    const result = await fetch(`${url}/body`, {
       method: 'SEARCH',
-      url: `${url}/body`,
       body: JSON.stringify({ foo: 'bar', test: 'test' }),
       headers: { 'content-type': 'application/json' }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 400)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      t.assert.deepStrictEqual(JSON.parse(body), {
-        error: 'Bad Request',
-        code: 'FST_ERR_VALIDATION',
-        message: 'body/test must be integer',
-        statusCode: 400
-      })
-      done()
+    })
+    const body = await result.text()
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 400)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'body/test must be integer',
+      statusCode: 400
     })
   })
 })

package/test/http2/closing.test.js

@@ -11,16 +11,13 @@ const { getServerUrl } = require('../helper')
 
 test.before(buildCertificate)
 
-test('http/2 request while fastify closing', (t, done) => {
-  let fastify
-  try {
-    fastify = Fastify({
-      http2: true
-    })
-    t.assert.ok('http2 successfully loaded')
-  } catch (e) {
-    t.assert.fail('http2 loading failed')
-  }
+const isNode24OrGreater = Number(process.versions.node.split('.')[0]) >= 24
+
+test('http/2 request while fastify closing Node <24', { skip: isNode24OrGreater }, (t, done) => {
+  const fastify = Fastify({
+    http2: true
+  })
+  t.assert.ok('http2 successfully loaded')
 
   fastify.get('/', () => Promise.resolve({}))
 
@@ -53,17 +50,38 @@ test('http/2 request while fastify closing', (t, done) => {
   })
 })
 
-test('http/2 request while fastify closing - return503OnClosing: false', (t, done) => {
-  let fastify
-  try {
-    fastify = Fastify({
-      http2: true,
-      return503OnClosing: false
+test('http/2 request while fastify closing Node >=24', { skip: !isNode24OrGreater }, (t, done) => {
+  const fastify = Fastify({
+    http2: true
+  })
+  t.assert.ok('http2 successfully loaded')
+
+  fastify.get('/', () => Promise.resolve({}))
+
+  t.after(() => { fastify.close() })
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+
+    const url = getServerUrl(fastify)
+    const session = http2.connect(url, function () {
+      session.on('error', () => {
+        // Nothing to do here,
+        // we are not interested in this error that might
+        // happen or not
+      })
+      session.on('close', () => {
+        done()
+      })
+      fastify.close()
     })
-    t.assert.ok('http2 successfully loaded')
-  } catch (e) {
-    t.assert.fail('http2 loading failed')
-  }
+  })
+})
+
+test('http/2 request while fastify closing - return503OnClosing: false', { skip: isNode24OrGreater }, (t, done) => {
+  const fastify = Fastify({
+    http2: true,
+    return503OnClosing: false
+  })
 
   t.after(() => { fastify.close() })