fastify 5.0.0 → 5.2.0

package/test/internals/validation.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
 const Ajv = require('ajv')
 const ajv = new Ajv({ coerceTypes: true })
@@ -13,11 +12,11 @@ const { kSchemaVisited } = require('../../lib/symbols')
 
 test('Symbols', t => {
   t.plan(5)
-  t.equal(typeof symbols.responseSchema, 'symbol')
-  t.equal(typeof symbols.bodySchema, 'symbol')
-  t.equal(typeof symbols.querystringSchema, 'symbol')
-  t.equal(typeof symbols.paramsSchema, 'symbol')
-  t.equal(typeof symbols.headersSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.responseSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.bodySchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.querystringSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.paramsSchema, 'symbol')
+  t.assert.strictEqual(typeof symbols.headersSchema, 'symbol')
 })
 
 ;['compileSchemasForValidation',
@@ -26,15 +25,15 @@ test('Symbols', t => {
     t.plan(2)
     const context = {}
     validation[func](context)
-    t.equal(typeof context[symbols.bodySchema], 'undefined')
-    t.equal(typeof context[symbols.responseSchema], 'undefined')
+    t.assert.strictEqual(typeof context[symbols.bodySchema], 'undefined')
+    t.assert.strictEqual(typeof context[symbols.responseSchema], 'undefined')
   })
 
   test(`${func} schema - missing output schema`, t => {
     t.plan(1)
     const context = { schema: {} }
     validation[func](context, null)
-    t.equal(typeof context[symbols.responseSchema], 'undefined')
+    t.assert.strictEqual(typeof context[symbols.responseSchema], 'undefined')
   })
 })
 
