fastify 5.0.0 → 5.2.0

package/test/500s.test.js

@@ -1,15 +1,14 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const symbols = require('../lib/symbols.js')
 
-test('default 500', t => {
+test('default 500', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -19,30 +18,31 @@ test('default 500', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
-    t.same(JSON.parse(res.payload), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.headers['content-type'], 'application/json; charset=utf-8')
+    t.assert.deepStrictEqual(JSON.parse(res.payload), {
       error: 'Internal Server Error',
       message: 'kaboom',
       statusCode: 500
     })
+    done()
   })
 })
 
-test('custom 500', t => {
+test('custom 500', (t, done) => {
   t.plan(6)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
   })
 
   fastify.setErrorHandler(function (err, request, reply) {
-    t.type(request, 'object')
-    t.type(request, fastify[symbols.kRequest].parent)
+    t.assert.ok(typeof request === 'object')
+    t.assert.ok(request instanceof fastify[symbols.kRequest].parent)
     reply
       .code(500)
       .type('text/plain')
@@ -53,18 +53,19 @@ test('custom 500', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(res.headers['content-type'], 'text/plain')
-    t.same(res.payload.toString(), 'an error happened: kaboom')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+    t.assert.deepStrictEqual(res.payload.toString(), 'an error happened: kaboom')
+    done()
   })
 })
 
-test('encapsulated 500', t => {
-  t.plan(10)
+test('encapsulated 500', async t => {
+  t.plan(8)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -76,8 +77,8 @@ test('encapsulated 500', t => {
     })
 
     f.setErrorHandler(function (err, request, reply) {
-      t.type(request, 'object')
-      t.type(request, fastify[symbols.kRequest].parent)
+      t.assert.ok(typeof request === 'object')
+      t.assert.ok(request instanceof fastify[symbols.kRequest].parent)
       reply
         .code(500)
         .type('text/plain')
@@ -87,36 +88,38 @@ test('encapsulated 500', t => {
     done()
   }, { prefix: 'test' })
 
-  fastify.inject({
-    method: 'GET',
-    url: '/test'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(res.headers['content-type'], 'text/plain')
-    t.same(res.payload.toString(), 'an error happened: kaboom')
-  })
+  {
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/test'
+    })
 
-  fastify.inject({
-    method: 'GET',
-    url: '/'
-  }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(res.headers['content-type'], 'application/json; charset=utf-8')
-    t.same(JSON.parse(res.payload), {
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.strictEqual(response.headers['content-type'], 'text/plain')
+    t.assert.deepStrictEqual(response.payload.toString(), 'an error happened: kaboom')
+  }
+
+  {
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/'
+    })
+
+    t.assert.strictEqual(response.statusCode, 500)
+    t.assert.strictEqual(response.headers['content-type'], 'application/json; charset=utf-8')
+    t.assert.deepStrictEqual(JSON.parse(response.payload), {
       error: 'Internal Server Error',
       message: 'kaboom',
       statusCode: 500
     })
-  })
+  }
 })
 
-test('custom 500 with hooks', t => {
+test('custom 500 with hooks', (t, done) => {
   t.plan(7)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/', function (req, reply) {
     reply.send(new Error('kaboom'))
@@ -130,15 +133,15 @@ test('custom 500 with hooks', t => {
   })
 
   fastify.addHook('onSend', (req, res, payload, done) => {
-    t.ok('called', 'onSend')
+    t.assert.ok('called', 'onSend')
     done()
   })
   fastify.addHook('onRequest', (req, res, done) => {
-    t.ok('called', 'onRequest')
+    t.assert.ok('called', 'onRequest')
     done()
   })
   fastify.addHook('onResponse', (request, reply, done) => {
-    t.ok('called', 'onResponse')
+    t.assert.ok('called', 'onResponse')
     done()
   })
 
@@ -146,54 +149,59 @@ test('custom 500 with hooks', t => {
     method: 'GET',
     url: '/'
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.equal(res.headers['content-type'], 'text/plain')
-    t.same(res.payload.toString(), 'an error happened: kaboom')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+    t.assert.deepStrictEqual(res.payload.toString(), 'an error happened: kaboom')
+    done()
   })
 })
 
-test('cannot set errorHandler after binding', t => {
+test('cannot set errorHandler after binding', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     try {
       fastify.setErrorHandler(() => { })
-      t.fail()
+      t.assert.fail()
     } catch (e) {
-      t.pass()
+      t.assert.ok(true)
+    } finally {
+      done()
     }
   })
 })
 
-test('cannot set childLoggerFactory after binding', t => {
+test('cannot set childLoggerFactory after binding', (t, done) => {
   t.plan(2)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     try {
       fastify.setChildLoggerFactory(() => { })
-      t.fail()
+      t.assert.fail()
     } catch (e) {
-      t.pass()
+      t.assert.ok(true)
+    } finally {
+      done()
     }
   })
 })
 
-test('catch synchronous errors', t => {
+test('catch synchronous errors', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.setErrorHandler((_, req, reply) => {
     throw new Error('kaboom2')
@@ -211,12 +219,13 @@ test('catch synchronous errors', t => {
     },
     payload: JSON.stringify({ hello: 'world' }).substring(0, 5)
   }, (err, res) => {
-    t.error(err)
-    t.equal(res.statusCode, 500)
-    t.same(res.json(), {
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
       error: 'Internal Server Error',
       message: 'kaboom2',
       statusCode: 500
     })
+    done()
   })
 })

package/test/{allowUnsafeRegex.test.js → allow-unsafe-regex.test.js}

@@ -1,117 +1,121 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const sget = require('simple-get').concat
 
-test('allow unsafe regex', t => {
+test('allow unsafe regex', (t, done) => {
   t.plan(4)
 
   const fastify = Fastify({
     allowUnsafeRegex: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/:foo(^[0-9]*$)', (req, reply) => {
     reply.send({ foo: req.params.foo })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         foo: '1234'
       })
+      done()
     })
   })
 })
 
-test('allow unsafe regex not match', t => {
+test('allow unsafe regex not match', (t, done) => {
   t.plan(3)
 
   const fastify = Fastify({
     allowUnsafeRegex: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
   fastify.get('/:foo(^[0-9]*$)', (req, reply) => {
     reply.send({ foo: req.params.foo })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/a1234'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 404)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 404)
+      done()
     })
   })
 })
 
-test('allow unsafe regex not safe', t => {
+test('allow unsafe regex not safe', (t, done) => {
   t.plan(1)
 
   const fastify = Fastify({
     allowUnsafeRegex: false
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
-  t.throws(() => {
+  t.assert.throws(() => {
     fastify.get('/:foo(^([0-9]+){4}$)', (req, reply) => {
       reply.send({ foo: req.params.foo })
     })
   })
+  done()
 })
 
-test('allow unsafe regex not safe by default', t => {
+test('allow unsafe regex not safe by default', (t, done) => {
   t.plan(1)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
-  t.throws(() => {
+  t.assert.throws(() => {
     fastify.get('/:foo(^([0-9]+){4}$)', (req, reply) => {
       reply.send({ foo: req.params.foo })
     })
   })
+  done()
 })
 
-test('allow unsafe regex allow unsafe', t => {
+test('allow unsafe regex allow unsafe', (t, done) => {
   t.plan(5)
 
   const fastify = Fastify({
     allowUnsafeRegex: true
   })
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
 
-  t.doesNotThrow(() => {
+  t.assert.doesNotThrow(() => {
     fastify.get('/:foo(^([0-9]+){4}$)', (req, reply) => {
       reply.send({ foo: req.params.foo })
     })
   })
 
   fastify.listen({ port: 0 }, err => {
-    t.error(err)
+    t.assert.ifError(err)
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), {
         foo: '1234'
       })
+      done()
     })
   })
 })

package/test/als.test.js

@@ -1,50 +1,40 @@
 'use strict'
 
 const { AsyncLocalStorage } = require('node:async_hooks')
-const t = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 const sget = require('simple-get').concat
 
-if (!AsyncLocalStorage) {
-  t.skip('AsyncLocalStorage not available, skipping test')
-  process.exit(0)
-}
+test('Async Local Storage test', (t, done) => {
+  t.plan(13)
+  if (!AsyncLocalStorage) {
+    t.skip('AsyncLocalStorage not available, skipping test')
+    process.exit(0)
+  }
 
-const storage = new AsyncLocalStorage()
-const app = Fastify({ logger: false })
+  const storage = new AsyncLocalStorage()
+  const app = Fastify({ logger: false })
 
-let counter = 0
-app.addHook('onRequest', (req, reply, next) => {
-  const id = counter++
-  storage.run({ id }, next)
-})
-
-app.get('/', function (request, reply) {
-  t.ok(storage.getStore())
-  const id = storage.getStore().id
-  reply.send({ id })
-})
+  let counter = 0
+  app.addHook('onRequest', (req, reply, next) => {
+    const id = counter++
+    storage.run({ id }, next)
+  })
 
-app.post('/', function (request, reply) {
-  t.ok(storage.getStore())
-  const id = storage.getStore().id
-  reply.send({ id })
-})
+  app.get('/', function (request, reply) {
+    t.assert.ok(storage.getStore())
+    const id = storage.getStore().id
+    reply.send({ id })
+  })
 
-app.listen({ port: 0 }, function (err, address) {
-  t.error(err)
+  app.post('/', function (request, reply) {
+    t.assert.ok(storage.getStore())
+    const id = storage.getStore().id
+    reply.send({ id })
+  })
 
-  sget({
-    method: 'POST',
-    url: 'http://localhost:' + app.server.address().port,
-    body: {
-      hello: 'world'
-    },
-    json: true
-  }, (err, response, body) => {
-    t.error(err)
-    t.equal(response.statusCode, 200)
-    t.same(body, { id: 0 })
+  app.listen({ port: 0 }, function (err, address) {
+    t.assert.ifError(err)
 
     sget({
       method: 'POST',
@@ -54,20 +44,33 @@ app.listen({ port: 0 }, function (err, address) {
       },
       json: true
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(body, { id: 1 })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(body, { id: 0 })
 
       sget({
-        method: 'GET',
+        method: 'POST',
         url: 'http://localhost:' + app.server.address().port,
+        body: {
+          hello: 'world'
+        },
         json: true
       }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 200)
-        t.same(body, { id: 2 })
-        app.close()
-        t.end()
+        t.assert.ifError(err)
+        t.assert.strictEqual(response.statusCode, 200)
+        t.assert.deepStrictEqual(body, { id: 1 })
+
+        sget({
+          method: 'GET',
+          url: 'http://localhost:' + app.server.address().port,
+          json: true
+        }, (err, response, body) => {
+          t.assert.ifError(err)
+          t.assert.strictEqual(response.statusCode, 200)
+          t.assert.deepStrictEqual(body, { id: 2 })
+          app.close()
+          done()
+        })
       })
     })
   })