fastify 5.4.0 → 5.6.0

package/test/http-methods/mkcalendar.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('MKCALENDAR', { hasBody: true })
 
@@ -78,93 +77,67 @@ test('can be created - mkcalendar', (t) => {
 })
 
 test('mkcalendar test', async t => {
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
   t.after(() => {
     fastify.close()
   })
 
-  await t.test('request - mkcalendar', (t, done) => {
-    t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/`,
-        method: 'MKCALENDAR'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 207)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+  await t.test('request - mkcalendar', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/`, {
+      method: 'MKCALENDAR'
+    })
+    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 other path - mkcalendar', (t, done) => {
-    t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        method: 'MKCALENDAR'
-      },
-      (err, response, body) => {
-        t.assert.ifError(err)
-        t.assert.strictEqual(response.statusCode, 207)
-        t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-        done()
-      }
-    )
+  await t.test('request with other path - mkcalendar', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR'
+    })
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.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 - mkcalendar', (t, done) => {
+  await t.test('request with body - mkcalendar', async t => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        headers: { 'content-type': 'text/plain' },
-        body: bodySample,
-        method: 'MKCALENDAR'
-      },
-      (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(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR',
+      headers: { 'content-type': 'text/plain' },
+      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) - mkcalendar', (t, done) => {
+  await t.test('request with body and no content type (415 error) - mkcalendar', async t => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        body: bodySample,
-        method: 'MKCALENDAR'
-      },
-      (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(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR',
+      body: bodySample,
+      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 - mkcalendar', (t, done) => {
+  await t.test('request without body - mkcalendar', async t => {
     t.plan(3)
-    sget(
-      {
-        url: `http://localhost:${fastify.server.address().port}/test`,
-        method: 'MKCALENDAR'
-      },
-      (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(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR'
+    })
+    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/move.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../')()
 fastify.addHttpMethod('MOVE')
 
@@ -24,23 +23,20 @@ test('shorthand - move', t => {
   }
 })
 test('move test', async t => {
-  await fastify.listen({ port: 0 })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
   t.after(() => { fastify.close() })
 
-  await t.test('request - move', (t, done) => {
+  await t.test('request - move', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+    const result = await fetch(`${fastifyServer}/test.txt`, {
       method: 'MOVE',
       headers: {
         Destination: '/test2.txt'
       }
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 201)
-      t.assert.strictEqual(response.headers.location, '/test2.txt')
-      done()
     })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 201)
+    t.assert.strictEqual(result.headers.get('location'), '/test2.txt')
   })
 })

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('../../')()
 fastify.addHttpMethod('PROPFIND', { hasBody: true })
 
@@ -74,73 +73,64 @@ test('propfind test', async t => {
     fastify.close()
   })
 
-  await t.test('request - propfind', (t, done) => {
+  await t.test('request - propfind', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/`,
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/`, {
       method: 'PROPFIND'
-    }, (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)
   })
 
-  await t.test('request with other path - propfind', (t, done) => {
+  await t.test('request with other path - propfind', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test`,
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
       method: 'PROPFIND'
-    }, (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)
   })
 
   // 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 - propfind', (t, done) => {
+  await t.test('request with body - propfind', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test`,
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'PROPFIND',
       headers: { 'content-type': 'text/plain' },
-      body: bodySample,
-      method: 'PROPFIND'
-    }, (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) - propfind', (t, done) => {
+  await t.test('request with body and no content type (415 error) - propfind', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test`,
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'PROPFIND',
       body: bodySample,
-      method: 'PROPFIND'
-    }, (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': '' }
     })
+    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 - propfind', (t, done) => {
+  await t.test('request without body - propfind', async t => {
     t.plan(3)
-    sget({
-      url: `http://localhost:${fastify.server.address().port}/test`,
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
       method: 'PROPFIND'
-    }, (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/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/secure-with-fallback.test.js

@@ -39,7 +39,7 @@ test('secure with fallback', async (t) => {
     throw new Error('kaboom')
   })
 
-  t.after(() => { fastify.close() })
+  t.after(() => fastify.close())
 
   const fastifyServer = await fastify.listen({ port: 0 })
 
@@ -80,6 +80,7 @@ test('secure with fallback', async (t) => {
 
   await t.test('http1 get request', async t => {
     t.plan(4)
+
     const result = await fetch(fastifyServer, {
       dispatcher: new Agent({
         connect: {
@@ -97,6 +98,7 @@ test('secure with fallback', async (t) => {
 
   await t.test('http1 get error', async t => {
     t.plan(2)
+
     const result = await fetch(`${fastifyServer}/error`, {
       dispatcher: new Agent({
         connect: {

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