fastify 2.7.1 → 2.11.0

package/lib/route.js

@@ -6,17 +6,28 @@ const Context = require('./context')
 const { buildMiddie, onRunMiddlewares } = require('./middleware')
 const { hookRunner, hookIterator } = require('./hooks')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const supportedHooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization', 'onResponse', 'onSend']
 const validation = require('./validation')
 const buildSchema = validation.build
 const { buildSchemaCompiler } = validation
 const { beforeHandlerWarning } = require('./warnings')
 
+const {
+  codes: {
+    FST_ERR_SCH_BUILD,
+    FST_ERR_SCH_MISSING_COMPILER
+  }
+} = require('./errors')
+
 const {
   kRoutePrefix,
   kLogLevel,
+  kLogSerializers,
   kHooks,
   kSchemas,
+  kOptions,
   kSchemaCompiler,
+  kSchemaResolver,
   kContentTypeParser,
   kReply,
   kReplySerializerDefault,
@@ -171,6 +182,10 @@ function buildRouting (options) {
       opts.prefix = prefix
       opts.logLevel = opts.logLevel || this[kLogLevel]
 
+      if (this[kLogSerializers] || opts.logSerializers) {
+        opts.logSerializers = Object.assign(Object.create(this[kLogSerializers]), opts.logSerializers)
+      }
+
       if (opts.attachValidation == null) {
         opts.attachValidation = false
       }
@@ -198,6 +213,7 @@ function buildRouting (options) {
         this._errorHandler,
         opts.bodyLimit,
         opts.logLevel,
+        opts.logSerializers,
         opts.attachValidation,
         this[kReplySerializerDefault]
       )
@@ -206,22 +222,26 @@ function buildRouting (options) {
       // not called for every single route. Creating a new one for every route
       // is going to be very expensive.
       if (opts.schema) {
+        if (this[kSchemaCompiler] == null && this[kSchemaResolver]) {
+          done(new FST_ERR_SCH_MISSING_COMPILER(opts.method, url))
+          return
+        }
+
         try {
           if (opts.schemaCompiler == null && this[kSchemaCompiler] == null) {
             const externalSchemas = this[kSchemas].getJsonSchemas({ onlyAbsoluteUri: true })
-            this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, schemaCache))
+            this.setSchemaCompiler(buildSchemaCompiler(externalSchemas, this[kOptions].ajv, schemaCache))
           }
 
-          buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas])
+          buildSchema(context, opts.schemaCompiler || this[kSchemaCompiler], this[kSchemas], this[kSchemaResolver])
         } catch (error) {
-          done(error)
+          // bubble up the FastifyError instance
+          done(error.code ? error : new FST_ERR_SCH_BUILD(opts.method, url, error.message))
           return
         }
       }
 
