node-fastify 5.8.3

package/test/http-methods/propfind.test.js

@@ -0,0 +1,136 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../')()
+fastify.addHttpMethod('PROPFIND', { hasBody: true })
+
+const bodySample = `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propfind xmlns:D="DAV:">
+          <D:prop xmlns:R="http://ns.fastify.test/boxschema/">
+            <R:bigbox/> <R:author/> <R:DingALing/> <R:Random/>
+          </D:prop>
+        </D:propfind>
+      `
+
+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.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('propfind test', async t => {
+  await fastify.listen({ port: 0 })
+
+  t.after(() => {
+    fastify.close()
+  })
+
+  await t.test('request - propfind', async t => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/`, {
+      method: 'PROPFIND'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+
+  await t.test('request with other path - propfind', async t => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'PROPFIND'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+
+  // the body test uses a text/plain content type instead of application/xml because it requires
+  // a specific content type parser
+  await t.test('request with body - propfind', async t => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'PROPFIND',
+      headers: { 'content-type': 'text/plain' },
+      body: bodySample
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+
+  await t.test('request with body and no content type (415 error) - propfind', async t => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'PROPFIND',
+      body: bodySample,
+      headers: { 'content-type': '' }
+    })
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 415)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+
+  await t.test('request without body - propfind', async t => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'PROPFIND'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+})

package/test/http-methods/proppatch.test.js

@@ -0,0 +1,105 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../')()
+fastify.addHttpMethod('PROPPATCH', { hasBody: true })
+
+const bodySample = `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propertyupdate xmlns:D="DAV:"
+          xmlns:Z="http://ns.fastify.test/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>`
+
+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.fastify.test/standards/z39.50/">
+              <D:response>
+                <D:href>http://www.fastify.test/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.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('proppatch test', async t => {
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => { fastify.close() })
+  // the body test uses a text/plain content type instead of application/xml because it requires
+  // a specific content type parser
+  await t.test('request with body - proppatch', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'PROPPATCH',
+      headers: { 'content-type': 'text/plain' },
+      body: bodySample
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+
+  await t.test('request with body and no content type (415 error) - proppatch', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'PROPPATCH',
+      body: bodySample,
+      headers: { 'content-type': undefined }
+    })
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 415)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+
+  await t.test('request without body - proppatch', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'PROPPATCH'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+})

package/test/http-methods/report.test.js

@@ -0,0 +1,142 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+fastify.addHttpMethod('REPORT', { hasBody: true })
+
+const bodySample = `<?xml version="1.0" encoding="UTF-8"?>
+  <B:calendar-query xmlns:B="urn:ietf:params:xml:ns:caldav">
+    <A:prop xmlns:A="DAV:">
+      <A:getetag/>
+      <A:getcontenttype/>
+    </A:prop>
+    <B:filter>
+      <B:comp-filter name="VCALENDAR">
+        <B:comp-filter name="VEVENT">
+          <B:time-range start="20170215T000000Z"/>
+        </B:comp-filter>
+      </B:comp-filter>
+    </B:filter>
+  </B:calendar-query>
+  `
+
+test('can be created - report', (t) => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'REPORT',
+      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.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('report test', async t => {
+  await fastify.listen({ port: 0 })
+
+  t.after(() => {
+    fastify.close()
+  })
+
+  await t.test('request - report', async (t) => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/`, {
+      method: 'REPORT'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
+  })
+
+  await t.test('request with other path - report', async (t) => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
+  })
+
+  // the body test uses a text/plain content type instead of application/xml because it requires
+  // a specific content type parser
+  await t.test('request with body - report', async (t) => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT',
+      headers: { 'content-type': 'text/plain' },
+      body: bodySample
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
+  })
+
+  await t.test('request with body and no content type (415 error) - report', async (t) => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT',
+      body: bodySample,
+      headers: { 'content-type': '' }
+    })
+
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 415)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
+  })
+
+  await t.test('request without body - report', async (t) => {
+    t.plan(3)
+    const result = await fetch(`http://localhost:${fastify.server.address().port}/test`, {
+      method: 'REPORT'
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 207)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + (await result.text()).length)
+  })
+})

