fastify 5.3.3 → 5.5.0

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/http-methods/unlock.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('UNLOCK')
 
@@ -22,21 +21,18 @@ test('can be created - unlock', t => {
 })
 
 test('unlock test', async t => {
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
   t.after(() => { fastify.close() })
-  await t.test('request - unlock', (t, done) => {
+  await t.test('request - unlock', async t => {
     t.plan(2)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
       method: 'UNLOCK',
       headers: {
         'Lock-Token': 'urn:uuid:a515cfa4-5da4-22e1-f5b5-00a0451e6bf7'
       }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 204)
-      done()
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 204)
   })
 })

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() })
 

package/test/http2/secure-with-fallback.test.js

@@ -3,10 +3,10 @@
 const { test } = require('node:test')
 const Fastify = require('../..')
 const h2url = require('h2url')
-const sget = require('simple-get').concat
 const msg = { hello: 'world' }
 
 const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
 test.before(buildCertificate)
 
 test('secure with fallback', async (t) => {
@@ -39,14 +39,14 @@ test('secure with fallback', async (t) => {
     throw new Error('kaboom')
   })
 
-  t.after(() => { fastify.close() })
+  t.after(() => fastify.close())
 
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
   await t.test('https get error', async (t) => {
     t.plan(1)
 
-    const url = `https://localhost:${fastify.server.address().port}/error`
+    const url = `${fastifyServer}/error`
     const res = await h2url.concat({ url })
 
     t.assert.strictEqual(res.headers[':status'], 500)
@@ -55,9 +55,8 @@ test('secure with fallback', async (t) => {
   await t.test('https post', async (t) => {
     t.plan(2)
 
-    const url = `https://localhost:${fastify.server.address().port}`
     const res = await h2url.concat({
-      url,
+      url: fastifyServer,
       method: 'POST',
       body: JSON.stringify({ hello: 'http2' }),
       headers: {
@@ -72,39 +71,43 @@ test('secure with fallback', async (t) => {
   await t.test('https get request', async (t) => {
     t.plan(3)
 
-    const url = `https://localhost:${fastify.server.address().port}`
-    const res = await h2url.concat({ url })
+    const res = await h2url.concat({ url: fastifyServer })
 
     t.assert.strictEqual(res.headers[':status'], 200)
     t.assert.strictEqual(res.headers['content-length'], '' + JSON.stringify(msg).length)
     t.assert.deepStrictEqual(JSON.parse(res.body), msg)
   })
 
-  await t.test('http1 get request', (t, done) => {
+  await t.test('http1 get request', async t => {
     t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (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(fastifyServer, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+
+    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), msg)
   })
 
-  await t.test('http1 get error', (t, done) => {
+  await t.test('http1 get error', async t => {
     t.plan(2)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port + '/error',
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      done()
+
+    const result = await fetch(`${fastifyServer}/error`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 500)
   })
 })

package/test/https/custom-https-server.test.js

@@ -4,8 +4,8 @@ const { test } = require('node:test')
 const Fastify = require('../..')
 const https = require('node:https')
 const dns = require('node:dns').promises
-const sget = require('simple-get').concat
 const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
 
 async function setup () {
   await buildCertificate()
@@ -13,7 +13,7 @@ async function setup () {
   const localAddresses = await dns.lookup('localhost', { all: true })
 
   test('Should support a custom https server', { skip: localAddresses.length < 1 }, async t => {
-    t.plan(4)
+    t.plan(5)
 
     const fastify = Fastify({
       serverFactory: (handler, opts) => {
@@ -42,20 +42,16 @@ async function setup () {
 
     await fastify.listen({ port: 0 })
 
-    await new Promise((resolve, reject) => {
-      sget({
-        method: 'GET',
-        url: 'https://localhost:' + fastify.server.address().port,
-        rejectUnauthorized: false
-      }, (err, response, body) => {
-        if (err) {
-          return reject(err)
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
         }
-        t.assert.strictEqual(response.statusCode, 200)
-        t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-        resolve()
       })
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
   })
 }
 

package/test/https/https.test.js

@@ -1,10 +1,11 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
+const { request } = require('undici')
 const Fastify = require('../..')
 
 const { buildCertificate } = require('../build-certificate')
+const { Agent } = require('undici')
 test.before(buildCertificate)
 
 test('https', async (t) => {
@@ -35,43 +36,45 @@ test('https', async (t) => {
 
   t.after(() => { fastify.close() })
 
-  await t.test('https get request', (t, done) => {
+  await t.test('https get request', async t => {
     t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (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('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+    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)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  await t.test('https get request without trust proxy - protocol', (t, done) => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port + '/proto',
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(JSON.parse(body), { proto: 'https' })
+  await t.test('https get request without trust proxy - protocol', async t => {
+    t.plan(3)
+    const result1 = await fetch(`${'https://localhost:' + fastify.server.address().port}/proto`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port + '/proto',
-      rejectUnauthorized: false,
+    t.assert.ok(result1.ok)
+    t.assert.deepStrictEqual(await result1.json(), { proto: 'https' })
+
+    const result2 = await fetch(`${'https://localhost:' + fastify.server.address().port}/proto`, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      }),
       headers: {
         'x-forwarded-proto': 'lorem'
       }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.deepStrictEqual(JSON.parse(body), { proto: 'https' })
-      done()
     })
+    t.assert.deepStrictEqual(await result2.json(), { proto: 'https' })
   })
 })
 
@@ -98,36 +101,36 @@ test('https - headers', async (t) => {
 
   await fastify.listen({ port: 0 })
 
-  await t.test('https get request', (t, done) => {
-    t.plan(4)
-    sget({
-      method: 'GET',
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (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(parsedBody.port, fastify.server.address().port)
-      done()
+  await t.test('https get request', async t => {
+    t.plan(3)
+    const result = await fetch('https://localhost:' + fastify.server.address().port, {
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.deepStrictEqual(await result.json(), { hostname: 'localhost', port: fastify.server.address().port, hello: 'world' })
   })
-  await t.test('https get request - test port fall back', (t, done) => {
-    t.plan(3)
-    sget({
+
+  await t.test('https get request - test port fall back', async t => {
+    t.plan(2)
+
+    const result = await request('https://localhost:' + fastify.server.address().port, {
       method: 'GET',
       headers: {
         host: 'example.com'
       },
-      url: 'https://localhost:' + fastify.server.address().port,
-      rejectUnauthorized: false
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      const parsedBody = JSON.parse(body)
-      t.assert.strictEqual(parsedBody.port, null)
-      done()
+      dispatcher: new Agent({
+        connect: {
+          rejectUnauthorized: false
+        }
+      })
     })
+
+    t.assert.strictEqual(result.statusCode, 200)
+    t.assert.deepStrictEqual(await result.body.json(), { hello: 'world', hostname: 'example.com', port: null })
   })
 })