fastify 5.3.2 → 5.3.3

package/test/plugin.1.test.js

@@ -1,21 +1,23 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const test = t.test
 const Fastify = require('../fastify')
 const sget = require('simple-get').concat
 const fp = require('fastify-plugin')
+const { waitForCb } = require('./toolkit')
 
-test('require a plugin', t => {
+test('require a plugin', (t, testDone) => {
   t.plan(1)
   const fastify = Fastify()
   fastify.register(require('./plugin.helper'))
   fastify.ready(() => {
-    t.ok(fastify.test)
+    t.assert.ok(fastify.test)
+    testDone()
   })
 })
 
-test('plugin metadata - ignore prefix', t => {
+test('plugin metadata - ignore prefix', (t, testDone) => {
   t.plan(2)
   const fastify = Fastify()
 
@@ -26,8 +28,9 @@ test('plugin metadata - ignore prefix', t => {
     method: 'GET',
     url: '/'
   }, function (err, res) {
-    t.error(err)
-    t.equal(res.payload, 'hello')
+    t.assert.ifError(err)
+    t.assert.strictEqual(res.payload, 'hello')
+    testDone()
   })
 
   function plugin (instance, opts, done) {
@@ -45,37 +48,37 @@ test('plugin metadata - naming plugins', async t => {
   fastify.register(require('./plugin.name.display'))
   fastify.register(function (fastify, opts, done) {
     // one line
-    t.equal(fastify.pluginName, 'function (fastify, opts, done) { -- // one line')
+    t.assert.strictEqual(fastify.pluginName, 'function (fastify, opts, done) { -- // one line')
     done()
   })
   fastify.register(function fooBar (fastify, opts, done) {
-    t.equal(fastify.pluginName, 'fooBar')
+    t.assert.strictEqual(fastify.pluginName, 'fooBar')
     done()
   })
 
   await fastify.ready()
 })
 
-test('fastify.register with fastify-plugin should not encapsulate his code', t => {
+test('fastify.register with fastify-plugin should not encapsulate his code', (t, testDone) => {
   t.plan(10)
   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()
     }))
 
-    t.notOk(instance.test)
+    t.assert.ok(!instance.test)
 
     // the decoration is added at the end
     instance.after(() => {
-      t.ok(instance.test)
+      t.assert.ok(instance.test)
     })
 
     instance.get('/', (req, reply) => {
-      t.ok(instance.test)
+      t.assert.ok(instance.test)
       reply.send({ hello: 'world' })
     })
 
@@ -83,41 +86,42 @@ test('fastify.register with fastify-plugin should not encapsulate his code', 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('fastify.register with fastify-plugin should provide access to external fastify instance if opts argument is a function', t => {
+test('fastify.register with fastify-plugin should provide access to external fastify instance if opts argument is a function', (t, testDone) => {
   t.plan(22)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.register(fp((i, o, n) => {
       i.decorate('global', () => {})
-      t.ok(i.global)
+      t.assert.ok(i.global)
       n()
     }))
 
     instance.register((i, o, n) => n(), p => {
-      t.notOk(p === instance || p === fastify)
-      t.ok(Object.prototype.isPrototypeOf.call(instance, p))
-      t.ok(Object.prototype.isPrototypeOf.call(fastify, p))
-      t.ok(p.global)
+      t.assert.ok(!(p === instance || p === fastify))
+      t.assert.ok(Object.prototype.isPrototypeOf.call(instance, p))
+      t.assert.ok(Object.prototype.isPrototypeOf.call(fastify, p))
+      t.assert.ok(p.global)
     })
 
     instance.register((i, o, n) => {
@@ -125,17 +129,17 @@ test('fastify.register with fastify-plugin should provide access to external fas
       n()
     })
 
-    instance.register((i, o, n) => n(), p => t.notOk(p.local))
+    instance.register((i, o, n) => n(), p => t.assert.ok(!p.local))
 
     instance.register((i, o, n) => {
-      t.ok(i.local)
+      t.assert.ok(i.local)
       n()
     }, p => p.decorate('local', () => {}))
 
-    instance.register((i, o, n) => n(), p => t.notOk(p.local))
+    instance.register((i, o, n) => n(), p => t.assert.ok(!p.local))
 
     instance.register(fp((i, o, n) => {
-      t.ok(i.global_2)
+      t.assert.ok(i.global_2)
       n()
     }), p => p.decorate('global_2', () => 'hello'))
 
@@ -143,40 +147,41 @@ test('fastify.register with fastify-plugin should provide access to external fas
       i.decorate('global_2', () => 'world')
       n()
     }, p => p.get('/', (req, reply) => {
-      t.ok(p.global_2)
+      t.assert.ok(p.global_2)
       reply.send({ hello: p.global_2() })
     }))
 
-    t.notOk(instance.global)
-    t.notOk(instance.global_2)
-    t.notOk(instance.local)
+    t.assert.ok(!instance.global)
+    t.assert.ok(!instance.global_2)
+    t.assert.ok(!instance.local)
 
     // the decoration is added at the end
     instance.after(() => {
-      t.ok(instance.global)
-      t.equal(instance.global_2(), 'hello')
-      t.notOk(instance.local)
+      t.assert.ok(instance.global)
+      t.assert.strictEqual(instance.global_2(), 'hello')
+      t.assert.ok(!instance.local)
     })
 
     done()
   })
 
   fastify.ready(() => {
-    t.notOk(fastify.global)
+    t.assert.ok(!fastify.global)
   })
 
   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()
     })
   })
 })
@@ -187,7 +192,7 @@ test('fastify.register with fastify-plugin registers fastify level plugins', t =
 
   function fastifyPlugin (instance, opts, done) {
     instance.decorate('test', 'first')
-    t.ok(instance.test)
+    t.assert.ok(instance.test)
     done()
   }
 
@@ -199,11 +204,11 @@ test('fastify.register with fastify-plugin registers fastify level plugins', t =
   fastify.register(fp(fastifyPlugin))
 
   fastify.register((instance, opts, done) => {
-    t.ok(instance.test)
+    t.assert.ok(instance.test)
     instance.register(fp(innerPlugin))
 
     instance.get('/test2', (req, reply) => {
-      t.ok(instance.test2)
+      t.assert.ok(instance.test2)
       reply.send({ test2: instance.test2 })
     })
 
@@ -211,37 +216,43 @@ test('fastify.register with fastify-plugin registers fastify level plugins', t =
   })
 
   fastify.ready(() => {
-    t.ok(fastify.test)
-    t.notOk(fastify.test2)
+    t.assert.ok(fastify.test)
+    t.assert.ok(!fastify.test2)
   })
 
   fastify.get('/', (req, reply) => {
-    t.ok(fastify.test)
+    t.assert.ok(fastify.test)
     reply.send({ test: fastify.test })
   })
 
+  const { stepIn, patience } = waitForCb({ steps: 2 })
+
   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), { test: '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), { test: 'first' })
+      stepIn()
     })
 
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/test2'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.equal(response.headers['content-length'], '' + body.length)
-      t.same(JSON.parse(body), { test2: '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), { test2: 'second' })
+      stepIn()
     })
   })
+
+  return patience
 })

package/test/promises.test.js

@@ -1,10 +1,12 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
+const assert = require('node:assert')
 const sget = require('simple-get').concat
 const fastify = require('..')()
 
+test.after(() => fastify.close())
+
 const opts = {
   schema: {
     response: {
@@ -61,80 +63,84 @@ fastify.get('/return-reply', opts, function (req, reply) {
 })
 
 fastify.listen({ port: 0 }, err => {
-  t.error(err)
-  t.teardown(() => { fastify.close() })
+  assert.ifError(err)
 
-  test('shorthand - sget return promise es6 get', t => {
+  test('shorthand - sget return promise es6 get', (t, done) => {
     t.plan(4)
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/return'
     }, (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' })
+      done()
     })
   })
 
-  test('shorthand - sget promise es6 get return error', t => {
+  test('shorthand - sget promise es6 get return error', (t, done) => {
     t.plan(2)
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/return-error'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 500)
+      done()
     })
   })
 
-  test('sget promise double send', t => {
+  test('sget promise double send', (t, done) => {
     t.plan(3)
-
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/double'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), { hello: '42' })
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 200)
+      t.assert.deepStrictEqual(JSON.parse(body), { hello: '42' })
+      done()
     })
   })
 
-  test('thenable', t => {
+  test('thenable', (t, done) => {
     t.plan(4)
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/thenable'
     }, (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' })
+      done()
     })
   })
 
-  test('thenable (error)', t => {
+  test('thenable (error)', (t, done) => {
     t.plan(2)
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/thenable-error'
     }, (err, response, body) => {
-      t.error(err)
-      t.equal(response.statusCode, 500)
+      t.assert.ifError(err)
+      t.assert.strictEqual(response.statusCode, 500)
+      done()
     })
   })
 
-  test('return-reply', t => {
+  test('return-reply', (t, done) => {
     t.plan(4)
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/return-reply'
     }, (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' })
+      done()
     })
   })
 })

package/test/put.error-handler.test.js

@@ -1,5 +1,5 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 require('./helper').payloadMethod('put', t, true)
 require('./input-validation').payloadMethod('put', t)

package/test/put.test.js

@@ -1,5 +1,5 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 require('./helper').payloadMethod('put', t)
 require('./input-validation').payloadMethod('put', t)