package/test/http-methods/search.test.js

@@ -0,0 +1,233 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+fastify.addHttpMethod('SEARCH', { hasBody: true })
+
+const schema = {
+  response: {
+    '2xx': {
+      type: 'object',
+      properties: {
+        hello: {
+          type: 'string'
+        }
+      }
+    }
+  }
+}
+
+const querySchema = {
+  querystring: {
+    type: 'object',
+    properties: {
+      hello: {
+        type: 'integer'
+      }
+    }
+  }
+}
+
+const paramsSchema = {
+  params: {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      },
+      test: {
+        type: 'integer'
+      }
+    }
+  }
+}
+
+const bodySchema = {
+  body: {
+    type: 'object',
+    properties: {
+      foo: {
+        type: 'string'
+      },
+      test: {
+        type: 'integer'
+      }
+    }
+  }
+}
+
+test('search', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/',
+      schema,
+      handler: function (request, reply) {
+        reply.code(200).send({ hello: 'world' })
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('search, params schema', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/params/:foo/:test',
+      schema: paramsSchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.params)
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('search, querystring schema', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/query',
+      schema: querySchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.query)
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('search, body schema', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/body',
+      schema: bodySchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.body)
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('search test', async t => {
+  await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+  const url = `http://localhost:${fastify.server.address().port}`
+
+  await t.test('request - search', async t => {
+    t.plan(4)
+    const result = await fetch(url, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  })
+
+  await t.test('request search params schema', async t => {
+    t.plan(4)
+    const result = await fetch(`${url}/params/world/123`, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { foo: 'world', test: 123 })
+  })
+
+  await t.test('request search params schema error', async t => {
+    t.plan(3)
+    const result = await fetch(`${url}/params/world/string`, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.strictEqual(result.status, 400)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'params/test must be integer',
+      statusCode: 400
+    })
+  })
+
+  await t.test('request search querystring schema', async t => {
+    t.plan(4)
+    const result = await fetch(`${url}/query?hello=123`, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 123 })
+  })
+
+  await t.test('request search querystring schema error', async t => {
+    t.plan(3)
+    const result = await fetch(`${url}/query?hello=world`, {
+      method: 'SEARCH'
+    })
+    const body = await result.text()
+    t.assert.strictEqual(result.status, 400)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'querystring/hello must be integer',
+      statusCode: 400
+    })
+  })
+
+  await t.test('request search body schema', async t => {
+    t.plan(4)
+    const replyBody = { foo: 'bar', test: 5 }
+    const result = await fetch(`${url}/body`, {
+      method: 'SEARCH',
+      body: JSON.stringify(replyBody),
+      headers: { 'content-type': 'application/json' }
+    })
+    const body = await result.text()
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), replyBody)
+  })
+
+  await t.test('request search body schema error', async t => {
+    t.plan(4)
+    const result = await fetch(`${url}/body`, {
+      method: 'SEARCH',
+      body: JSON.stringify({ foo: 'bar', test: 'test' }),
+      headers: { 'content-type': 'application/json' }
+    })
+    const body = await result.text()
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 400)
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), {
+      error: 'Bad Request',
+      code: 'FST_ERR_VALIDATION',
+      message: 'body/test must be integer',
+      statusCode: 400
+    })
+  })
+})

package/test/http-methods/trace.test.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+fastify.addHttpMethod('TRACE')
+
+test('shorthand - trace', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'TRACE',
+      url: '/',
+      handler: function (request, reply) {
+        reply.code(200).send('TRACE OK')
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})

package/test/http-methods/unlock.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+fastify.addHttpMethod('UNLOCK')
+
+test('can be created - unlock', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'UNLOCK',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(204).send()
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('unlock test', async t => {
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => { fastify.close() })
+  await t.test('request - unlock', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'UNLOCK',
+      headers: {
+        'Lock-Token': 'urn:uuid:a515cfa4-5da4-22e1-f5b5-00a0451e6bf7'
+      }
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 204)
+  })
+})