@@ -59,8 +58,8 @@ test('build schema - output schema', t => {
     }
   }
   validation.compileSchemasForSerialization(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.equal(typeof opts[symbols.responseSchema]['2xx'], 'function')
-  t.equal(typeof opts[symbols.responseSchema]['201'], 'function')
+  t.assert.strictEqual(typeof opts[symbols.responseSchema]['2xx'], 'function')
+  t.assert.strictEqual(typeof opts[symbols.responseSchema]['201'], 'function')
 })
 
 test('build schema - body schema', t => {
@@ -76,7 +75,7 @@ test('build schema - body schema', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.equal(typeof opts[symbols.bodySchema], 'function')
+  t.assert.strictEqual(typeof opts[symbols.bodySchema], 'function')
 })
 
 test('build schema - body with multiple content type schemas', t => {
@@ -101,8 +100,8 @@ test('build schema - body with multiple content type schemas', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.type(opts[symbols.bodySchema]['application/json'], 'function')
-  t.type(opts[symbols.bodySchema]['text/plain'], 'function')
+  t.assert.ok(opts[symbols.bodySchema]['application/json'], 'function')
+  t.assert.ok(opts[symbols.bodySchema]['text/plain'], 'function')
 })
 
 test('build schema - avoid repeated normalize schema', t => {
@@ -119,9 +118,9 @@ test('build schema - avoid repeated normalize schema', t => {
     }
   }
   opts.schema = normalizeSchema(opts.schema, serverConfig)
-  t.not(kSchemaVisited, undefined)
-  t.equal(opts.schema[kSchemaVisited], true)
-  t.equal(opts.schema, normalizeSchema(opts.schema, serverConfig))
+  t.assert.notStrictEqual(kSchemaVisited, undefined)
+  t.assert.strictEqual(opts.schema[kSchemaVisited], true)
+  t.assert.strictEqual(opts.schema, normalizeSchema(opts.schema, serverConfig))
 })
 
 test('build schema - query schema', t => {
@@ -139,8 +138,8 @@ test('build schema - query schema', t => {
   }
   opts.schema = normalizeSchema(opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.type(opts[symbols.querystringSchema].schema.type, 'string')
-  t.equal(typeof opts[symbols.querystringSchema], 'function')
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
 })
 
 test('build schema - query schema abbreviated', t => {
@@ -158,8 +157,8 @@ test('build schema - query schema abbreviated', t => {
   }
   opts.schema = normalizeSchema(opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.type(opts[symbols.querystringSchema].schema.type, 'string')
-  t.equal(typeof opts[symbols.querystringSchema], 'function')
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
 })
 
 test('build schema - querystring schema', t => {
@@ -175,8 +174,8 @@ test('build schema - querystring schema', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.type(opts[symbols.querystringSchema].schema.type, 'string')
-  t.equal(typeof opts[symbols.querystringSchema], 'function')
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
 })
 
 test('build schema - querystring schema abbreviated', t => {
@@ -194,8 +193,8 @@ test('build schema - querystring schema abbreviated', t => {
   }
   opts.schema = normalizeSchema(opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.type(opts[symbols.querystringSchema].schema.type, 'string')
-  t.equal(typeof opts[symbols.querystringSchema], 'function')
+  t.assert.ok(typeof opts[symbols.querystringSchema].schema.type === 'string')
+  t.assert.strictEqual(typeof opts[symbols.querystringSchema], 'function')
 })
 
 test('build schema - must throw if querystring and query schema exist', t => {
@@ -220,8 +219,8 @@ test('build schema - must throw if querystring and query schema exist', t => {
     }
     opts.schema = normalizeSchema(opts.schema, serverConfig)
   } catch (err) {
-    t.equal(err.code, 'FST_ERR_SCH_DUPLICATE')
-    t.equal(err.message, 'Schema with \'querystring\' already present!')
+    t.assert.strictEqual(err.code, 'FST_ERR_SCH_DUPLICATE')
+    t.assert.strictEqual(err.message, 'Schema with \'querystring\' already present!')
   }
 })
 
@@ -238,7 +237,7 @@ test('build schema - params schema', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.equal(typeof opts[symbols.paramsSchema], 'function')
+  t.assert.strictEqual(typeof opts[symbols.paramsSchema], 'function')
 })
 
 test('build schema - headers schema', t => {
@@ -254,7 +253,7 @@ test('build schema - headers schema', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
-  t.equal(typeof opts[symbols.headersSchema], 'function')
+  t.assert.strictEqual(typeof opts[symbols.headersSchema], 'function')
 })
 
 test('build schema - headers are lowercase', t => {
@@ -270,7 +269,7 @@ test('build schema - headers are lowercase', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
-    t.ok(schema.properties['content-type'], 'lowercase content-type exists')
+    t.assert.ok(schema.properties['content-type'], 'lowercase content-type exists')
     return () => { }
   })
 })
@@ -285,7 +284,7 @@ test('build schema - headers are not lowercased in case of custom object', t =>
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
-    t.type(schema, Headers)
+    t.assert.ok(schema, Headers)
     return () => { }
   })
 })
@@ -300,7 +299,7 @@ test('build schema - headers are not lowercased in case of custom validator prov
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
-    t.type(schema, Headers)
+    t.assert.ok(schema, Headers)
     return () => { }
   }, true)
 })
@@ -318,7 +317,7 @@ test('build schema - uppercased headers are not included', t => {
     }
   }
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => {
-    t.notOk('Content-Type' in schema.properties, 'uppercase does not exist')
+    t.assert.ok(!('Content-Type' in schema.properties), 'uppercase does not exist')
     return () => { }
   })
 })
@@ -333,7 +332,7 @@ test('build schema - mixed schema types are individually skipped or normalized',
       body: new CustomSchemaClass()
     },
     assertions: (schema) => {
-      t.type(schema.body, CustomSchemaClass)
+      t.assert.ok(schema.body, CustomSchemaClass)
     }
   }, {
     schema: {
@@ -342,7 +341,7 @@ test('build schema - mixed schema types are individually skipped or normalized',
       }
     },
     assertions: (schema) => {
-      t.type(schema.response[200], CustomSchemaClass)
+      t.assert.ok(schema.response[200], CustomSchemaClass)
     }
   }]
 

