fastify 5.3.3 → 5.5.0

package/test/delete.test.js

@@ -1,8 +1,6 @@
 'use strict'
 
-const assert = require('node:assert')
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('..')()
 
 const schema = {
@@ -159,155 +157,148 @@ test('body - delete', t => {
   }
 })
 
-fastify.listen({ port: 0 }, err => {
-  assert.ifError(err)
-  test.after(() => { fastify.close() })
+test('delete tests', async t => {
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-  test('shorthand - request delete', (t, done) => {
+  await t.test('shorthand - request delete', async t => {
     t.plan(4)
-    sget({
-      method: 'DELETE',
-      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' })
-      done()
+
+    const response = await fetch(fastifyServer, {
+      method: 'DELETE'
     })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.strictEqual(response.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  test('shorthand - request delete params schema', (t, done) => {
+  await t.test('shorthand - request delete params schema', async t => {
     t.plan(4)
-    sget({
-      method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port + '/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 response = await fetch(fastifyServer + '/params/world/123', {
+      method: 'DELETE'
     })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.strictEqual(response.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { foo: 'world', test: 123 })
   })
 
-  test('shorthand - request delete params schema error', (t, done) => {
+  await t.test('shorthand - request delete params schema error', async t => {
     t.plan(3)
-    sget({
-      method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port + '/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 response = await fetch(fastifyServer + '/params/world/string', {
+      method: 'DELETE'
+    })
+
+    t.assert.ok(!response.ok)
+    t.assert.strictEqual(response.status, 400)
+    t.assert.deepStrictEqual(await response.json(), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'params/test must be integer',
+      statusCode: 400
     })
   })
 
-  test('shorthand - request delete headers schema', (t, done) => {
+  await t.test('shorthand - request delete headers schema', async t => {
     t.plan(4)
-    sget({
+
+    const response = await fetch(fastifyServer + '/headers', {
       method: 'DELETE',
       headers: {
-        'x-test': 1
-      },
-      url: 'http://localhost:' + fastify.server.address().port + '/headers'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.strictEqual(response.headers['content-length'], '' + body.length)
-      t.assert.strictEqual(JSON.parse(body)['x-test'], 1)
-      done()
+        'x-test': '1'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.strictEqual(response.headers.get('content-length'), '' + body.length)
+    t.assert.strictEqual(JSON.parse(body)['x-test'], 1)
   })
 
-  test('shorthand - request delete headers schema error', (t, done) => {
+  await t.test('shorthand - request delete headers schema error', async t => {
     t.plan(3)
-    sget({
+
+    const response = await fetch(fastifyServer + '/headers', {
       method: 'DELETE',
       headers: {
         'x-test': 'abc'
-      },
-      url: 'http://localhost:' + fastify.server.address().port + '/headers'
-    }, (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: 'headers/x-test must be number',
-        statusCode: 400
-      })
-      done()
+      }
+    })
+
+    t.assert.ok(!response.ok)
+    t.assert.strictEqual(response.status, 400)
+    const body = await response.text()
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'headers/x-test must be number',
+      statusCode: 400
     })
   })
 
-  test('shorthand - request delete querystring schema', (t, done) => {
+  await t.test('shorthand - request delete querystring schema', async t => {
     t.plan(4)
-    sget({
-      method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port + '/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 response = await fetch(fastifyServer + '/query?hello=123', {
+      method: 'DELETE'
     })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.strictEqual(response.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 123 })
   })
 
-  test('shorthand - request delete querystring schema error', (t, done) => {
+  await t.test('shorthand - request delete querystring schema error', async t => {
     t.plan(3)
-    sget({
-      method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port + '/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 response = await fetch(fastifyServer + '/query?hello=world', {
+      method: 'DELETE'
+    })
+
+    t.assert.ok(!response.ok)
+    t.assert.strictEqual(response.status, 400)
+    const body = await response.text()
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'querystring/hello must be integer',
+      statusCode: 400
     })
   })
 
-  test('shorthand - request delete missing schema', (t, done) => {
+  await t.test('shorthand - request delete missing schema', async t => {
     t.plan(4)
-    sget({
-      method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port + '/missing'
-    }, (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 response = await fetch(fastifyServer + '/missing', {
+      method: 'DELETE'
     })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.strictEqual(response.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
   })
 
-  test('shorthand - delete with body', (t, done) => {
+  await t.test('shorthand - delete with body', async t => {
     t.plan(3)
-    sget({
+
+    const response = await fetch(fastifyServer + '/body', {
       method: 'DELETE',
-      url: 'http://localhost:' + fastify.server.address().port + '/body',
-      body: {
-        hello: 'world'
-      },
-      json: true
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(body, { hello: 'world' })
-      done()
+      body: JSON.stringify({ hello: 'world' }),
+      headers: {
+        'Content-Type': 'application/json'
+      }
     })
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.json()
+    t.assert.deepStrictEqual(body, { hello: 'world' })
   })
 })
 

package/test/diagnostics-channel/404.test.js

@@ -2,13 +2,11 @@
 
 const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel sync events fire in expected order', (t, done) => {
+test('diagnostics channel sync events fire in expected order', async t => {
   t.plan(9)
   let callOrder = 0
   let firstEncounteredMessage
@@ -40,18 +38,12 @@ test('diagnostics channel sync events fire in expected order', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 404)
-      done()
-    })
+  const response = await fetch(fastifyServer, {
+    method: 'GET'
   })
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 404)
 })

package/test/diagnostics-channel/async-delay-request.test.js

@@ -2,13 +2,11 @@
 
 const diagnostics = require('node:diagnostics_channel')
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel async events fire in expected order', (t, done) => {
+test('diagnostics channel async events fire in expected order', async t => {
   t.plan(19)
   let callOrder = 0
   let firstEncounteredMessage
@@ -56,19 +54,12 @@ test('diagnostics channel async events fire in expected order', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  t.after(() => { fastify.close() })
 
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
-    })
-  })
+  const result = await fetch(fastifyServer + '/')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
 })

package/test/diagnostics-channel/async-request.test.js

@@ -2,13 +2,11 @@
 
 const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel async events fire in expected order', (t, done) => {
+test('diagnostics channel async events fire in expected order', async t => {
   t.plan(18)
   let callOrder = 0
   let firstEncounteredMessage
@@ -54,19 +52,13 @@ test('diagnostics channel async events fire in expected order', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    t.after(() => { fastify.close() })
+  t.after(() => { fastify.close() })
 
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
-    })
-  })
+  const response = await fetch(fastifyServer)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
 })

package/test/diagnostics-channel/error-request.test.js

@@ -2,13 +2,11 @@
 
 const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel events report on errors', (t, done) => {
+test('diagnostics channel events report on errors', async t => {
   t.plan(14)
   let callOrder = 0
   let firstEncounteredMessage
@@ -44,18 +42,12 @@ test('diagnostics channel events report on errors', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 500)
-      done()
-    })
+  const response = await fetch(fastifyServer, {
+    method: 'GET'
   })
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.status, 500)
 })

package/test/diagnostics-channel/sync-delay-request.test.js

@@ -2,13 +2,11 @@
 
 const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel sync events fire in expected order', (t, done) => {
+test('diagnostics channel sync events fire in expected order', async t => {
   t.plan(10)
   let callOrder = 0
   let firstEncounteredMessage
@@ -40,19 +38,12 @@ test('diagnostics channel sync events fire in expected order', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  t.after(() => { fastify.close() })
 
-    t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
-    })
-  })
+  const result = await fetch(fastifyServer + '/')
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { hello: 'world' })
 })

package/test/diagnostics-channel/sync-request-reply.test.js

@@ -2,13 +2,11 @@
 
 const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel sync events fire in expected order', (t, done) => {
+test('diagnostics channel sync events fire in expected order', async t => {
   t.plan(10)
   let callOrder = 0
   let firstEncounteredMessage
@@ -40,19 +38,14 @@ test('diagnostics channel sync events fire in expected order', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
-    })
+  const response = await fetch(fastifyServer, {
+    method: 'GET'
   })
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
 })

package/test/diagnostics-channel/sync-request.test.js

@@ -2,13 +2,11 @@
 
 const { test } = require('node:test')
 const diagnostics = require('node:diagnostics_channel')
-const sget = require('simple-get').concat
 const Fastify = require('../..')
-const { getServerUrl } = require('../helper')
 const Request = require('../../lib/request')
 const Reply = require('../../lib/reply')
 
-test('diagnostics channel sync events fire in expected order', (t, done) => {
+test('diagnostics channel sync events fire in expected order', async t => {
   t.plan(13)
   let callOrder = 0
   let firstEncounteredMessage
@@ -43,19 +41,14 @@ test('diagnostics channel sync events fire in expected order', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    if (err) t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
 
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'GET',
-      url: getServerUrl(fastify) + '/7'
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
-      done()
-    })
+  const response = await fetch(fastifyServer + '/7', {
+    method: 'GET'
   })
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
 })

package/test/fastify-instance.test.js

@@ -296,5 +296,5 @@ test('fastify instance should ensure ready promise cleanup on ready', async t =>
   t.plan(1)
   const fastify = Fastify()
   await fastify.ready()
-  t.assert.strictEqual(fastify[kState].readyPromise, null)
+  t.assert.strictEqual(fastify[kState].readyResolver, null)
 })

package/test/header-overflow.test.js

@@ -2,12 +2,11 @@
 
 const { test } = require('node:test')
 const Fastify = require('..')
-const sget = require('simple-get').concat
 
 const maxHeaderSize = 1024
 
-test('Should return 431 if request header fields are too large', (t, done) => {
-  t.plan(3)
+test('Should return 431 if request header fields are too large', async (t) => {
+  t.plan(2)
 
   const fastify = Fastify({ http: { maxHeaderSize } })
   fastify.route({
@@ -18,27 +17,23 @@ test('Should return 431 if request header fields are too large', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port,
-      headers: {
-        'Large-Header': 'a'.repeat(maxHeaderSize)
-      }
-    }, (err, res) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(res.statusCode, 431)
-      done()
-    })
+  const result = await fetch(fastifyServer, {
+    method: 'GET',
+    headers: {
+      'Large-Header': 'a'.repeat(maxHeaderSize)
+    }
   })
 
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 431)
+
   t.after(() => fastify.close())
 })
 
-test('Should return 431 if URI is too long', (t, done) => {
-  t.plan(3)
+test('Should return 431 if URI is too long', async (t) => {
+  t.plan(2)
 
   const fastify = Fastify({ http: { maxHeaderSize } })
   fastify.route({
@@ -49,18 +44,12 @@ test('Should return 431 if URI is too long', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, function (err) {
-    t.assert.ifError(err)
+  const fastifyServer = await fastify.listen({ port: 0 })
 
-    sget({
-      method: 'GET',
-      url: 'http://localhost:' + fastify.server.address().port + `/${'a'.repeat(maxHeaderSize)}`
-    }, (err, res) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(res.statusCode, 431)
-      done()
-    })
-  })
+  const result = await fetch(`${fastifyServer}/${'a'.repeat(maxHeaderSize)}`)
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 431)
 
   t.after(() => fastify.close())
 })