@fastify/reply-from 12.1.0 → 12.2.0

package/test/full-get-test.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)
 
-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, '/hello')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('full get', 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, '/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(`http://localhost:${target.address().port}/hello`)
-})
+  instance.get('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}/hello`)
+  })
 
-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.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/full-https-get.test.js

@@ -1,10 +1,10 @@
 'use strict'
 
-const t = require('tap')
+const t = require('node:test')
 const Fastify = require('fastify')
+const { request, Agent } = require('undici')
 const From = require('..')
 const https = require('node:https')
-const get = require('simple-get').concat
 const fs = require('node:fs')
 const path = require('node:path')
 const certs = {
@@ -17,39 +17,39 @@ const instance = Fastify({
 })
 instance.register(From)
 
-t.plan(9)
-t.teardown(instance.close.bind(instance))
-
-const target = https.createServer(certs, (req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'GET')
-  res.statusCode = 205
-  res.setHeader('Content-Type', 'text/plain')
-  res.setHeader('x-my-header', 'hello!')
-  res.end('hello world')
-})
+t.test('full-https-get', async (t) => {
+  t.plan(6)
+  t.after(() => instance.close())
+
+  const target = https.createServer(certs, (req, res) => {
+    t.assert.ok('request proxied')
+    t.assert.strictEqual(req.method, 'GET')
+    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(`https://localhost:${target.address().port}`)
-})
+  instance.get('/', (_request, reply) => {
+    reply.from(`https://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: `https://localhost:${instance.server.address().port}`,
-      rejectUnauthorized: false
-    }, (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(`https://localhost:${instance.server.address().port}`, {
+    dispatcher: new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
     })
   })
+
+  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/full-post-extended-content-type.test.js

@@ -1,59 +1,55 @@
 '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')
 
 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'].startsWith('application/json'), true)
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
+t.test('full post extended 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'].startsWith('application/json'), true)
+    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' }))
+    })
   })
-  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' }))
+
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`)
-})
+  t.after(() => target.close())
 
-t.teardown(target.close.bind(target))
-
-instance.listen({ port: 0 }, (err) => {
-  t.error(err)
-
-  target.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    get.concat({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'POST',
-      body: JSON.stringify({
-        hello: 'world'
-      }),
-      headers: {
-        'content-type': 'application/json;charset=utf-8'
-      }
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'application/json')
-      t.same(JSON.parse(data.toString()), { something: 'else' })
-    })
+  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}`, {
+    method: 'POST',
+    body: JSON.stringify({
+      hello: 'world'
+    }),
+    headers: {
+      'content-type': 'application/json;charset=utf-8'
+    }
   })
+
+  t.assert.strictEqual(result.headers['content-type'], 'application/json')
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })

package/test/full-post-http2.test.js

@@ -1,22 +1,22 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('fastify')
 const From = require('..')
-const got = require('got')
+const { request, Agent } = require('undici')
 
 test('http -> http2', async function (t) {
   const instance = Fastify()
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
   const target = Fastify({
     http2: true
   })
 
   target.post('/', (request, reply) => {
-    t.pass('request proxied')
-    t.same(request.body, { something: 'else' })
+    t.assert.ok('request proxied')
+    t.assert.deepStrictEqual(request.body, { something: 'else' })
     reply.code(200).header('x-my-header', 'hello!').send({
       hello: 'world'
     })
@@ -26,7 +26,7 @@ test('http -> http2', async function (t) {
     reply.from()
   })
 
-  t.teardown(target.close.bind(target))
+  t.after(() => target.close())
 
   await target.listen({ port: 0 })
 
@@ -37,15 +37,20 @@ test('http -> http2', async function (t) {
 
   await instance.listen({ port: 0 })
 
-  const { headers, body, statusCode } = await got(`http://localhost:${instance.server.address().port}`, {
+  const { headers, body, statusCode } = await request(`http://localhost:${instance.server.address().port}`, {
     method: 'POST',
-    json: { something: 'else' },
-    responseType: 'json'
+    body: JSON.stringify({ something: 'else' }),
+    headers: {
+      'content-type': 'application/json'
+    },
+    dispatcher: new Agent({
+      pipelining: 0
+    })
   })
-  t.equal(statusCode, 200)
-  t.equal(headers['x-my-header'], 'hello!')
-  t.match(headers['content-type'], /application\/json/)
-  t.same(body, { hello: 'world' })
+  t.assert.strictEqual(statusCode, 200)
+  t.assert.strictEqual(headers['x-my-header'], 'hello!')
+  t.assert.match(headers['content-type'], /application\/json/)
+  t.assert.deepStrictEqual(await body.json(), { hello: 'world' })
   instance.close()
   target.close()
 })

package/test/full-post-stream-core.test.js

@@ -1,66 +1,62 @@
 '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(8)
-t.teardown(instance.close.bind(instance))
+t.test('full post stream core', async (t) => {
+  t.plan(5)
+  t.after(() => instance.close())
 
-instance.addContentTypeParser('application/octet-stream', function (_req, payload, done) {
-  done(null, payload)
-})
+  instance.addContentTypeParser('application/octet-stream', function (_req, payload, done) {
+    done(null, payload)
+  })
 
-t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/octet-stream')
-  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/octet-stream')
-    res.end(JSON.stringify({ something: 'else' }))
+  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/octet-stream')
+    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/octet-stream')
+      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/octet-stream'
-      },
-      body: JSON.stringify({
-        hello: 'world'
-      })
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(JSON.parse(data), { something: 'else' })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/octet-stream'
+    },
+    body: JSON.stringify({
+      hello: 'world'
     })
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })

package/test/full-post-stream.test.js

@@ -1,64 +1,60 @@
 '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('full post stream', async (t) => {
+  t.plan(5)
+  t.after(() => instance.close())
 
-instance.addContentTypeParser('application/octet-stream', function (_req, payload, done) {
-  done(null, payload)
-})
+  instance.addContentTypeParser('application/octet-stream', function (_req, payload, done) {
+    done(null, payload)
+  })
 
-t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
 
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/octet-stream')
-  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/octet-stream')
-    res.end(JSON.stringify({ something: 'else' }))
+  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/octet-stream')
+    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/octet-stream')
+      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/octet-stream'
-      },
-      body: JSON.stringify({
-        hello: 'world'
-      })
-    }, (err, _res, data) => {
-      t.error(err)
-      t.same(JSON.parse(data), { something: 'else' })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/octet-stream'
+    },
+    body: JSON.stringify({
+      hello: 'world'
     })
   })
+
+  t.assert.deepStrictEqual(await result.body.json(), { something: 'else' })
 })

package/test/full-post.test.js

@@ -1,56 +1,54 @@
 '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))
-
-const target = http.createServer((req, res) => {
-  t.pass('request proxied')
-  t.equal(req.method, 'POST')
-  t.equal(req.headers['content-type'], 'application/json')
-  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' }))
+t.test('full post', async (t) => {
+  t.plan(5)
+  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')
+    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',
-      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' })
 })