@fastify/reply-from 12.0.2 → 12.2.0

package/test/full-rewrite-body-content-type.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const fastifyReplyFrom = require('..')
 const http = require('node:http')
-const get = require('simple-get').concat
 
 const instance = Fastify()
 instance.register(fastifyReplyFrom)
@@ -12,51 +12,47 @@ instance.register(fastifyReplyFrom)
 const payload = { hello: 'world' }
 const msgPackPayload = Buffer.from([0x81, 0xa5, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0xa5, 0x77, 0x6f, 0x72, 0x6c, 0x64])
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/msgpack')
-  const data = []
-  req.on('data', (d) => {
-    data.push(d)
-  })
-  req.on('end', () => {
-    t.same(Buffer.concat(data), msgPackPayload)
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    res.end(JSON.stringify({ something: 'else' }))
+t.test('full rewrite body content-type', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  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/msgpack')
+    const data = []
+    req.on('data', (d) => {
+      data.push(d)
+    })
+    req.on('end', () => {
+      t.assert.deepStrictEqual(Buffer.concat(data), msgPackPayload)
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ something: 'else' }))
+    })
   })
-})
 
-instance.post('/', (request, reply) => {
-  t.same(request.body, payload)
-  reply.from(`http://localhost:${target.address().port}`, {
-    contentType: 'application/msgpack',
-    body: msgPackPayload
+  instance.post('/', (request, reply) => {
+    t.assert.deepStrictEqual(request.body, payload)
+    reply.from(`http://localhost:${target.address().port}`, {
+      contentType: 'application/msgpack',
+      body: msgPackPayload
+    })
   })
-})
 
-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',
-      json: true,
-      body: {
-        hello: 'world'
-      }
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(data, { something: 'else' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({ hello: 'world' }),
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })

package/test/full-rewrite-body-http.test.js

@@ -1,63 +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, {
   http: true
 })
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/json')
-  t.equal(req.headers['content-length'], '20')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.same(JSON.parse(data), { something: 'else' })
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    res.end(JSON.stringify({ hello: 'fastify' }))
+t.test('full rewrite body', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  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.strictEqual(req.headers['content-length'], '20')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.deepStrictEqual(JSON.parse(data), { something: 'else' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ hello: 'fastify' }))
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    body: {
-      something: 'else'
-    }
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      body: {
+        something: 'else'
+      }
+    })
   })
-})
 
-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',
-      json: true,
-      body: {
-        hello: 'world'
-      }
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(data, { hello: 'fastify' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({ hello: 'world' }),
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { hello: 'fastify' })
 })

package/test/full-rewrite-body-to-empty-string.test.js

@@ -1,61 +1,57 @@
 '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, {
   http: true
 })
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/json')
-  t.equal(req.headers['content-length'], '2')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.same(JSON.parse(data), '')
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    res.end(JSON.stringify({ hello: 'fastify' }))
+t.test('full rewrite body to empty string', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  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.strictEqual(req.headers['content-length'], '2')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.deepStrictEqual(JSON.parse(data), '')
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ hello: 'fastify' }))
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    body: ''
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      body: ''
+    })
   })
-})
 
-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',
-      json: true,
-      body: {
-        hello: 'world'
-      }
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(data, { hello: 'fastify' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({ hello: 'world' }),
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { hello: 'fastify' })
 })

package/test/full-rewrite-body-to-null.test.js

@@ -1,61 +1,57 @@
 '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, {
   http: true
 })
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.notOk('content-type' in req.headers)
-  t.equal(req.headers['content-length'], '0')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.equal(data.length, 0)
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    res.end(JSON.stringify({ hello: 'fastify' }))
+t.test('full rewrite body to null', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  const target = http.createServer((req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'POST')
+    t.assert.ok(!('content-type' in req.headers))
+    t.assert.strictEqual(req.headers['content-length'], '0')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.strictEqual(data.length, 0)
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ hello: 'fastify' }))
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    body: null
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      body: null
+    })
   })
-})
 
-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',
-      json: true,
-      body: {
-        hello: 'world'
-      }
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(data, { hello: 'fastify' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({ hello: 'world' }),
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { hello: 'fastify' })
 })

package/test/full-rewrite-body.test.js

@@ -1,61 +1,57 @@
 '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))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/json')
