fastify 5.3.2 → 5.4.0

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

package/test/plugin.3.test.js

@@ -1,12 +1,12 @@
 '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('if a plugin raises an error and there is not a callback to handle it, the server must not start', t => {
+test('if a plugin raises an error and there is not a callback to handle it, the server must not start', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -15,14 +15,16 @@ test('if a plugin raises an error and there is not a callback to handle it, the
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.ok(err instanceof Error)
-    t.equal(err.message, 'err')
+    t.assert.ok(err instanceof Error)
+    t.assert.strictEqual(err.message, 'err')
+    testDone()
   })
 })
 
-test('add hooks after route declaration', t => {
+test('add hooks after route declaration', (t, testDone) => {
   t.plan(3)
   const fastify = Fastify()
+  t.after(() => fastify.close())
 
   function plugin (instance, opts, done) {
     instance.decorateRequest('check', null)
@@ -58,25 +60,25 @@ test('add hooks after route declaration', t => {
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port
     }, (err, response, body) => {
-      t.error(err)
-      t.same(JSON.parse(body), { hook1: true, hook2: true, hook3: true })
-      fastify.close()
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(JSON.parse(body), { hook1: true, hook2: true, hook3: true })
+      testDone()
     })
   })
 })
 
-test('nested plugins', t => {
+test('nested plugins', (t, testDone) => {
   t.plan(5)
 
   const fastify = Fastify()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.register(function (fastify, opts, done) {
     fastify.register((fastify, opts, done) => {
@@ -97,32 +99,39 @@ test('nested plugins', t => {
   }, { prefix: '/parent' })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+
+    const completion = waitForCb({
+      steps: 2
+    })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/parent/child1'
     }, (err, response, body) => {
-      t.error(err)
-      t.same(body.toString(), 'I am child 1')
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(body.toString(), 'I am child 1')
+      completion.stepIn()
     })
-
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/parent/child2'
     }, (err, response, body) => {
-      t.error(err)
-      t.same(body.toString(), 'I am child 2')
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(body.toString(), 'I am child 2')
+      completion.stepIn()
     })
+
+    completion.patience.then(testDone)
   })
 })
 
-test('nested plugins awaited', t => {
+test('nested plugins awaited', (t, testDone) => {
   t.plan(5)
 
   const fastify = Fastify()
 
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.register(async function wrap (fastify, opts) {
     await fastify.register(async function child1 (fastify, opts) {
@@ -139,27 +148,34 @@ test('nested plugins awaited', t => {
   }, { prefix: '/parent' })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
+
+    const completion = waitForCb({
+      steps: 2
+    })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/parent/child1'
     }, (err, response, body) => {
-      t.error(err)
-      t.same(body.toString(), 'I am child 1')
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(body.toString(), 'I am child 1')
+      completion.stepIn()
     })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/parent/child2'
     }, (err, response, body) => {
-      t.error(err)
-      t.same(body.toString(), 'I am child 2')
+      t.assert.ifError(err)
+      t.assert.deepStrictEqual(body.toString(), 'I am child 2')
+      completion.stepIn()
     })
+    completion.patience.then(testDone)
   })
 })
 
-test('plugin metadata - decorators', t => {
+test('plugin metadata - decorators', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -179,7 +195,8 @@ test('plugin metadata - decorators', t => {
   fastify.register(plugin)
 
   fastify.ready(() => {
-    t.ok(fastify.plugin)
+    t.assert.ok(fastify.plugin)
+    testDone()
   })
 
   function plugin (instance, opts, done) {
@@ -188,7 +205,7 @@ test('plugin metadata - decorators', t => {
   }
 })
 
-test('plugin metadata - decorators - should throw', t => {
+test('plugin metadata - decorators - should throw', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -206,7 +223,8 @@ test('plugin metadata - decorators - should throw', t => {
 
   fastify.register(plugin)
   fastify.ready((err) => {
-    t.equal(err.message, "The decorator 'plugin1' is not present in Request")
+    t.assert.strictEqual(err.message, "The decorator 'plugin1' is not present in Request")
+    testDone()
   })
 
   function plugin (instance, opts, done) {
@@ -215,7 +233,7 @@ test('plugin metadata - decorators - should throw', t => {
   }
 })
 
-test('plugin metadata - decorators - should throw with plugin name', t => {
+test('plugin metadata - decorators - should throw with plugin name', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -234,7 +252,8 @@ test('plugin metadata - decorators - should throw with plugin name', t => {
 
   fastify.register(plugin)
   fastify.ready((err) => {
-    t.equal(err.message, "The decorator 'plugin1' required by 'the-plugin' is not present in Request")
+    t.assert.strictEqual(err.message, "The decorator 'plugin1' required by 'the-plugin' is not present in Request")
+    testDone()
   })
 
   function plugin (instance, opts, done) {
@@ -243,7 +262,7 @@ test('plugin metadata - decorators - should throw with plugin name', t => {
   }
 })
 
-test('plugin metadata - dependencies', t => {
+test('plugin metadata - dependencies', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -261,7 +280,8 @@ test('plugin metadata - dependencies', t => {
   fastify.register(plugin)
 
   fastify.ready(() => {
-    t.pass('everything right')
+    t.assert.ok('everything right')
+    testDone()
   })
 
   function dependency (instance, opts, done) {
@@ -273,7 +293,7 @@ test('plugin metadata - dependencies', t => {
   }
 })
 
-test('plugin metadata - dependencies (nested)', t => {
+test('plugin metadata - dependencies (nested)', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
 
@@ -291,7 +311,8 @@ test('plugin metadata - dependencies (nested)', t => {
   fastify.register(plugin)
 
   fastify.ready(() => {
-    t.pass('everything right')
+    t.assert.ok('everything right')
+    testDone()
   })
 
   function dependency (instance, opts, done) {