@fastify/reply-from 12.0.2 → 12.2.0

package/test/no-body-opts-with-get.test.js

@@ -1,49 +1,43 @@
 '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(6)
-t.teardown(instance.close.bind(instance))
+t.test('no body opts with get', async (t) => {
+  t.plan(3)
+  t.after(() => instance.close())
 
-const target = http.createServer((_req, res) => {
-  t.fail('this should never get called')
-  res.end('hello world')
-})
+  const target = http.createServer((_req, res) => {
+    t.fail('this should never get called')
+    res.end('hello world')
+  })
 
-instance.get('/', (_request, reply) => {
-  try {
-    reply.from(null, { body: 'this is the new body' })
-  } catch (e) {
-    t.equal(e.message, 'Rewriting the body when doing a GET is not allowed')
-    reply.send('hello world')
-  }
-})
+  instance.get('/', (_request, reply) => {
+    try {
+      reply.from(null, { body: 'this is the new body' })
+    } catch (e) {
+      t.assert.strictEqual(e.message, 'Rewriting the body when doing a GET is not allowed')
+      reply.send('hello world')
+    }
+  })
 
-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}`
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'GET'
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.equal(data.toString(), 'hello world')
-    })
-  })
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/no-body-opts-with-head.test.js

@@ -1,51 +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(7)
-t.teardown(instance.close.bind(instance))
+t.test('no body opts with head', async (t) => {
+  t.plan(4)
+  t.after(() => instance.close())
 
-const target = http.createServer((_req, res) => {
-  t.fail('this should never get called')
-  res.end('hello world')
-})
+  const target = http.createServer((_req, res) => {
+    t.fail('this should never get called')
+    res.end('hello world')
+  })
 
-instance.head('/', (_request, reply) => {
-  try {
-    reply.from(null, { body: 'this is the new body' })
-  } catch (e) {
-    t.equal(e.message, 'Rewriting the body when doing a HEAD is not allowed')
-    reply.header('x-http-error', '1')
-    reply.send('hello world')
-  }
-})
+  instance.head('/', (_request, reply) => {
+    try {
+      reply.from(null, { body: 'this is the new body' })
+    } catch (e) {
+      t.assert.strictEqual(e.message, 'Rewriting the body when doing a HEAD is not allowed')
+      reply.header('x-http-error', '1')
+      reply.send('hello world')
+    }
+  })
 
-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}`
   })
 
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'HEAD'
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-      t.equal(res.headers['x-http-error'], '1')
-      t.equal(data.toString(), '')
-    })
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'HEAD'
   })
+
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(result.headers['x-http-error'], '1')
+  t.assert.strictEqual(await result.body.text(), '')
 })

package/test/no-stream-body-option.test.js

@@ -1,58 +1,56 @@
 '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 Readable = require('node:stream').Readable
 
 const instance = Fastify()
 instance.register(From)
 
-t.plan(5)
-t.teardown(instance.close.bind(instance))
+t.test('no stream body option', async (t) => {
+  t.plan(2)
+  t.after(() => instance.close())
 
-const target = http.createServer((_req, res) => {
-  t.fail('the target server should never be called')
-  res.end()
-})
-
-instance.post('/', (_request, reply) => {
-  const body = new Readable({
-    read: function () {
-      t.fail('the read function should never be called')
-    }
+  const target = http.createServer((_req, res) => {
+    t.fail('the target server should never be called')
+    res.end()
   })
 
-  t.throws(() => {
-    reply.from(`http://localhost:${target.address().port}`, {
-      body
+  instance.post('/', (_request, reply) => {
+    const body = new Readable({
+      read: function () {
+        t.fail('the read function should never be called')
+      }
     })
-  })
 
-  // return a 500
-  reply.code(500).send({ an: 'error' })
-})
+    t.assert.throws(() => {
+      reply.from(`http://localhost:${target.address().port}`, {
+        body
+      })
+    })
 
-t.teardown(target.close.bind(target))
+    // return a 500
+    reply.code(500).send({ an: 'error' })
+  })
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  t.after(() => target.close())
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'POST',
-      json: true,
-      body: {
-        hello: 'world'
-      }
-    }, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 500)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({
+      hello: 'world'
     })
   })
+
+  t.assert.strictEqual(result.statusCode, 500)
 })

package/test/on-error.test.js

@@ -1,64 +1,62 @@
 'use strict'
 