-  t.equal(req.headers['content-length'], '20')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    t.same(JSON.parse(data), { something: 'else' })
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/json')
-    res.end(JSON.stringify({ hello: 'fastify' }))
+t.test('full rewrite body', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  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.strictEqual(req.headers['content-length'], '20')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      t.assert.deepStrictEqual(JSON.parse(data), { something: 'else' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ hello: 'fastify' }))
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`, {
-    body: {
-      something: 'else'
-    }
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`, {
+      body: {
+        something: 'else'
+      }
+    })
   })
-})
 
-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',
-      json: true,
-      body: {
-        hello: 'world'
-      }
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(data, { hello: 'fastify' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({ hello: 'world' }),
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { hello: 'fastify' })
 })

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
 const From = require('..')
 
@@ -13,13 +13,11 @@ async function createTarget (i) {
     return `Hello from target ${i}`
   })
 
-  t.teardown(() => target.close())
+  t.after(() => target.close())
   await target.listen({ port: 3000 + i })
 }
 
-t.plan(4)
-
-async function run () {
+async function run (t) {
   await Promise.all([
     createTarget(1),
     createTarget(2)
@@ -45,7 +43,7 @@ async function run () {
     })
   })
 
-  t.teardown(() => instance.close())
+  t.after(() => instance.close())
   await instance.listen({ port: 3000 })
 
   const res1 = await instance.inject({
@@ -55,8 +53,8 @@ async function run () {
       'x-host-number': 1
     }
   })
-  t.equal(res1.statusCode, 200)
-  t.equal(res1.body, 'Hello from target 1')
+  t.assert.strictEqual(res1.statusCode, 200)
+  t.assert.strictEqual(res1.body, 'Hello from target 1')
 
   const res2 = await instance.inject({
     method: 'GET',
@@ -65,8 +63,11 @@ async function run () {
       'x-host-number': 2
     }
   })
-  t.equal(res2.statusCode, 200)
-  t.equal(res2.body, 'Hello from target 2')
+  t.assert.strictEqual(res2.statusCode, 200)
+  t.assert.strictEqual(res2.body, 'Hello from target 2')
 }
 
-run()
+t.test('get-upstream-cache', async (t) => {
+  t.plan(4)
+  await run(t)
+})

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

@@ -1,10 +1,10 @@
 '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()
 const instanceWithoutBase = Fastify()
@@ -19,52 +19,46 @@ instanceWithoutBase.register(From, {
   disableCache: true
 })
 
-t.plan(13)
-t.teardown(instance.close.bind(instance))
-t.teardown(instanceWithoutBase.close.bind(instanceWithoutBase))
+t.test('getUpstream http', async (t) => {
+  t.plan(8)
+  t.after(() => instance.close())
+  t.after(() => instanceWithoutBase.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: (_req, base) => {
-      t.pass('getUpstream called')
-      return `${base}:${target.address().port}`
-    }
+  instance.get('/test', (_request, reply) => {
+    reply.from('/test', {
+      getUpstream: (_req, base) => {
+        t.assert.ok('getUpstream called')
+        return `${base}:${target.address().port}`
+      }
+    })
   })
-})
 
-instanceWithoutBase.get('/test2', (_request, reply) => {
-  reply.from('/test2', {
-    getUpstream: () => {
-      t.pass('getUpstream called')
-      return `http://localhost:${target.address().port}`
-    }
+  instanceWithoutBase.get('/test2', (_request, reply) => {
+    reply.from('/test2', {
+      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)
-  instanceWithoutBase.listen({ port: 0 }, (err) => {
-    t.error(err)
-    target.listen({ port: 0 }, (err) => {
-      t.error(err)
+  await new Promise(resolve => instance.listen({ port: 0 }, resolve))
 
-      get(`http://localhost:${instance.server.address().port}/test`, (err, res) => {
-        t.error(err)
-        t.equal(res.statusCode, 200)
-      })
+  await new Promise(resolve => instanceWithoutBase.listen({ port: 0 }, resolve))
 
-      get(`http://localhost:${instanceWithoutBase.server.address().port}/test2`, (err, res) => {
-        t.error(err)
-        t.equal(res.statusCode, 200)
-      })
-    })
-  })
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
+
+  const result = await request(`http://localhost:${instance.server.address().port}/test`)
+  t.assert.strictEqual(result.statusCode, 200)
+
+  const result1 = await request(`http://localhost:${instanceWithoutBase.server.address().port}/test2`)
+  t.assert.strictEqual(result1.statusCode, 200)
 })