fastify 5.3.3 → 5.4.0

package/test/nullable-validation.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const Fastify = require('..')
 
 test('nullable string', (t, done) => {
@@ -52,8 +51,8 @@ test('nullable string', (t, done) => {
   })
 })
 
-test('object or null body', (t, done) => {
-  t.plan(5)
+test('object or null body', async (t) => {
+  t.plan(4)
 
   const fastify = Fastify()
 
@@ -88,24 +87,20 @@ test('object or null body', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    t.after(() => { fastify.close() })
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { isUndefinedBody: true })
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST'
   })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { isUndefinedBody: true })
 })
 
-test('nullable body', (t, done) => {
-  t.plan(5)
+test('nullable body', async (t) => {
+  t.plan(4)
 
   const fastify = Fastify()
 
@@ -141,24 +136,20 @@ test('nullable body', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 200)
-      t.assert.deepStrictEqual(JSON.parse(body), { isUndefinedBody: true })
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST'
   })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+  t.assert.deepStrictEqual(await result.json(), { isUndefinedBody: true })
 })
 
-test('Nullable body with 204', (t, done) => {
-  t.plan(5)
+test('Nullable body with 204', async (t) => {
+  t.plan(4)
 
   const fastify = Fastify()
 
@@ -183,18 +174,14 @@ test('Nullable body with 204', (t, done) => {
     }
   })
 
-  fastify.listen({ port: 0 }, (err) => {
-    t.assert.ifError(err)
-    t.after(() => fastify.close())
-
-    sget({
-      method: 'POST',
-      url: 'http://localhost:' + fastify.server.address().port
-    }, (err, response, body) => {
-      t.assert.ifError(err)
-      t.assert.strictEqual(response.statusCode, 204)
-      t.assert.strictEqual(body.length, 0)
-      done()
-    })
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST'
   })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 204)
+  t.assert.strictEqual((await result.text()).length, 0)
 })