-const t = require('tap')
+const t = 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')
 
 const clock = FakeTimers.createClock()
 
 t.test('on-error', async (t) => {
   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')
 
     clock.setTimeout(() => {
       reply.status(200).send('hello world')
-      t.end()
     }, 1000)
   })
 
   await target.listen({ port: 0 })
 
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.register(From, { http: { requestOptions: { timeout: 100 } } })
 
   instance.get('/', (_request, reply) => {
     reply.from(`http://localhost:${target.server.address().port}/`,
       {
-        onError: (reply, { error }) => {
-          t.same(error, {
+        onError: (reply, { error: { stack, ...errorContent } }) => {
+          t.assert.deepStrictEqual(errorContent, {
             statusCode: 504,
             name: 'FastifyError',
             code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
             message: 'Gateway Timeout'
           })
-          reply.code(error.statusCode).send(error)
+          reply.code(errorContent.statusCode).send(errorContent)
         }
       })
   })
 
   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
     })
-    clock.tick(1000)
-    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',
+    name: 'FastifyError',
+    message: 'Gateway Timeout'
+  })
+  clock.tick(1000)
 })

package/test/on-invalid-upstream-response.test.js

@@ -1,52 +1,45 @@
 '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()
 instance.register(From)
 
-t.plan(8)
-t.teardown(instance.close.bind(instance))
+t.test('on-invalid-upstream-response', async (t) => {
+  t.plan(5)
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 888
-  res.end('non-standard status code')
-})
-
-instance.get('/', (_, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    onResponse: (_, _reply, res) => {
-      t.equal(res.statusCode, 888)
-    }
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.statusCode = 888
+    res.end('non-standard status code')
   })
-})
 
-t.teardown(target.close.bind(target))
-
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
-
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get(
-      `http://localhost:${instance.server.address().port}`,
-      (err, res, data) => {
-        t.error(err)
-        t.equal(res.statusCode, 502)
-        t.same(JSON.parse(data), {
-          statusCode: 502,
-          code: 'FST_REPLY_FROM_BAD_GATEWAY',
-          error: 'Bad Gateway',
-          message: 'Bad Gateway'
-        })
+  instance.get('/', (_, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      onResponse: (_, _reply, res) => {
+        t.assert.strictEqual(res.statusCode, 888)
       }
-    )
+    })
+  })
+
+  t.after(() => target.close())
+
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
+
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 502)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 502,
+    code: 'FST_REPLY_FROM_BAD_GATEWAY',
+    error: 'Bad Gateway',
+    message: 'Bad Gateway'
   })
 })

package/test/onResponse.test.js

@@ -1,49 +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 http = require('node:http')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 instance.register(From)
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
+t.test('onResponse', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 200
-  res.end('hello world')
-})
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.statusCode = 200
+    res.end('hello world')
+  })
 
-instance.get('/', (request1, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    onResponse: (request2, reply, res) => {
-      t.equal(res.statusCode, 200)
-      t.equal(request1.raw, request2.raw)
-      reply.send(res.stream)
-    }
+  instance.get('/', (request1, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      onResponse: (request2, reply, res) => {
+        t.assert.strictEqual(res.statusCode, 200)
+        t.assert.strictEqual(request1.raw, request2.raw)
+        reply.send(res.stream)
+      }
+    })
   })
-})
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-    get(
-      `http://localhost:${instance.server.address().port}`,
-      (err, res, data) => {
-        t.error(err)
-        t.equal(res.statusCode, 200)
-        t.equal(data.toString(), 'hello world')
-      }
-    )
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 200)
+  t.assert.strictEqual(await result.body.text(), 'hello world')
 })

package/test/padded-body.test.js

@@ -1,64 +1,59 @@
 '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()
 instance.register(From)
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
+t.test('padded body', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
 
-const bodyString = `{
+  const bodyString = `{
   "hello": "world"
 }`
 
-const parsedLength = Buffer.byteLength(JSON.stringify(JSON.parse(bodyString)))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/json')
-  t.same(req.headers['content-length'], parsedLength)
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.same(JSON.parse(data), { hello: 'world' })
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    res.end(JSON.stringify({ something: 'else' }))
+  const parsedLength = Buffer.byteLength(JSON.stringify(JSON.parse(bodyString)))
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'POST')
+    t.assert.strictEqual(req.headers['content-type'], 'application/json')
+    t.assert.deepStrictEqual(req.headers['content-length'], `${parsedLength}`)
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.deepStrictEqual(JSON.parse(data), { hello: 'world' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ something: 'else' }))
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`)
-})
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
 
-t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json'
-      },
-      body: bodyString
-    }, (err, _res, data) => {
-      t.error(err)
-      const parsed = JSON.parse(data)
-      t.same(parsed, { something: 'else' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: bodyString
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })