node-fastify 5.8.3

package/test/register.test.js

@@ -0,0 +1,184 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('register', async (t) => {
+  t.plan(16)
+
+  const fastify = Fastify()
+
+  fastify.register(function (instance, opts, done) {
+    t.assert.notStrictEqual(instance, fastify)
+    t.assert.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
+
+    t.assert.strictEqual(typeof opts, 'object')
+    t.assert.strictEqual(typeof done, 'function')
+
+    instance.get('/first', function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+    done()
+  })
+
+  fastify.register(function (instance, opts, done) {
+    t.assert.notStrictEqual(instance, fastify)
+    t.assert.ok(Object.prototype.isPrototypeOf.call(fastify, instance))
+
+    t.assert.strictEqual(typeof opts, 'object')
+    t.assert.strictEqual(typeof done, 'function')
+
+    instance.get('/second', function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+    done()
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  await makeRequest('first')
+  await makeRequest('second')
+
+  async function makeRequest (path) {
+    const response = await fetch(fastifyServer + '/' + path)
+    t.assert.ok(response.ok)
+    t.assert.strictEqual(response.status, 200)
+    const body = await response.text()
+    t.assert.strictEqual(response.headers.get('content-length'), '' + body.length)
+    t.assert.deepStrictEqual(JSON.parse(body), { hello: 'world' })
+  }
+})
+
+test('internal route declaration should pass the error generated by the register to the done handler / 1', (t, done) => {
+  t.plan(1)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    done(new Error('kaboom'))
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.after(() => fastify.close())
+    t.assert.strictEqual(err.message, 'kaboom')
+    done()
+  })
+})
+
+test('internal route declaration should pass the error generated by the register to the done handler / 2', (t, done) => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.register((instance, opts, done) => {
+    done(new Error('kaboom'))
+  })
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  fastify.after(err => {
+    t.assert.strictEqual(err.message, 'kaboom')
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.after(() => fastify.close())
+    t.assert.ifError(err)
+    done()
+  })
+})
+
+test('awaitable register and after', async t => {
+  const fastify = Fastify()
+  let first = false
+  let second = false
+  let third = false
+
+  await fastify.register(async (instance, opts) => {
+    first = true
+  })
+
+  t.assert.strictEqual(first, true)
+
+  fastify.register(async (instance, opts) => {
+    second = true
+  })
+
+  await fastify.after()
+  t.assert.strictEqual(second, true)
+
+  fastify.register(async (instance, opts) => {
+    third = true
+  })
+
+  await fastify.ready()
+  t.assert.strictEqual(third, true)
+})
+
+function thenableRejects (t, promise, error) {
+  return t.assert.rejects(async () => { await promise }, error)
+}
+
+test('awaitable register error handling', async t => {
+  const fastify = Fastify()
+
+  const e = new Error('kaboom')
+
+  await thenableRejects(t, fastify.register(async (instance, opts) => {
+    throw e
+  }), e)
+
+  fastify.register(async (instance, opts) => {
+    t.assert.fail('should not be executed')
+  })
+
+  await t.assert.rejects(fastify.after(), e)
+
+  fastify.register(async (instance, opts) => {
+    t.assert.fail('should not be executed')
+  })
+
+  await thenableRejects(t, fastify.ready(), e)
+})
+
+test('awaitable after error handling', async t => {
+  const fastify = Fastify()
+
+  const e = new Error('kaboom')
+
+  fastify.register(async (instance, opts) => {
+    throw e
+  })
+
+  fastify.register(async (instance, opts) => {
+    t.assert.fail('should not be executed')
+  })
+
+  await t.assert.rejects(fastify.after(), e)
+
+  fastify.register(async (instance, opts) => {
+    t.assert.fail('should not be executed')
+  })
+
+  await t.assert.rejects(fastify.ready())
+})
+
+test('chainable register', async t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.register(async () => {
+    t.assert.ok('first loaded')
+  }).register(async () => {
+    t.assert.ok('second loaded')
+  }).register(async () => {
+    t.assert.ok('third loaded')
+  })
+
+  await fastify.ready()
+})

package/test/reply-code.test.js

