fastify 5.2.0 → 5.2.2

package/test/issue-4959.test.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { test } = require('node:test')
+const http = require('node:http')
+const Fastify = require('../fastify')
+
+function runBadClientCall (reqOptions, payload) {
+  let innerResolve, innerReject
+  const promise = new Promise((resolve, reject) => {
+    innerResolve = resolve
+    innerReject = reject
+  })
+
+  const postData = JSON.stringify(payload)
+
+  const req = http.request({
+    ...reqOptions,
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(postData),
+    }
+  }, () => {
+    innerReject(new Error('Request should have failed'))
+  })
+
+  // Kill the socket immediately (before sending data)
+  req.on('socket', (socket) => {
+    setTimeout(() => { socket.destroy() }, 5)
+  })
+  req.on('error', innerResolve)
+  req.write(postData)
+  req.end()
+
+  return promise
+}
+
+test('should handle a soket error', async (t) => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  function shouldNotHappen () {
+    t.assert.fail('This should not happen')
+  }
+  process.on('unhandledRejection', shouldNotHappen)
+
+  t.after(() => {
+    fastify.close()
+    process.removeListener('unhandledRejection', shouldNotHappen)
+  })
+
+  fastify.addHook('onRequest', async (request, reply) => {
+    t.assert.ok('onRequest hook called')
+  })
+
+  fastify.addHook('onSend', async (request, reply, payload) => {
+    if (request.onSendCalled) {
+      t.assert.fail('onSend hook called more than once')
+      return
+    }
+
+    t.assert.ok('onSend hook called')
+    request.onSendCalled = true
+
+    // Introduce a delay
+    await new Promise(resolve => setTimeout(resolve, 5))
+    return payload
+  })
+
+  // The handler must be async to trigger the error
+  fastify.put('/', async (request, reply) => {
+    t.assert.ok('PUT handler called')
+    return reply.send({ hello: 'world' })
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const err = await runBadClientCall({
+    hostname: 'localhost',
+    port: fastify.server.address().port,
+    path: '/',
+    method: 'PUT',
+  }, { test: 'me' })
+  t.assert.equal(err.code, 'ECONNRESET')
+})

package/test/listen.1.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
 
@@ -13,69 +13,70 @@ before(async function () {
 
 test('listen works without arguments', async t => {
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   await fastify.listen()
   const address = fastify.server.address()
-  t.equal(address.address, localhost)
-  t.ok(address.port > 0)
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
 })
 
 test('Async/await listen with arguments', async t => {
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   const addr = await fastify.listen({ port: 0, host: '0.0.0.0' })
   const address = fastify.server.address()
-  t.equal(addr, `http://127.0.0.1:${address.port}`)
-  t.same(address, {
+  t.assert.strictEqual(addr, `http://127.0.0.1:${address.port}`)
+  t.assert.deepEqual(address, {
     address: '0.0.0.0',
     family: 'IPv4',
     port: address.port
   })
 })
 
-test('listen accepts a callback', t => {
+test('listen accepts a callback', (t, done) => {
   t.plan(2)
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   fastify.listen({ port: 0 }, (err) => {
-    t.equal(fastify.server.address().address, localhost)
-    t.error(err)
+    t.assert.ifError(err)
+    t.assert.strictEqual(fastify.server.address().address, localhost)
+    done()
   })
 })
 
-test('listen accepts options and a callback', t => {
+test('listen accepts options and a callback', (t, done) => {
   t.plan(1)
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(() => {
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
@@ -88,40 +89,42 @@ test('listen accepts options and a callback', t => {
     writableAll: false,
     ipv6Only: false
   }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
+    done()
   })
 })
 
-test('listen after Promise.resolve()', t => {
+test('listen after Promise.resolve()', (t, done) => {
   t.plan(2)
-  const f = Fastify()
-  t.teardown(f.close.bind(f))
+  const fastify = Fastify()
+  t.after(() => fastify.close())
   Promise.resolve()
     .then(() => {
-      f.listen({ port: 0 }, (err, address) => {
-        f.server.unref()
-        t.equal(address, `http://${localhostForURL}:${f.server.address().port}`)
-        t.error(err)
+      fastify.listen({ port: 0 }, (err, address) => {
+        fastify.server.unref()
+        t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+        t.assert.ifError(err)
+        done()
       })
     })
 })
 
 test('listen works with undefined host', async t => {
   const doNotWarn = () => {
-    t.fail('should not be deprecated')
+    t.assert.fail('should not be deprecated')
   }
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  t.teardown(() => {
+  t.after(() => fastify.close())
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   await fastify.listen({ host: undefined, port: 0 })
   const address = fastify.server.address()
-  t.equal(address.address, localhost)
-  t.ok(address.port > 0)
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
 })
 
 test('listen works with null host', async t => {
@@ -131,13 +134,13 @@ test('listen works with null host', async t => {
   process.on('warning', doNotWarn)
 
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  t.teardown(() => {
+  t.after(() => fastify.close())
+  t.after(() => {
     fastify.close()
     process.removeListener('warning', doNotWarn)
   })
   await fastify.listen({ host: null, port: 0 })
   const address = fastify.server.address()
-  t.equal(address.address, localhost)
-  t.ok(address.port > 0)
+  t.assert.strictEqual(address.address, localhost)
+  t.assert.ok(address.port > 0)
 })

package/test/listen.2.test.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
 
@@ -10,94 +10,101 @@ before(async function () {
   [, localhostForURL] = await helper.getLoopbackHost()
 })
 
-test('register after listen using Promise.resolve()', t => {
+test('register after listen using Promise.resolve()', async t => {
   t.plan(1)
-  const f = Fastify()
+  const fastify = Fastify()
 
   const handler = (req, res) => res.send({})
-  Promise.resolve()
+  await Promise.resolve()
     .then(() => {
-      f.get('/', handler)
-      f.register((f2, options, done) => {
+      fastify.get('/', handler)
+      fastify.register((f2, options, done) => {
         f2.get('/plugin', handler)
         done()
       })
-      return f.ready()
+      return fastify.ready()
+    })
+    .catch((err) => {
+      t.assert.fail(err.message)
     })
-    .catch(t.error)
-    .then(() => t.pass('resolved'))
+    .then(() => t.assert.ok('resolved'))
 })
 
-test('double listen errors', t => {
+test('double listen errors', (t, done) => {
   t.plan(3)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err) => {
-    t.error(err)
+    t.assert.ifError(err)
     fastify.listen({ port: fastify.server.address().port }, (err, address) => {
-      t.equal(address, null)
-      t.ok(err)
+      t.assert.strictEqual(address, null)
+      t.assert.ok(err)
+      done()
     })
   })
 })
 
-test('double listen errors callback with (err, address)', t => {
+test('double listen errors callback with (err, address)', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err1, address1) => {
-    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err1)
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
+    t.assert.ifError(err1)
     fastify.listen({ port: fastify.server.address().port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })
 
-test('nonlocalhost double listen errors callback with (err, address)', t => {
+test('nonlocalhost double listen errors callback with (err, address)', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ host: '::1', port: 0 }, (err, address) => {
-    t.equal(address, `http://${'[::1]'}:${fastify.server.address().port}`)
-    t.error(err)
+    t.assert.strictEqual(address, `http://${'[::1]'}:${fastify.server.address().port}`)
+    t.assert.ifError(err)
     fastify.listen({ host: '::1', port: fastify.server.address().port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })
 
-test('listen twice on the same port', t => {
+test('listen twice on the same port', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err1, address1) => {
-    t.equal(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
-    t.error(err1)
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${fastify.server.address().port}`)
+    t.assert.ifError(err1)
     const s2 = Fastify()
-    t.teardown(s2.close.bind(s2))
+    t.after(() => fastify.close())
     s2.listen({ port: fastify.server.address().port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })
 
-test('listen twice on the same port callback with (err, address)', t => {
+test('listen twice on the same port callback with (err, address)', (t, done) => {
   t.plan(4)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 }, (err1, address1) => {
     const _port = fastify.server.address().port
-    t.equal(address1, `http://${localhostForURL}:${_port}`)
-    t.error(err1)
+    t.assert.strictEqual(address1, `http://${localhostForURL}:${_port}`)
+    t.assert.ifError(err1)
     const s2 = Fastify()
-    t.teardown(s2.close.bind(s2))
+    t.after(() => fastify.close())
     s2.listen({ port: _port }, (err2, address2) => {
-      t.equal(address2, null)
-      t.ok(err2)
+      t.assert.strictEqual(address2, null)
+      t.assert.ok(err2)
+      done()
     })
   })
 })

package/test/listen.3.test.js

@@ -3,7 +3,7 @@
 const os = require('node:os')
 const path = require('node:path')
 const fs = require('node:fs')
-const { test, before } = require('tap')
+const { test, before } = require('node:test')
 const Fastify = require('..')
 const helper = require('./helper')
 
@@ -15,73 +15,69 @@ before(async function () {
 
 // https://nodejs.org/api/net.html#net_ipc_support
 if (os.platform() !== 'win32') {
-  test('listen on socket', t => {
-    t.plan(3)
+  test('listen on socket', async t => {
+    t.plan(2)
     const fastify = Fastify()
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const sockFile = path.join(os.tmpdir(), `${(Math.random().toString(16) + '0000000').slice(2, 10)}-server.sock`)
     try {
       fs.unlinkSync(sockFile)
     } catch (e) { }
 
-    fastify.listen({ path: sockFile }, (err, address) => {
-      t.error(err)
-      t.strictSame(fastify.addresses(), [sockFile])
-      t.equal(address, sockFile)
-    })
+    await fastify.listen({ path: sockFile })
+    t.assert.deepStrictEqual(fastify.addresses(), [sockFile])
+    t.assert.strictEqual(fastify.server.address(), sockFile)
   })
 } else {
-  test('listen on socket', t => {
-    t.plan(3)
+  test('listen on socket', async t => {
+    t.plan(2)
     const fastify = Fastify()
-    t.teardown(fastify.close.bind(fastify))
+    t.after(() => fastify.close())
 
     const sockFile = `\\\\.\\pipe\\${(Math.random().toString(16) + '0000000').slice(2, 10)}-server-sock`
 
-    fastify.listen({ path: sockFile }, (err, address) => {
-      t.error(err)
-      t.strictSame(fastify.addresses(), [sockFile])
-      t.equal(address, sockFile)
-    })
+    await fastify.listen({ path: sockFile })
+    t.assert.deepStrictEqual(fastify.addresses(), [sockFile])
+    t.assert.strictEqual(fastify.server.address(), sockFile)
   })
 }
 
-test('listen without callback with (address)', t => {
+test('listen without callback with (address)', async t => {
   t.plan(1)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
-  fastify.listen({ port: 0 })
-    .then(address => {
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
-    })
+  t.after(() => fastify.close())
+  const address = await fastify.listen({ port: 0 })
+  t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
 })
 
-test('double listen without callback rejects', t => {
+test('double listen without callback rejects', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 })
     .then(() => {
       fastify.listen({ port: 0 })
         .catch(err => {
-          t.ok(err)
+          t.assert.ok(err)
+          done()
         })
     })
-    .catch(err => t.error(err))
+    .catch(err => t.assert.ifError(err))
 })
 
-test('double listen without callback with (address)', t => {
+test('double listen without callback with (address)', (t, done) => {
   t.plan(2)
   const fastify = Fastify()
-  t.teardown(fastify.close.bind(fastify))
+  t.after(() => fastify.close())
   fastify.listen({ port: 0 })
     .then(address => {
-      t.equal(address, `http://${localhostForURL}:${fastify.server.address().port}`)
+      t.assert.strictEqual(address, `http://${localhostForURL}:${fastify.server.address().port}`)
       fastify.listen({ port: 0 })
         .catch(err => {
-          t.ok(err)
+          t.assert.ok(err)
+          done()
         })
     })
-    .catch(err => t.error(err))
+    .catch(err => t.assert.ifError(err))
 })