fastify 5.0.0 → 5.2.0

package/test/internals/request.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 
 const Request = require('../../lib/request')
 const Context = require('../../lib/context')
@@ -42,34 +42,33 @@ test('Regular request', t => {
       [kRequest]: Request,
       [kOptions]: {
         requestIdLogLabel: 'reqId'
-      }
+      },
+      server: {}
     }
   })
   req.connection = req.socket
   const request = new Request('id', 'params', req, 'query', 'log', context)
-  t.type(request, Request)
-  t.type(request.validateInput, Function)
-  t.type(request.getValidationFunction, Function)
-  t.type(request.compileValidationSchema, Function)
-  t.equal(request.id, 'id')
-  t.equal(request.params, 'params')
-  t.equal(request.raw, req)
-  t.equal(request.query, 'query')
-  t.equal(request.headers, headers)
-  t.equal(request.log, 'log')
-  t.equal(request.ip, 'ip')
-  t.equal(request.ips, undefined)
-  t.equal(request.host, 'hostname')
-  t.equal(request.body, undefined)
-  t.equal(request.method, 'GET')
-  t.equal(request.url, '/')
-  t.equal(request.originalUrl, '/')
-  t.equal(request.socket, req.socket)
-  t.equal(request.protocol, 'http')
+  t.assert.ok(request instanceof Request)
+  t.assert.ok(request.validateInput instanceof Function)
+  t.assert.ok(request.getValidationFunction instanceof Function)
+  t.assert.ok(request.compileValidationSchema instanceof Function)
+  t.assert.strictEqual(request.id, 'id')
+  t.assert.strictEqual(request.params, 'params')
+  t.assert.strictEqual(request.raw, req)
+  t.assert.strictEqual(request.query, 'query')
+  t.assert.strictEqual(request.headers, headers)
+  t.assert.strictEqual(request.log, 'log')
+  t.assert.strictEqual(request.ip, 'ip')
+  t.assert.strictEqual(request.ips, undefined)
+  t.assert.strictEqual(request.host, 'hostname')
+  t.assert.strictEqual(request.body, undefined)
+  t.assert.strictEqual(request.method, 'GET')
+  t.assert.strictEqual(request.url, '/')
+  t.assert.strictEqual(request.originalUrl, '/')
+  t.assert.strictEqual(request.socket, req.socket)
+  t.assert.strictEqual(request.protocol, 'http')
   // Aim to not bad property keys (including Symbols)
-  t.notOk('undefined' in request)
-
-  t.end()
+  t.assert.ok(!('undefined' in request))
 })
 
 test('Request with undefined config', t => {
@@ -97,35 +96,34 @@ test('Request with undefined config', t => {
       [kRequest]: Request,
       [kOptions]: {
         requestIdLogLabel: 'reqId'
-      }
+      },
+      server: {}
     }
   })
   req.connection = req.socket
   const request = new Request('id', 'params', req, 'query', 'log', context)
-  t.type(request, Request)
-  t.type(request.validateInput, Function)
-  t.type(request.getValidationFunction, Function)
-  t.type(request.compileValidationSchema, Function)
-  t.equal(request.id, 'id')
-  t.equal(request.params, 'params')
-  t.equal(request.raw, req)
-  t.equal(request.query, 'query')
-  t.equal(request.headers, headers)
-  t.equal(request.log, 'log')
-  t.equal(request.ip, 'ip')
-  t.equal(request.ips, undefined)
-  t.equal(request.hostname, 'hostname')
-  t.equal(request.body, undefined)
-  t.equal(request.method, 'GET')
-  t.equal(request.url, '/')
-  t.equal(request.originalUrl, '/')
-  t.equal(request.socket, req.socket)
-  t.equal(request.protocol, 'http')
+  t.assert.ok(request, Request)
+  t.assert.ok(request.validateInput, Function)
+  t.assert.ok(request.getValidationFunction, Function)
+  t.assert.ok(request.compileValidationSchema, Function)
+  t.assert.strictEqual(request.id, 'id')
+  t.assert.strictEqual(request.params, 'params')
+  t.assert.strictEqual(request.raw, req)
+  t.assert.strictEqual(request.query, 'query')
+  t.assert.strictEqual(request.headers, headers)
+  t.assert.strictEqual(request.log, 'log')
+  t.assert.strictEqual(request.ip, 'ip')
+  t.assert.strictEqual(request.ips, undefined)
+  t.assert.strictEqual(request.hostname, 'hostname')
+  t.assert.strictEqual(request.body, undefined)
+  t.assert.strictEqual(request.method, 'GET')
+  t.assert.strictEqual(request.url, '/')
+  t.assert.strictEqual(request.originalUrl, '/')
+  t.assert.strictEqual(request.socket, req.socket)
+  t.assert.strictEqual(request.protocol, 'http')
 
   // Aim to not bad property keys (including Symbols)