package/test/{keepAliveTimeout.test.js → keep-alive-timeout.test.js}

@@ -2,34 +2,33 @@
 
 const Fastify = require('..')
 const http = require('node:http')
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 
 test('keepAliveTimeout', t => {
   t.plan(6)
 
   try {
     Fastify({ keepAliveTimeout: 1.3 })
-    t.fail('option must be an integer')
+    t.assert.fail('option must be an integer')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 
   try {
     Fastify({ keepAliveTimeout: [] })
-    t.fail('option must be an integer')
+    t.assert.fail('option must be an integer')
   } catch (err) {
-    t.ok(err)
+    t.assert.ok(err)
   }
 
   const httpServer = Fastify({ keepAliveTimeout: 1 }).server
-  t.equal(httpServer.keepAliveTimeout, 1)
+  t.assert.strictEqual(httpServer.keepAliveTimeout, 1)
 
   const httpsServer = Fastify({ keepAliveTimeout: 2, https: {} }).server
-  t.equal(httpsServer.keepAliveTimeout, 2)
+  t.assert.strictEqual(httpsServer.keepAliveTimeout, 2)
 
   const http2Server = Fastify({ keepAliveTimeout: 3, http2: true }).server
-  t.not(http2Server.keepAliveTimeout, 3)
+  t.assert.notStrictEqual(http2Server.keepAliveTimeout, 3)
 
   const serverFactory = (handler, _) => {
     const server = http.createServer((req, res) => {
@@ -39,5 +38,5 @@ test('keepAliveTimeout', t => {
     return server
   }
   const customServer = Fastify({ keepAliveTimeout: 4, serverFactory }).server
-  t.equal(customServer.keepAliveTimeout, 5)
+  t.assert.strictEqual(customServer.keepAliveTimeout, 5)
 })

package/test/listen.5.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const net = require('node:net')
 const Fastify = require('../fastify')
 const { once } = require('node:events')
@@ -26,9 +26,9 @@ test('same port conflict and success should not fire callback multiple times - c
     switch (count) {
       case 6: {
         // success in here
-        t.error(err)
+        t.assert.ifError(err)
         fastify.close((err) => {
-          t.error(err)
+          t.assert.ifError(err)
           promise.resolve()
         })
         break
@@ -42,7 +42,7 @@ test('same port conflict and success should not fire callback multiple times - c
       }
       default: {
         // expect error
-        t.equal(err.code, 'EADDRINUSE')
+        t.assert.strictEqual(err.code, 'EADDRINUSE')
         setTimeout(() => {
           fastify.listen(option, callback)
         }, 100)
@@ -65,27 +65,27 @@ test('same port conflict and success should not fire callback multiple times - p
   try {
     await fastify.listen(option)
   } catch (err) {
-    t.equal(err.code, 'EADDRINUSE')
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
   }
   try {
     await fastify.listen(option)
   } catch (err) {
-    t.equal(err.code, 'EADDRINUSE')
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
   }
   try {
     await fastify.listen(option)
   } catch (err) {
-    t.equal(err.code, 'EADDRINUSE')
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
   }
   try {
     await fastify.listen(option)
   } catch (err) {
-    t.equal(err.code, 'EADDRINUSE')
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
   }
   try {
     await fastify.listen(option)
   } catch (err) {
-    t.equal(err.code, 'EADDRINUSE')
+    t.assert.strictEqual(err.code, 'EADDRINUSE')
   }
 
   server.close()

package/test/{maxRequestsPerSocket.test.js → max-requests-per-socket.test.js}

@@ -1,10 +1,10 @@
 'use strict'
 
 const net = require('node:net')
-const { test } = require('tap')
-const Fastify = require('../fastify')
+const { test } = require('node:test')
+const Fastify = require('..')
 
-test('maxRequestsPerSocket', t => {
+test('maxRequestsPerSocket', (t, done) => {
   t.plan(8)
 
   const fastify = Fastify({ maxRequestsPerSocket: 2 })
@@ -12,32 +12,32 @@ test('maxRequestsPerSocket', t => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
-
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     const port = fastify.server.address().port
     const client = net.createConnection({ port }, () => {
       client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
       client.once('data', data => {
-        t.match(data.toString(), /Connection:\s*keep-alive/i)
-        t.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
-        t.match(data.toString(), /200 OK/i)
+        t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+        t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+        t.assert.match(data.toString(), /200 OK/i)
 
         client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
         client.once('data', data => {
-          t.match(data.toString(), /Connection:\s*close/i)
-          t.match(data.toString(), /200 OK/i)
+          t.assert.match(data.toString(), /Connection:\s*close/i)
+          t.assert.match(data.toString(), /200 OK/i)
 
           client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
           client.once('data', data => {
-            t.match(data.toString(), /Connection:\s*close/i)
-            t.match(data.toString(), /503 Service Unavailable/i)
+            t.assert.match(data.toString(), /Connection:\s*close/i)
+            t.assert.match(data.toString(), /503 Service Unavailable/i)
             client.end()
+            fastify.close()
+            done()
           })
         })
       })
@@ -45,7 +45,7 @@ test('maxRequestsPerSocket', t => {
   })
 })
 
-test('maxRequestsPerSocket zero should behave same as null', t => {
+test('maxRequestsPerSocket zero should behave same as null', (t, done) => {
   t.plan(10)
 
   const fastify = Fastify({ maxRequestsPerSocket: 0 })
@@ -53,34 +53,34 @@ test('maxRequestsPerSocket zero should behave same as null', t => {
     reply.send({ hello: 'world' })
   })
 
-  t.teardown(fastify.close.bind(fastify))
-
   fastify.listen({ port: 0 }, function (err) {
-    t.error(err)
+    t.assert.ifError(err)
 
     const port = fastify.server.address().port
     const client = net.createConnection({ port }, () => {
       client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
       client.once('data', data => {
-        t.match(data.toString(), /Connection:\s*keep-alive/i)
-        t.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
-        t.match(data.toString(), /200 OK/i)
+        t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+        t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+        t.assert.match(data.toString(), /200 OK/i)
 
         client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
         client.once('data', data => {
-          t.match(data.toString(), /Connection:\s*keep-alive/i)
-          t.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
-          t.match(data.toString(), /200 OK/i)
+          t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+          t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+          t.assert.match(data.toString(), /200 OK/i)
 
           client.write('GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
 
           client.once('data', data => {
-            t.match(data.toString(), /Connection:\s*keep-alive/i)
-            t.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
-            t.match(data.toString(), /200 OK/i)
+            t.assert.match(data.toString(), /Connection:\s*keep-alive/i)
+            t.assert.match(data.toString(), /Keep-Alive:\s*timeout=\d+/i)
+            t.assert.match(data.toString(), /200 OK/i)
             client.end()
+            fastify.close()
+            done()
           })
         })
       })
@@ -92,22 +92,22 @@ test('maxRequestsPerSocket should be set', async (t) => {
   t.plan(1)
 
   const initialConfig = Fastify({ maxRequestsPerSocket: 5 }).initialConfig
-  t.same(initialConfig.maxRequestsPerSocket, 5)
+  t.assert.deepStrictEqual(initialConfig.maxRequestsPerSocket, 5)
 })
 
 test('maxRequestsPerSocket should 0', async (t) => {
   t.plan(1)
 
   const initialConfig = Fastify().initialConfig
-  t.same(initialConfig.maxRequestsPerSocket, 0)
+  t.assert.deepStrictEqual(initialConfig.maxRequestsPerSocket, 0)
 })
 
 test('requestTimeout passed to server', t => {
   t.plan(2)
 
   const httpServer = Fastify({ maxRequestsPerSocket: 5 }).server
-  t.equal(httpServer.maxRequestsPerSocket, 5)
+  t.assert.strictEqual(httpServer.maxRequestsPerSocket, 5)
 
   const httpsServer = Fastify({ maxRequestsPerSocket: 5, https: true }).server
-  t.equal(httpsServer.maxRequestsPerSocket, 5)
+  t.assert.strictEqual(httpsServer.maxRequestsPerSocket, 5)
 })

package/test/middleware.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 const {
   FST_ERR_DEC_ALREADY_PRESENT
@@ -10,7 +10,7 @@ test('Should be able to override the default use API', t => {
   t.plan(1)
   const fastify = Fastify()
   fastify.decorate('use', () => true)
-  t.equal(fastify.use(), true)
+  t.assert.strictEqual(fastify.use(), true)
 })
 
 test('Cannot decorate use twice', t => {
@@ -20,17 +20,16 @@ test('Cannot decorate use twice', t => {
   try {
     fastify.decorate('use', () => true)
   } catch (err) {
-    t.ok(err instanceof FST_ERR_DEC_ALREADY_PRESENT)
+    t.assert.ok(err instanceof FST_ERR_DEC_ALREADY_PRESENT)
   }
 })
 
 test('Encapsulation works', t => {
-  t.plan(1)
   const fastify = Fastify()
 
   fastify.register((instance, opts, done) => {
     instance.decorate('use', () => true)
-    t.equal(instance.use(), true)
+    t.assert.strictEqual(instance.use(), true)
     done()
   })
 

package/test/noop-set.test.js

@@ -1,19 +1,19 @@
 'use strict'
 
-const tap = require('tap')
+const { test } = require('node:test')
 const noopSet = require('../lib/noop-set')
 
-tap.test('does a lot of nothing', async t => {
+test('does a lot of nothing', async t => {
   const aSet = noopSet()
-  t.type(aSet, 'object')
+  t.assert.ok(aSet, 'object')
 
   const item = {}
   aSet.add(item)
   aSet.add({ another: 'item' })
   aSet.delete(item)
-  t.equal(aSet.has(item), true)
+  t.assert.strictEqual(aSet.has(item), true)
 
   for (const i of aSet) {
-    t.fail('should not have any items', i)
+    t.assert.fail('should not have any items: ' + i)
   }
 })

package/test/post-empty-body.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
-const { test } = require('tap')
-const fastify = require('../')
+const { test } = require('node:test')
+const Fastify = require('..')
 const { request, setGlobalDispatcher, Agent } = require('undici')
 
 setGlobalDispatcher(new Agent({
@@ -9,23 +9,30 @@ setGlobalDispatcher(new Agent({
   keepAliveMaxTimeout: 10
 }))
 
-test('post empty body', async t => {
-  const app = fastify()
-  t.teardown(app.close.bind(app))
+test('post empty body', { timeout: 3_000 }, async t => {
+  const fastify = Fastify({ forceCloseConnections: true })
+  const abortController = new AbortController()
+  const { signal } = abortController
+  t.after(() => {
+    fastify.close()
+    abortController.abort()
+  })
 
-  app.post('/bug', async (request, reply) => {
+  fastify.post('/bug', async () => {
+    // This function must be async and return nothing
   })
 
-  await app.listen({ port: 0 })
+  await fastify.listen({ port: 0 })
 
-  const res = await request(`http://127.0.0.1:${app.server.address().port}/bug`, {
+  const res = await request(`http://localhost:${fastify.server.address().port}/bug`, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json'
     },
-    body: JSON.stringify({ foo: 'bar' })
+    body: JSON.stringify({ foo: 'bar' }),
+    signal
   })
 
-  t.equal(res.statusCode, 200)
-  t.equal(await res.body.text(), '')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(await res.body.text(), '')
 })