package/test/output-validation.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test } = require('node:test')
-const sget = require('simple-get').concat
 const fastify = require('..')()
 
 const opts = {
@@ -90,37 +89,33 @@ test('unlisted response code', t => {
 })
 
 test('start server and run tests', async (t) => {
-  await fastify.listen({ port: 0 })
-  const baseUrl = 'http://localhost:' + fastify.server.address().port
+  const fastifyServer = await fastify.listen({ port: 0 })
   t.after(() => fastify.close())
 
-  function sgetAsync (opts) {
-    return new Promise((resolve, reject) => {
-      sget(opts, (err, res, body) => {
-        if (err) return reject(err)
-        resolve({ res, body })
-      })
-    })
-  }
-
   await test('shorthand - string get ok', async (t) => {
-    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/string` })
-    t.assert.strictEqual(res.statusCode, 200)
-    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    const result = await fetch(fastifyServer + '/string')
+    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 test('shorthand - number get ok', async (t) => {
-    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/number` })
-    t.assert.strictEqual(res.statusCode, 201)
-    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    const result = await fetch(fastifyServer + '/number')
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 201)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
     t.assert.deepStrictEqual(JSON.parse(body), { hello: 55 })
   })
 
   await test('shorthand - wrong-object-for-schema', async (t) => {
-    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/wrong-object-for-schema` })
-    t.assert.strictEqual(res.statusCode, 500)
-    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    const result = await fetch(fastifyServer + '/wrong-object-for-schema')
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 500)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
     t.assert.deepStrictEqual(JSON.parse(body), {
       statusCode: 500,
       error: 'Internal Server Error',
@@ -129,14 +124,17 @@ test('start server and run tests', async (t) => {
   })
 
   await test('shorthand - empty', async (t) => {
-    const { res } = await sgetAsync({ method: 'GET', url: `${baseUrl}/empty` })
-    t.assert.strictEqual(res.statusCode, 204)
+    const result = await fetch(fastifyServer + '/empty')
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 204)
   })
 
   await test('shorthand - 400', async (t) => {
-    const { res, body } = await sgetAsync({ method: 'GET', url: `${baseUrl}/400` })
-    t.assert.strictEqual(res.statusCode, 400)
-    t.assert.strictEqual(res.headers['content-length'], '' + body.length)
+    const result = await fetch(fastifyServer + '/400')
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 400)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
     t.assert.deepStrictEqual(JSON.parse(body), { hello: 'DOOM' })
   })
 })

package/test/plugin.2.test.js

@@ -1,36 +1,36 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../fastify')
 const sget = require('simple-get').concat
 const fp = require('fastify-plugin')
+const { waitForCb } = require('./toolkit')
 
-test('check dependencies - should not throw', t => {
+test('check dependencies - should not throw', (t, testDone) => {
   t.plan(12)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.register(fp((i, o, n) => {
       i.decorate('test', () => {})
-      t.ok(i.test)
+      t.assert.ok(i.test)
       n()
     }))
 
     instance.register(fp((i, o, n) => {
       try {
         i.decorate('otherTest', () => {}, ['test'])
-        t.ok(i.test)
-        t.ok(i.otherTest)
+        t.assert.ok(i.test)
+        t.assert.ok(i.otherTest)
         n()
       } catch (e) {
-        t.fail()
+        t.assert.fail()
       }
     }))
 
     instance.get('/', (req, reply) => {
-      t.ok(instance.test)
-      t.ok(instance.otherTest)
+      t.assert.ok(instance.test)
+      t.assert.ok(instance.otherTest)
       reply.send({ hello: 'world' })
     })
 
@@ -38,27 +38,28 @@ test('check dependencies - should not throw', t => {
   })
 
   fastify.ready(() => {
-    t.notOk(fastify.test)
-    t.notOk(fastify.otherTest)
+    t.assert.ok(!fastify.test)
+    t.assert.ok(!fastify.otherTest)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
+      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' })
+      testDone()
     })
   })
 })
 
-test('check dependencies - should throw', t => {
+test('check dependencies - should throw', (t, testDone) => {
   t.plan(12)
   const fastify = Fastify()
 
@@ -66,24 +67,24 @@ test('check dependencies - should throw', t => {
     instance.register(fp((i, o, n) => {
       try {
         i.decorate('otherTest', () => {}, ['test'])
-        t.fail()
+        t.assert.fail()
       } catch (e) {
-        t.equal(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
-        t.equal(e.message, 'The decorator is missing dependency \'test\'.')
+        t.assert.strictEqual(e.code, 'FST_ERR_DEC_MISSING_DEPENDENCY')
+        t.assert.strictEqual(e.message, 'The decorator is missing dependency \'test\'.')
       }
       n()
     }))
 
     instance.register(fp((i, o, n) => {
       i.decorate('test', () => {})
-      t.ok(i.test)
-      t.notOk(i.otherTest)
+      t.assert.ok(i.test)
+      t.assert.ok(!i.otherTest)
       n()
     }))
 
     instance.get('/', (req, reply) => {
-      t.ok(instance.test)
-      t.notOk(instance.otherTest)
+      t.assert.ok(instance.test)
+      t.assert.ok(!instance.otherTest)
       reply.send({ hello: 'world' })
     })
 
@@ -91,183 +92,192 @@ test('check dependencies - should throw', t => {
   })
 
   fastify.ready(() => {
-    t.notOk(fastify.test)
+    t.assert.ok(!fastify.test)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { hello: 'world' })
+      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' })
+      testDone()
     })
   })
 })
 
-test('set the plugin name based on the plugin displayName symbol', t => {
+test('set the plugin name based on the plugin displayName symbol', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.register(fp((fastify, opts, done) => {
-    t.equal(fastify.pluginName, 'fastify -> plugin-A')
+    t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A')
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
       done()
     }, { name: 'plugin-AB' }))
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
       done()
     }, { name: 'plugin-AC' }))
     done()
   }, { name: 'plugin-A' }))
 
   fastify.register(fp((fastify, opts, done) => {
-    t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC -> plugin-B')
+    t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC -> plugin-B')
     done()
   }, { name: 'plugin-B' }))
 
-  t.equal(fastify.pluginName, 'fastify')
+  t.assert.strictEqual(fastify.pluginName, 'fastify')
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('plugin name will change when using no encapsulation', t => {
+test('plugin name will change when using no encapsulation', (t, testDone) => {
   t.plan(6)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.register(fp((fastify, opts, done) => {
     // store it in a different variable will hold the correct name
     const pluginName = fastify.pluginName
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB')
       done()
     }, { name: 'plugin-AB' }))
     fastify.register(fp((fastify, opts, done) => {
-      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
       done()
     }, { name: 'plugin-AC' }))
     setImmediate(() => {
       // normally we would expect the name plugin-A
       // but we operate on the same instance in each plugin
-      t.equal(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
-      t.equal(pluginName, 'fastify -> plugin-A')
+      t.assert.strictEqual(fastify.pluginName, 'fastify -> plugin-A -> plugin-AB -> plugin-AC')
+      t.assert.strictEqual(pluginName, 'fastify -> plugin-A')
     })
     done()
   }, { name: 'plugin-A' }))
 
-  t.equal(fastify.pluginName, 'fastify')
+  t.assert.strictEqual(fastify.pluginName, 'fastify')
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('plugin name is undefined when accessing in no plugin context', t => {
+test('plugin name is undefined when accessing in no plugin context', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
-  t.equal(fastify.pluginName, 'fastify')
+  t.assert.strictEqual(fastify.pluginName, 'fastify')
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('set the plugin name based on the plugin function name', t => {
+test('set the plugin name based on the plugin function name', (t, testDone) => {
   t.plan(5)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.register(function myPluginA (fastify, opts, done) {
-    t.equal(fastify.pluginName, 'myPluginA')
+    t.assert.strictEqual(fastify.pluginName, 'myPluginA')
     fastify.register(function myPluginAB (fastify, opts, done) {
-      t.equal(fastify.pluginName, 'myPluginAB')
+      t.assert.strictEqual(fastify.pluginName, 'myPluginAB')
       done()
     })
     setImmediate(() => {
       // exact name due to encapsulation
-      t.equal(fastify.pluginName, 'myPluginA')
+      t.assert.strictEqual(fastify.pluginName, 'myPluginA')
     })
     done()
   })
 
   fastify.register(function myPluginB (fastify, opts, done) {
-    t.equal(fastify.pluginName, 'myPluginB')
+    t.assert.strictEqual(fastify.pluginName, 'myPluginB')
     done()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('approximate a plugin name when no meta data is available', t => {
+test('approximate a plugin name when no meta data is available', (t, testDone) => {
   t.plan(7)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.register((fastify, opts, done) => {
     // A
-    t.equal(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
-    t.equal(fastify.pluginName.includes('// A'), true)
+    t.assert.strictEqual(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
+    t.assert.strictEqual(fastify.pluginName.includes('// A'), true)
     fastify.register((fastify, opts, done) => {
       // B
-      t.equal(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
-      t.equal(fastify.pluginName.includes('// B'), true)
+      t.assert.strictEqual(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
+      t.assert.strictEqual(fastify.pluginName.includes('// B'), true)
       done()
     })
     setImmediate(() => {
-      t.equal(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
-      t.equal(fastify.pluginName.includes('// A'), true)
+      t.assert.strictEqual(fastify.pluginName.startsWith('(fastify, opts, done)'), true)
+      t.assert.strictEqual(fastify.pluginName.includes('// A'), true)
     })
     done()
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('approximate a plugin name also when fastify-plugin has no meta data', t => {
+test('approximate a plugin name also when fastify-plugin has no meta data', (t, testDone) => {
   t.plan(4)
   const fastify = Fastify()
+  t.after(() => fastify.close())
+
   // plugin name is got from current file name
   const pluginName = /plugin\.2\.test/
   const pluginNameWithFunction = /plugin\.2\.test-auto-\d+ -> B/
 
   fastify.register(fp((fastify, opts, done) => {
-    t.match(fastify.pluginName, pluginName)
+    t.assert.match(fastify.pluginName, pluginName)
     fastify.register(fp(function B (fastify, opts, done) {
       // function has name
-      t.match(fastify.pluginName, pluginNameWithFunction)
+      t.assert.match(fastify.pluginName, pluginNameWithFunction)
       done()
     }))
     setImmediate(() => {
-      t.match(fastify.pluginName, pluginNameWithFunction)
+      t.assert.match(fastify.pluginName, pluginNameWithFunction)
     })
     done()
   }))
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    testDone()
   })
 })
 
-test('plugin encapsulation', t => {
+test('plugin encapsulation', (t, testDone) => {
   t.plan(10)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   fastify.register((instance, opts, done) => {
     instance.register(fp((i, o, n) => {
@@ -296,31 +306,39 @@ test('plugin encapsulation', t => {
   })
 
   fastify.ready(() => {
-    t.notOk(fastify.test)
+    t.assert.ok(!fastify.test)
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
+
+    const completion = waitForCb({
+      steps: 2
+    })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/first'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { plugin: 'first' })
+      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), { plugin: 'first' })
+      completion.stepIn()
     })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/second'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { plugin: 'second' })
+      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), { plugin: 'second' })
+      completion.stepIn()
     })
+
+    completion.patience.then(testDone)
   })
 })