fastify 5.1.0 → 5.2.0

package/test/server.test.js

@@ -85,7 +85,7 @@ test('abort signal', async t => {
   await t.test('listen should not start server', (t, end) => {
     t.plan(2)
     function onClose (instance, done) {
-      t.assert.equal(instance, fastify)
+      t.assert.strictEqual(instance, fastify)
       done()
       end()
     }
@@ -103,7 +103,7 @@ test('abort signal', async t => {
   await t.test('listen should not start server if already aborted', (t, end) => {
     t.plan(2)
     function onClose (instance, done) {
-      t.assert.equal(instance, fastify)
+      t.assert.strictEqual(instance, fastify)
       done()
       end()
     }
@@ -134,21 +134,19 @@ test('abort signal', async t => {
   })
 })
 
-test('#5180 - preClose should be called before closing secondary server', (t, end) => {
+test('#5180 - preClose should be called before closing secondary server', async (t) => {
   t.plan(2)
   const fastify = Fastify({ forceCloseConnections: true })
   let flag = false
   t.after(() => fastify.close())
 
-  fastify.addHook('preClose', async () => {
+  fastify.addHook('preClose', () => {
     flag = true
   })
 
   fastify.get('/', async (req, reply) => {
-    await new Promise((resolve) => {
-      setTimeout(() => resolve(1), 1000)
-    })
-
+    // request will be pending for 1 second to simulate a slow request
+    await new Promise((resolve) => { setTimeout(resolve, 1000) })
     return { hello: 'world' }
   })
 
@@ -177,12 +175,14 @@ test('#5180 - preClose should be called before closing secondary server', (t, en
         () => { t.assert.fail('Request should not succeed') },
         () => {
           t.assert.ok(flag)
-          end()
         }
       )
 
-    setTimeout(() => {
-      fastify.close()
-    }, 250)
+    // Close the server while the slow request is pending
+    setTimeout(fastify.close, 250)
   })
+
+  // Wait 1000ms to ensure that the test is finished and async operations are
+  // completed
+  await new Promise((resolve) => { setTimeout(resolve, 1000) })
 })

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

@@ -1,7 +1,6 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const { FST_ERR_ERROR_HANDLER_NOT_FN } = require('../lib/errors')
 
@@ -9,5 +8,5 @@ test('setErrorHandler should throw an error if the handler is not a function', t
   t.plan(1)
   const fastify = Fastify()
 
-  t.throws(() => fastify.setErrorHandler('not a function'), new FST_ERR_ERROR_HANDLER_NOT_FN())
+  t.assert.throws(() => fastify.setErrorHandler('not a function'), new FST_ERR_ERROR_HANDLER_NOT_FN())
 })

package/test/stream-serializers.test.js

@@ -1,18 +1,19 @@
 'use strict'
 
-const t = require('tap')
-const test = t.test
+const { test } = require('node:test')
 const Fastify = require('..')
 const Reply = require('../lib/reply')
 
-test('should serialize reply when response stream is ended', t => {
-  t.plan(3)
+test('should serialize reply when response stream is ended', (t, done) => {
+  t.plan(5)
+
   const stream = require('node:stream')
   const fastify = Fastify({
     logger: {
       serializers: {
         res (reply) {
-          t.type(reply, Reply)
+          t.assert.strictEqual(reply instanceof Reply, true)
+          t.assert.ok('passed')
           return reply
         }
       }
@@ -27,11 +28,13 @@ test('should serialize reply when response stream is ended', t => {
     reply.raw.end(Buffer.from('hello\n'))
   })
 
+  t.after(() => fastify.close())
+
   fastify.inject({
     url: '/error',
     method: 'GET'
   }, (err) => {
-    t.error(err)
-    fastify.close()
+    t.assert.ifError(err)
+    done()
   })
 })

package/test/sync-routes.test.js

@@ -1,32 +1,32 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 
 test('sync route', async t => {
-  const app = Fastify()
-  t.teardown(app.close.bind(app))
-  app.get('/', () => 'hello world')
-  const res = await app.inject('/')
-  t.equal(res.statusCode, 200)
-  t.equal(res.body, 'hello world')
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.get('/', () => 'hello world')
+  const res = await fastify.inject('/')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body, 'hello world')
 })
 
 test('sync route return null', async t => {
-  const app = Fastify()
-  t.teardown(app.close.bind(app))
-  app.get('/', () => null)
-  const res = await app.inject('/')
-  t.equal(res.statusCode, 200)
-  t.equal(res.body, 'null')
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.get('/', () => null)
+  const res = await fastify.inject('/')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body, 'null')
 })
 
 test('sync route, error', async t => {
-  const app = Fastify()
-  t.teardown(app.close.bind(app))
-  app.get('/', () => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.get('/', () => {
     throw new Error('kaboom')
   })
-  const res = await app.inject('/')
-  t.equal(res.statusCode, 500)
+  const res = await fastify.inject('/')
+  t.assert.strictEqual(res.statusCode, 500)
 })

package/test/trust-proxy.test.js

@@ -1,12 +1,13 @@
 'use strict'
 
-const t = require('tap')
-const { test, before } = t
+const { test, before } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('..')
 const helper = require('./helper')
 
-const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
+const noop = () => {}
+
+const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) => {
   const headers = {
     'X-Forwarded-For': forHeader,
     'X-Forwarded-Host': 'example.com'
@@ -18,30 +19,30 @@ const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
     method: 'GET',
     headers,
     url: 'http://localhost:' + app.server.address().port + path
-  }, () => {})
+  }, testCaseDone || noop)
 }
 
 const testRequestValues = (t, req, options) => {
   if (options.ip) {
-    t.ok(req.ip, 'ip is defined')
-    t.equal(req.ip, options.ip, 'gets ip from x-forwarded-for')
+    t.assert.ok(req.ip, 'ip is defined')
+    t.assert.strictEqual(req.ip, options.ip, 'gets ip from x-forwarded-for')
   }
   if (options.host) {
-    t.ok(req.host, 'host is defined')
-    t.equal(req.host, options.host, 'gets host from x-forwarded-host')
-    t.ok(req.hostname)
-    t.equal(req.hostname, options.host, 'gets hostname from x-forwarded-host')
+    t.assert.ok(req.host, 'host is defined')
+    t.assert.strictEqual(req.host, options.host, 'gets host from x-forwarded-host')
+    t.assert.ok(req.hostname)
+    t.assert.strictEqual(req.hostname, options.host, 'gets hostname from x-forwarded-host')
   }
   if (options.ips) {
-    t.same(req.ips, options.ips, 'gets ips from x-forwarded-for')
+    t.assert.deepStrictEqual(req.ips, options.ips, 'gets ips from x-forwarded-for')
   }
   if (options.protocol) {
-    t.ok(req.protocol, 'protocol is defined')
-    t.equal(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
+    t.assert.ok(req.protocol, 'protocol is defined')
+    t.assert.strictEqual(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
   }
   if (options.port) {
-    t.ok(req.port, 'port is defined')
-    t.equal(req.port, options.port, 'port is taken from x-forwarded-for or host')
+    t.assert.ok(req.port, 'port is defined')
+    t.assert.strictEqual(req.port, options.port, 'port is taken from x-forwarded-for or host')
   }
 }
 
@@ -50,11 +51,13 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('trust proxy, not add properties to node req', (t) => {
+test('trust proxy, not add properties to node req', (t, done) => {
   t.plan(14)
   const app = fastify({
     trustProxy: true
   })
+  t.after(() => app.close())
+
   app.get('/trustproxy', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
     reply.code(200).send({ ip: req.ip, host: req.host })
@@ -65,17 +68,23 @@ test('trust proxy, not add properties to node req', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy')
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain')
+    t.assert.ifError(err)
+
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completed)
+    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completed)
+
+    let pending = 2
+    function completed () {
+      if (--pending === 0) {
+        done()
+      }
+    }
   })
 })
 
-test('trust proxy chain', (t) => {
+test('trust proxy chain', (t, done) => {
   t.plan(9)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
@@ -86,16 +95,15 @@ test('trust proxy chain', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, done)
   })
 })
 
-test('trust proxy function', (t) => {
+test('trust proxy function', (t, done) => {
   t.plan(9)
   const app = fastify({
     trustProxy: (address) => address === localhost
@@ -105,16 +113,15 @@ test('trust proxy function', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc', undefined, done)
   })
 })
 
-test('trust proxy number', (t) => {
+test('trust proxy number', (t, done) => {
   t.plan(10)
   const app = fastify({
     trustProxy: 1
@@ -124,16 +131,15 @@ test('trust proxy number', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, done)
   })
 })
 
-test('trust proxy IP addresses', (t) => {
+test('trust proxy IP addresses', (t, done) => {
   t.plan(10)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
@@ -143,16 +149,15 @@ test('trust proxy IP addresses', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, done)
   })
 })
 
-test('trust proxy protocol', (t) => {
+test('trust proxy protocol', (t, done) => {
   t.plan(31)
   const app = fastify({
     trustProxy: true
@@ -170,13 +175,14 @@ test('trust proxy protocol', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
+  t.after(() => app.close())
 
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
+    t.assert.ifError(err)
     sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem')
     sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol')
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
+    // Allow for sgetForwardedRequest requests above to finish
+    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', done))
   })
 })

package/test/type-provider.test.js

@@ -1,20 +1,22 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 
-test('Should export withTypeProvider function', t => {
+test('Should export withTypeProvider function', (t, done) => {
   t.plan(1)
   try {
     Fastify().withTypeProvider()
-    t.pass()
+    t.assert.ok('pass')
+    done()
   } catch (e) {
-    t.fail()
+    t.assert.fail(e)
   }
 })
 
-test('Should return same instance', t => {
+test('Should return same instance', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
-  t.equal(fastify, fastify.withTypeProvider())
+  t.assert.strictEqual(fastify, fastify.withTypeProvider())
+  done()
 })

package/test/types/content-type-parser.test-d.ts

@@ -1,6 +1,6 @@
 import fastify, { FastifyBodyParser } from '../../fastify'
 import { expectError, expectType } from 'tsd'
-import { IncomingMessage } from 'http'
+import { IncomingMessage } from 'node:http'
 import { FastifyRequest } from '../../types/request'
 
 expectType<void>(fastify().addContentTypeParser('contentType', function (request, payload, done) {

package/test/types/fastify.test-d.ts

@@ -1,8 +1,8 @@
 import { ErrorObject as AjvErrorObject } from 'ajv'
-import * as http from 'http'
-import * as http2 from 'http2'
-import * as https from 'https'
-import { Socket } from 'net'
+import * as http from 'node:http'
+import * as http2 from 'node:http2'
+import * as https from 'node:https'
+import { Socket } from 'node:net'
 import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
 import fastify, {
   ConnectionError,

package/test/types/instance.test-d.ts

@@ -13,7 +13,7 @@ import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
 import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
-import { AddressInfo } from 'net'
+import { AddressInfo } from 'node:net'
 import { Bindings, ChildLoggerOptions } from '../../types/logger'
 
 const server = fastify()
@@ -193,6 +193,8 @@ function invalidSchemaErrorFormatter (err: Error) {
 }
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
+expectType<FastifyInstance>(server.addHttpMethod('SEARCH', { hasBody: true }))
+
 // test listen opts objects
 expectAssignable<PromiseLike<string>>(server.listen())
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000 }))

package/test/types/logger.test-d.ts

@@ -7,8 +7,8 @@ import fastify, {
   FastifyReply,
   FastifyBaseLogger
 } from '../../fastify'
-import { Server, IncomingMessage, ServerResponse } from 'http'
-import * as fs from 'fs'
+import { Server, IncomingMessage, ServerResponse } from 'node:http'
+import * as fs from 'node:fs'
 import P from 'pino'
 import { ResSerializerReply } from '../../types/logger'
 

package/test/types/plugin.test-d.ts

@@ -1,6 +1,6 @@
 import fastify, { FastifyInstance, FastifyPluginOptions, SafePromiseLike } from '../../fastify'
-import * as http from 'http'
-import * as https from 'https'
+import * as http from 'node:http'
+import * as https from 'node:https'
 import { expectType, expectError, expectAssignable } from 'tsd'
 import { FastifyPluginCallback, FastifyPluginAsync } from '../../types/plugin'
 import { FastifyError } from '@fastify/error'

package/test/types/register.test-d.ts

@@ -1,6 +1,6 @@
 import { expectAssignable, expectError, expectType } from 'tsd'
-import { IncomingMessage, Server, ServerResponse } from 'http'
-import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'http2'
+import { IncomingMessage, Server, ServerResponse } from 'node:http'
+import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'node:http2'
 import fastify, { FastifyInstance, FastifyError, FastifyLoggerInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
 
 const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }

package/test/types/reply.test-d.ts

@@ -1,4 +1,4 @@
-import { Buffer } from 'buffer'
+import { Buffer } from 'node:buffer'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, { FastifyContextConfig, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'

package/test/types/route.test-d.ts

@@ -1,5 +1,5 @@
 import { FastifyError } from '@fastify/error'
-import * as http from 'http'
+import * as http from 'node:http'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from '../../fastify'
 import { RequestPayload } from '../../types/hooks'

package/test/types/serverFactory.test-d.ts

@@ -1,5 +1,5 @@
 import fastify, { FastifyServerFactory } from '../../fastify'
-import * as http from 'http'
+import * as http from 'node:http'
 import { expectType } from 'tsd'
 
 // Custom Server

package/test/types/type-provider.test-d.ts

@@ -8,7 +8,7 @@ import fastify, {
   SafePromiseLike
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
-import { IncomingHttpHeaders } from 'http'
+import { IncomingHttpHeaders } from 'node:http'
 import { Type, TSchema, Static } from '@sinclair/typebox'
 import { FromSchema, JSONSchema } from 'json-schema-to-ts'