@fastify/reply-from 12.0.2 → 12.2.0

package/test/post-formbody.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()
 instance.register(From, {
@@ -12,48 +12,43 @@ instance.register(From, {
 })
 instance.register(require('@fastify/formbody'))
 
-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/x-www-form-urlencoded')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    const str = data.toString()
-    t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/x-www-form-urlencoded')
-    res.end(str)
+t.test('post-formbody', 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/x-www-form-urlencoded')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      const str = data.toString()
+      t.assert.deepStrictEqual(JSON.parse(data), { some: 'info', another: 'detail' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/x-www-form-urlencoded')
+      res.end(str)
+    })
   })
-})
 
-instance.post('/', (_request, reply) => {
-  reply.from(`http://localhost:${target.address().port}`)
-})
-
-t.teardown(target.close.bind(target))
+  instance.post('/', (_request, reply) => {
+    reply.from(`http://localhost:${target.address().port}`)
+  })
 
-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))
+  await new Promise(resolve => target.listen({ port: 0 }, resolve))
 
-    get({
-      url: `http://localhost:${instance.server.address().port}`,
-      method: 'POST',
-      headers: { 'content-type': 'application/x-www-form-urlencoded' },
-      body: 'some=info&another=detail'
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'application/x-www-form-urlencoded')
-      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/x-www-form-urlencoded' },
+    body: 'some=info&another=detail'
   })
+
+  t.assert.strictEqual(result.headers['content-type'], 'application/x-www-form-urlencoded')
+  t.assert.deepStrictEqual(await result.body.json(), { some: 'info', another: 'detail' })
 })

package/test/post-plain-text.test.js

@@ -1,56 +1,52 @@
 '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'], 'text/plain')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    const str = data.toString()
-    t.same(str, 'this is plain text')
-    res.statusCode = 200
-    res.setHeader('content-type', 'text/plain')
-    res.end(str)
+t.test('post plain text', 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'], 'text/plain')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      const str = data.toString()
+      t.assert.deepStrictEqual(str, 'this is plain text')
+      res.statusCode = 200
+      res.setHeader('content-type', 'text/plain')
+      res.end(str)
+    })
   })
-})
 
-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': 'text/plain' },
-      body: 'this is plain text'
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'text/plain')
-      t.same(data.toString(), 'this is plain text')
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: { 'content-type': 'text/plain' },
+    body: 'this is plain text'
   })
+
+  t.assert.strictEqual(result.headers['content-type'], 'text/plain')
+  t.assert.deepStrictEqual(await result.body.text(), 'this is plain text')
 })

package/test/post-with-custom-encoded-contenttype.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 { parse } = require('node:querystring')
 
 const instance = Fastify()
@@ -18,48 +18,46 @@ instance.addContentTypeParser(
   (_req, body, done) => done(null, parse(body.toString()))
 )
 
-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/x-www-form-urlencoded')
-  let data = ''
-  req.setEncoding('utf8')
-  req.on('data', (d) => {
-    data += d
-  })
-  req.on('end', () => {
-    const str = data.toString()
-    t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-    res.statusCode = 200
-    res.setHeader('content-type', 'application/x-www-form-urlencoded')
-    res.end(str)
+t.test('post with custom encoded 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/x-www-form-urlencoded')
+    let data = ''
+    req.setEncoding('utf8')
+    req.on('data', (d) => {
+      data += d
+    })
+    req.on('end', () => {
+      const str = data.toString()
+      t.assert.deepStrictEqual(JSON.parse(data), { some: 'info', another: 'detail' })
+      res.statusCode = 200
+      res.setHeader('content-type', 'application/x-www-form-urlencoded')
+      res.end(str)
+    })
   })
-})
 
-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/x-www-form-urlencoded' },
-      body: 'some=info&another=detail'
-    }, (err, res, data) => {
-      t.error(err)
-      t.equal(res.headers['content-type'], 'application/x-www-form-urlencoded')
-      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-    })
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/x-www-form-urlencoded'
+    },
+    body: 'some=info&another=detail'
   })
+
+  t.assert.strictEqual(result.headers['content-type'], 'application/x-www-form-urlencoded')
+  t.assert.deepStrictEqual(await result.body.json(), { some: 'info', another: 'detail' })
 })

package/test/post-with-octet-stream.test.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const test = require('tap').test
+const { test } = require('node:test')
 const Fastify = require('fastify')
+const { request } = require('undici')
 const From = require('../index')
 const http = require('node:http')
-const get = require('simple-get').concat
 const { parse } = require('node:querystring')
 
