@fastify/reply-from 12.0.2 → 12.2.0

package/test/get-upstream-type.test.js

@@ -1,46 +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()
 instance.register(From, {
   disableCache: true
 })
 
-t.plan(8)
-t.teardown(instance.close.bind(instance))
+t.test('getUpstream type', 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.end(req.headers.host)
-})
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.end(req.headers.host)
+  })
 
-instance.get('/', (request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    getUpstream: (req) => {
-      t.pass('getUpstream called with correct request parameter')
-      t.equal(req, request)
-      return `http://localhost:${target.address().port}`
-    }
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      getUpstream: (req) => {
+        t.assert.ok('getUpstream called with correct request parameter')
+        t.assert.strictEqual(req, request)
+        return `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(`http://localhost:${instance.server.address().port}`, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 200)
 })

package/test/get-upstream-undici.test.js

@@ -1,45 +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, {
   disableCache: true
 })
 
-t.plan(7)
-t.teardown(instance.close.bind(instance))
+t.test('getUpstream undici', async (t) => {
+  t.plan(4)
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.end(req.headers.host)
-})
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    res.end(req.headers.host)
+  })
 
-instance.get('/test', (_request, reply) => {
-  reply.from('/test', {
-    getUpstream: () => {
-      t.pass('getUpstream called')
-      return `http://localhost:${target.address().port}`
-    }
+  instance.get('/test', (_request, reply) => {
+    reply.from('/test', {
+      getUpstream: () => {
+        t.assert.ok('getUpstream called')
+        return `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(`http://localhost:${instance.server.address().port}/test`, (err, res) => {
-      t.error(err)
-      t.equal(res.statusCode, 200)
-    })
-  })
+  const result = await request(`http://localhost:${instance.server.address().port}/test`)
+
+  t.assert.strictEqual(result.statusCode, 200)
 })

package/test/host-header.test.js

@@ -1,27 +1,27 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
 const nock = require('nock')
-const got = require('got')
 
 test('hostname', async (t) => {
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   nock('http://httpbin.org')
     .get('/ip')
     .reply(200, function () {
-      t.equal(this.req.headers.host, 'httpbin.org')
+      t.assert.strictEqual(this.req.headers.host, 'httpbin.org')
       return { origin: '127.0.0.1' }
     })
 
   instance.get('*', (_request, reply) => {
     reply.from(null, {
       rewriteRequestHeaders: (originalReq, headers) => {
-        t.equal(headers.host, 'httpbin.org')
-        t.equal(originalReq.headers.host, `localhost:${instance.server.address().port}`)
+        t.assert.strictEqual(headers.host, 'httpbin.org')
+        t.assert.strictEqual(originalReq.headers.host, `localhost:${instance.server.address().port}`)
         return headers
       }
     })
@@ -34,22 +34,24 @@ test('hostname', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}/ip`, {
-    retry: 0
+  const res = await request(`http://localhost:${instance.server.address().port}/ip`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
   })
-  t.equal(res.statusCode, 200)
-  t.equal(res.headers['content-type'], 'application/json')
-  t.equal(typeof JSON.parse(res.body).origin, 'string')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['content-type'], 'application/json')
+  t.assert.strictEqual(typeof (await res.body.json()).origin, 'string')
 })
 
 test('hostname and port', async (t) => {
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   nock('http://httpbin.org:8080')
     .get('/ip')
     .reply(200, function () {
-      t.equal(this.req.headers.host, 'httpbin.org:8080')
+      t.assert.strictEqual(this.req.headers.host, 'httpbin.org:8080')
       return { origin: '127.0.0.1' }
     })
 
@@ -64,10 +66,12 @@ test('hostname and port', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}/ip`, {
-    retry: 0
+  const res = await request(`http://localhost:${instance.server.address().port}/ip`, {
+    dispatcher: new Agent({
+      pipelining: 0
+    })
   })
-  t.equal(res.statusCode, 200)
-  t.equal(res.headers['content-type'], 'application/json')
-  t.equal(typeof JSON.parse(res.body).origin, 'string')
+  t.assert.strictEqual(res.statusCode, 200)
+  t.assert.strictEqual(res.headers['content-type'], 'application/json')
+  t.assert.strictEqual(typeof (await res.body.json()).origin, 'string')
 })

package/test/http-agents.test.js

@@ -1,35 +1,35 @@
 '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 https = require('node:https')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 
-t.plan(10)
-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, '/')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('http agents', async (t) => {
+  t.plan(7)
+  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, '/')
+    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}`,
@@ -41,15 +41,12 @@ target.listen({ port: 0 }, (err) => {
     }
   })
 
-  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/http-global-agent.test.js

@@ -1,57 +1,44 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = 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
 
 test('http global agent is used, but not destroyed', async (t) => {
   http.globalAgent.destroy = () => {
     t.fail()
   }
   const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
   instance.get('/', (_request, reply) => {
     reply.from()
   })
 
   const target = http.createServer((req, res) => {
-    t.pass('request proxied')
-    t.equal(req.method, 'GET')
-    t.equal(req.url, '/')
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    t.assert.strictEqual(req.url, '/')
     res.statusCode = 200
     res.end()
   })
-  t.teardown(target.close.bind(target))
-
-  const executionFlow = () => new Promise((resolve) => {
-    target.listen({ port: 0 }, (err) => {
-      t.error(err)
-
-      instance.register(From, {
-        base: `http://localhost:${target.address().port}`,
-        globalAgent: true,
-        http: {
-        }
-      })
-
-      instance.listen({ port: 0 }, (err) => {
-        t.error(err)
-
-        get(
-          `http://localhost:${instance.server.address().port}`,
-          (err, res) => {
-            t.error(err)
-            t.equal(res.statusCode, 200)
-            resolve()
-          }
-        )
-      })
-    })
+  t.after(() => target.close())
+
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    globalAgent: true,
+    http: {
+    }
   })
 
