@fastify/reply-from 12.1.0 → 12.2.0

package/test/undici-timeout-body-partial.test.js

@@ -1,17 +1,17 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const http = require('node:http')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
 const FakeTimers = require('@sinonjs/fake-timers')
 
 const clock = FakeTimers.createClock()
 
 t.test('undici body timeout', async (t) => {
   const target = http.createServer((req, res) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
     req.on('data', () => undefined)
     req.on('end', () => {
       res.writeHead(200)
@@ -19,16 +19,15 @@ t.test('undici body timeout', async (t) => {
       res.write('test')
       clock.setTimeout(() => {
         res.end()
-        t.end()
       }, 1000)
     })
   })
 
-  await target.listen({ port: 0 })
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
-  t.teardown(target.close.bind(target))
+  t.after(() => instance.close())
+  t.after(() => target.close())
 
   instance.register(From, {
     base: `http://localhost:${target.address().port}`,
@@ -43,14 +42,13 @@ t.test('undici body timeout', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.code, 'ECONNRESET')
-    t.equal(err.response.statusCode, 200)
-    clock.tick(1000)
-    return
-  }
+  const result = await request(`http://localhost:${instance.server.address().port}/`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
+  })
+
+  t.assert.strictEqual(result.statusCode, 200)
 
-  t.fail()
+  clock.tick(1000)
 })

package/test/undici-timeout-body.test.js

@@ -1,23 +1,22 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const http = require('node:http')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
 const FakeTimers = require('@sinonjs/fake-timers')
 
 const clock = FakeTimers.createClock()
 
 t.test('undici body timeout', async (t) => {
   const target = http.createServer((req, res) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
     req.on('data', () => undefined)
     req.on('end', () => {
       res.flushHeaders()
       clock.setTimeout(() => {
         res.end()
-        t.end()
       }, 1000)
     })
   })
@@ -25,8 +24,8 @@ t.test('undici body timeout', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
-  t.teardown(target.close.bind(target))
+  t.after(() => instance.close())
+  t.after(() => target.close())
 
   instance.register(From, {
     base: `http://localhost:${target.address().port}`,
@@ -41,19 +40,18 @@ t.test('undici body timeout', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 500,
-      code: 'UND_ERR_BODY_TIMEOUT',
-      error: 'Internal Server Error',
-      message: 'Body Timeout Error'
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-    clock.tick(1000)
-    return
-  }
+  })
 
-  t.fail()
+  t.assert.strictEqual(result.statusCode, 500)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 500,
+    code: 'UND_ERR_BODY_TIMEOUT',
+    error: 'Internal Server Error',
+    message: 'Body Timeout Error'
+  })
+  clock.tick(1000)
 })

package/test/undici-timeout.test.js

@@ -1,18 +1,18 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
 const FakeTimers = require('@sinonjs/fake-timers')
 
 test('undici request timeout', async (t) => {
   const clock = FakeTimers.createClock()
   const target = Fastify()
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     setTimeout(() => {
       reply.status(200).send('hello world')
@@ -24,7 +24,7 @@ test('undici request timeout', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
@@ -39,30 +39,30 @@ test('undici request timeout', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-    return
-  }
+  })
 
-  t.fail()
+  t.assert.strictEqual(result.statusCode, 504)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
+  clock.tick(1000)
 })
 
 test('undici request with specific timeout', async (t) => {
   const clock = FakeTimers.createClock()
   const target = Fastify()
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   target.get('/', (_request, reply) => {
-    t.pass('request arrives')
+    t.assert.ok('request arrives')
 
     setTimeout(() => {
       reply.status(200).send('hello world')
@@ -74,7 +74,7 @@ test('undici request with specific timeout', async (t) => {
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
@@ -96,22 +96,26 @@ test('undici request with specific timeout', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/success`, { retry: 0 })
-  t.equal(statusCode, 200)
-
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/fail`, { retry: 0 })
-  } catch (err) {
-    t.equal(err.response.statusCode, 504)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 504,
-      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
-      error: 'Gateway Timeout',
-      message: 'Gateway Timeout'
+  const result = await request(`http://localhost:${instance.server.address().port}/success`, {
+    dispatcher: new Agent({
+      pipelining: 0
     })
-    return
-  }
+  })
+  t.assert.strictEqual(result.statusCode, 200)
 
-  t.fail()
+  const result2 = await request(`http://localhost:${instance.server.address().port}/fail`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
+  })
+
+  t.assert.strictEqual(result2.statusCode, 504)
+  t.assert.match(result2.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result2.body.json(), {
+    statusCode: 504,
+    code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+    error: 'Gateway Timeout',
+    message: 'Gateway Timeout'
+  })
+  clock.tick(1000)
 })

package/test/undici-with-path-in-base.test.js

@@ -1,50 +1,47 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const http = require('node:http')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 
-t.plan(11)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  t.equal(req.headers.connection, 'keep-alive')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('undici request with path in base', async (t) => {
+  t.plan(8)
+  t.after(() => instance.close())
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    t.assert.strictEqual(req.headers.connection, 'keep-alive')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.setHeader('x-my-header', 'hello!')
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from('/hello')
-})
+  instance.get('/', (_request, reply) => {
+    reply.from('/hello')
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-target.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise((resolve) => target.listen({ port: 0 }, resolve))
 
   instance.register(From, {
     base: `http://localhost:${target.address().port}/hello`,
     undici: true
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise((resolve) => instance.listen({ port: 0 }, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.headers['x-my-header'], 'hello!')
-      t.equal(res.statusCode, 205)
-      t.equal(data.toString(), 'hello world')
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/undici.test.js

@@ -1,50 +1,47 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const http = require('node:http')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 
-t.plan(11)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/')
-  t.equal(req.headers.connection, 'keep-alive')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('undici', async (t) => {
+  t.plan(8)
+  t.after(() => instance.close())
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/')
+    t.assert.strictEqual(req.headers.connection, 'keep-alive')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.setHeader('x-my-header', 'hello!')
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from()
-})
+  instance.get('/', (_request, reply) => {
+    reply.from()
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-target.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
   instance.register(From, {
     base: `http://localhost:${target.address().port}`,
     undici: true
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.headers['x-my-header'], 'hello!')
-      t.equal(res.statusCode, 205)
-      t.equal(data.toString(), 'hello world')
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/unexpected-error.test.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
-const got = require('got')
+const { request } = require('undici')
 const proxyquire = require('proxyquire')
 
 // Stub request to throw error 'foo'
@@ -18,10 +18,10 @@ const From = proxyquire('..', {
 test('unexpected error renders 500', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.get('/', (_request, reply) => {
-    reply.code(201)
+    reply.code(205)
     reply.from()
   })
   instance.register(From, {
@@ -30,18 +30,13 @@ test('unexpected error renders 500', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got(`http://localhost:${instance.server.address().port}`)
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 500,
-      code: 'FST_REPLY_FROM_INTERNAL_SERVER_ERROR',
-      error: 'Internal Server Error',
-      message: 'foo'
-    })
-    return
-  }
-  t.fail()
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 500)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 500,
+    code: 'FST_REPLY_FROM_INTERNAL_SERVER_ERROR',
+    error: 'Internal Server Error',
+    message: 'foo'
+  })
 })

package/test/unix-http-undici-from.test.js

@@ -1,51 +1,42 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const fs = require('node:fs')
 const querystring = require('node:querystring')
 const http = require('node:http')
-const get = require('simple-get').concat
-
-if (process.platform === 'win32') {
-  t.pass()
-  process.exit(0)
-}
 
 const instance = Fastify()
 instance.register(From)
 
-t.plan(4)
-t.teardown(instance.close.bind(instance))
+t.test('unix http undici from', { skip: process.platform === 'win32' }, async (t) => {
+  t.plan(1)
+  t.after(() => instance.close())
 
-const socketPath = `${__filename}.socket`
+  const socketPath = `${__filename}.socket`
 
-try {
-  fs.unlinkSync(socketPath)
-} catch (_) {
-}
+  try {
+    fs.unlinkSync(socketPath)
+  } catch (_) {
+  }
 
-const target = http.createServer((_req, res) => {
-  t.fail('no response')
-  res.end()
-})
+  const target = http.createServer((_req, res) => {
+    t.fail('no response')
+    res.end()
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from(`unix+http://${querystring.escape(socketPath)}/hello`)
-})
+  instance.get('/', (_request, reply) => {
+    reply.from(`unix+http://${querystring.escape(socketPath)}/hello`)
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await instance.listen({ port: 0 })
 
-  target.listen(socketPath, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen(socketPath, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 500)
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 500)
 })

package/test/unix-http-undici.test.js

@@ -1,17 +1,12 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
 const fs = require('node:fs')
 const querystring = require('node:querystring')
 const http = require('node:http')
-const get = require('simple-get').concat
-
-if (process.platform === 'win32') {
-  t.pass()
-  process.exit(0)
-}
 
 const socketPath = `${__filename}.socket`
 const upstream = `unix+http://${querystring.escape(socketPath)}/`
@@ -21,42 +16,39 @@ instance.register(From, {
   base: upstream
 })
 
-t.plan(10)
-t.teardown(instance.close.bind(instance))
-
-try {
-  fs.unlinkSync(socketPath)
-} catch (_) {
-}
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  t.equal(req.url, '/hello')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('unix http undici', { skip: process.platform === 'win32' }, async t => {
+  t.plan(7)
+  t.after(() => instance.close())
+
+  try {
+    fs.unlinkSync(socketPath)
+  } catch (_) {
+  }
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/hello')
+    res.statusCode = 205
+    res.setHeader('Content-Type', 'text/plain')
+    res.setHeader('x-my-header', 'hello!')
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  reply.from('hello')
-})
+  instance.get('/', (_request, reply) => {
+    reply.from('hello')
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await instance.listen({ port: 0 })
 
-  target.listen(socketPath, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen(socketPath, resolve))
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.equal(res.headers['x-my-header'], 'hello!')
-      t.equal(res.statusCode, 205)
-      t.equal(data.toString(), 'hello world')
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.strictEqual(result.statusCode, 205)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })