node-fastify 5.8.3

package/test/stream.3.test.js

@@ -0,0 +1,198 @@
+'use strict'
+
+const { test } = require('node:test')
+const split = require('split2')
+const Fastify = require('..')
+
+test('Destroying streams prematurely', (t, testDone) => {
+  t.plan(6)
+
+  let fastify = null
+  const logStream = split(JSON.parse)
+  try {
+    fastify = Fastify({
+      logger: {
+        stream: logStream,
+        level: 'info'
+      }
+    })
+  } catch (e) {
+    t.assert.fail()
+  }
+  const stream = require('node:stream')
+  const http = require('node:http')
+
+  // Test that "premature close" errors are logged with level warn
+  logStream.on('data', line => {
+    if (line.res) {
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
+      testDone()
+    }
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.ok('Received request')
+
+    let sent = false
+    const reallyLongStream = new stream.Readable({
+      read: function () {
+        if (!sent) {
+          this.push(Buffer.from('hello\n'))
+        }
+        sent = true
+      }
+    })
+
+    reply.send(reallyLongStream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
+
+    const port = fastify.server.address().port
+
+    http.get(`http://localhost:${port}`, function (response) {
+      t.assert.strictEqual(response.statusCode, 200)
+      response.on('readable', function () {
+        response.destroy()
+      })
+
+      // Node bug? Node never emits 'close' here.
+      response.on('aborted', function () {
+        t.assert.ok('Response closed')
+      })
+    })
+  })
+})
+
+test('Destroying streams prematurely should call close method', (t, testDone) => {
+  t.plan(7)
+
+  let fastify = null
+  const logStream = split(JSON.parse)
+  try {
+    fastify = Fastify({
+      logger: {
+        stream: logStream,
+        level: 'info'
+      }
+    })
+  } catch (e) {
+    t.assert.fail()
+  }
+  const stream = require('node:stream')
+  const http = require('node:http')
+
+  // Test that "premature close" errors are logged with level warn
+  logStream.on('data', line => {
+    if (line.res) {
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
+    }
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.ok('Received request')
+
+    let sent = false
+    const reallyLongStream = new stream.Readable({
+      read: function () {
+        if (!sent) {
+          this.push(Buffer.from('hello\n'))
+        }
+        sent = true
+      }
+    })
+    reallyLongStream.destroy = undefined
+    reallyLongStream.close = () => {
+      t.assert.ok('called')
+      testDone()
+    }
+    reply.send(reallyLongStream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
+
+    const port = fastify.server.address().port
+
+    http.get(`http://localhost:${port}`, function (response) {
+      t.assert.strictEqual(response.statusCode, 200)
+      response.on('readable', function () {
+        response.destroy()
+      })
+      // Node bug? Node never emits 'close' here.
+      response.on('aborted', function () {
+        t.assert.ok('Response closed')
+      })
+    })
+  })
+})
+
+test('Destroying streams prematurely should call close method when destroy is not a function', (t, testDone) => {
+  t.plan(7)
+
+  let fastify = null
+  const logStream = split(JSON.parse)
+  try {
+    fastify = Fastify({
+      logger: {
+        stream: logStream,
+        level: 'info'
+      }
+    })
+  } catch (e) {
+    t.assert.fail()
+  }
+  const stream = require('node:stream')
+  const http = require('node:http')
+
+  // Test that "premature close" errors are logged with level warn
+  logStream.on('data', line => {
+    if (line.res) {
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
+    }
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.ok('Received request')
+
+    let sent = false
+    const reallyLongStream = new stream.Readable({
+      read: function () {
+        if (!sent) {
+          this.push(Buffer.from('hello\n'))
+        }
+        sent = true
+      }
+    })
+    reallyLongStream.destroy = true
+    reallyLongStream.close = () => {
+      t.assert.ok('called')
+      testDone()
+    }
+    reply.send(reallyLongStream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
+
+    const port = fastify.server.address().port
+
+    http.get(`http://localhost:${port}`, function (response) {
+      t.assert.strictEqual(response.statusCode, 200)
+      response.on('readable', function () {
+        response.destroy()
+      })
+      // Node bug? Node never emits 'close' here.
+      response.on('aborted', function () {
+        t.assert.ok('Response closed')
+      })
+    })
+  })
+})

package/test/stream.4.test.js

@@ -0,0 +1,176 @@
+'use strict'
+
+const { test } = require('node:test')
+const errors = require('http-errors')
+const JSONStream = require('JSONStream')
+const Readable = require('node:stream').Readable
+const split = require('split2')
+const Fastify = require('..')
+const { kDisableRequestLogging } = require('../lib/symbols.js')
+
+test('Destroying streams prematurely should call abort method', (t, testDone) => {
+  t.plan(7)
+
+  let fastify = null
+  const logStream = split(JSON.parse)
+  try {
+    fastify = Fastify({
+      logger: {
+        stream: logStream,
+        level: 'info'
+      }
+    })
+  } catch (e) {
+    t.assert.fail()
+  }
+  const stream = require('node:stream')
+  const http = require('node:http')
+
+  // Test that "premature close" errors are logged with level warn
+  logStream.on('data', line => {
+    if (line.res) {
+      t.assert.strictEqual(line.msg, 'stream closed prematurely')
+      t.assert.strictEqual(line.level, 30)
+      testDone()
+    }
+  })
+
+  fastify.get('/', function (request, reply) {
+    t.assert.ok('Received request')
+
+    let sent = false
+    const reallyLongStream = new stream.Readable({
+      read: function () {
+        if (!sent) {
+          this.push(Buffer.from('hello\n'))
+        }
+        sent = true
+      }
+    })
+    reallyLongStream.destroy = undefined
+    reallyLongStream.close = undefined
+    reallyLongStream.abort = () => t.assert.ok('called')
+    reply.send(reallyLongStream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
+
+    const port = fastify.server.address().port
+
+    http.get(`http://localhost:${port}`, function (response) {
+      t.assert.strictEqual(response.statusCode, 200)
+      response.on('readable', function () {
+        response.destroy()
+      })
+      // Node bug? Node never emits 'close' here.
+      response.on('aborted', function () {
+        t.assert.ok('Response closed')
+      })
+    })
+  })
+})
+
+test('Destroying streams prematurely, log is disabled', (t, testDone) => {
+  t.plan(4)
+
+  let fastify = null
+  try {
+    fastify = Fastify({
+      logger: false
+    })
+  } catch (e) {
+    t.assert.fail()
+  }
+  const stream = require('node:stream')
+  const http = require('node:http')
+
+  fastify.get('/', function (request, reply) {
+    reply.log[kDisableRequestLogging] = true
+
+    let sent = false
+    const reallyLongStream = new stream.Readable({
+      read: function () {
+        if (!sent) {
+          this.push(Buffer.from('hello\n'))
+        }
+        sent = true
+      }
+    })
+    reallyLongStream.destroy = true
+    reallyLongStream.close = () => {
+      t.assert.ok('called')
+      testDone()
+    }
+    reply.send(reallyLongStream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => { fastify.close() })
+
+    const port = fastify.server.address().port
+
+    http.get(`http://localhost:${port}`, function (response) {
+      t.assert.strictEqual(response.statusCode, 200)
+      response.on('readable', function () {
+        response.destroy()
+      })
+      // Node bug? Node never emits 'close' here.
+      response.on('aborted', function () {
+        t.assert.ok('Response closed')
+      })
+    })
+  })
+})
+
+test('should respond with a stream1', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.get('/', function (req, reply) {
+    const stream = JSONStream.stringify()
+    reply.code(200).type('application/json').send(stream)
+    stream.write({ hello: 'world' })
+    stream.end({ a: 42 })
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.headers.get('content-type'), 'application/json')
+  t.assert.strictEqual(response.status, 200)
+  const body = await response.text()
+  t.assert.deepStrictEqual(JSON.parse(body), [{ hello: 'world' }, { a: 42 }])
+})
+
+test('return a 404 if the stream emits a 404 error', async (t) => {
+  t.plan(4)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    t.assert.ok('Received request')
+
+    const reallyLongStream = new Readable({
+      read: function () {
+        setImmediate(() => {
+          this.emit('error', new errors.NotFound())
+        })
+      }
+    })
+
+    reply.send(reallyLongStream)
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const response = await fetch(fastifyServer)
+  t.assert.ok(!response.ok)
+  t.assert.strictEqual(response.headers.get('content-type'), 'application/json; charset=utf-8')
+  t.assert.strictEqual(response.status, 404)
+})

package/test/stream.5.test.js

@@ -0,0 +1,188 @@
+'use strict'
+
+const { test } = require('node:test')
+const proxyquire = require('proxyquire')
+const fs = require('node:fs')
+const Readable = require('node:stream').Readable
+const Fastify = require('..')
+
+test('should destroy stream when response is ended', async (t) => {
+  t.plan(3)
+  const stream = require('node:stream')
+  const fastify = Fastify()
+
+  fastify.get('/error', function (req, reply) {
+    const reallyLongStream = new stream.Readable({
+      read: function () { },
+      destroy: function (err, callback) {
+        t.assert.ok('called')
+        callback(err)
+      }
+    })
+    reply.code(200).send(reallyLongStream)
+    reply.raw.end(Buffer.from('hello\n'))
+  })
+
+  const fastifyServer = await fastify.listen({ port: 0 })
+  t.after(() => fastify.close())
+
+  const response = await fetch(`${fastifyServer}/error`)
+  t.assert.ok(response.ok)
+  t.assert.strictEqual(response.status, 200)
+})
+
+test('should mark reply as sent before pumping the payload stream into response for async route handler', async (t) => {
+  t.plan(2)
+  t.after(() => fastify.close())
+
+  const handleRequest = proxyquire('../lib/handle-request', {
+    './wrap-thenable': (thenable, reply) => {
+      thenable.then(function (payload) {
+        t.assert.strictEqual(reply.sent, true)
+      })
+    }
+  })
+
+  const route = proxyquire('../lib/route', {
+    './handle-request': handleRequest
+  })
+
+  const Fastify = proxyquire('..', {
+    './lib/route': route
+  })
+
+  const fastify = Fastify()
+
+  fastify.get('/', async function (req, reply) {
+    const stream = fs.createReadStream(__filename, 'utf8')
+    return reply.code(200).send(stream)
+  })
+
+  const res = await fastify.inject({
+    url: '/',
+    method: 'GET'
+  })
+  t.assert.strictEqual(res.payload, fs.readFileSync(__filename, 'utf8'))
+})
+
+test('reply.send handles aborted requests', (t, done) => {
+  t.plan(2)
+
+  const spyLogger = {
+    level: 'error',
+    fatal: () => { },
+    error: () => {
+      t.assert.fail('should not log an error')
+    },
+    warn: () => { },
+    info: () => { },
+    debug: () => { },
+    trace: () => { },
+    child: () => { return spyLogger }
+  }
+  const fastify = Fastify({
+    loggerInstance: spyLogger
+  })
+
+  fastify.get('/', (req, reply) => {
+    setTimeout(() => {
+      const stream = new Readable({
+        read: function () {
+          this.push(null)
+        }
+      })
+      reply.send(stream)
+    }, 6)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
+
+    const port = fastify.server.address().port
+    const http = require('node:http')
+    const req = http.get(`http://localhost:${port}`)
+      .on('error', (err) => {
+        t.assert.strictEqual(err.code, 'ECONNRESET')
+        done()
+      })
+
+    setTimeout(() => {
+      req.destroy()
+    }, 1)
+  })
+})
+
+test('request terminated should not crash fastify', (t, done) => {
+  t.plan(10)
+
+  const spyLogger = {
+    level: 'error',
+    fatal: () => { },
+    error: () => {
+      t.assert.fail('should not log an error')
+    },
+    warn: () => { },
+    info: () => { },
+    debug: () => { },
+    trace: () => { },
+    child: () => { return spyLogger }
+  }
+  const fastify = Fastify({
+    loggerInstance: spyLogger
+  })
+
+  fastify.get('/', async (req, reply) => {
+    const stream = new Readable()
+    stream._read = () => { }
+    reply.header('content-type', 'text/html; charset=utf-8')
+    reply.header('transfer-encoding', 'chunked')
+    stream.push('<h1>HTML</h1>')
+
+    reply.send(stream)
+
+    await new Promise((resolve) => { setTimeout(resolve, 100).unref() })
+
+    stream.push('<h1>should display on second stream</h1>')
+    stream.push(null)
+    return reply
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+    t.after(() => fastify.close())
+
+    const port = fastify.server.address().port
+    const http = require('node:http')
+    const req = http.get(`http://localhost:${port}`, function (res) {
+      const { statusCode, headers } = res
+      t.assert.strictEqual(statusCode, 200)
+      t.assert.strictEqual(headers['content-type'], 'text/html; charset=utf-8')
+      t.assert.strictEqual(headers['transfer-encoding'], 'chunked')
+      res.on('data', function (chunk) {
+        t.assert.strictEqual(chunk.toString(), '<h1>HTML</h1>')
+      })
+
+      setTimeout(() => {
+        req.destroy()
+
+        // the server is not crash, we can connect it
+        http.get(`http://localhost:${port}`, function (res) {
+          const { statusCode, headers } = res
+          t.assert.strictEqual(statusCode, 200)
+          t.assert.strictEqual(headers['content-type'], 'text/html; charset=utf-8')
+          t.assert.strictEqual(headers['transfer-encoding'], 'chunked')
+          let payload = ''
+          res.on('data', function (chunk) {
+            payload += chunk.toString()
+          })
+          res.on('end', function () {
+            t.assert.strictEqual(payload, '<h1>HTML</h1><h1>should display on second stream</h1>')
+            t.assert.ok('should end properly')
+            done()
+          })
+        })
+      }, 1)
+    })
+  })
+})

package/test/sync-routes.test.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const { test } = require('node:test')
+const Fastify = require('..')
+
+test('sync route', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.get('/', () => 'hello world')
+  const res = await fastify.inject('/')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body, 'hello world')
+})
+
+test('sync route return null', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.get('/', () => null)
+  const res = await fastify.inject('/')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.body, 'null')
+})
+
+test('sync route, error', async t => {
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+  fastify.get('/', () => {
+    throw new Error('kaboom')
+  })
+  const res = await fastify.inject('/')
+  t.assert.strictEqual(res.statusCode, 500)
+})