-  t.notOk('undefined' in request)
-
-  t.end()
+  t.assert.ok(!('undefined' in request))
 })
 
 test('Regular request - hostname from authority', t => {
@@ -139,11 +137,35 @@ test('Regular request - hostname from authority', t => {
     socket: { remoteAddress: 'ip' },
     headers
   }
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request,
+      [kOptions]: {
+        requestIdLogLabel: 'reqId'
+      },
+      server: {}
+    }
+  })
 
-  const request = new Request('id', 'params', req, 'query', 'log')
-  t.type(request, Request)
-  t.equal(request.host, 'authority')
-  t.equal(request.port, null)
+  const request = new Request('id', 'params', req, 'query', 'log', context)
+  t.assert.ok(request instanceof Request)
+  t.assert.strictEqual(request.host, 'authority')
+  t.assert.strictEqual(request.port, null)
 })
 
 test('Regular request - host header has precedence over authority', t => {
@@ -158,10 +180,34 @@ test('Regular request - host header has precedence over authority', t => {
     socket: { remoteAddress: 'ip' },
     headers
   }
-  const request = new Request('id', 'params', req, 'query', 'log')
-  t.type(request, Request)
-  t.equal(request.host, 'hostname')
-  t.equal(request.port, null)
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request,
+      [kOptions]: {
+        requestIdLogLabel: 'reqId'
+      },
+      server: {}
+    }
+  })
+  const request = new Request('id', 'params', req, 'query', 'log', context)
+  t.assert.ok(request instanceof Request)
+  t.assert.strictEqual(request.host, 'hostname')
+  t.assert.strictEqual(request.port, null)
 })
 
 test('Request with trust proxy', t => {
@@ -202,24 +248,24 @@ test('Request with trust proxy', t => {
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log', context)
-  t.type(request, TpRequest)
-  t.equal(request.id, 'id')
-  t.equal(request.params, 'params')
-  t.same(request.raw, req)
-  t.equal(request.query, 'query')
-  t.equal(request.headers, headers)
-  t.equal(request.log, 'log')
-  t.equal(request.ip, '2.2.2.2')
-  t.same(request.ips, ['ip', '1.1.1.1', '2.2.2.2'])
-  t.equal(request.host, 'example.com')
-  t.equal(request.body, undefined)
-  t.equal(request.method, 'GET')
-  t.equal(request.url, '/')
-  t.equal(request.socket, req.socket)
-  t.equal(request.protocol, 'http')
-  t.type(request.validateInput, Function)
-  t.type(request.getValidationFunction, Function)
-  t.type(request.compileValidationSchema, Function)
+  t.assert.ok(request instanceof TpRequest)
+  t.assert.strictEqual(request.id, 'id')
+  t.assert.strictEqual(request.params, 'params')
+  t.assert.deepStrictEqual(request.raw, req)
+  t.assert.strictEqual(request.query, 'query')
+  t.assert.strictEqual(request.headers, headers)
+  t.assert.strictEqual(request.log, 'log')
+  t.assert.strictEqual(request.ip, '2.2.2.2')
+  t.assert.deepStrictEqual(request.ips, ['ip', '1.1.1.1', '2.2.2.2'])
+  t.assert.strictEqual(request.host, 'example.com')
+  t.assert.strictEqual(request.body, undefined)
+  t.assert.strictEqual(request.method, 'GET')
+  t.assert.strictEqual(request.url, '/')
+  t.assert.strictEqual(request.socket, req.socket)
+  t.assert.strictEqual(request.protocol, 'http')
+  t.assert.ok(request.validateInput instanceof Function)
+  t.assert.ok(request.getValidationFunction instanceof Function)
+  t.assert.ok(request.compileValidationSchema instanceof Function)
 })
 
 test('Request with trust proxy, encrypted', t => {
@@ -237,8 +283,8 @@ test('Request with trust proxy, encrypted', t => {
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.type(request, TpRequest)
-  t.equal(request.protocol, 'https')
+  t.assert.ok(request instanceof TpRequest)
+  t.assert.strictEqual(request.protocol, 'https')
 })
 
 test('Request with trust proxy - no x-forwarded-host header', t => {
@@ -253,11 +299,35 @@ test('Request with trust proxy - no x-forwarded-host header', t => {
     socket: { remoteAddress: 'ip' },
     headers
   }
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request,
+      [kOptions]: {
+        requestIdLogLabel: 'reqId'
+      },
+      server: {}
+    }
+  })
 
   const TpRequest = Request.buildRequest(Request, true)
-  const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.type(request, TpRequest)
-  t.equal(request.host, 'hostname')
+  const request = new TpRequest('id', 'params', req, 'query', 'log', context)
+  t.assert.ok(request instanceof TpRequest)
+  t.assert.strictEqual(request.host, 'hostname')
 })
 
 test('Request with trust proxy - no x-forwarded-host header and fallback to authority', t => {
@@ -272,11 +342,35 @@ test('Request with trust proxy - no x-forwarded-host header and fallback to auth
     socket: { remoteAddress: 'ip' },
     headers
   }
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request,
+      [kOptions]: {
+        requestIdLogLabel: 'reqId'
+      },
+      server: {}
+    }
+  })
 
   const TpRequest = Request.buildRequest(Request, true)
-  const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.type(request, TpRequest)
-  t.equal(request.host, 'authority')
+  const request = new TpRequest('id', 'params', req, 'query', 'log', context)
+  t.assert.ok(request instanceof TpRequest)
+  t.assert.strictEqual(request.host, 'authority')
 })
 
 test('Request with trust proxy - x-forwarded-host header has precedence over host', t => {
@@ -295,8 +389,8 @@ test('Request with trust proxy - x-forwarded-host header has precedence over hos
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.type(request, TpRequest)
-  t.equal(request.host, 'example.com')
+  t.assert.ok(request instanceof TpRequest)
+  t.assert.strictEqual(request.host, 'example.com')
 })
 
 test('Request with trust proxy - handles multiple entries in x-forwarded-host/proto', t => {
@@ -314,9 +408,9 @@ test('Request with trust proxy - handles multiple entries in x-forwarded-host/pr
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.type(request, TpRequest)
-  t.equal(request.host, 'example.com')
-  t.equal(request.protocol, 'https')
+  t.assert.ok(request instanceof TpRequest)
+  t.assert.strictEqual(request.host, 'example.com')
+  t.assert.strictEqual(request.protocol, 'https')
 })
 
 test('Request with trust proxy - plain', t => {
@@ -334,7 +428,7 @@ test('Request with trust proxy - plain', t => {
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.same(request.protocol, 'http')
+  t.assert.deepStrictEqual(request.protocol, 'http')
 })
 
 test('Request with undefined socket', t => {
@@ -348,25 +442,49 @@ test('Request with undefined socket', t => {
     socket: undefined,
     headers
   }
-  const request = new Request('id', 'params', req, 'query', 'log')
-  t.type(request, Request)
-  t.equal(request.id, 'id')
-  t.equal(request.params, 'params')
-  t.same(request.raw, req)
-  t.equal(request.query, 'query')
-  t.equal(request.headers, headers)
-  t.equal(request.log, 'log')
-  t.equal(request.ip, undefined)
-  t.equal(request.ips, undefined)
-  t.equal(request.host, 'hostname')
-  t.same(request.body, null)
-  t.equal(request.method, 'GET')
-  t.equal(request.url, '/')
-  t.equal(request.protocol, undefined)
-  t.same(request.socket, req.socket)
-  t.type(request.validateInput, Function)
-  t.type(request.getValidationFunction, Function)
-  t.type(request.compileValidationSchema, Function)
+  const context = new Context({
+    schema: {
+      body: {
+        type: 'object',
+        required: ['hello'],
+        properties: {
+          hello: { type: 'string' }
+        }
+      }
+    },
+    config: {
+      some: 'config',
+      url: req.url,
+      method: req.method
+    },
+    server: {
+      [kReply]: {},
+      [kRequest]: Request,
+      [kOptions]: {
+        requestIdLogLabel: 'reqId'
+      },
+      server: {}
+    }
+  })
+  const request = new Request('id', 'params', req, 'query', 'log', context)
+  t.assert.ok(request instanceof Request)
+  t.assert.strictEqual(request.id, 'id')
+  t.assert.strictEqual(request.params, 'params')
+  t.assert.deepStrictEqual(request.raw, req)
+  t.assert.strictEqual(request.query, 'query')
+  t.assert.strictEqual(request.headers, headers)
+  t.assert.strictEqual(request.log, 'log')
+  t.assert.strictEqual(request.ip, undefined)
+  t.assert.strictEqual(request.ips, undefined)
+  t.assert.strictEqual(request.host, 'hostname')
+  t.assert.deepStrictEqual(request.body, undefined)
+  t.assert.strictEqual(request.method, 'GET')
+  t.assert.strictEqual(request.url, '/')
+  t.assert.strictEqual(request.protocol, undefined)
+  t.assert.deepStrictEqual(request.socket, req.socket)
+  t.assert.ok(request.validateInput instanceof Function)
+  t.assert.ok(request.getValidationFunction instanceof Function)
+  t.assert.ok(request.compileValidationSchema instanceof Function)
 })
 
 test('Request with trust proxy and undefined socket', t => {
@@ -384,5 +502,5 @@ test('Request with trust proxy and undefined socket', t => {
 
   const TpRequest = Request.buildRequest(Request, true)
   const request = new TpRequest('id', 'params', req, 'query', 'log')
-  t.same(request.protocol, undefined)
+  t.assert.deepStrictEqual(request.protocol, undefined)
 })

package/test/internals/server.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const proxyquire = require('proxyquire')
 
 const Fastify = require('../../fastify')
@@ -15,7 +15,7 @@ test('start listening', async t => {
   const { server, listen } = createServer({}, handler)
   await listen.call(Fastify(), { port: 0, host: 'localhost' })
   server.close()
-  t.pass('server started')
+  t.assert.ok(true, 'server started')
 })
 
 test('DNS errors does not stop the main server on localhost - promise interface', async t => {
@@ -29,10 +29,10 @@ test('DNS errors does not stop the main server on localhost - promise interface'
   const { server, listen } = createServer({}, handler)
   await listen.call(Fastify(), { port: 0, host: 'localhost' })
   server.close()
-  t.pass('server started')
+  t.assert.ok(true, 'server started')
 })
 
-test('DNS errors does not stop the main server on localhost - callback interface', t => {
+test('DNS errors does not stop the main server on localhost - callback interface', (t, done) => {
   t.plan(2)
   const { createServer } = proxyquire('../../lib/server', {
     'node:dns': {
@@ -43,13 +43,14 @@ test('DNS errors does not stop the main server on localhost - callback interface
   })
   const { server, listen } = createServer({}, handler)
   listen.call(Fastify(), { port: 0, host: 'localhost' }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
     server.close()
-    t.pass('server started')
+    t.assert.ok(true, 'server started')
+    done()
   })
 })
 
-test('DNS returns empty binding', t => {
+test('DNS returns empty binding', (t, done) => {
   t.plan(2)
   const { createServer } = proxyquire('../../lib/server', {
     'node:dns': {
@@ -60,13 +61,14 @@ test('DNS returns empty binding', t => {
   })
   const { server, listen } = createServer({}, handler)
   listen.call(Fastify(), { port: 0, host: 'localhost' }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
     server.close()
-    t.pass('server started')
+    t.assert.ok(true, 'server started')
+    done()
   })
 })
 
-test('DNS returns more than two binding', t => {
+test('DNS returns more than two binding', (t, done) => {
   t.plan(2)
   const { createServer } = proxyquire('../../lib/server', {
     'node:dns': {
@@ -81,8 +83,9 @@ test('DNS returns more than two binding', t => {
   })
   const { server, listen } = createServer({}, handler)
   listen.call(Fastify(), { port: 0, host: 'localhost' }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
     server.close()
-    t.pass('server started')
+    t.assert.ok(true, 'server started')
+    done()
   })
 })