fastify 4.3.0 → 4.5.1

package/test/copy.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - copy', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'COPY',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(204).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - copy', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+      method: 'COPY',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 204)
+    })
+  })
+})

package/test/hooks-async.test.js

@@ -710,3 +710,46 @@ test('preSerializationEnd should handle errors if the serialize method throws',
 
   t.end()
 })
+
+t.test('nested hooks to do not crash on 404', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/hello', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.register(async function (fastify) {
+    fastify.get('/something', (req, reply) => {
+      reply.callNotFound()
+    })
+
+    fastify.setNotFoundHandler(async (request, reply) => {
+      reply.statusCode = 404
+      return { status: 'nested-not-found' }
+    })
+
+    fastify.setErrorHandler(async (error, request, reply) => {
+      reply.statusCode = 500
+      return { status: 'nested-error', error }
+    })
+  }, { prefix: '/nested' })
+
+  fastify.setNotFoundHandler(async (request, reply) => {
+    reply.statusCode = 404
+    return { status: 'not-found' }
+  })
+
+  fastify.setErrorHandler(async (error, request, reply) => {
+    reply.statusCode = 500
+    return { status: 'error', error }
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/nested/something'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 404)
+  })
+})

package/test/internals/all.test.js

@@ -3,9 +3,15 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('../..')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('../../lib/httpMethods')
 
 test('fastify.all should add all the methods to the same url', t => {
+  const requirePayload = [
+    'POST',
+    'PUT',
+    'PATCH'
+  ]
+
   t.plan(supportedMethods.length * 2)
 
   const fastify = Fastify()
@@ -22,7 +28,7 @@ test('fastify.all should add all the methods to the same url', t => {
       method
     }
 
-    if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+    if (requirePayload.includes(method)) {
       options.payload = { hello: 'world' }
     }
 

package/test/internals/reply.test.js

@@ -1044,7 +1044,7 @@ test('reply.hasHeader returns correct values', t => {
 })
 
 test('reply.getHeader returns correct values', t => {
-  t.plan(4)
+  t.plan(5)
 
   const fastify = require('../../')()
 
@@ -1055,6 +1055,9 @@ test('reply.getHeader returns correct values', t => {
     reply.header('x-foo', 'bar')
     t.strictSame(reply.getHeader('x-foo'), 'bar')
 
+    reply.header('x-foo', 42)
+    t.strictSame(reply.getHeader('x-foo'), 42)
+
     reply.header('set-cookie', 'one')
     reply.header('set-cookie', 'two')
     t.strictSame(reply.getHeader('set-cookie'), ['one', 'two'])

package/test/lock.test.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - lock', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'LOCK',
+      url: '*',
+      handler: function (req, reply) {
+        reply
+          .code(200)
+          .send(`<?xml version="1.0" encoding="utf-8" ?>
+            <D:prop xmlns:D="DAV:">
+              <D:lockdiscovery>
+                <D:activelock>
+                  <D:locktype>
+                    <D:write/>
+                  </D:locktype>
+                  <D:lockscope>
+                    <D:exclusive/>
+                  </D:lockscope>
+                  <D:depth>infinity</D:depth>
+                  <D:owner>
+                    <D:href>http://example.org/~ejw/contact.html</D:href>
+                  </D:owner>
+                  <D:timeout>Second-604800</D:timeout>
+                  <D:locktoken>
+                    <D:href>urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4</:href>
+                  </D:locktoken>
+                  <D:lockroot>
+                    <D:href>http://example.com/workspace/webdav/proposal.oc</D:href>
+                  </D:lockroot>
+                </D:activelock>
+              </D:lockdiscovery>
+            </D:prop>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - lock', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:lockinfo xmlns:D='DAV:'>
+          <D:lockscope> <D:exclusive/> </D:lockscope>
+          <D:locktype> <D:write/> </D:locktype>
+          <D:owner>
+            <D:href>http://example.org/~ejw/contact.html</D:href>
+          </D:owner>
+        </D:lockinfo> `,
+      method: 'LOCK'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/logger.test.js

@@ -330,6 +330,51 @@ test('The request id header key can be customized', t => {
   })
 })
 
+test('The request id header key can be ignored', t => {
+  t.plan(9)
+  const REQUEST_ID = 'ignore-me'
+
+  const stream = split(JSON.parse)
+  const fastify = Fastify({
+    logger: { stream, level: 'info' },
+    requestIdHeader: false
+  })
+  t.teardown(() => fastify.close())
+
+  fastify.get('/', (req, reply) => {
+    t.equal(req.id, 'req-1')
+    req.log.info('some log message')
+    reply.send({ id: req.id })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/',
+    headers: {
+      'request-id': REQUEST_ID
+    }
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'req-1')
+
+    stream.once('data', line => {
+      t.equal(line.reqId, 'req-1')
+      t.equal(line.msg, 'incoming request', 'message is set')
+
+      stream.once('data', line => {
+        t.equal(line.reqId, 'req-1')
+        t.equal(line.msg, 'some log message', 'message is set')
+
+        stream.once('data', line => {
+          t.equal(line.reqId, 'req-1')
+          t.equal(line.msg, 'request completed', 'message is set')
+        })
+      })
+    })
+  })
+})
+
 test('The request id header key can be customized along with a custom id generator', t => {
   t.plan(12)
   const REQUEST_ID = '42'
@@ -393,6 +438,69 @@ test('The request id header key can be customized along with a custom id generat
   })
 })
 
+test('The request id header key can be ignored along with a custom id generator', t => {
+  t.plan(12)
+  const REQUEST_ID = 'ignore-me'
+
+  const stream = split(JSON.parse)
+  const fastify = Fastify({
+    logger: { stream, level: 'info' },
+    requestIdHeader: false,
+    genReqId (req) {
+      return 'foo'
+    }
+  })
+  t.teardown(() => fastify.close())
+
+  fastify.get('/one', (req, reply) => {
+    t.equal(req.id, 'foo')
+    req.log.info('some log message')
+    reply.send({ id: req.id })
+  })
+
+  fastify.get('/two', (req, reply) => {
+    t.equal(req.id, 'foo')
+    req.log.info('some log message 2')
+    reply.send({ id: req.id })
+  })
+
+  const matches = [
+    { reqId: 'foo', msg: /incoming request/ },
+    { reqId: 'foo', msg: /some log message/ },
+    { reqId: 'foo', msg: /request completed/ },
+    { reqId: 'foo', msg: /incoming request/ },
+    { reqId: 'foo', msg: /some log message 2/ },
+    { reqId: 'foo', msg: /request completed/ }
+  ]
+
+  let i = 0
+  stream.on('data', line => {
+    t.match(line, matches[i])
+    i += 1
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/one',
+    headers: {
+      'request-id': REQUEST_ID
+    }
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/two'
+  }, (err, res) => {
+    t.error(err)
+    const payload = JSON.parse(res.payload)
+    t.equal(payload.id, 'foo')
+  })
+})
+
 test('The request id log label can be changed', t => {
   t.plan(6)
   const REQUEST_ID = '42'

package/test/mkcol.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - mkcol', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MKCOL',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(201).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - mkcol', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/`,
+      method: 'MKCOL'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 201)
+    })
+  })
+})

