fastify 5.3.3 → 5.5.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/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/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/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/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)
   })
 })