-      const hooks = ['preParsing', 'preValidation', 'onRequest', 'preHandler', 'preSerialization']
-
-      for (const hook of hooks) {
+      for (const hook of supportedHooks) {
         if (opts[hook]) {
           if (Array.isArray(opts[hook])) {
             opts[hook] = opts[hook].map(fn => fn.bind(this))
@@ -250,7 +270,7 @@ function buildRouting (options) {
         context.onError = onError.length ? onError : null
         context.onResponse = onResponse.length ? onResponse : null
 
-        for (const hook of hooks) {
+        for (const hook of supportedHooks) {
           const toSet = this[kHooks][hook].concat(opts[hook] || [])
           context[hook] = toSet.length ? toSet : null
         }
@@ -287,7 +307,7 @@ function buildRouting (options) {
 
     req.id = req.headers[requestIdHeader] || genReqId(req)
     req.originalUrl = req.url
-    var hostname = req.headers['host']
+    var hostname = req.headers.host
     var ip = req.connection.remoteAddress
     var ips
 
@@ -299,7 +319,15 @@ function buildRouting (options) {
       }
     }
 
-    var childLogger = logger.child({ [requestIdLogLabel]: req.id, level: context.logLevel })
+    var loggerOpts = {
+      [requestIdLogLabel]: req.id,
+      level: context.logLevel
+    }
+
+    if (context.logSerializers) {
+      loggerOpts.serializers = context.logSerializers
+    }
+    var childLogger = logger.child(loggerOpts)
     childLogger[kDisableRequestLogging] = disableRequestLogging
 
     // added hostname, ip, and ips back to the Node req object to maintain backward compatibility

package/lib/schemas.js

@@ -18,12 +18,12 @@ function Schemas () {
   this.store = {}
 }
 
-Schemas.prototype.add = function (inputSchema) {
-  var schema = fastClone(inputSchema[kFluentSchema]
+Schemas.prototype.add = function (inputSchema, refResolver) {
+  var schema = fastClone((inputSchema.isFluentSchema || inputSchema[kFluentSchema])
     ? inputSchema.valueOf()
     : inputSchema
   )
-  const id = schema['$id']
+  const id = schema.$id
   if (id === undefined) {
     throw new FST_ERR_SCH_MISSING_ID()
   }
@@ -32,17 +32,17 @@ Schemas.prototype.add = function (inputSchema) {
     throw new FST_ERR_SCH_ALREADY_PRESENT(id)
   }
 
-  this.store[id] = this.resolveRefs(schema, true)
+  this.store[id] = this.resolveRefs(schema, true, refResolver)
 }
 
 Schemas.prototype.resolve = function (id) {
   if (this.store[id] === undefined) {
     throw new FST_ERR_SCH_NOT_PRESENT(id)
   }
-  return this.store[id]
+  return Object.assign({}, this.store[id])
 }
 
-Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId) {
+Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId, refResolver) {
   // alias query to querystring schema
   if (routeSchemas.query) {
     // check if our schema has both querystring and query
@@ -65,7 +65,7 @@ Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId) {
   try {
     // this will work only for standard json schemas
     // other compilers such as Joi will fail
-    this.traverse(routeSchemas)
+    this.traverse(routeSchemas, refResolver)
 
     // when a plugin uses the 'skip-override' and call addSchema
     // the same JSON will be pass throug all the avvio tree. In this case
@@ -99,15 +99,26 @@ Schemas.prototype.resolveRefs = function (routeSchemas, dontClearId) {
   return routeSchemas
 }
 
-Schemas.prototype.traverse = function (schema) {
+Schemas.prototype.traverse = function (schema, refResolver) {
   for (var key in schema) {
     // resolve the `sharedSchemaId#' only if is not a standard $ref JSON Pointer
     if (typeof schema[key] === 'string' && key !== '$schema' && key !== '$ref' && schema[key].slice(-1) === '#') {
       schema[key] = this.resolve(schema[key].slice(0, -1))
+    } else if (key === '$ref' && refResolver) {
+      const refValue = schema[key]
+
+      const framePos = refValue.indexOf('#')
+      const refId = framePos >= 0 ? refValue.slice(0, framePos) : refValue
+      if (refId.length > 0 && !this.store[refId]) {
+        const resolvedSchema = refResolver(refId)
+        if (resolvedSchema) {
+          this.add(resolvedSchema, refResolver)
+        }
+      }
     }
 
     if (schema[key] !== null && typeof schema[key] === 'object') {
-      this.traverse(schema[key])
+      this.traverse(schema[key], refResolver)
     }
   }
 }
@@ -124,7 +135,7 @@ Schemas.prototype.cleanId = function (schema) {
 }
 
 Schemas.prototype.getSchemaAnyway = function (schema) {
-  if (schema.oneOf || schema.allOf || schema.anyOf) return schema
+  if (schema.oneOf || schema.allOf || schema.anyOf || schema.$merge || schema.$patch) return schema
   if (!schema.type || !schema.properties) {
     return {
       type: 'object',
@@ -142,8 +153,8 @@ Schemas.prototype.getJsonSchemas = function (options) {
   const store = this.getSchemas()
   const schemasArray = Object.keys(store).map(schemaKey => {
     // if the shared-schema "replace-way" has been used, the $id field has been removed
-    if (store[schemaKey]['$id'] === undefined) {
-      store[schemaKey]['$id'] = schemaKey
+    if (store[schemaKey].$id === undefined) {
+      store[schemaKey].$id = schemaKey
     }
     return store[schemaKey]
   })

package/lib/symbols.js

@@ -5,9 +5,11 @@ const keys = {
   kBodyLimit: Symbol('fastify.bodyLimit'),
   kRoutePrefix: Symbol('fastify.routePrefix'),
   kLogLevel: Symbol('fastify.logLevel'),
+  kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
   kSchemas: Symbol('fastify.schemas'),
   kSchemaCompiler: Symbol('fastify.schemaCompiler'),
+  kSchemaResolver: Symbol('fastify.schemaRefResolver'),
   kReplySerializerDefault: Symbol('fastify.replySerializerDefault'),
   kContentTypeParser: Symbol('fastify.contentTypeParser'),
   kReply: Symbol('fastify.Reply'),
@@ -30,7 +32,8 @@ const keys = {
   kState: Symbol('fastify.state'),
   kOptions: Symbol('fastify.options'),
   kGlobalHooks: Symbol('fastify.globalHooks'),
-  kDisableRequestLogging: Symbol('fastify.disableRequestLogging')
+  kDisableRequestLogging: Symbol('fastify.disableRequestLogging'),
+  kPluginNameChain: Symbol('fastify.pluginNameChain')
 }
 
 module.exports = keys

package/lib/validation.js

@@ -22,13 +22,13 @@ function getResponseSchema (responseSchemaDefinition, sharedSchemas) {
   }, {})
 }
 
-function build (context, compile, schemas) {
+function build (context, compile, schemas, schemaResolver) {
   if (!context.schema) {
     return
   }
 
   generateFluentSchema(context.schema)
-  context.schema = schemas.resolveRefs(context.schema)
+  context.schema = schemas.resolveRefs(context.schema, false, schemaResolver)
 
   const headers = context.schema.headers
 
@@ -44,6 +44,7 @@ function build (context, compile, schemas) {
       headersSchemaLowerCase.required = headersSchemaLowerCase.required.map(h => h.toLowerCase())
     }
     if (headers.properties) {
+      headersSchemaLowerCase.properties = {}
       Object.keys(headers.properties).forEach(k => {
         headersSchemaLowerCase.properties[k.toLowerCase()] = headers.properties[k]
       })
@@ -70,14 +71,14 @@ function build (context, compile, schemas) {
 
 function generateFluentSchema (schema) {
   ;['params', 'body', 'querystring', 'query', 'headers'].forEach(key => {
-    if (schema[key] && schema[key][kFluentSchema]) {
+    if (schema[key] && (schema[key].isFluentSchema || schema[key][kFluentSchema])) {
       schema[key] = schema[key].valueOf()
     }
   })
 
   if (schema.response) {
     Object.keys(schema.response).forEach(code => {
-      if (schema.response[code][kFluentSchema]) {
+      if (schema.response[code].isFluentSchema || schema.response[code][kFluentSchema]) {
         schema.response[code] = schema.response[code].valueOf()
       }
     })
@@ -162,17 +163,22 @@ function schemaErrorsText (errors, dataVar) {
   return text.slice(0, -separator.length)
 }
 
-function buildSchemaCompiler (externalSchemas, cache) {
+function buildSchemaCompiler (externalSchemas, options, cache) {
   // This instance of Ajv is private
   // it should not be customized or used
-  const ajv = new Ajv({
+  const ajv = new Ajv(Object.assign({
     coerceTypes: true,
     useDefaults: true,
     removeAdditional: true,
     allErrors: true,
-    nullable: true,
-    cache
-  })
+    nullable: true
+  }, options.customOptions, { cache }))
+
+  if (options.plugins && options.plugins.length > 0) {
+    for (const plugin of options.plugins) {
+      plugin[0](ajv, plugin[1])
+    }
+  }
 
   if (Array.isArray(externalSchemas)) {
     externalSchemas.forEach(s => ajv.addSchema(s))

package/lib/wrapThenable.js

@@ -31,7 +31,7 @@ function wrapThenable (thenable, reply) {
         reply.send(err)
       }
     } else if (reply[kReplySent] === false) {
-      reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULLFILLED() }, `Promise may not be fulfilled with 'undefined' when statusCode is not 204`)
+      reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULLFILLED() }, "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
     }
   }, function (err) {
     if (reply[kReplySentOverwritten] === true) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "2.7.1",
+  "version": "2.11.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "typings": "fastify.d.ts",
@@ -15,10 +15,10 @@
     "test:report": "npm run lint && npm run unit:report && npm run typescript",
     "test": "npm run lint && npm run unit && npm run typescript",
     "coverage": "npm run unit -- --cov --coverage-report=html",
-    "coveralls": "npm run unit -- --cov",
+    "test:ci": "npm run lint && npm run unit -- --cov --coverage-report=lcovonly && npm run typescript",
     "bench": "branchcmp -r 2 -g -s \"npm run benchmark\"",
     "benchmark": "npx concurrently -k -s first \"node ./examples/simple.js\" \"npx autocannon -c 100 -d 5 -p 10 localhost:3000/\"",
-    "license-checker": "license-checker --production --onlyAllow='MIT;ISC;BSD-3-Clause;BSD-2-Clause'"
+    "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\""
   },
   "repository": {
     "type": "git",
@@ -77,6 +77,10 @@
     {
       "name": "James Sumners",
       "url": "https://james.sumners.info"
+    },
+    {
+      "name": "Denis Fäcke",
+      "url": "https://github.com/SerayaEryn"
     }
   ],
   "license": "MIT",
@@ -88,24 +92,26 @@
     "node": ">=6"
   },
   "devDependencies": {
-    "@types/node": "^11.13.18",
-    "@typescript-eslint/eslint-plugin": "^1.13.0",
-    "@typescript-eslint/parser": "^1.13.0",
+    "@types/node": "^12.0.0",
+    "@typescript-eslint/eslint-plugin": "^2.10.0",
+    "@typescript-eslint/parser": "^2.10.0",
     "JSONStream": "^1.3.5",
+    "ajv-merge-patch": "^4.1.0",
     "ajv-pack": "^0.3.1",
-    "autocannon": "^3.2.0",
+    "autocannon": "^3.2.2",
     "branch-comparer": "^0.4.0",
-    "concurrently": "^4.1.1",
+    "concurrently": "^5.0.0",
     "cors": "^2.8.5",
-    "coveralls": "^3.0.5",
+    "coveralls": "^3.0.9",
     "dns-prefetch-control": "^0.2.0",
+    "eslint": "^6.7.2",
     "eslint-import-resolver-node": "^0.3.2",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^1.5.0",
-    "fluent-schema": "^0.7.3",
-    "form-data": "^2.5.0",
+    "fluent-schema": "^0.9.0",
+    "form-data": "^3.0.0",
     "frameguard": "^3.0.0",
-    "h2url": "^0.1.2",
+    "h2url": "^0.2.0",
     "helmet": "^3.20.0",
     "hide-powered-by": "^1.0.0",
     "hsts": "^2.1.0",
@@ -113,9 +119,9 @@
     "ienoopen": "^1.0.0",
     "joi": "^12.0.0",
     "license-checker": "^25.0.1",
-    "lolex": "^4.0.1",
+    "lolex": "^4.2.0",
     "pre-commit": "^1.2.2",
-    "proxyquire": "^2.1.1",
+    "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "semver": "^6.3.0",
     "send": "^0.17.0",
@@ -123,28 +129,28 @@
     "simple-get": "^3.0.3",
     "snazzy": "^8.0.0",
     "split2": "^3.1.0",
-    "standard": "^13.0.1",
+    "standard": "^14.0.0",
     "tap": "^12.5.2",
     "tap-mocha-reporter": "^3.0.7",
     "then-sleep": "^1.0.1",
-    "typescript": "^3.5.3",
+    "typescript": "^3.7.3",
     "x-xss-protection": "^1.1.0"
   },
   "dependencies": {
-    "abstract-logging": "^1.0.0",
+    "abstract-logging": "^2.0.0",
     "ajv": "^6.10.2",
-    "avvio": "^6.1.1",
-    "fast-json-stringify": "^1.15.0",
-    "find-my-way": "^2.0.0",
+    "avvio": "^6.2.2",
+    "fast-json-stringify": "^1.15.7",
+    "find-my-way": "^2.2.0",
     "flatstr": "^1.0.12",
-    "light-my-request": "^3.4.1",
-    "middie": "^4.0.1",
-    "pino": "^5.13.1",
+    "light-my-request": "^3.6.2",
+    "middie": "^4.1.0",
+    "pino": "^5.14.0",
     "proxy-addr": "^2.0.4",
     "readable-stream": "^3.1.1",
     "rfdc": "^1.1.2",
-    "secure-json-parse": "^1.0.0",
-    "tiny-lru": "^6.0.1"
+    "secure-json-parse": "^2.0.0",
+    "tiny-lru": "^7.0.2"
   },
   "greenkeeper": {
     "ignore": [
@@ -153,7 +159,9 @@
       "joi",
       "@types/node",
       "tap",
-      "tap-mocha-reporter"
+      "tap-mocha-reporter",
+      "@typescript-eslint/eslint-plugin",
+      "lolex"
     ]
   },
   "standard": {

package/test/404s.test.js

@@ -979,7 +979,7 @@ test('log debug for 404', t => {
 
       const INFO_LEVEL = 30
       t.strictEqual(JSON.parse(logStream.logs[0]).msg, 'incoming request')
-      t.strictEqual(JSON.parse(logStream.logs[1]).msg, 'Not Found')
+      t.strictEqual(JSON.parse(logStream.logs[1]).msg, 'Route GET:/not-found not found')
       t.strictEqual(JSON.parse(logStream.logs[1]).level, INFO_LEVEL)
       t.strictEqual(JSON.parse(logStream.logs[2]).msg, 'request completed')
       t.strictEqual(logStream.logs.length, 3)
@@ -1733,3 +1733,43 @@ test('Should fail to invoke callNotFound inside a 404 handler', t => {
     t.is(res.payload, '404 Not Found')
   })
 })
+
+test('400 in case of bad url (pre find-my-way v2.2.0 was a 404)', t => {
+  t.test('Dyamic route', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    fastify.get('/hello/:id', () => t.fail('we should not be here'))
+    fastify.inject({
+      url: '/hello/%world',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 400)
+      t.deepEqual(JSON.parse(response.payload), {
+        error: 'Bad Request',
+        message: "'%world' is not a valid url component",
+        statusCode: 400
+      })
+    })
+  })
+
+  t.test('Wildcard', t => {
+    t.plan(3)
+    const fastify = Fastify()
+    fastify.get('*', () => t.fail('we should not be here'))
+    fastify.inject({
+      url: '/hello/%world',
+      method: 'GET'
+    }, (err, response) => {
+      t.error(err)
+      t.strictEqual(response.statusCode, 400)
+      t.deepEqual(JSON.parse(response.payload), {
+        error: 'Bad Request',
+        message: "'/hello/%world' is not a valid url component",
+        statusCode: 400
+      })
+    })
+  })
+
+  t.end()
+})

package/test/async-await.js

@@ -205,6 +205,72 @@ function asyncTest (t) {
     })
   })
 
+  test('await reply if we will be calling reply.send in the future', t => {
+    const lines = ['incoming request', 'request completed']
+    t.plan(lines.length + 2)
+
+    const splitStream = split(JSON.parse)
+    splitStream.on('data', (line) => {
+      t.is(line.msg, lines.shift())
+    })
+
+    const server = Fastify({
+      logger: {
+        stream: splitStream
+      }
+    })
+    const payload = { hello: 'world' }
+
+    server.get('/', async function awaitMyFunc (req, reply) {
+      setImmediate(function () {
+        reply.send(payload)
+      })
+
+      await reply
+    })
+
+    server.inject({
+      method: 'GET',
+      url: '/'
+    }, (err, res) => {
+      t.error(err)
+      const payload = JSON.parse(res.payload)
+      t.deepEqual(payload, { hello: 'world' })
+    })
+  })
+
+  test('await reply if we will be calling reply.send in the future (error case)', t => {
+    const lines = ['incoming request', 'kaboom', 'request completed']
+    t.plan(lines.length + 2)
+
+    const splitStream = split(JSON.parse)
+    splitStream.on('data', (line) => {
+      t.is(line.msg, lines.shift())
+    })
+
+    const server = Fastify({
+      logger: {
+        stream: splitStream
+      }
+    })
+
+    server.get('/', async function awaitMyFunc (req, reply) {
+      setImmediate(function () {
+        reply.send(new Error('kaboom'))
+      })
+
+      await reply
+    })
+
+    server.inject({
+      method: 'GET',
+      url: '/'
+    }, (err, res) => {
+      t.error(err)
+      t.equal(res.statusCode, 500)
+    })
+  })
+
   test('support reply decorators with await', t => {
     t.plan(2)
 

package/test/custom-parser.test.js

@@ -1060,7 +1060,7 @@ test('Wrong parseAs parameter', t => {
     fastify.addContentTypeParser('application/json', { parseAs: 'fireworks' }, () => {})
     t.fail('should throw')
   } catch (err) {
-    t.is(err.message, `FST_ERR_CTP_INVALID_PARSE_TYPE: The body parser can only parse your data as 'string' or 'buffer', you asked 'fireworks' which is not supported.`)
+    t.is(err.message, "FST_ERR_CTP_INVALID_PARSE_TYPE: The body parser can only parse your data as 'string' or 'buffer', you asked 'fireworks' which is not supported.")
   }
 })
 

package/test/custom-querystring-parser.test.js

@@ -131,7 +131,7 @@ test('Custom querystring parser should be a function', t => {
   } catch (err) {
     t.strictEqual(
       err.message,
-      `querystringParser option should be a function, instead got 'number'`
+      "querystringParser option should be a function, instead got 'number'"
     )
   }
 })

package/test/decorator.test.js

@@ -660,3 +660,51 @@ test('a decorator should addSchema to all the encapsulated tree', t => {
 
   fastify.ready(t.error)
 })
+
+test('after can access to a decorated instance and previous plugin decoration', t => {
+  t.plan(11)
+  const TEST_VALUE = {}
+  const OTHER_TEST_VALUE = {}
+  const NEW_TEST_VALUE = {}
+
+  const fastify = Fastify()
+
+  fastify.register(fp(function (instance, options, next) {
+    instance.decorate('test', TEST_VALUE)
+
+    next()
+  })).after(function (err, instance, done) {
+    t.error(err)
+    t.equal(instance.test, TEST_VALUE)
+
+    instance.decorate('test2', OTHER_TEST_VALUE)
+    done()
+  })
+
+  fastify.register(fp(function (instance, options, next) {
+    t.equal(instance.test, TEST_VALUE)
+    t.equal(instance.test2, OTHER_TEST_VALUE)
+
+    instance.decorate('test3', NEW_TEST_VALUE)
+
+    next()
+  })).after(function (err, instance, done) {
+    t.error(err)
+    t.equal(instance.test, TEST_VALUE)
+    t.equal(instance.test2, OTHER_TEST_VALUE)
+    t.equal(instance.test3, NEW_TEST_VALUE)
+
+    done()
+  })
+
+  fastify.get('/', function (req, res) {
+    t.equal(this.test, TEST_VALUE)
+    t.equal(this.test2, OTHER_TEST_VALUE)
+    res.send({})
+  })
+
+  fastify.inject('/')
+    .then(response => {
+      t.equal(response.statusCode, 200)
+    })
+})

package/test/emit-warning.test.js

@@ -7,7 +7,7 @@ test('should emit warning using genReqId prop in logger options', t => {
   t.plan(1)
 
   process.once('warning', warning => {
-    t.strictEqual(warning.message, `Using 'genReqId' in logger options is deprecated. Use fastify options instead. See: https://www.fastify.io/docs/latest/Server/#gen-request-id`)
+    t.strictEqual(warning.message, "Using 'genReqId' in logger options is deprecated. Use fastify options instead. See: https://www.fastify.io/docs/latest/Server/#gen-request-id")
   })
 
   Fastify({ logger: { genReqId: 'test' } })
@@ -17,7 +17,7 @@ test('should emit warning if basePath prop is used', t => {
   t.plan(1)
 
   process.once('warning', warning => {
-    t.strictEqual(warning.message, `basePath is deprecated. Use prefix instead. See: https://www.fastify.io/docs/latest/Server/#prefix`)
+    t.strictEqual(warning.message, 'basePath is deprecated. Use prefix instead. See: https://www.fastify.io/docs/latest/Server/#prefix')
   })
 
   const fastify = Fastify({ basePath: '/test' })
@@ -28,7 +28,7 @@ test('should emit warning if preHandler is used', t => {
   t.plan(1)
 
   process.once('warning', warning => {
-    t.strictEqual(warning.message, `The route option \`beforeHandler\` has been deprecated, use \`preHandler\` instead`)
+    t.strictEqual(warning.message, 'The route option `beforeHandler` has been deprecated, use `preHandler` instead')
   })
 
   const fastify = Fastify()