package/test/move.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('shorthand - move', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MOVE',
+      url: '*',
+      handler: function (req, reply) {
+        const destination = req.headers.destination
+        reply.code(201)
+          .header('location', destination)
+          .send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - move', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+      method: 'MOVE',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 201)
+      t.equal(response.headers.location, '/test2.txt')
+    })
+  })
+})

package/test/propfind.test.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - propfind', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'PROPFIND',
+      url: '*',
+      handler: function (req, reply) {
+        return reply.code(207)
+          .send(`<?xml version="1.0" encoding="utf-8"?>
+            <D:multistatus xmlns:D="DAV:">
+              <D:response xmlns:lp1="DAV:">
+                <D:href>/</D:href>
+                <D:propstat>
+                  <D:prop>
+                    <lp1:resourcetype>
+                      <D:collection/>
+                    </lp1:resourcetype>
+                    <lp1:creationdate>2022-04-13T12:35:30Z</lp1:creationdate>
+                    <lp1:getlastmodified>Wed, 13 Apr 2022 12:35:30 GMT</lp1:getlastmodified>
+                    <lp1:getetag>"e0-5dc8869b53ef1"</lp1:getetag>
+                    <D:supportedlock>
+                      <D:lockentry>
+                        <D:lockscope>
+                          <D:exclusive/>
+                        </D:lockscope>
+                        <D:locktype>
+                          <D:write/>
+                        </D:locktype>
+                      </D:lockentry>
+                      <D:lockentry>
+                        <D:lockscope>
+                          <D:shared/>
+                        </D:lockscope>
+                        <D:locktype>
+                          <D:write/>
+                        </D:locktype>
+                      </D:lockentry>
+                    </D:supportedlock>
+                    <D:lockdiscovery/>
+                    <D:getcontenttype>httpd/unix-directory</D:getcontenttype>
+                  </D:prop>
+                  <D:status>HTTP/1.1 200 OK</D:status>
+                </D:propstat>
+              </D:response>
+            </D:multistatus>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/`,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+
+  test('request with other path - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test`,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+
+  test('request with body - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propfind xmlns:D="DAV:">
+          <D:prop xmlns:R="http://ns.example.com/boxschema/">
+            <R:bigbox/> <R:author/> <R:DingALing/> <R:Random/>
+          </D:prop>
+        </D:propfind>
+      `,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/proppatch.test.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('shorthand - proppatch', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'PROPPATCH',
+      url: '*',
+      handler: function (req, reply) {
+        reply
+          .code(207)
+          .send(`<?xml version="1.0" encoding="utf-8" ?>
+            <D:multistatus xmlns:D="DAV:"
+              xmlns:Z="http://ns.example.com/standards/z39.50/">
+              <D:response>
+                <D:href>http://www.example.com/bar.html</D:href>
+                <D:propstat>
+                  <D:prop>
+                    <Z:Authors/>
+                  </D:prop>
+                  <D:status>HTTP/1.1 424 Failed Dependency</D:status>
+                </D:propstat>
+                <D:propstat>
+                  <D:prop>
+                    <Z:Copyright-Owner/>
+                  </D:prop>
+                  <D:status>HTTP/1.1 409 Conflict</D:status>
+                </D:propstat>
+                <D:responsedescription> Copyright Owner cannot be deleted or altered.</D:responsedescription>
+              </D:response>
+            </D:multistatus>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - proppatch', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propertyupdate xmlns:D="DAV:"
+          xmlns:Z="http://ns.example.com/standards/z39.50/">
+          <D:set>
+            <D:prop>
+              <Z:Authors>
+                <Z:Author>Jim Whitehead</Z:Author>
+                <Z:Author>Roy Fielding</Z:Author>
+              </Z:Authors>
+            </D:prop>
+          </D:set>
+          <D:remove>
+            <D:prop>
+              <Z:Copyright-Owner/>
+            </D:prop>
+          </D:remove>
+        </D:propertyupdate>`,
+      method: 'PROPPATCH'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/schema-examples.test.js

@@ -509,6 +509,60 @@ test('should return custom error messages with ajv-errors', t => {
   })
 })
 
+test('should be able to handle formats of ajv-formats when added by plugins option', t => {
+  t.plan(3)
+
+  const fastify = Fastify({
+    ajv: {
+      plugins: [
+        require('ajv-formats')
+      ]
+    }
+  })
+
+  const schema = {
+    body: {
+      type: 'object',
+      properties: {
+        id: { type: 'string', format: 'uuid' },
+        email: { type: 'string', format: 'email' }
+      },
+      required: ['id', 'email']
+    }
+  }
+
+  fastify.post('/', { schema }, function (req, reply) {
+    reply.code(200).send(req.body.id)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      id: '254381a5-888c-4b41-8116-e3b1a54980bd',
+      email: 'info@fastify.io'
+    },
+    url: '/'
+  }, (_err, res) => {
+    t.equal(res.body, '254381a5-888c-4b41-8116-e3b1a54980bd')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    method: 'POST',
+    payload: {
+      id: 'invalid',
+      email: 'info@fastify.io'
+    },
+    url: '/'
+  }, (_err, res) => {
+    t.same(JSON.parse(res.payload), {
+      statusCode: 400,
+      error: 'Bad Request',
+      message: 'body/id must match format "uuid"'
+    })
+  })
+})
+
 test('should return localized error messages with ajv-i18n', t => {
   t.plan(3)