-  await executionFlow()
+  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)
 
   target.close()
 })

package/test/http-http2.test.js

@@ -1,21 +1,21 @@
 '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')
 
 test('http -> http2', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   const target = Fastify({
     http2: true
   })
 
   target.get('/', (_request, reply) => {
-    t.pass('request proxied')
+    t.assert.ok('request proxied')
     reply.code(404).header('x-my-header', 'hello!').send({
       hello: 'world'
     })
@@ -25,7 +25,7 @@ test('http -> http2', async (t) => {
     reply.from()
   })
 
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await target.listen({ port: 0 })
 
@@ -36,17 +36,12 @@ test('http -> http2', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got(`http://localhost:${instance.server.address().port}`)
-  } catch (err) {
-    t.equal(err.response.statusCode, 404)
-    t.equal(err.response.headers['x-my-header'], 'hello!')
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), { hello: 'world' })
-    instance.close()
-    target.close()
-    return
-  }
-
-  t.fail()
+  const result = await request(`http://localhost:${instance.server.address().port}`, { dispatcher: new Agent({ pipelining: 0 }) })
+
+  t.assert.strictEqual(result.statusCode, 404)
+  t.assert.strictEqual(result.headers['x-my-header'], 'hello!')
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), { hello: 'world' })
+  instance.close()
+  target.close()
 })

package/test/http-invalid-target.test.js

@@ -1,14 +1,14 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('..')
-const got = require('got')
 
 test('http invalid target', async (t) => {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   instance.get('/', (_request, reply) => {
     reply.from()
@@ -19,18 +19,14 @@ test('http invalid target', async (t) => {
 
   await instance.listen({ port: 0 })
 
-  try {
-    await got(`http://localhost:${instance.server.address().port}`)
-  } catch (err) {
-    t.equal(err.response.statusCode, 503)
-    t.match(err.response.headers['content-type'], /application\/json/)
-    t.same(JSON.parse(err.response.body), {
-      statusCode: 503,
-      code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
-      error: 'Service Unavailable',
-      message: 'Service Unavailable'
-    })
-    return
-  }
-  t.fail()
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+
+  t.assert.strictEqual(result.statusCode, 503)
+  t.assert.match(result.headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await result.body.json(), {
+    statusCode: 503,
+    code: 'FST_REPLY_FROM_SERVICE_UNAVAILABLE',
+    error: 'Service Unavailable',
+    message: 'Service Unavailable'
+  })
 })

package/test/http-retry.test.js

@@ -1,9 +1,9 @@
 'use strict'
 
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
-const got = require('got')
-const { test } = require('tap')
+const { test } = require('node:test')
 
 let retryNum = 1
 
@@ -20,10 +20,10 @@ const target = require('node:http').createServer(function (req, res) {
 })
 
 test('Will retry', async function (t) {
-  t.teardown(() => { retryNum = 1 })
+  t.after(() => { retryNum = 1 })
 
   await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   const instance = Fastify()
 
@@ -33,24 +33,24 @@ test('Will retry', async function (t) {
     reply.from(`http://localhost:${target.address().port}/`, {
       retriesCount: 1,
       onError: (reply, { error }) => {
-        t.equal(error.code, 'ECONNRESET')
+        t.assert.strictEqual(error.code, 'ECONNRESET')
         reply.send(error)
       }
     })
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-  t.equal(statusCode, 200)
+  const { statusCode } = await request(`http://localhost:${instance.server.address().port}/`, { dispatcher: new Agent({ pipelining: 0 }) })
+  t.assert.strictEqual(statusCode, 200)
 })
 
 test('will not retry', async function (t) {
-  t.teardown(() => { retryNum = 1 })
+  t.after(() => { retryNum = 1 })
 
   await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   const instance = Fastify()
 
@@ -60,28 +60,25 @@ test('will not retry', async function (t) {
     reply.from(`http://localhost:${target.address().port}/`, {
       retriesCount: 0,
       onError: (reply, { error }) => {
-        t.equal(error.code, 'ECONNRESET')
+        t.assert.strictEqual(error.code, 'ECONNRESET')
         reply.send(error)
       }
     })
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-    t.fail()
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-  }
+  const result = await request(`http://localhost:${instance.server.address().port}/`, { dispatcher: new Agent({ pipelining: 0 }) })
+
+  t.assert.strictEqual(result.statusCode, 500)
 })
 
 test('will not retry unsupported method', async function (t) {
-  t.teardown(() => { retryNum = 1 })
+  t.after(() => { retryNum = 1 })
 
-  await target.listen({ port: 0 })
-  t.teardown(target.close.bind(target))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+  t.after(() => target.close())
 
   const instance = Fastify()
 
@@ -91,19 +88,15 @@ test('will not retry unsupported method', async function (t) {
     reply.from(`http://localhost:${target.address().port}/`, {
       retriesCount: 1,
       onError: (reply, { error }) => {
-        t.equal(error.code, 'ECONNRESET')
+        t.assert.strictEqual(error.code, 'ECONNRESET')
         reply.send(error)
       }
     })
   })
 
   await instance.listen({ port: 0 })
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
-    t.fail()
-  } catch (err) {
-    t.equal(err.response.statusCode, 500)
-  }
+  const result = await request(`http://localhost:${instance.server.address().port}/`, { dispatcher: new Agent({ pipelining: 0 }) })
+  t.assert.strictEqual(result.statusCode, 500)
 })