node-fastify 5.8.3

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

@@ -0,0 +1,263 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+
+const schema = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'null'
+      }
+    }
+  }
+}
+
+const querySchema = {
+  schema: {
+    querystring: {
+      type: 'object',
+      properties: {
+        hello: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}
+
+const paramsSchema = {
+  schema: {
+    params: {
+      type: 'object',
+      properties: {
+        foo: {
+          type: 'string'
+        },
+        test: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}
+
+test('shorthand - head', t => {
+  t.plan(1)
+  try {
+    fastify.head('/', schema, function (req, reply) {
+      reply.code(200).send(null)
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('shorthand - custom head', t => {
+  t.plan(1)
+  try {
+    fastify.head('/proxy/*', function (req, reply) {
+      reply.headers({ 'x-foo': 'bar' })
+      reply.code(200).send(null)
+    })
+
+    fastify.get('/proxy/*', function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('shorthand - custom head with constraints', t => {
+  t.plan(1)
+  try {
+    fastify.head('/proxy/*', { constraints: { version: '1.0.0' } }, function (req, reply) {
+      reply.headers({ 'x-foo': 'bar' })
+      reply.code(200).send(null)
+    })
+
+    fastify.get('/proxy/*', { constraints: { version: '1.0.0' } }, function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('shorthand - should not reset a head route', t => {
+  t.plan(1)
+  try {
+    fastify.get('/query1', function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    fastify.put('/query1', function (req, reply) {
+      reply.code(200).send(null)
+    })
+
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('shorthand - should set get and head route in the same api call', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: ['HEAD', 'GET'],
+      url: '/query4',
+      handler: function (req, reply) {
+        reply.headers({ 'x-foo': 'bar' })
+        reply.code(200).send(null)
+      }
+    })
+
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('shorthand - head params', t => {
+  t.plan(1)
+  try {
+    fastify.head('/params/:foo/:test', paramsSchema, function (req, reply) {
+      reply.send(null)
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('shorthand - head, querystring schema', t => {
+  t.plan(1)
+  try {
+    fastify.head('/query', querySchema, function (req, reply) {
+      reply.code(200).send(null)
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('missing schema - head', t => {
+  t.plan(1)
+  try {
+    fastify.head('/missing', function (req, reply) {
+      reply.code(200).send(null)
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('head test', async t => {
+  t.after(() => { fastify.close() })
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  await t.test('shorthand - request head', async t => {
+    t.plan(2)
+    const result = await fetch(fastifyServer, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - request head params schema', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/params/world/123`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - request head params schema error', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/params/world/string`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 400)
+  })
+
+  await t.test('shorthand - request head querystring schema', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/query?hello=123`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - request head querystring schema error', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/query?hello=world`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 400)
+  })
+
+  await t.test('shorthand - request head missing schema', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/missing`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - request head custom head', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/proxy/test`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.headers.get('x-foo'), 'bar')
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - request head custom head with constraints', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/proxy/test`, {
+      method: 'HEAD',
+      headers: {
+        version: '1.0.0'
+      }
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.headers.get('x-foo'), 'bar')
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - should not reset a head route', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/query1`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+  })
+
+  await t.test('shorthand - should set get and head route in the same api call', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/query4`, {
+      method: 'HEAD'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.headers.get('x-foo'), 'bar')
+    t.assert.strictEqual(result.status, 200)
+  })
+})

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

@@ -0,0 +1,108 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+fastify.addHttpMethod('LOCK', { hasBody: true })
+
+const bodySample = `<?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://fastify.test/~ejw/contact.html</D:href>
+          </D:owner>
+        </D:lockinfo> `
+
+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://fastify.test/~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://fastify.test/workspace/webdav/proposal.oc</D:href>
+                  </D:lockroot>
+                </D:activelock>
+              </D:lockdiscovery>
+            </D:prop>`
+          )
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('lock 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 - lock', async (t) => {
+    t.plan(3)
+
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'LOCK',
+      headers: { 'content-type': 'text/plain' },
+      body: bodySample
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    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) - lock', async (t) => {
+    t.plan(3)
+
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'LOCK',
+      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 - lock', async (t) => {
+    t.plan(3)
+
+    const result = await fetch(`${fastifyServer}/test/a.txt`, {
+      method: 'LOCK',
+      headers: { 'content-type': 'text/plain' }
+    })
+
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    const body = await result.text()
+    t.assert.strictEqual(result.headers.get('content-length'), '' + body.length)
+  })
+})

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

@@ -0,0 +1,143 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../fastify')()
+fastify.addHttpMethod('MKCALENDAR', { hasBody: true })
+
+const bodySample = `<?xml version="1.0" encoding="UTF-8"?>
+  <B:mkcalendar xmlns:B="urn:ietf:params:xml:ns:caldav">
+    <A:set xmlns:A="DAV:">
+      <A:prop>
+        <B:calendar-free-busy-set>
+          <NO/>
+        </B:calendar-free-busy-set>
+        <E:calendar-order xmlns:E="http://apple.com/ns/ical/">0</E:calendar-order>
+        <B:supported-calendar-component-set>
+          <B:comp name="VEVENT"/>
+        </B:supported-calendar-component-set>
+        <A:displayname>CALENDAR_NAME</A:displayname>
+        <B:calendar-timezone>BEGIN:VCALENDAR&#13;
+          VERSION:2.0&#13;
+        </B:calendar-timezone>
+      </A:prop>
+    </A:set>
+  </B:mkcalendar>
+  `
+
+test('can be created - mkcalendar', (t) => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MKCALENDAR',
+      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('mkcalendar test', async t => {
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => {
+    fastify.close()
+  })
+
+  await t.test('request - mkcalendar', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/`, {
+      method: 'MKCALENDAR'
+    })
+    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 - mkcalendar', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR'
+    })
+    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 - mkcalendar', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR',
+      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) - mkcalendar', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR',
+      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 - mkcalendar', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test`, {
+      method: 'MKCALENDAR'
+    })
+    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/mkcol.test.js

@@ -0,0 +1,35 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../')()
+fastify.addHttpMethod('MKCOL')
+
+test('can be created - mkcol', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MKCOL',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(201).send()
+      }
+    })
+    t.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+
+test('mkcol test', async t => {
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => { fastify.close() })
+
+  await t.test('request - mkcol', async t => {
+    t.plan(2)
+    const result = await fetch(`${fastifyServer}/test/`, {
+      method: 'MKCOL'
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 201)
+  })
+})

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

@@ -0,0 +1,42 @@
+'use strict'
+
+const { test } = require('node:test')
+const fastify = require('../../')()
+fastify.addHttpMethod('MOVE')
+
+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.assert.ok(true)
+  } catch (e) {
+    t.assert.fail()
+  }
+})
+test('move test', async t => {
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  t.after(() => { fastify.close() })
+
+  await t.test('request - move', async t => {
+    t.plan(3)
+    const result = await fetch(`${fastifyServer}/test.txt`, {
+      method: 'MOVE',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    })
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 201)
+    t.assert.strictEqual(result.headers.get('location'), '/test2.txt')
+  })
+})