-test('with explicitly set content-type application/octet-stream', t => {
+test('with explicitly set content-type application/octet-stream', async t => {
   const instance = Fastify()
   instance.register(From, {
     contentTypesToEncode: ['application/octet-stream']
@@ -19,13 +19,13 @@ test('with explicitly set content-type application/octet-stream', t => {
     (_req, body, done) => done(null, parse(body.toString()))
   )
 
-  t.plan(9)
-  t.teardown(instance.close.bind(instance))
+  t.plan(6)
+  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')
+    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) => {
@@ -33,7 +33,7 @@ test('with explicitly set content-type application/octet-stream', t => {
     })
     req.on('end', () => {
       const str = data.toString()
-      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
+      t.assert.deepStrictEqual(JSON.parse(data), { some: 'info', another: 'detail' })
       res.statusCode = 200
       res.setHeader('content-type', 'application/octet-stream')
       res.end(str)
@@ -44,88 +44,18 @@ test('with explicitly set content-type application/octet-stream', t => {
     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: 'some=info&another=detail'
-      }, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'application/octet-stream')
-        t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-      })
-    })
-  })
-})
-
-test('with implicit content-type application/octet-stream', t => {
-  const instance = Fastify()
-  instance.register(From, {
-    contentTypesToEncode: ['application/octet-stream']
-  })
-
-  instance.addContentTypeParser(
-    'application/octet-stream',
-    { parseAs: 'buffer', bodyLimit: 1000 },
-    (_req, body, done) => done(null, parse(body.toString()))
-  )
-
-  instance.addContentTypeParser(
-    '*',
-    { parseAs: 'buffer', bodyLimit: 1000 },
-    (_req, body, done) => done(null, parse(body.toString()))
-  )
-
-  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/octet-stream')
-    let data = ''
-    req.setEncoding('utf8')
-    req.on('data', (d) => {
-      data += d
-    })
-    req.on('end', () => {
-      const str = data.toString()
-      t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-      res.statusCode = 200
-      res.setHeader('content-type', 'application/octet-stream')
-      res.end(str)
-    })
-  })
-
-  instance.post('/', (_request, reply) => {
-    reply.from(`http://localhost:${target.address().port}`)
+  const result = await request(`http://localhost:${instance.server.address().port}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/octet-stream' },
+    body: 'some=info&another=detail'
   })
 
-  t.teardown(target.close.bind(target))
-
-  instance.listen({ port: 0 }, (err) => {
-    t.error(err)
-
-    target.listen({ port: 0 }, (err) => {
-      t.error(err)
-
-      get({
-        url: `http://localhost:${instance.server.address().port}`,
-        method: 'POST',
-        body: 'some=info&another=detail'
-      }, (err, res, data) => {
-        t.error(err)
-        t.equal(res.headers['content-type'], 'application/octet-stream')
-        t.same(JSON.parse(data), { some: 'info', another: 'detail' })
-      })
-    })
-  })
+  t.assert.strictEqual(result.headers['content-type'], 'application/octet-stream')
+  t.assert.deepStrictEqual(await result.body.json(), { some: 'info', another: 'detail' })
 })

package/test/retry-on-503.test.js

@@ -1,10 +1,10 @@
 '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 got = require('got')
 
 function createTargetServer (withRetryAfterHeader, stopAfter = 1) {
   let requestCount = 0
@@ -26,8 +26,8 @@ function createTargetServer (withRetryAfterHeader, stopAfter = 1) {
 test('Should retry on 503 HTTP error', async function (t) {
   t.plan(3)
   const target = createTargetServer()
-  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()
 
@@ -39,20 +39,20 @@ test('Should retry on 503 HTTP error', async function (t) {
     reply.from()
   })
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
   await instance.listen({ port: 0 })
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 0 })
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 2!')
+  const res = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 2!')
 })
 
 test('Should retry on 503 HTTP error with Retry-After response header', async function (t) {
   t.plan(3)
   const target = createTargetServer(true)
-  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()
 
@@ -64,20 +64,20 @@ test('Should retry on 503 HTTP error with Retry-After response header', async fu
     reply.from()
   })
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
   await instance.listen({ port: 0 })
 
-  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 0 })
-  t.equal(res.headers['content-type'], 'text/plain')
-  t.equal(res.statusCode, 205)
-  t.equal(res.body.toString(), 'Hello World 2!')
+  const res = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(res.headers['content-type'], 'text/plain')
+  t.assert.strictEqual(res.statusCode, 205)
+  t.assert.strictEqual(await res.body.text(), 'Hello World 2!')
 })
 
 test('Should abort if server is always returning 503', async function (t) {
   t.plan(2)
   const target = createTargetServer(true, Number.MAX_SAFE_INTEGER)
-  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()
 
@@ -89,13 +89,14 @@ test('Should abort if server is always returning 503', async function (t) {
     reply.from()
   })
 
-  t.teardown(instance.close.bind(instance))
+  t.after(() => instance.close())
   await instance.listen({ port: 0 })
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}`, { retry: 0 })
-    t.fail()
-  } catch (err) {
-    t.equal(err.response.statusCode, 503)
-    t.equal(err.response.body.toString(), 'This Service is Unavailable')
-  }
+
+  await request(`http://localhost:${instance.server.address().port}`)
+  await request(`http://localhost:${instance.server.address().port}`)
+  await request(`http://localhost:${instance.server.address().port}`)
+  await request(`http://localhost:${instance.server.address().port}`)
+  const result = await request(`http://localhost:${instance.server.address().port}`)
+  t.assert.strictEqual(result.statusCode, 503)
+  t.assert.strictEqual(await result.body.text(), 'This Service is Unavailable')
 })