node-fastify 5.8.3

package/test/pretty-print.test.js

@@ -0,0 +1,366 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('pretty print - static routes', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/hello', () => {})
+  fastify.get('/hello/world', () => {})
+
+  fastify.ready(() => {
+    const tree = fastify.printRoutes()
+
+    const expected = `\
+└── /
+    ├── test (GET)
+    │   └── /hello (GET)
+    └── hello/world (GET)
+`
+
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
+  })
+})
+
+test('pretty print - internal tree - static routes', (t, done) => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/hello', () => {})
+  fastify.get('/hello/world', () => {})
+
+  fastify.put('/test', () => {})
+  fastify.put('/test/foo', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /hello (GET)
+    └── hello/world (GET)
+`
+
+    t.assert.strictEqual(typeof getTree, 'string')
+    t.assert.strictEqual(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    └── test (PUT)
+        └── /foo (PUT)
+`
+
+    t.assert.strictEqual(typeof putTree, 'string')
+    t.assert.strictEqual(putTree, expectedPutTree)
+    done()
+  })
+})
+
+test('pretty print - parametric routes', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/:hello', () => {})
+  fastify.get('/hello/:world', () => {})
+
+  fastify.ready(() => {
+    const tree = fastify.printRoutes()
+
+    const expected = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── :hello (GET)
+    └── hello/
+        └── :world (GET)
+`
+
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
+  })
+})
+
+test('pretty print - internal tree - parametric routes', (t, done) => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/:hello', () => {})
+  fastify.get('/hello/:world', () => {})
+
+  fastify.put('/test', () => {})
+  fastify.put('/test/:hello', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── :hello (GET)
+    └── hello/
+        └── :world (GET)
+`
+
+    t.assert.strictEqual(typeof getTree, 'string')
+    t.assert.strictEqual(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    └── test (PUT)
+        └── /
+            └── :hello (PUT)
+`
+
+    t.assert.strictEqual(typeof putTree, 'string')
+    t.assert.strictEqual(putTree, expectedPutTree)
+    done()
+  })
+})
+
+test('pretty print - mixed parametric routes', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/:hello', () => {})
+  fastify.post('/test/:hello', () => {})
+  fastify.get('/test/:hello/world', () => {})
+
+  fastify.ready(() => {
+    const tree = fastify.printRoutes()
+
+    const expected = `\
+└── /
+    └── test (GET)
+        └── /
+            └── :hello (GET, POST)
+                └── /world (GET)
+`
+
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
+  })
+})
+
+test('pretty print - wildcard routes', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/*', () => {})
+  fastify.get('/hello/*', () => {})
+
+  fastify.ready(() => {
+    const tree = fastify.printRoutes()
+
+    const expected = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── * (GET)
+    └── hello/
+        └── * (GET)
+`
+
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.strictEqual(tree, expected)
+    done()
+  })
+})
+
+test('pretty print - internal tree - wildcard routes', (t, done) => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/*', () => {})
+  fastify.get('/hello/*', () => {})
+
+  fastify.put('/*', () => {})
+  fastify.put('/test/*', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── * (GET)
+    └── hello/
+        └── * (GET)
+`
+
+    t.assert.strictEqual(typeof getTree, 'string')
+    t.assert.strictEqual(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    ├── test/
+    │   └── * (PUT)
+    └── * (PUT)
+`
+
+    t.assert.strictEqual(typeof putTree, 'string')
+    t.assert.strictEqual(putTree, expectedPutTree)
+    done()
+  })
+})
+
+test('pretty print - empty plugins', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  fastify.ready(() => {
+    const tree = fastify.printPlugins()
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.match(tree, /root \d+ ms\n└── bound _after \d+ ms/m)
+    done()
+  })
+})
+
+test('pretty print - nested plugins', (t, done) => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.register(async function foo (instance) {
+    instance.register(async function bar () {})
+    instance.register(async function baz () {})
+  })
+  fastify.ready(() => {
+    const tree = fastify.printPlugins()
+    t.assert.strictEqual(typeof tree, 'string')
+    t.assert.match(tree, /foo/)
+    t.assert.match(tree, /bar/)
+    t.assert.match(tree, /baz/)
+    done()
+  })
+})
+
+test('pretty print - commonPrefix', (t, done) => {
+  t.plan(4)
+
+  const fastify = Fastify()
+  fastify.get('/hello', () => {})
+  fastify.put('/hello', () => {})
+  fastify.get('/helicopter', () => {})
+
+  fastify.ready(() => {
+    const radixTree = fastify.printRoutes()
+    const flatTree = fastify.printRoutes({ commonPrefix: false })
+
+    const radixExpected = `\
+└── /
+    └── hel
+        ├── lo (GET, HEAD, PUT)
+        └── icopter (GET, HEAD)
+`
+    const flatExpected = `\
+├── /hello (GET, HEAD, PUT)
+└── /helicopter (GET, HEAD)
+`
+    t.assert.strictEqual(typeof radixTree, 'string')
+    t.assert.strictEqual(typeof flatTree, 'string')
+    t.assert.strictEqual(radixTree, radixExpected)
+    t.assert.strictEqual(flatTree, flatExpected)
+    done()
+  })
+})
+
+test('pretty print - includeMeta, includeHooks', (t, done) => {
+  t.plan(6)
+
+  const fastify = Fastify()
+  const onTimeout = () => {}
+  fastify.get('/hello', () => {})
+  fastify.put('/hello', () => {})
+  fastify.get('/helicopter', () => {})
+
+  fastify.addHook('onRequest', () => {})
+  fastify.addHook('onTimeout', onTimeout)
+
+  fastify.ready(() => {
+    const radixTree = fastify.printRoutes({ includeHooks: true, includeMeta: ['errorHandler'] })
+    const flatTree = fastify.printRoutes({ commonPrefix: false, includeHooks: true, includeMeta: ['errorHandler'] })
+    const hooksOnly = fastify.printRoutes({ commonPrefix: false, includeHooks: true })
+
+    const radixExpected = `\
+└── /
+    └── hel
+        ├── lo (GET, PUT)
+        │   • (onTimeout) ["onTimeout()"]
+        │   • (onRequest) ["anonymous()"]
+        │   • (errorHandler) "defaultErrorHandler()"
+        │   lo (HEAD)
+        │   • (onTimeout) ["onTimeout()"]
+        │   • (onRequest) ["anonymous()"]
+        │   • (onSend) ["headRouteOnSendHandler()"]
+        │   • (errorHandler) "defaultErrorHandler()"
+        └── icopter (GET)
+            • (onTimeout) ["onTimeout()"]
+            • (onRequest) ["anonymous()"]
+            • (errorHandler) "defaultErrorHandler()"
+            icopter (HEAD)
+            • (onTimeout) ["onTimeout()"]
+            • (onRequest) ["anonymous()"]
+            • (onSend) ["headRouteOnSendHandler()"]
+            • (errorHandler) "defaultErrorHandler()"
+`
+    const flatExpected = `\
+├── /hello (GET, PUT)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (errorHandler) "defaultErrorHandler()"
+│   /hello (HEAD)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (onSend) ["headRouteOnSendHandler()"]
+│   • (errorHandler) "defaultErrorHandler()"
+└── /helicopter (GET)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (errorHandler) "defaultErrorHandler()"
+    /helicopter (HEAD)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (onSend) ["headRouteOnSendHandler()"]
+    • (errorHandler) "defaultErrorHandler()"
+`
+
+    const hooksOnlyExpected = `\
+├── /hello (GET, PUT)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   /hello (HEAD)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (onSend) ["headRouteOnSendHandler()"]
+└── /helicopter (GET)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    /helicopter (HEAD)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (onSend) ["headRouteOnSendHandler()"]
+`
+    t.assert.strictEqual(typeof radixTree, 'string')
+    t.assert.strictEqual(typeof flatTree, 'string')
+    t.assert.strictEqual(typeof hooksOnlyExpected, 'string')
+    t.assert.strictEqual(radixTree, radixExpected)
+    t.assert.strictEqual(flatTree, flatExpected)
+    t.assert.strictEqual(hooksOnly, hooksOnlyExpected)
+    done()
+  })
+})

package/test/promises.test.js

@@ -0,0 +1,125 @@
+'use strict'
+
+const { test } = require('node:test')
+const assert = require('node:assert')
+const fastify = require('..')()
+
+test.after(() => fastify.close())
+
+const opts = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+fastify.get('/return', opts, function (req, reply) {
+  const promise = new Promise((resolve, reject) => {
+    resolve({ hello: 'world' })
+  })
+  return promise
+})
+
+fastify.get('/return-error', opts, function (req, reply) {
+  const promise = new Promise((resolve, reject) => {
+    reject(new Error('some error'))
+  })
+  return promise
+})
+
+fastify.get('/double', function (req, reply) {
+  setTimeout(function () {
+    // this should not throw
+    reply.send({ hello: 'world' })
+  }, 20)
+  return Promise.resolve({ hello: '42' })
+})
+
+fastify.get('/thenable', opts, function (req, reply) {
+  setImmediate(function () {
+    reply.send({ hello: 'world' })
+  })
+  return reply
+})
+
+fastify.get('/thenable-error', opts, function (req, reply) {
+  setImmediate(function () {
+    reply.send(new Error('kaboom'))
+  })
+  return reply
+})
+
+fastify.get('/return-reply', opts, function (req, reply) {
+  return reply.send({ hello: 'world' })
+})
+
+fastify.listen({ port: 0 }, (err, fastifyServer) => {
+  assert.ifError(err)
+
+  test('shorthand - fetch return promise es6 get', async t => {
+    t.plan(4)
+
+    const result = await fetch(`${fastifyServer}/return`)
+    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)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  })
+
+  test('shorthand - fetch promise es6 get return error', async t => {
+    t.plan(2)
+
+    const result = await fetch(`${fastifyServer}/return-error`)
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 500)
+  })
+
+  test('fetch promise double send', async t => {
+    t.plan(3)
+
+    const result = await fetch(`${fastifyServer}/double`)
+    t.assert.ok(result.ok)
+    t.assert.strictEqual(result.status, 200)
+    const body = await result.text()
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: '42' })
+  })
+
+  test('thenable', async t => {
+    t.plan(4)
+
+    const result = await fetch(`${fastifyServer}/thenable`)
+    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)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  })
+
+  test('thenable (error)', async t => {
+    t.plan(2)
+
+    const result = await fetch(`${fastifyServer}/thenable-error`)
+    t.assert.ok(!result.ok)
+    t.assert.strictEqual(result.status, 500)
+  })
+
+  test('return-reply', async t => {
+    t.plan(4)
+
+    const result = await fetch(`${fastifyServer}/return-reply`)
+    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)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  })
+})

package/test/proto-poisoning.test.js

@@ -0,0 +1,145 @@
+'use strict'
+
+const Fastify = require('..')
+const { test } = require('node:test')
+
+test('proto-poisoning error', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (request, reply) => {
+    t.assert.fail('handler should not be called')
+  })
+
+  t.after(() => fastify.close())
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{ "__proto__": { "a": 42 } }'
+  })
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 400)
+})
+
+test('proto-poisoning remove', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify({ onProtoPoisoning: 'remove' })
+
+  t.after(() => fastify.close())
+
+  fastify.post('/', (request, reply) => {
+    t.assert.strictEqual(undefined, Object.assign({}, request.body).a)
+    reply.send({ ok: true })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{ "__proto__": { "a": 42 }, "b": 42 }'
+  })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+})
+
+test('proto-poisoning ignore', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify({ onProtoPoisoning: 'ignore' })
+
+  fastify.post('/', (request, reply) => {
+    t.assert.strictEqual(42, Object.assign({}, request.body).a)
+    reply.send({ ok: true })
+  })
+
+  t.after(() => fastify.close())
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{ "__proto__": { "a": 42 }, "b": 42 }'
+  })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+})
+
+test('constructor-poisoning error (default in v3)', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.post('/', (request, reply) => {
+    reply.send('ok')
+  })
+
+  t.after(() => fastify.close())
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+  })
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 400)
+})
+
+test('constructor-poisoning error', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify({ onConstructorPoisoning: 'error' })
+
+  t.after(() => fastify.close())
+
+  fastify.post('/', (request, reply) => {
+    t.assert.fail('handler should not be called')
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+  })
+
+  t.assert.ok(!result.ok)
+  t.assert.strictEqual(result.status, 400)
+})
+
+test('constructor-poisoning remove', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify({ onConstructorPoisoning: 'remove' })
+
+  t.after(() => fastify.close())
+
+  fastify.post('/', (request, reply) => {
+    t.assert.strictEqual(undefined, Object.assign({}, request.body).foo)
+    reply.send({ ok: true })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+
+  const result = await fetch(fastifyServer, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: '{ "constructor": { "prototype": { "foo": "bar" } } }'
+  })
+
+  t.assert.ok(result.ok)
+  t.assert.strictEqual(result.status, 200)
+})

package/test/put.error-handler.test.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const t = require('node:test')
+require('./helper').payloadMethod('put', t, true)
+require('./input-validation').payloadMethod('put', t)

package/test/put.test.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const t = require('node:test')
+require('./helper').payloadMethod('put', t)
+require('./input-validation').payloadMethod('put', t)