fastify 5.0.0 → 5.1.0

package/test/imports.test.js

@@ -1,18 +1,17 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
 test('should import as default', t => {
   t.plan(2)
   const fastify = require('..')
-  t.ok(fastify)
-  t.equal(typeof fastify, 'function')
+  t.assert.ok(fastify)
+  t.assert.equal(typeof fastify, 'function')
 })
 
 test('should import as esm', t => {
   t.plan(2)
   const { fastify } = require('..')
-  t.ok(fastify)
-  t.equal(typeof fastify, 'function')
+  t.assert.ok(fastify)
+  t.assert.equal(typeof fastify, 'function')
 })

package/test/internals/all.test.js

@@ -1,10 +1,9 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('../..')
 
-test('fastify.all should add all the methods to the same url', t => {
+test('fastify.all should add all the methods to the same url', async t => {
   const fastify = Fastify()
 
   const requirePayload = [
@@ -14,15 +13,15 @@ test('fastify.all should add all the methods to the same url', t => {
   ]
 
   const supportedMethods = fastify.supportedMethods
-  t.plan(supportedMethods.length * 2)
+  t.plan(supportedMethods.length)
 
   fastify.all('/', (req, reply) => {
     reply.send({ method: req.raw.method })
   })
 
-  supportedMethods.forEach(injectRequest)
+  await Promise.all(supportedMethods.map(async method => injectRequest(method)))
 
-  function injectRequest (method) {
+  async function injectRequest (method) {
     const options = {
       url: '/',
       method
@@ -32,10 +31,8 @@ test('fastify.all should add all the methods to the same url', t => {
       options.payload = { hello: 'world' }
     }
 
-    fastify.inject(options, (err, res) => {
-      t.error(err)
-      const payload = JSON.parse(res.payload)
-      t.same(payload, { method })
-    })
+    const res = await fastify.inject(options)
+    const payload = JSON.parse(res.payload)
+    t.assert.deepStrictEqual(payload, { method })
   }
 })

package/test/internals/contentTypeParser.test.js

@@ -1,8 +1,7 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('node:test')
 const proxyquire = require('proxyquire')
-const test = t.test
 const { Readable } = require('node:stream')
 const { kTestInternals, kRouteContext } = require('../../lib/symbols')
 const Request = require('../../lib/request')
@@ -17,8 +16,8 @@ test('rawBody function', t => {
     asString: true,
     asBuffer: false,
     fn (req, bodyInString, done) {
-      t.equal(bodyInString, body.toString())
-      t.equal(typeof done, 'function')
+      t.assert.strictEqual(bodyInString, body.toString())
+      t.assert.strictEqual(typeof done, 'function')
       return {
         then (cb) {
           cb()
@@ -70,8 +69,8 @@ test('Should support Webpack and faux modules', t => {
     asString: true,
     asBuffer: false,
     fn (req, bodyInString, done) {
-      t.equal(bodyInString, body.toString())
-      t.equal(typeof done, 'function')
+      t.assert.strictEqual(bodyInString, body.toString())
+      t.assert.strictEqual(typeof done, 'function')
       return {
         then (cb) {
           cb()

package/test/internals/context.test.js

@@ -1,23 +1,23 @@
 'use strict'
 
-const { test } = require('tap')
-
+const { test } = require('node:test')
 const { kRouteContext } = require('../../lib/symbols')
 const Context = require('../../lib/context')
 
 const Fastify = require('../..')
 
-test('context', context => {
+test('context', async context => {
   context.plan(1)
 
-  context.test('Should not contain undefined as key prop', async t => {
+  await context.test('Should not contain undefined as key prop', async t => {
+    t.plan(4)
     const app = Fastify()
 
     app.get('/', (req, reply) => {
-      t.type(req[kRouteContext], Context)
-      t.type(reply[kRouteContext], Context)
-      t.notOk('undefined' in reply[kRouteContext])
-      t.notOk('undefined' in req[kRouteContext])
+      t.assert.ok(req[kRouteContext] instanceof Context)
+      t.assert.ok(reply[kRouteContext] instanceof Context)
+      t.assert.ok(!('undefined' in reply[kRouteContext]))
+      t.assert.ok(!('undefined' in req[kRouteContext]))
 
       reply.send('hello world!')
     })
@@ -25,9 +25,7 @@ test('context', context => {
     try {
       await app.inject('/')
     } catch (e) {
-      t.fail(e)
+      t.assert.fail(e)
     }
-
-    t.plan(4)
   })
 })

package/test/internals/decorator.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const decorator = require('../../lib/decorate')
 const {
   kState
@@ -22,7 +21,7 @@ test('decorate should add the given method to its instance', t => {
 
   const server = build()
   server.add('test', () => {})
-  t.ok(server.test)
+  t.assert.ok(server.test)
 })
 
 test('decorate is chainable', t => {
@@ -44,15 +43,15 @@ test('decorate is chainable', t => {
     .add('test2', () => {})
     .add('test3', () => {})
 
-  t.ok(server.test1)
-  t.ok(server.test2)
-  t.ok(server.test3)
+  t.assert.ok(server.test1)
+  t.assert.ok(server.test2)
+  t.assert.ok(server.test3)
 })
 
 test('checkExistence should check if a property is part of the given instance', t => {
   t.plan(1)
   const instance = { test: () => {} }
-  t.ok(decorator.exist(instance, 'test'))
+  t.assert.ok(decorator.exist(instance, 'test'))
 })
 
 test('checkExistence should find the instance if not given', t => {
@@ -71,7 +70,7 @@ test('checkExistence should find the instance if not given', t => {
 
   const server = build()
   server.add('test', () => {})
-  t.ok(server.check('test'))
+  t.assert.ok(server.check('test'))
 })
 
 test('checkExistence should check the prototype as well', t => {
@@ -80,7 +79,7 @@ test('checkExistence should check the prototype as well', t => {
   Instance.prototype.test = () => {}
 
   const instance = new Instance()
-  t.ok(decorator.exist(instance, 'test'))
+  t.assert.ok(decorator.exist(instance, 'test'))
 })
 
 test('checkDependencies should throw if a dependency is not present', t => {
@@ -88,10 +87,10 @@ test('checkDependencies should throw if a dependency is not present', t => {
   const instance = {}
   try {
     decorator.dependencies(instance, 'foo', ['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\'.')
   }
 })
 
@@ -112,10 +111,10 @@ test('decorate should internally call checkDependencies', t => {
 
   try {
     server.add('method', () => {}, ['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\'.')
   }
 })
 
@@ -132,14 +131,14 @@ test('decorate should recognize getter/setter objects', t => {
   decorator.add.call(one, 'foo', {
     getter: () => this._a,
     setter: (val) => {
-      t.pass()
+      t.assert.ok(true)
       this._a = val
     }
   })
-  t.equal(Object.hasOwn(one, 'foo'), true)
-  t.equal(one.foo, undefined)
+  t.assert.strictEqual(Object.hasOwn(one, 'foo'), true)
+  t.assert.strictEqual(one.foo, undefined)
   one.foo = 'a'
-  t.equal(one.foo, 'a')
+  t.assert.strictEqual(one.foo, 'a')
 
   // getter only
   const two = {
@@ -152,6 +151,6 @@ test('decorate should recognize getter/setter objects', t => {
   decorator.add.call(two, 'foo', {
     getter: () => 'a getter'
   })
-  t.equal(Object.hasOwn(two, 'foo'), true)
-  t.equal(two.foo, 'a getter')
+  t.assert.strictEqual(Object.hasOwn(two, 'foo'), true)
+  t.assert.strictEqual(two.foo, 'a getter')
 })