@@ -0,0 +1,148 @@
+'use strict'
+
+const { test } = require('node:test')
+const { Readable } = require('node:stream')
+const Fastify = require('..')
+
+test('code should handle null/undefined/float', (t, done) => {
+  t.plan(8)
+
+  const fastify = Fastify()
+
+  fastify.get('/null', function (request, reply) {
+    reply.status(null).send()
+  })
+
+  fastify.get('/undefined', function (request, reply) {
+    reply.status(undefined).send()
+  })
+
+  fastify.get('/404.5', function (request, reply) {
+    reply.status(404.5).send()
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/null'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
+      statusCode: 500,
+      code: 'FST_ERR_BAD_STATUS_CODE',
+      error: 'Internal Server Error',
+      message: 'Called reply with an invalid status code: null'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefined'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 500)
+    t.assert.deepStrictEqual(res.json(), {
+      statusCode: 500,
+      code: 'FST_ERR_BAD_STATUS_CODE',
+      error: 'Internal Server Error',
+      message: 'Called reply with an invalid status code: undefined'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/404.5'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 404)
+    done()
+  })
+})
+
+test('code should handle 204', (t, done) => {
+  t.plan(13)
+
+  const fastify = Fastify()
+
+  fastify.get('/204', function (request, reply) {
+    reply.status(204)
+    return null
+  })
+
+  fastify.get('/undefined/204', function (request, reply) {
+    reply.status(204).send({ message: 'hello' })
+  })
+
+  fastify.get('/stream/204', function (request, reply) {
+    const stream = new Readable({
+      read () {
+        this.push(null)
+      }
+    })
+    stream.on('end', () => {
+      t.assert.ok('stream ended')
+    })
+    reply.status(204).send(stream)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/204'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/undefined/204'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/stream/204'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+    done()
+  })
+})
+
+test('code should handle onSend hook on 204', (t, done) => {
+  t.plan(5)
+
+  const fastify = Fastify()
+  fastify.addHook('onSend', async function (request, reply, payload) {
+    return {
+      ...payload,
+      world: 'hello'
+    }
+  })
+
+  fastify.get('/204', function (request, reply) {
+    reply.status(204).send({
+      hello: 'world'
+    })
+  })
+
+  fastify.inject({
+    method: 'GET',
+    url: '/204'
+  }, (error, res) => {
+    t.assert.ifError(error)
+    t.assert.strictEqual(res.statusCode, 204)
+    t.assert.strictEqual(res.payload, '')
+    t.assert.strictEqual(res.headers['content-length'], undefined)
+    t.assert.strictEqual(res.headers['content-type'], undefined)
+    done()
+  })
+})

package/test/reply-early-hints.test.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const Fastify = require('..')
+const { test } = require('node:test')
+const http = require('node:http')
+const http2 = require('node:http2')
+
+const testResBody = 'Hello, world!'
+
+test('sends early hints', (t, done) => {
+  t.plan(6)
+
+  const fastify = Fastify({
+    logger: false
+  })
+
+  fastify.get('/', async (request, reply) => {
+    reply.writeEarlyHints({
+      link: '</styles.css>; rel=preload; as=style'
+    }, () => {
+      t.assert.ok('callback called')
+    })
+
+    return testResBody
+  })
+
+  fastify.listen({ port: 0 }, (err, address) => {
+    t.assert.ifError(err)
+
+    const req = http.get(address)
+
+    req.on('information', (res) => {
+      t.assert.strictEqual(res.statusCode, 103)
+      t.assert.strictEqual(res.headers.link, '</styles.css>; rel=preload; as=style')
+    })
+
+    req.on('response', (res) => {
+      t.assert.strictEqual(res.statusCode, 200)
+
+      let data = ''
+      res.on('data', (chunk) => {
+        data += chunk
+      })
+
+      res.on('end', () => {
+        t.assert.strictEqual(data, testResBody)
+        fastify.close()
+        done()
+      })
+    })
+  })
+})
+
+test('sends early hints (http2)', (t, done) => {
+  t.plan(6)
+
+  const fastify = Fastify({
+    http2: true,
+    logger: false
+  })
+
+  fastify.get('/', async (request, reply) => {
+    reply.writeEarlyHints({
+      link: '</styles.css>; rel=preload; as=style'
+    })
+
+    return testResBody
+  })
+
+  fastify.listen({ port: 0 }, (err, address) => {
+    t.assert.ifError(err)
+
+    const client = http2.connect(address)
+    const req = client.request()
+
+    req.on('headers', (headers) => {
+      t.assert.notStrictEqual(headers, undefined)
+      t.assert.strictEqual(headers[':status'], 103)
+      t.assert.strictEqual(headers.link, '</styles.css>; rel=preload; as=style')
+    })
+
+    req.on('response', (headers) => {
+      t.assert.strictEqual(headers[':status'], 200)
+    })
+
+    let data = ''
+    req.on('data', (chunk) => {
+      data += chunk
+    })
+
+    req.on('end', () => {
+      t.assert.strictEqual(data, testResBody)
+      client.close()
+      fastify.close()
+      done()
+    })
+
+    req.end()
+  })
+})