File: 0008-Avoid-parted.patch

package info (click to toggle)
node-minipass 5.0.0%2B~cs13.3.24-1
links: PTS, VCS
area: main
in suites: forky, sid
size: 3,348 kB
sloc: javascript: 9,187; sh: 33; makefile: 5
file content (2390 lines) | stat: -rw-r--r-- 72,175 bytes
parent folder | download | duplicates (2)
From: =?utf-8?q?Bastien_Roucari=C3=A8s?= <rouca@debian.org>
Date: Sun, 28 Jul 2024 23:41:33 +0000
Subject: Avoid parted

forwarded: not-needed
---
 minipass-fetch/test/fixtures/server.js |  398 -------
 minipass-fetch/test/index.js           | 1968 --------------------------------
 2 files changed, 2366 deletions(-)
 delete mode 100644 minipass-fetch/test/fixtures/server.js
 delete mode 100644 minipass-fetch/test/index.js

diff --git a/minipass-fetch/test/fixtures/server.js b/minipass-fetch/test/fixtures/server.js
deleted file mode 100644
index c2215c5..0000000
--- a/minipass-fetch/test/fixtures/server.js
+++ /dev/null
@@ -1,398 +0,0 @@
-const http = require('http')
-const zlib = require('minizlib')
-const { multipart: Multipart } = require('parted')
-const convert = require('encoding').convert
-
-class TestServer {
-  constructor () {
-    this.server = http.createServer((req, res) => this.router(req, res))
-    this.port = 30000 + (+process.env.TAP_CHILD_ID || 1)
-    this.hostname = 'localhost'
-    // node 8 default keepalive timeout is 5000ms
-    // make it shorter here as we want to close server
-    // quickly at the end of tests
-    this.server.keepAliveTimeout = 1000
-    this.server.on('error', err => console.log(err.stack))
-    this.server.on('connection', socket => socket.setTimeout(1500))
-  }
-
-  start (cb) {
-    this.server.listen(this.port, this.hostname, cb)
-  }
-
-  stop (cb) {
-    this.server.close(cb)
-  }
-
-  router (req, res) {
-    const p = req.url
-
-    if (p === '/hello') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.end('world')
-    }
-
-    if (p === '/plain') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.end('text')
-    }
-
-    if (p === '/options') {
-      res.statusCode = 200
-      res.setHeader('Allow', 'GET, HEAD, OPTIONS')
-      res.end('hello world')
-    }
-
-    if (p === '/html') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html')
-      res.end('<html></html>')
-    }
-
-    if (p === '/json') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'application/json')
-      res.end(JSON.stringify({ name: 'value' }))
-    }
-
-    if (p === '/gzip') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'gzip')
-      // eslint-disable-next-line promise/catch-or-return
-      new zlib.Gzip().end('hello world').concat().then(buf => res.end(buf))
-    }
-
-    if (p === '/gzip-truncated') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'gzip')
-      // eslint-disable-next-line promise/catch-or-return
-      new zlib.Gzip().end('hello world').concat().then(buf =>
-        res.end(buf.slice(0, buf.length - 8)))
-    }
-
-    if (p === '/deflate') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'deflate')
-      // eslint-disable-next-line promise/catch-or-return
-      new zlib.Deflate().end('hello world').concat().then(buf => res.end(buf))
-    }
-
-    if (p === '/brotli') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'br')
-      // pre-compressed 'hello world', in-lined here so tests will run when the
-      // client doesn't support brotli
-      const buf = Buffer.from([
-        0x0b, 0x05, 0x80, 0x68, 0x65, 0x6c, 0x6c,
-        0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x03,
-      ])
-      res.end(buf)
-    }
-
-    if (p === '/deflate-raw') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'deflate')
-      // eslint-disable-next-line promise/catch-or-return
-      new zlib.DeflateRaw().end('hello world').concat().then(buf => res.end(buf))
-    }
-
-    if (p === '/sdch') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'sdch')
-      res.end('fake sdch string')
-    }
-
-    if (p === '/invalid-content-encoding') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.setHeader('Content-Encoding', 'gzip')
-      res.end('fake gzip string')
-    }
-
-    if (p === '/timeout') {
-      setTimeout(() => {
-        res.statusCode = 200
-        res.setHeader('Content-Type', 'text/plain')
-        res.end('text')
-      }, 1000)
-    }
-
-    if (p === '/slow') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.write('test')
-      setTimeout(() => res.end('test'), 1000)
-    }
-
-    if (p === '/cookie') {
-      res.statusCode = 200
-      res.setHeader('Set-Cookie', ['a=1', 'b=1'])
-      res.end('cookie')
-    }
-
-    if (p === '/size/chunk') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      setTimeout(() => res.write('test'), 10)
-      setTimeout(() => res.end('test'), 20)
-    }
-
-    if (p === '/size/long') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain')
-      res.end('testtest')
-    }
-
-    if (p === '/encoding/gbk') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html')
-      res.end(convert('<meta charset="gbk"><div>中文</div>', 'gbk'))
-    }
-
-    if (p === '/encoding/gb2312') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html')
-      res.end(convert('<meta http-equiv="Content-Type" content="text/html; charset=gb2312">' +
-        '<div>中文</div>', 'gb2312'))
-    }
-
-    if (p === '/encoding/gb2312-reverse') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html')
-      res.end(convert('<meta content="text/html; charset=gb2312" http-equiv="Content-Type">' +
-        '<div>中文</div>', 'gb2312'))
-    }
-
-    if (p === '/encoding/shift-jis') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html; charset=Shift-JIS')
-      res.end(convert('<div>日本語</div>', 'Shift_JIS'))
-    }
-
-    if (p === '/encoding/euc-jp') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/xml')
-      res.end(convert('<?xml version="1.0" encoding="EUC-JP"?><title>日本語</title>', 'EUC-JP'))
-    }
-
-    if (p === '/encoding/utf8') {
-      res.statusCode = 200
-      res.end('中文')
-    }
-
-    if (p === '/encoding/order1') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'charset=gbk; text/plain')
-      res.end(convert('中文', 'gbk'))
-    }
-
-    if (p === '/encoding/order2') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/plain; charset=gbk; qs=1')
-      res.end(convert('中文', 'gbk'))
-    }
-
-    if (p === '/encoding/chunked') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html')
-      res.setHeader('Transfer-Encoding', 'chunked')
-      res.write('a'.repeat(10))
-      res.end(convert('<meta http-equiv="Content-Type" content="text/html; charset=Shift_JIS" />' +
-        '<div>日本語</div>', 'Shift_JIS'))
-    }
-
-    if (p === '/encoding/invalid') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'text/html')
-      res.setHeader('Transfer-Encoding', 'chunked')
-      res.write('a'.repeat(1200))
-      res.end(convert('中文', 'gbk'))
-    }
-
-    if (p === '/redirect/301') {
-      res.statusCode = 301
-      res.setHeader('Location', '/inspect')
-      res.end()
-    }
-
-    if (p === '/redirect/301/invalid') {
-      res.statusCode = 301
-      res.setHeader('Location', '//super:invalid:url%/')
-      res.end()
-    }
-
-    if (p === '/redirect/302') {
-      res.statusCode = 302
-      res.setHeader('Location', '/inspect')
-      res.end()
-    }
-
-    if (p === '/redirect/303') {
-      res.statusCode = 303
-      res.setHeader('Location', '/inspect')
-      res.end()
-    }
-
-    if (p === '/redirect/307') {
-      res.statusCode = 307
-      res.setHeader('Location', '/inspect')
-      res.end()
-    }
-
-    if (p === '/redirect/308') {
-      res.statusCode = 308
-      res.setHeader('Location', '/inspect')
-      res.end()
-    }
-
-    if (p === '/redirect/chain') {
-      res.statusCode = 301
-      res.setHeader('Location', '/redirect/301')
-      res.end()
-    }
-
-    if (p === '/redirect/no-location') {
-      res.statusCode = 301
-      res.end()
-    }
-
-    if (p === '/redirect/slow') {
-      res.statusCode = 301
-      res.setHeader('Location', '/redirect/301')
-      setTimeout(() => res.end(), 1000)
-    }
-
-    if (p === '/redirect/slow-chain') {
-      res.statusCode = 301
-      res.setHeader('Location', '/redirect/slow')
-      setTimeout(() => res.end(), 10)
-    }
-
-    if (p === '/redirect/slow-stream') {
-      res.statusCode = 301
-      res.setHeader('Location', '/slow')
-      res.end()
-    }
-
-    if (p === '/error/400') {
-      res.statusCode = 400
-      res.setHeader('Content-Type', 'text/plain')
-      res.end('client error')
-    }
-
-    if (p === '/error/404') {
-      res.statusCode = 404
-      res.setHeader('Content-Encoding', 'gzip')
-      res.end()
-    }
-
-    if (p === '/error/500') {
-      res.statusCode = 500
-      res.setHeader('Content-Type', 'text/plain')
-      res.end('server error')
-    }
-
-    if (p === '/error/reset') {
-      res.destroy()
-    }
-
-    if (p === '/error/json') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'application/json')
-      res.end('invalid json')
-    }
-
-    if (p === '/no-content') {
-      res.statusCode = 204
-      res.end()
-    }
-
-    if (p === '/no-content/gzip') {
-      res.statusCode = 204
-      res.setHeader('Content-Encoding', 'gzip')
-      res.end()
-    }
-
-    if (p === '/no-content/brotli') {
-      res.statusCode = 204
-      res.setHeader('Content-Encoding', 'br')
-      res.end()
-    }
-
-    if (p === '/not-modified') {
-      res.statusCode = 304
-      res.end()
-    }
-
-    if (p === '/not-modified/gzip') {
-      res.statusCode = 304
-      res.setHeader('Content-Encoding', 'gzip')
-      res.end()
-    }
-
-    if (p === '/inspect') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'application/json')
-      let body = ''
-      req.on('data', c => body += c)
-      req.on('end', () => res.end(JSON.stringify({
-        method: req.method,
-        url: req.url,
-        headers: req.headers,
-        body,
-      })))
-    }
-
-    if (p === '/multipart') {
-      res.statusCode = 200
-      res.setHeader('Content-Type', 'application/json')
-      // the path option passed to the Multipart constructor cannot be an
-      // absolute path in Windows, we set it here manually because the default
-      // provided by 'parsed' is an absolute path
-      // ref: https://github.com/chjj/parsed/issues/10
-      const parser = new Multipart(req.headers['content-type'], { path: './' })
-      let body = ''
-      parser.on('part', (field, part) => body += field + '=' + part)
-      parser.on('end', () => res.end(JSON.stringify({
-        method: req.method,
-        url: req.url,
-        headers: req.headers,
-        body: body,
-      })))
-      req.pipe(parser)
-    }
-
-    if (p === '/trailers') {
-      res.statusCode = 200
-      res.setHeader('Transfer-Encoding', 'chunked')
-      res.setHeader('Trailer', 'X-Node-Fetch')
-      res.write('Body of the response')
-      res.addTrailers({ 'X-Node-Fetch': 'hello world!' })
-      res.end()
-    }
-
-    if (p === '/host-redirect') {
-      if (req.headers.host !== `localhost:${this.port}`) {
-        res.setHeader('location', `http://localhost:${this.port}/host-redirect`)
-        res.statusCode = 302
-      }
-      res.end(`http://${req.headers.host}/host-redirect`)
-    }
-  }
-}
-
-module.exports = TestServer
-
-if (require.main === module) {
-  const server = new TestServer()
-  server.start(() =>
-    console.log(`Server started listening at port ${server.port}`))
-}
diff --git a/minipass-fetch/test/index.js b/minipass-fetch/test/index.js
deleted file mode 100644
index ab92af2..0000000
--- a/minipass-fetch/test/index.js
+++ /dev/null
@@ -1,1968 +0,0 @@
-'use strict'
-const t = require('tap')
-const TestServer = require('./fixtures/server.js')
-const fetch = require('../lib/index.js')
-//const stringToArrayBuffer = require('string-to-arraybuffer')
-const URLSearchParamsPolyfill = require('@ungap/url-search-params')
-const { AbortError, FetchError, Headers, Request, Response } = fetch
-const AbortErrorOrig = require('../lib/abort-error.js')
-const FetchErrorOrig = require('../lib/fetch-error.js')
-const HeadersOrig = require('../lib/headers.js')
-const { createHeadersLenient } = HeadersOrig
-const RequestOrig = require('../lib/request.js')
-const ResponseOrig = require('../lib/response.js')
-const Body = require('../lib/body.js')
-const { getTotalBytes, extractContentType } = Body
-const Blob = require('../lib/blob.js')
-const realZlib = require('zlib')
-const { lookup } = require('dns')
-const { promisify } = require('util')
-const supportToString = ({
-  [Symbol.toStringTag]: 'z',
-}).toString() === '[object z]'
-const FormData = require('form-data')
-const fs = require('fs')
-const http = require('http')
-// use of url.parse here is intentional and for coverage purposes
-// eslint-disable-next-line node/no-deprecated-api
-const { parse: parseURL, URLSearchParams } = require('url')
-const nock = require('nock')
-
-const vm = require('vm')
-const {
-  ArrayBuffer: VMArrayBuffer,
-  Uint8Array: VMUint8Array,
-} = vm.runInNewContext('this')
-
-const { spawn } = require('child_process')
-const path = require('path')
-
-const { Minipass } = require('minipass')
-const supportStreamDestroy = 'destroy' in Minipass.prototype
-
-const { AbortController } = require('abortcontroller-polyfill/dist/abortcontroller')
-const AbortController2 = require('abort-controller')
-
-const local = new TestServer()
-const base = `http://${local.hostname}:${local.port}/`
-
-t.Test.prototype.addAssert('contain', 2, function (list, key, m, e) {
-  m = m || 'expected item to be contained in list'
-  e.found = list
-  e.wanted = key
-  return this.ok(list.indexOf(key) !== -1, m, e)
-})
-t.Test.prototype.addAssert('notContain', 2, function (list, key, m, e) {
-  m = m || 'expected item to not be contained in list'
-  e.found = list
-  e.wanted = key
-  return this.notOk(list.indexOf(key) !== -1, m, e)
-})
-
-const streamToPromise = (stream, dataHandler) =>
-  new Promise((resolve, reject) => {
-    stream.on('data', (...args) =>
-      Promise.resolve()
-        .then(() => dataHandler(...args))
-        .catch(reject))
-
-    stream.on('end', resolve)
-    stream.on('error', reject)
-  })
-
-t.test('start server', t => {
-  local.start(t.end)
-  t.parent.teardown(() => local.stop())
-})
-
-t.test('return a promise', t => {
-  const p = fetch(`${base}hello`)
-  t.type(p, Promise)
-  t.equal(typeof p.then, 'function')
-  t.end()
-})
-
-t.test('expose AbortError, FetchError, Headers, Response and Request constructors', t => {
-  t.equal(AbortError, AbortErrorOrig)
-  t.equal(FetchError, FetchErrorOrig)
-  t.equal(Headers, HeadersOrig)
-  t.equal(Response, ResponseOrig)
-  t.equal(Request, RequestOrig)
-  t.end()
-})
-
-t.test('support proper toString output', { skip: !supportToString }, t => {
-  t.equal(new Headers().toString(), '[object Headers]')
-  t.equal(new Response().toString(), '[object Response]')
-  t.equal(new Request('http://localhost:30000').toString(), '[object Request]')
-  t.end()
-})
-
-t.test('reject with error if url is protocol relative', t =>
-  t.rejects(fetch('//example.com/'), {
-    code: 'ERR_INVALID_URL',
-    name: 'TypeError',
-  }))
-
-t.test('reject if url is relative path', t =>
-  t.rejects(fetch('/some/path'), {
-    code: 'ERR_INVALID_URL',
-    name: 'TypeError',
-  }))
-
-t.test('reject if protocol unsupported', t =>
-  t.rejects(fetch('ftp://example.com/'), new TypeError(
-    'Only HTTP(S) protocols are supported')))
-
-t.test('reject with error on network failure', t =>
-  t.rejects(fetch('http://localhost:55555/'), {
-    name: 'FetchError',
-    code: 'ECONNREFUSED',
-    errno: 'ECONNREFUSED',
-    type: 'system',
-  }))
-
-t.test('resolve into response', async t => {
-  const res = await fetch(`${base}hello`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(res.bodyUsed, true)
-  t.equal(result, 'world')
-})
-
-t.test('accept html response (like plain text)', async t => {
-  const res = await fetch(`${base}html`)
-  t.equal(res.headers.get('content-type'), 'text/html')
-  const result = await res.text()
-  t.equal(res.bodyUsed, true)
-  t.equal(result, '<html></html>')
-})
-
-t.test('accept json response', async t => {
-  const res = await fetch(`${base}json`)
-  t.equal(res.headers.get('content-type'), 'application/json')
-  const result = await res.json()
-  t.equal(res.bodyUsed, true)
-  t.strictSame(result, { name: 'value' })
-})
-
-t.test('send request with custom hedaers', async t => {
-  const res = await fetch(`${base}inspect`, {
-    headers: { 'x-custom-header': 'abc' },
-  })
-  const json = await res.json()
-  t.equal(json.headers['x-custom-header'], 'abc')
-})
-
-t.test('accept headers instance', async t => {
-  const res = await fetch(`${base}inspect`, {
-    headers: new Headers({ 'x-custom-header': 'abc' }),
-  })
-  const json = await res.json()
-  t.equal(json.headers['x-custom-header'], 'abc')
-})
-
-t.test('accept custom host header', async t => {
-  const res = await fetch(`${base}inspect`, {
-    headers: {
-      host: 'example.com',
-    },
-  })
-  const json = await res.json()
-  t.equal(json.headers.host, 'example.com')
-})
-
-t.test('accept custom HoSt header', async t => {
-  const res = await fetch(`${base}inspect`, {
-    headers: {
-      HoSt: 'example.com',
-    },
-  })
-  const json = await res.json()
-  t.equal(json.headers.host, 'example.com')
-})
-
-t.test('follow redirects', async t => {
-  const codes = [301, 302, 303, 307, 308, 'chain']
-  t.plan(codes.length)
-  for (const code of codes) {
-    t.test(code, async t => {
-      const res = await fetch(`${base}redirect/${code}`)
-      t.equal(res.url, `${base}inspect`)
-      t.equal(res.status, 200)
-      t.equal(res.ok, true)
-    })
-  }
-})
-
-t.test('redirect to different host strips headers', async (t) => {
-  nock.disableNetConnect()
-  t.teardown(() => {
-    nock.cleanAll()
-    nock.enableNetConnect()
-  })
-
-  const first = nock('http://x.y', {
-    reqheaders: {
-      authorization: 'totally-authed-request',
-      cookie: 'fake-cookie',
-    },
-  })
-    .get('/')
-    .reply(301, null, { location: 'http://a.b' })
-
-  const second = nock('http://a.b', {
-    badheaders: ['authorization', 'cookie'],
-  })
-    .get('/')
-    .reply(200)
-
-  const res = await fetch('http://x.y', {
-    headers: {
-      authorization: 'totally-authed-request',
-      cookie: 'fake-cookie',
-    },
-  })
-  await res.text() // drain the response stream
-
-  t.ok(first.isDone(), 'initial request made')
-  t.ok(second.isDone(), 'redirect followed')
-  t.equal(res.status, 200)
-  t.ok(res.ok)
-})
-
-t.test('follow POST request redirect with GET', async t => {
-  for (const code of [301, 302]) {
-    t.test(code, async t => {
-      const url = `${base}redirect/${code}`
-      const opts = {
-        method: 'POST',
-        body: 'a=1',
-      }
-      const res = await fetch(url, opts)
-      t.equal(res.url, `${base}inspect`)
-      t.equal(res.status, 200)
-      const result = await res.json()
-      t.equal(result.method, 'GET')
-      t.equal(result.body, '')
-    })
-  }
-})
-
-t.test('follow PATCH request redirect with PATCH', async t => {
-  const codes = [301, 302, 307]
-  t.plan(codes.length)
-  for (const code of codes) {
-    t.test(code, async t => {
-      const url = `${base}redirect/${code}`
-      const opts = {
-        method: 'PATCH',
-        body: 'a=1',
-      }
-      const res = await fetch(url, opts)
-      t.equal(res.url, `${base}inspect`)
-      t.equal(res.status, 200)
-      const result = await res.json()
-      t.equal(result.method, 'PATCH')
-      t.equal(result.body, 'a=1')
-    })
-  }
-})
-
-t.test('no follow non-GET redirect if body is readable stream', async t => {
-  const url = `${base}redirect/307`
-  const body = new Minipass()
-  body.pause()
-  body.end('a=1')
-  setTimeout(() => body.resume(), 100)
-  const opts = {
-    method: 'PATCH',
-    body,
-  }
-  await t.rejects(fetch(url, opts), {
-    name: 'FetchError',
-    type: 'unsupported-redirect',
-  })
-})
-
-t.test('obey maximum redirect, reject case', async t => {
-  const url = `${base}redirect/chain`
-  const opts = {
-    follow: 1,
-  }
-  await t.rejects(fetch(url, opts), {
-    name: 'FetchError',
-    type: 'max-redirect',
-  })
-})
-
-t.test('obey redirect chain, resolve case', async t => {
-  const url = `${base}redirect/chain`
-  const opts = {
-    follow: 2,
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.url, `${base}inspect`)
-  t.equal(res.status, 200)
-})
-
-t.test('allow not following redirect', async t => {
-  const url = `${base}redirect/301`
-  const opts = {
-    follow: 0,
-  }
-  await t.rejects(fetch(url, opts), {
-    name: 'FetchError',
-    type: 'max-redirect',
-  })
-})
-
-t.test('redirect mode, manual flag', async t => {
-  const url = `${base}redirect/301`
-  const opts = {
-    redirect: 'manual',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.url, url)
-  t.equal(res.status, 301)
-  t.equal(res.headers.get('location'), `${base}inspect`)
-})
-
-t.test('redirect mode, error flag', async t => {
-  const url = `${base}redirect/301`
-  const opts = {
-    redirect: 'error',
-  }
-  await t.rejects(fetch(url, opts), {
-    name: 'FetchError',
-    type: 'no-redirect',
-  })
-})
-
-t.test('redirect mode, manual flag when there is no redirect', async t => {
-  const url = `${base}hello`
-  const opts = {
-    redirect: 'manual',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.url, url)
-  t.equal(res.status, 200)
-  t.equal(res.headers.get('location'), null)
-})
-
-t.test('redirect code 301 and keep existing headers', async t => {
-  const url = `${base}redirect/301`
-  const opts = {
-    headers: new Headers({ 'x-custom-header': 'abc' }),
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.url, `${base}inspect`)
-  const json = await res.json()
-  t.equal(json.headers['x-custom-header'], 'abc')
-})
-
-t.test('treat broken redirect as ordinary response (follow)', async t => {
-  const url = `${base}redirect/no-location`
-  const res = await fetch(url)
-  t.equal(res.url, url)
-  t.equal(res.status, 301)
-  t.equal(res.headers.get('location'), null)
-})
-
-t.test('treat broken redirect as ordinary response (manual)', async t => {
-  const url = `${base}redirect/no-location`
-  const opts = {
-    redirect: 'manual',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.url, url)
-  t.equal(res.status, 301)
-  t.equal(res.headers.get('location'), null)
-})
-
-t.test('should process an invalid redirect (manual)', async t => {
-  const url = `${base}redirect/301/invalid`
-  const options = {
-    redirect: 'manual',
-  }
-  const res = await fetch(url, options)
-  t.equal(res.url, url)
-  t.equal(res.status, 301)
-  t.equal(res.headers.get('location'), '//super:invalid:url%/')
-})
-
-t.test('should throw an error on invalid redirect url', async t => {
-  const url = `${base}redirect/301/invalid`
-  await t.rejects(fetch(url), {
-    name: 'FetchError',
-    message: 'uri requested responds with an invalid redirect URL: //super:invalid:url%/',
-  })
-})
-
-t.test('set redirected property on response when redirect', t =>
-  fetch(`${base}redirect/301`).then(res => t.equal(res.redirected, true)))
-
-t.test('no redirected property on response when not redirect', t =>
-  fetch(`${base}hello`).then(res => t.equal(res.redirected, false)))
-
-t.test('ignore invalid headers', t => {
-  var headers = {
-    'Invalid-Header ': 'abc\r\n',
-    'Invalid-Header-Value': '\x07k\r\n',
-    'Set-Cookie': ['\x07k\r\n', '\x07kk\r\n'],
-  }
-  headers = createHeadersLenient(headers)
-  t.equal(headers['Invalid-Header '], undefined)
-  t.equal(headers['Invalid-Header-Value'], undefined)
-  t.equal(headers['Set-Cookie'], undefined)
-  t.end()
-})
-
-t.test('handle client-error response', async t => {
-  const url = `${base}error/400`
-  const res = await fetch(url)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  t.equal(res.status, 400)
-  t.equal(res.statusText, 'Bad Request')
-  t.equal(res.ok, false)
-  const result = await res.text()
-  t.equal(res.bodyUsed, true)
-  t.equal(result, 'client error')
-})
-
-t.test('handle server-error response', async t => {
-  const url = `${base}error/500`
-  const res = await fetch(url)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  t.equal(res.status, 500)
-  t.equal(res.statusText, 'Internal Server Error')
-  t.equal(res.ok, false)
-  const result = await res.text()
-  t.equal(res.bodyUsed, true)
-  t.equal(result, 'server error')
-})
-
-t.test('handle network-error response', async t => {
-  await t.rejects(fetch(`${base}error/reset`), {
-    name: 'FetchError',
-    code: 'ECONNRESET',
-  })
-})
-
-t.test('handle DNS-error response', async t => {
-  await t.rejects(fetch('http://domain.invalid'), {
-    name: 'FetchError',
-    // this error depends on the platform and dns server in use,
-    // but it should be one of these two codes
-    code: /^(ENOTFOUND|EAI_AGAIN)$/,
-  })
-})
-
-t.test('reject invalid json response', async t => {
-  const res = await fetch(`${base}error/json`)
-  t.equal(res.headers.get('content-type'), 'application/json')
-  await t.rejects(res.json(), {
-    name: 'FetchError',
-    type: 'invalid-json',
-  })
-})
-
-t.test('reject invalid json response', async t => {
-  const res = await fetch(`${base}error/json`)
-  t.equal(res.headers.get('content-type'), 'application/json')
-  await t.rejects(res.json(), {
-    name: 'FetchError',
-    type: 'invalid-json',
-  })
-})
-
-t.test('handle no content response', async t => {
-  const res = await fetch(`${base}no-content`)
-  t.equal(res.status, 204)
-  t.equal(res.statusText, 'No Content')
-  t.equal(res.ok, true)
-  const result = await res.text()
-  t.equal(result, '')
-})
-
-t.test('reject parsing no content response as json', async t => {
-  const res = await fetch(`${base}no-content`)
-  t.equal(res.status, 204)
-  t.equal(res.statusText, 'No Content')
-  t.equal(res.ok, true)
-  await t.rejects(res.json(), {
-    name: 'FetchError',
-    type: 'invalid-json',
-  })
-})
-
-t.test('handle no content response with gzip encoding', async t => {
-  const res = await fetch(`${base}no-content/gzip`)
-  t.equal(res.status, 204)
-  t.equal(res.statusText, 'No Content')
-  t.equal(res.headers.get('content-encoding'), 'gzip')
-  t.equal(res.ok, true)
-  const result = await res.text()
-  t.equal(result, '')
-})
-
-t.test('handle not modified response', async t => {
-  const res = await fetch(`${base}not-modified`)
-  t.equal(res.status, 304)
-  t.equal(res.statusText, 'Not Modified')
-  t.equal(res.ok, false)
-  const result = await res.text()
-  t.equal(result, '')
-})
-
-t.test('handle not modified response with gzip encoding', async t => {
-  const res = await fetch(`${base}not-modified/gzip`)
-  t.equal(res.status, 304)
-  t.equal(res.statusText, 'Not Modified')
-  t.equal(res.headers.get('content-encoding'), 'gzip')
-  t.equal(res.ok, false)
-  const result = await res.text()
-  t.equal(result, '')
-})
-
-t.test('decompress gzip response', async t => {
-  const res = await fetch(`${base}gzip`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(result, 'hello world')
-})
-
-t.test('decompress slightly invalid gzip response', async t => {
-  const res = await fetch(`${base}gzip-truncated`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(result, 'hello world')
-})
-
-t.test('decompress deflate response', async t => {
-  const res = await fetch(`${base}deflate`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(result, 'hello world')
-})
-
-t.test('decompress deflate raw response from old apache server', async t => {
-  const res = await fetch(`${base}deflate-raw`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(result, 'hello world')
-})
-
-t.test('decompress brotli response', async t => {
-  // if the node core zlib doesn't export brotli functions, we'll end up
-  // rejecting the request with an error that comes from minizlib, assert
-  // that here
-  if (typeof realZlib.BrotliCompress !== 'function') {
-    return t.rejects(fetch(`${base}brotli`), {
-      message: 'Brotli is not supported in this version of Node.js',
-    }, 'rejects the promise')
-  }
-
-  const res = await fetch(`${base}brotli`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(result, 'hello world')
-})
-
-t.test('handle no content response with brotli encoding', async t => {
-  const res = await fetch(`${base}no-content/brotli`)
-  t.equal(res.status, 204)
-  t.equal(res.statusText, 'No Content')
-  t.equal(res.headers.get('content-encoding'), 'br')
-  t.equal(res.ok, true)
-  const result = await res.text()
-  t.equal(result, '')
-})
-
-t.test('skip decompression if unsupported', async t => {
-  const res = await fetch(`${base}sdch`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  const result = await res.text()
-  t.equal(result, 'fake sdch string')
-})
-
-t.test('reject if response compression is invalid', async t => {
-  const res = await fetch(`${base}invalid-content-encoding`)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  await t.rejects(res.text(), {
-    name: 'FetchError',
-    code: 'Z_DATA_ERROR',
-  })
-})
-
-t.test('handle errors on the body stream even if it is not used', async t => {
-  const res = await fetch(`${base}invalid-content-encoding`)
-  t.equal(res.status, 200)
-  // Wait a few ms to see if a uncaught error occurs
-  await promisify(setTimeout)(20)
-})
-
-t.test('collect handled errors on body stream, reject if used later', async t => {
-  const delay = value => new Promise(resolve =>
-    setTimeout(() => resolve(value), 20))
-
-  const res = await fetch(`${base}invalid-content-encoding`).then(delay)
-  const delayed = await delay(res)
-  t.equal(delayed.headers.get('content-type'), 'text/plain')
-  t.rejects(delayed.text(), {
-    name: 'FetchError',
-    code: 'Z_DATA_ERROR',
-  })
-})
-
-t.test('allow disabling auto decompression', t =>
-  fetch(`${base}gzip`, { compress: false }).then(res => {
-    t.equal(res.headers.get('content-type'), 'text/plain')
-    return res.text().then(result => t.not(result, 'hello world'))
-  }))
-
-t.test('do not overwrite accept-encoding when auto decompression', t =>
-  fetch(`${base}inspect`, {
-    compress: true,
-    headers: {
-      'Accept-Encoding': 'gzip',
-    },
-  })
-    .then(res => res.json())
-    .then(res => t.equal(res.headers['accept-encoding'], 'gzip')))
-
-t.test('allow custom timeout', t => {
-  return t.rejects(fetch(`${base}timeout`, { timeout: 20 }), {
-    name: 'FetchError',
-    type: 'request-timeout',
-  })
-})
-
-t.test('allow custom timeout on response body', t => {
-  return fetch(`${base}slow`, { timeout: 50 }).then(res => {
-    t.equal(res.ok, true)
-    return t.rejects(res.text(), {
-      name: 'FetchError',
-      type: 'body-timeout',
-    })
-  })
-})
-
-t.test('allow custom timeout on redirected requests', t =>
-  t.rejects(fetch(`${base}redirect/slow-chain`, { timeout: 50 }), {
-    name: 'FetchError',
-    type: 'request-timeout',
-  }))
-
-t.test('clear internal timeout on fetch response', { timeout: 2000 }, t => {
-  const args = ['-e', `require('./')('${base}hello', { timeout: 10000 })`]
-  spawn(process.execPath, args, { cwd: path.resolve(__dirname, '..') })
-    .on('close', (code, signal) => {
-      t.equal(code, 0)
-      t.equal(signal, null)
-      t.end()
-    })
-})
-
-t.test('clear internal timeout on fetch redirect', { timeout: 2000 }, t => {
-  const args = ['-e', `require('./')('${base}redirect/301', { timeout: 10000 })`]
-  spawn(process.execPath, args, { cwd: path.resolve(__dirname, '..') })
-    .on('close', (code, signal) => {
-      t.equal(code, 0)
-      t.equal(signal, null)
-      t.end()
-    })
-})
-
-t.test('clear internal timeout on fetch error', { timeout: 2000 }, t => {
-  const args = ['-e', `require('./')('${base}error/reset', { timeout: 10000 })`]
-  // note: promise rejections started setting exit status code in node 15
-  const stderr = []
-  spawn(process.execPath, args, { cwd: path.resolve(__dirname, '..') })
-    .on('close', (code, signal) => {
-      t.match(Buffer.concat(stderr).toString(), 'FetchError')
-      t.equal(signal, null)
-      t.end()
-    })
-    .stderr.on('data', c => stderr.push(c))
-})
-
-t.test('request cancellation with signal', { timeout: 500 }, t => {
-  const controller = new AbortController()
-  const controller2 = new AbortController2()
-
-  const fetches = [
-    fetch(`${base}timeout`, { signal: controller.signal }),
-    fetch(`${base}timeout`, { signal: controller2.signal }),
-    fetch(
-      `${base}timeout`,
-      {
-        method: 'POST',
-        signal: controller.signal,
-        headers: {
-          'Content-Type': 'application/json',
-          body: JSON.stringify({ hello: 'world' }),
-        },
-      }
-    ),
-  ]
-  setTimeout(() => {
-    controller.abort()
-    controller2.abort()
-  }, 100)
-
-  return Promise.all(fetches.map(fetched => t.rejects(fetched, {
-    name: 'AbortError',
-    type: 'aborted',
-  })))
-})
-
-t.test('reject immediately if signal already aborted', t => {
-  const url = `${base}timeout`
-  const controller = new AbortController()
-  const opts = {
-    signal: controller.signal,
-  }
-  controller.abort()
-  const fetched = fetch(url, opts)
-  return t.rejects(fetched, {
-    name: 'AbortError',
-    type: 'aborted',
-  })
-})
-
-t.test('clear internal timeout when cancelled with AbortSignal', { timeout: 2000 }, t => {
-  const script = `
-const ACP = require('abortcontroller-polyfill/dist/cjs-ponyfill')
-var AbortController = ACP.AbortController
-var controller = new AbortController()
-require('./')(
-'${base}timeout',
-{ signal: controller.signal, timeout: 10000 }
-)
-setTimeout(function () { controller.abort(); }, 20)
-  `
-  // note: promise rejections started setting exit status code in node 15
-  const stderr = []
-  spawn('node', ['-e', script], { cwd: path.resolve(__dirname, '..') })
-    .on('close', (code, signal) => {
-      t.match(Buffer.concat(stderr).toString(), 'AbortError')
-      t.equal(signal, null)
-      t.end()
-    })
-    .stderr.on('data', c => stderr.push(c))
-})
-
-t.test('remove internal AbortSignal listener when request aborted', t => {
-  const controller = new AbortController()
-  const { signal } = controller
-  const promise = fetch(
-    `${base}timeout`,
-    { signal }
-  )
-  const result = t.rejects(promise, { name: 'AbortError' })
-    .then(() => t.equal(signal.listeners.abort.length, 0))
-  controller.abort()
-  return result
-})
-
-t.test('allow redirects to be aborted', t => {
-  const abortController = new AbortController()
-  const request = new Request(`${base}redirect/slow`, {
-    signal: abortController.signal,
-  })
-  setTimeout(() => abortController.abort(), 20)
-  return t.rejects(fetch(request), { name: 'AbortError' })
-})
-
-t.test('allow redirected response body to be aborted', t => {
-  const abortController = new AbortController()
-  const request = new Request(`${base}redirect/slow-stream`, {
-    signal: abortController.signal,
-  })
-  return t.rejects(fetch(request).then(res => {
-    t.equal(res.headers.get('content-type'), 'text/plain')
-    const result = res.text()
-    abortController.abort()
-    return result
-  }), { name: 'AbortError' })
-})
-
-t.test('remove internal AbortSignal listener when req/res complete', t => {
-  const controller = new AbortController()
-  const { signal } = controller
-  const fetchHtml = fetch(`${base}html`, { signal })
-    .then(res => res.text())
-  const fetchResponseError = fetch(`${base}error/reset`, { signal })
-  const fetchRedirect = fetch(`${base}redirect/301`, { signal })
-    .then(res => res.json())
-  return Promise.all([
-    t.resolves(fetchHtml.then(result => t.equal(result, '<html></html>'))),
-    t.rejects(fetchResponseError),
-    t.resolves(fetchRedirect),
-  ]).then(() => t.equal(signal.listeners.abort.length, 0))
-})
-
-t.test('reject body with AbortError when aborted before read completely', t => {
-  const controller = new AbortController()
-  return fetch(`${base}slow`, { signal: controller.signal }).then(res => {
-    const promise = res.text()
-    controller.abort()
-    return t.rejects(promise, { name: 'AbortError' })
-  })
-})
-
-t.test('reject body methods immediately with AbortError when aborted before disturbed', t => {
-  const controller = new AbortController()
-  return fetch(`${base}slow`, { signal: controller.signal })
-    .then(res => {
-      controller.abort()
-      return t.rejects(res.text(), { name: 'AbortError' })
-    })
-})
-
-t.test('raise AbortError when aborted before stream is closed', async t => {
-  t.plan(1)
-  const controller = new AbortController()
-  const res = await fetch(`${base}slow`, { signal: controller.signal })
-  res.body.once('error', (err) => {
-    t.match(err, { name: 'AbortError', code: 'FETCH_ABORT' })
-  })
-  controller.abort()
-})
-
-t.test('cancel request body stream with AbortError when aborted', {
-  skip: supportStreamDestroy ? false : 'stream.destroy not supported',
-}, t => {
-  const controller = new AbortController()
-  const body = new Minipass({ objectMode: true })
-  const promise = fetch(`${base}slow`, {
-    signal: controller.signal,
-    body,
-    method: 'POST',
-  })
-
-  const result = Promise.all([
-    new Promise((resolve, reject) => {
-      body.on('error', (error) => {
-        t.match(error, { name: 'AbortError' })
-        resolve()
-      })
-    }),
-    t.rejects(promise, { name: 'AbortError' }),
-  ])
-
-  controller.abort()
-
-  return result
-})
-
-t.test('immediately reject when attempting to cancel and unsupported', async t => {
-  const controller = new AbortController()
-  const body = new (class extends Minipass {
-    get destroy () {
-      return undefined
-    }
-  })({ objectMode: true })
-
-  await t.rejects(fetch(`${base}slow`, {
-    signal: controller.signal,
-    body,
-    method: 'POST',
-  }), { message: 'not supported' })
-})
-
-t.test('throw TypeError if a signal is not AbortSignal', async t => {
-  await t.rejects(fetch(`${base}inspect`, { signal: {} }), {
-    name: 'TypeError',
-    message: /AbortSignal/,
-  })
-  await t.rejects(fetch(`${base}inspect`, { signal: '' }), {
-    name: 'TypeError',
-    message: /AbortSignal/,
-  })
-  await t.rejects(fetch(`${base}inspect`, { signal: Object.create(null) }), {
-    name: 'TypeError',
-    message: /AbortSignal/,
-  })
-})
-
-t.test('set default User-Agent', async t => {
-  const res = await fetch(`${base}inspect`)
-  const json = await res.json()
-  t.match(json.headers['user-agent'], /^minipass-fetch/)
-})
-
-t.test('setting User-Agent', t =>
-  fetch(`${base}inspect`, {
-    headers: {
-      'user-agent': 'faked',
-    },
-  }).then(res => res.json()).then(res =>
-    t.equal(res.headers['user-agent'], 'faked')))
-
-t.test('set default Accept header', async t => {
-  const res = await fetch(`${base}inspect`)
-  const json = await res.json()
-  t.equal(json.headers.accept, '*/*')
-})
-
-t.test('allow setting Accept header', async t => {
-  const res = await fetch(`${base}inspect`, {
-    headers: {
-      accept: 'application/json',
-    },
-  })
-  const json = await res.json()
-  t.equal(json.headers.accept, 'application/json')
-})
-
-t.test('allow POST request', async t => {
-  const res = await fetch(`${base}inspect`, { method: 'POST' })
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '0')
-})
-
-t.test('POST request with string body', async t => {
-  const res = await fetch(`${base}inspect`, {
-    method: 'POST',
-    body: 'a=1',
-  })
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], 'text/plain;charset=UTF-8')
-  t.equal(json.headers['content-length'], '3')
-})
-
-t.test('POST request with buffer body', async t => {
-  const res = await fetch(`${base}inspect`, {
-    method: 'POST',
-    body: Buffer.from('a=1', 'utf-8'),
-  })
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '3')
-})
-/*
-t.test('allow POST request with ArrayBuffer body', async t => {
-  const res = await fetch(`${base}inspect`, {
-    method: 'POST',
-    body: stringToArrayBuffer('Hello, world!\n'),
-  })
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'Hello, world!\n')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '14')
-})
-*/
-t.test('POST request with ArrayBuffer body from VM context', async t => {
-  Buffer.from(new VMArrayBuffer())
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new VMUint8Array(Buffer.from('Hello, world!\n')).buffer,
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'Hello, world!\n')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '14')
-})
-/*
-t.test('POST request with ArrayBufferView (Uint8Array) body', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new Uint8Array(stringToArrayBuffer('Hello, world!\n')),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'Hello, world!\n')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '14')
-})
-*/
-/*
-t.test('POST request with ArrayBufferView (DataView) body', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new DataView(stringToArrayBuffer('Hello, world!\n')),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'Hello, world!\n')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '14')
-})
-*/
-t.test('POST with ArrayBufferView (Uint8Array) body from a VM context', async t => {
-  Buffer.from(new VMArrayBuffer())
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new VMUint8Array(Buffer.from('Hello, world!\n')),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'Hello, world!\n')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '14')
-})
-/*
-t.test('POST with ArrayBufferView (Uint8Array, offset, length) body', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new Uint8Array(stringToArrayBuffer('Hello, world!\n'), 7, 6),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'world!')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '6')
-})
-*/
-t.test('POST with blob body without type', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new Blob(['a=1']),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], '3')
-})
-
-t.test('POST with blob body with type', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: new Blob(['a=1'], {
-      type: 'text/plain;charset=UTF-8',
-    }),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], 'text/plain;charset=utf-8')
-  t.equal(json.headers['content-length'], '3')
-})
-
-t.test('POST with readable stream as body', async t => {
-  const body = new Minipass()
-  body.pause()
-  body.end('a=1')
-  setTimeout(() => {
-    body.resume()
-  }, 100)
-
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: body.pipe(new Minipass()),
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], 'chunked')
-  t.equal(json.headers['content-type'], undefined)
-  t.equal(json.headers['content-length'], undefined)
-})
-
-t.test('POST with form-data as body', async t => {
-  const form = new FormData()
-  form.append('a', '1')
-
-  const url = `${base}multipart`
-  const opts = {
-    method: 'POST',
-    body: form,
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.match(json.headers['content-type'], /^multipart\/form-data;boundary=/)
-  t.match(json.headers['content-length'], String)
-  t.equal(json.body, 'a=1')
-})
-
-t.test('POST with form-data using stream as body', async t => {
-  t.teardown(() => {
-    const root = path.dirname(__dirname)
-    // parted's multipart form parser writes a temporary file to disk, this removes it
-    fs.readdirSync(root).filter((file) => {
-      return file.startsWith('dummy.') && file.endsWith('.txt')
-    }).forEach((file) => {
-      fs.unlinkSync(path.join(root, file))
-    })
-  })
-  const form = new FormData()
-  form.append('my_field', fs.createReadStream(path.join(__dirname, 'fixtures/dummy.txt')))
-
-  const url = `${base}multipart`
-  const opts = {
-    method: 'POST',
-    body: form,
-  }
-
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.match(json.headers['content-type'], /^multipart\/form-data;boundary=/)
-  t.equal(json.headers['content-length'], undefined)
-  t.match(json.body, 'my_field=')
-})
-
-t.test('POST with form-data as body and custom headers', async t => {
-  const form = new FormData()
-  form.append('a', '1')
-
-  const headers = form.getHeaders()
-  headers.b = '2'
-
-  const url = `${base}multipart`
-  const opts = {
-    method: 'POST',
-    body: form,
-    headers,
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.match(json.headers['content-type'], /multipart\/form-data; boundary=/)
-  t.match(json.headers['content-length'], String)
-  t.equal(json.headers.b, '2')
-  t.equal(json.body, 'a=1')
-})
-
-t.test('POST with object body', async t => {
-  const url = `${base}inspect`
-  // note that fetch simply calls tostring on an object
-  const opts = {
-    method: 'POST',
-    body: { a: 1 },
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, '[object Object]')
-  t.equal(json.headers['content-type'], 'text/plain;charset=UTF-8')
-  t.equal(json.headers['content-length'], '15')
-})
-
-const uspOpt = {
-  skip: typeof URLSearchParams === 'function' ? false
-  : 'no URLSearchParams function',
-}
-
-t.test('constructing a Response with URLSearchParams as body has a Content-Type', uspOpt, t => {
-  const params = new URLSearchParams()
-  const res = new Response(params)
-  res.headers.get('Content-Type')
-  t.equal(res.headers.get('Content-Type'), 'application/x-www-form-urlencoded;charset=UTF-8')
-})
-
-t.test('constructing a Request with URLSearchParams as body has a Content-Type', uspOpt, t => {
-  const params = new URLSearchParams()
-  const req = new Request(base, { method: 'POST', body: params })
-  t.equal(req.headers.get('Content-Type'), 'application/x-www-form-urlencoded;charset=UTF-8')
-})
-
-t.test('Reading a body with URLSearchParams should echo back the result', uspOpt, async t => {
-  const params = new URLSearchParams()
-  params.append('a', '1')
-  const text = await new Response(params).text()
-  t.equal(text, 'a=1')
-})
-
-// Body should been cloned...
-// eslint-disable-next-line max-len
-t.test('Request/Response with URLSearchParams and mutation should not affected body', uspOpt, async t => {
-  const params = new URLSearchParams()
-  const req = new Request(`${base}inspect`, { method: 'POST', body: params })
-  params.append('a', '1')
-  const text = await req.text()
-  t.equal(text, '')
-})
-
-t.test('POST with URLSearchParams as body', uspOpt, async t => {
-  const params = new URLSearchParams()
-  params.append('a', '1')
-
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: params,
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.headers['content-type'], 'application/x-www-form-urlencoded;charset=UTF-8')
-  t.equal(json.headers['content-length'], '3')
-  t.equal(json.body, 'a=1')
-})
-
-t.test('recognize URLSearchParams when extended', uspOpt, async t => {
-  class CustomSearchParams extends URLSearchParams {}
-  const params = new CustomSearchParams()
-  params.append('a', '1')
-
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: params,
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.headers['content-type'], 'application/x-www-form-urlencoded;charset=UTF-8')
-  t.equal(json.headers['content-length'], '3')
-  t.equal(json.body, 'a=1')
-})
-
-/* for 100% code coverage, checks for duck-typing-only detection
- * where both constructor.name and brand tests fail */
-t.test('recognize URLSearchParams when extended from polyfill', async t => {
-  class CustomPolyfilledSearchParams extends URLSearchParamsPolyfill {}
-  const params = new CustomPolyfilledSearchParams()
-  params.append('a', '1')
-
-  const url = `${base}inspect`
-  const opts = {
-    method: 'POST',
-    body: params,
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.headers['content-type'], 'application/x-www-form-urlencoded;charset=UTF-8')
-  t.equal(json.headers['content-length'], '3')
-  t.equal(json.body, 'a=1')
-})
-
-t.test('overwrite Content-Length if possible', async t => {
-  const url = `${base}inspect`
-  // note that fetch simply calls tostring on an object
-  const opts = {
-    method: 'POST',
-    headers: {
-      'Content-Length': '1000',
-    },
-    body: 'a=1',
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'POST')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-type'], 'text/plain;charset=UTF-8')
-  t.equal(json.headers['content-length'], '3')
-})
-
-t.test('PUT', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'PUT',
-    body: 'a=1',
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'PUT')
-  t.equal(json.body, 'a=1')
-})
-
-t.test('DELETE', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'DELETE',
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'DELETE')
-})
-
-t.test('DELETE with string body', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'DELETE',
-    body: 'a=1',
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'DELETE')
-  t.equal(json.body, 'a=1')
-  t.equal(json.headers['transfer-encoding'], undefined)
-  t.equal(json.headers['content-length'], '3')
-})
-
-t.test('PATCH', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    method: 'PATCH',
-    body: 'a=1',
-  }
-  const res = await fetch(url, opts)
-  const json = await res.json()
-  t.equal(json.method, 'PATCH')
-  t.equal(json.body, 'a=1')
-})
-
-t.test('HEAD', async t => {
-  const url = `${base}hello`
-  const opts = {
-    method: 'HEAD',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.status, 200)
-  t.equal(res.statusText, 'OK')
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  t.match(res.body, Minipass)
-  const text = await res.text()
-  t.equal(text, '')
-})
-
-t.test('HEAD with content-encoding header', async t => {
-  const url = `${base}error/404`
-  const opts = {
-    method: 'HEAD',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.status, 404)
-  t.equal(res.headers.get('content-encoding'), 'gzip')
-  const text = await res.text()
-  t.equal(text, '')
-})
-
-t.test('OPTIONS', async t => {
-  const url = `${base}options`
-  const opts = {
-    method: 'OPTIONS',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.status, 200)
-  t.equal(res.statusText, 'OK')
-  t.equal(res.headers.get('allow'), 'GET, HEAD, OPTIONS')
-  t.match(res.body, Minipass)
-})
-
-t.test('reject decoding body twice', async t => {
-  const url = `${base}plain`
-  const res = await fetch(url)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  await res.text()
-  t.equal(res.bodyUsed, true)
-  t.rejects(res.text())
-})
-
-t.test('response trailers', async t => {
-  const res = await fetch(`${base}trailers`)
-  t.equal(res.status, 200)
-  t.equal(res.statusText, 'OK')
-  t.equal(res.headers.get('Trailer'), 'X-Node-Fetch')
-  const trailers = await res.trailer
-  t.same(Array.from(trailers.keys()), ['x-node-fetch'])
-  t.equal(trailers.get('x-node-fetch'), 'hello world!')
-})
-
-t.test('maximum response size, multiple chunk', async t => {
-  const url = `${base}size/chunk`
-  const opts = {
-    size: 5,
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.status, 200)
-  t.equal(res.headers.get('content-type'), 'text/plain')
-  await t.rejects(res.text(), {
-    name: 'FetchError',
-    type: 'max-size',
-  })
-})
-
-t.test('maximum response size, single chunk', t => {
-  const url = `${base}size/long`
-  const opts = {
-    size: 5,
-  }
-  return t.rejects(fetch(url, opts).then(res => {
-    t.equal(res.status, 200)
-    t.equal(res.headers.get('content-type'), 'text/plain')
-    return res.text()
-  }), {
-    name: 'FetchError',
-    type: 'max-size',
-  })
-})
-
-t.test('pipe response body as stream', async t => {
-  t.plan(2)
-  const url = `${base}hello`
-  const res = await fetch(url)
-  t.match(res.body, Minipass)
-  await streamToPromise(res.body, chunk => {
-    if (chunk === null) {
-      return
-    }
-    t.equal(chunk.toString(), 'world')
-  })
-})
-
-t.test('clone a response, and use both as stream', async t => {
-  t.plan(4)
-  const url = `${base}hello`
-  const res = await fetch(url)
-  const cloned = res.clone()
-  t.match(res.body, Minipass)
-  t.match(cloned.body, Minipass)
-  const dataHandler = chunk => {
-    if (chunk === null) {
-      return
-    }
-    t.equal(chunk.toString(), 'world')
-  }
-
-  await Promise.all([
-    streamToPromise(res.body, dataHandler),
-    streamToPromise(cloned.body, dataHandler),
-  ])
-})
-
-t.test('clone a json response and log it as text response', async t => {
-  const url = `${base}json`
-  const res = await fetch(url)
-  const cloned = res.clone()
-  const results = await Promise.all([res.json(), cloned.text()])
-  t.same(results[0], { name: 'value' })
-  t.equal(results[1], '{"name":"value"}')
-})
-
-t.test('clone a json response, and then log it as text response', async t => {
-  const url = `${base}json`
-  const res = await fetch(url)
-  const cloned = res.clone()
-  const jsonResult = await res.json()
-  t.same(jsonResult, { name: 'value' })
-  const textResult = await cloned.text()
-  t.equal(textResult, '{"name":"value"}')
-})
-
-t.test('clone a json response, first log as text response, then return json object', async t => {
-  const url = `${base}json`
-  const res = await fetch(url)
-  const cloned = res.clone()
-  const textResult = await cloned.text()
-  t.equal(textResult, '{"name":"value"}')
-  const jsonResult = await res.json()
-  t.same(jsonResult, { name: 'value' })
-})
-
-t.test('do not allow cloning a response after its been used', async t => {
-  const url = `${base}hello`
-  const res = await fetch(url)
-  await res.text()
-  t.throws(() => res.clone())
-})
-
-t.test('get all responses of a header', async t => {
-  const url = `${base}cookie`
-  const res = await fetch(url)
-  const expected = 'a=1, b=1'
-  t.equal(res.headers.get('set-cookie'), expected)
-  t.equal(res.headers.get('Set-Cookie'), expected)
-})
-
-t.test('return all headers using raw()', async t => {
-  const url = `${base}cookie`
-  const res = await fetch(url)
-  t.same(res.headers.raw()['set-cookie'], ['a=1', 'b=1'])
-})
-
-t.test('delete header', async t => {
-  const url = `${base}cookie`
-  const res = await fetch(url)
-  res.headers.delete('set-cookie')
-  t.equal(res.headers.get('set-cookie'), null)
-})
-
-t.test('send request with connection keep-alive if agent is provided', async t => {
-  const url = `${base}inspect`
-  const opts = {
-    agent: new http.Agent({
-      keepAlive: true,
-    }),
-  }
-  const res = await fetch(url, opts)
-  const body = await res.json()
-  t.equal(body.headers.connection, 'keep-alive')
-})
-
-t.test('fetch with Request instance', async t => {
-  const url = `${base}hello`
-  const req = new Request(url)
-  const res = await fetch(req)
-  t.equal(res.url, url)
-  t.equal(res.ok, true)
-  t.equal(res.status, 200)
-})
-
-t.test('fetch with Node.js legacy URL object', async t => {
-  const url = `${base}hello`
-  const urlObj = parseURL(url)
-  const req = new Request(urlObj)
-  const res = await fetch(req)
-  t.equal(res.url, url)
-  t.equal(res.ok, true)
-  t.equal(res.status, 200)
-})
-
-t.test('fetch with Node.js URL object', async t => {
-  const url = `${base}hello`
-  const urlObj = new URL(url)
-  const req = new Request(urlObj)
-  const res = await fetch(req)
-  t.equal(res.url, url)
-  t.equal(res.ok, true)
-  t.equal(res.status, 200)
-})
-
-t.test('reading blob as text', async t => {
-  const blob = await new Response(`hello`).blob()
-  const body = await blob.text()
-  t.equal(body, 'hello')
-})
-
-t.test('reading blob as arrayBuffer', async t => {
-  const blob = await new Response(`hello`).blob()
-  const ab = await blob.arrayBuffer()
-  const str = String.fromCharCode.apply(null, new Uint8Array(ab))
-  t.equal(str, 'hello')
-})
-
-t.test('reading blob as stream', t => {
-  return new Response(`hello`)
-    .blob()
-    .then(blob => streamToPromise(blob.stream(), data => {
-      const str = data.toString()
-      t.equal(str, 'hello')
-    }))
-})
-
-t.test('blob round-trip', async t => {
-  const url = `${base}hello`
-
-  const res = await fetch(url)
-  const blob = await res.blob()
-  const inspectUrl = `${base}inspect`
-  const length = blob.size
-  const type = blob.type
-  const res2 = await fetch(inspectUrl, {
-    method: 'POST',
-    body: blob,
-  })
-  const { body, headers } = await res2.json()
-  t.equal(body, 'world')
-  t.equal(headers['content-type'], type)
-  t.equal(headers['content-length'], String(length))
-})
-
-t.test('overwrite Request instance', async t => {
-  const url = `${base}inspect`
-  const req = new Request(url, {
-    method: 'POST',
-    headers: {
-      a: '1',
-    },
-  })
-  const res = await fetch(req, {
-    method: 'GET',
-    headers: {
-      a: '2',
-    },
-  })
-  const body = await res.json()
-  t.equal(body.method, 'GET')
-  t.equal(body.headers.a, '2')
-})
-
-t.test('arrayBuffer(), blob(), text(), json() and buffer() method in Body constructor', t => {
-  const body = new Body('a=1')
-  t.match(body.arrayBuffer, Function)
-  t.match(body.blob, Function)
-  t.match(body.text, Function)
-  t.match(body.json, Function)
-  t.match(body.buffer, Function)
-  t.end()
-})
-
-t.test('https request', { timeout: 5000 }, async t => {
-  const url = 'https://github.com/'
-  const opts = {
-    method: 'HEAD',
-  }
-  const res = await fetch(url, opts)
-  t.equal(res.status, 200)
-  t.equal(res.ok, true)
-})
-
-// issue #414
-t.test('reject if attempt to accumulate body stream throws', async t => {
-  const body = new Minipass()
-  body.pause()
-  body.end('a=1')
-  setTimeout(() => body.resume(), 100)
-  const res = new Response(body.pipe(new Minipass()))
-  const bufferConcat = Buffer.concat
-  Buffer.concat = () => {
-    throw new Error('embedded error')
-  }
-
-  t.teardown(() => {
-    Buffer.concat = bufferConcat
-  })
-
-  return t.rejects(res.text(), {
-    name: 'FetchError',
-    type: 'system',
-    message: /embedded error/,
-  })
-})
-
-t.test('supports supplying a lookup function to the agent', async t => {
-  const url = `${base}redirect/301`
-  let called = 0
-  function lookupSpy (hostname, options, callback) {
-    called++
-    return lookup(hostname, options, callback)
-  }
-  const agent = http.Agent({ lookup: lookupSpy })
-  await fetch(url, { agent })
-  t.equal(called, 2)
-})
-
-t.test('supports supplying a famliy option to the agent', async t => {
-  const url = `${base}redirect/301`
-  const families = []
-  const family = Symbol('family')
-  function lookupSpy (hostname, options, callback) {
-    families.push(options.family)
-    return lookup(hostname, {}, callback)
-  }
-  const agent = http.Agent({ lookup: lookupSpy, family })
-  await fetch(url, { agent })
-  t.same(families, [family, family])
-})
-
-t.test('function supplying the agent', async t => {
-  const url = `${base}inspect`
-
-  const agent = new http.Agent({
-    keepAlive: true,
-  })
-
-  let parsedURL
-
-  const res = await fetch(url, {
-    agent: function (_parsedURL) {
-      parsedURL = _parsedURL
-      return agent
-    },
-  })
-  const body = await res.json()
-  // the agent provider should have been called
-  t.equal(parsedURL.protocol, 'http:')
-  // the agent we returned should have been used
-  t.equal(body.headers.connection, 'keep-alive')
-})
-
-t.test('calculate content length and extract content type', t => {
-  const url = `${base}hello`
-  const bodyContent = 'a=1'
-
-  let streamBody = new Minipass()
-  streamBody.pause()
-  streamBody.end(bodyContent)
-  setTimeout(() => streamBody.resume(), 100)
-  streamBody = streamBody.pipe(new Minipass())
-
-  const streamRequest = new Request(url, {
-    method: 'POST',
-    body: streamBody,
-    size: 1024,
-  })
-
-  const blobBody = new Blob([bodyContent], { type: 'text/plain' })
-  const blobRequest = new Request(url, {
-    method: 'POST',
-    body: blobBody,
-    size: 1024,
-  })
-
-  const formBody = new FormData()
-  formBody.append('a', '1')
-  const formRequest = new Request(url, {
-    method: 'POST',
-    body: formBody,
-    size: 1024,
-  })
-
-  const bufferBody = Buffer.from(bodyContent)
-  const bufferRequest = new Request(url, {
-    method: 'POST',
-    body: bufferBody,
-    size: 1024,
-  })
-
-  const stringRequest = new Request(url, {
-    method: 'POST',
-    body: bodyContent,
-    size: 1024,
-  })
-
-  const nullRequest = new Request(url, {
-    method: 'GET',
-    body: null,
-    size: 1024,
-  })
-
-  t.equal(getTotalBytes(streamRequest), null)
-  t.equal(getTotalBytes(blobRequest), blobBody.size)
-  t.not(getTotalBytes(formRequest), null)
-  t.equal(getTotalBytes(bufferRequest), bufferBody.length)
-  t.equal(getTotalBytes(stringRequest), bodyContent.length)
-  t.equal(getTotalBytes(nullRequest), 0)
-
-  t.equal(extractContentType(streamBody), null)
-  t.equal(extractContentType(blobBody), 'text/plain')
-  t.match(extractContentType(formBody), /^multipart\/form-data/)
-  t.equal(extractContentType(bufferBody), null)
-  t.equal(extractContentType(bodyContent), 'text/plain;charset=UTF-8')
-  t.equal(extractContentType(null), null)
-  t.end()
-})
-
-t.test('with optional `encoding`', t => {
-  t.test('only use UTF-8 decoding with text()', async t => {
-    const res = await fetch(`${base}encoding/euc-jp`)
-    t.equal(res.status, 200)
-    const result = await res.text()
-    t.equal(result, '<?xml version="1.0" encoding="EUC-JP"?>' +
-      '<title>\ufffd\ufffd\ufffd\u0738\ufffd</title>')
-  })
-
-  t.test('encoding decode, xml dtd detect', async t => {
-    const res = await fetch(`${base}encoding/euc-jp`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '<?xml version="1.0" encoding="EUC-JP"?><title>日本語</title>')
-  })
-
-  t.test('encoding decode, content-type detect', async t => {
-    const res = await fetch(`${base}encoding/shift-jis`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '<div>日本語</div>')
-  })
-
-  t.test('encoding decode, html5 detect', async t => {
-    const res = await fetch(`${base}encoding/gbk`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '<meta charset="gbk"><div>中文</div>')
-  })
-
-  t.test('encoding decode, html4 detect', async t => {
-    const res = await fetch(`${base}encoding/gb2312`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '<meta http-equiv="Content-Type" content="text/html; charset=gb2312">' +
-      '<div>中文</div>')
-  })
-
-  t.test('encoding decode, html4 detect reverse http-equiv', async t => {
-    const res = await fetch(`${base}encoding/gb2312-reverse`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '<meta content="text/html; charset=gb2312" http-equiv="Content-Type">' +
-      '<div>中文</div>')
-  })
-
-  t.test('default to utf8 encoding', async t => {
-    const res = await fetch(`${base}encoding/utf8`)
-    t.equal(res.status, 200)
-    t.equal(res.headers.get('content-type'), null)
-    const result = await res.textConverted()
-    t.equal(result, '中文')
-  })
-
-  t.test('uncommon content-type order, charset in front', async t => {
-    const res = await fetch(`${base}encoding/order1`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '中文')
-  })
-
-  t.test('uncommon content-type order, end with qs', async t => {
-    const res = await fetch(`${base}encoding/order2`)
-    t.equal(res.status, 200)
-    const result = await res.textConverted()
-    t.equal(result, '中文')
-  })
-
-  t.test('chunked encoding, html4 detect', async t => {
-    const url = `${base}encoding/chunked`
-    const res = await fetch(url)
-    t.equal(res.status, 200)
-    const padding = 'a'.repeat(10)
-    const result = await res.textConverted()
-    t.equal(result, `${padding}<meta http-equiv="Content-Type" content="text/html;` +
-      ' charset=Shift_JIS" /><div>日本語</div>')
-  })
-
-  t.test('only do encoding detection up to 1024 bytes', async t => {
-    const url = `${base}encoding/invalid`
-    const res = await fetch(url)
-    t.equal(res.status, 200)
-    const padding = 'a'.repeat(1200)
-    const result = await res.textConverted()
-    t.not(result, `${padding}中文`)
-  })
-
-  t.end()
-})
-
-t.test('data uri', t => {
-  const dataUrl = 'data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs='
-
-  const invalidDataUrl = 'data:@@@@'
-
-  t.test('accept data uri', t =>
-    fetch(dataUrl).then(r => {
-      t.equal(r.status, 200)
-      t.equal(r.headers.get('Content-Type'), 'image/gif')
-      return r.buffer().then(b => t.type(b, Buffer))
-    }))
-
-  t.test('reject invalid data uri', t =>
-    t.rejects(fetch(invalidDataUrl), {
-      message: 'invalid data: URI',
-    }))
-
-  t.test('data uri not base64 encoded', t =>
-    fetch('data:text/plain,hello, world!').then(r => {
-      t.equal(r.status, 200)
-      t.equal(r.headers.get('Content-Type'), 'text/plain')
-      return r.buffer().then(b => t.equal(b.toString(), 'hello, world!'))
-    }))
-
-  t.test('data uri with no type specified', t =>
-    fetch('data:,hello,%20world!').then(r => {
-      t.equal(r.status, 200)
-      t.equal(r.headers.get('Content-Type'), null)
-      return r.buffer().then(b => t.equal(b.toString(), 'hello, world!'))
-    }))
-
-  t.test('search included, hash not included', t =>
-    fetch('data:,hello?with=search#no%20hash').then(r => {
-      t.equal(r.status, 200)
-      t.equal(r.headers.get('Content-Type'), null)
-      return r.buffer().then(b => t.equal(b.toString(), 'hello?with=search'))
-    }))
-
-  t.end()
-})
-
-t.test('aborting data uris', t => {
-  const controllers = [AbortController, AbortController2]
-  t.plan(controllers.length)
-  const url = 'data:text/plain;base64,SGVsbG8sIFdvcmxkIQ=='
-  controllers.forEach((Controller, idx) => {
-    t.test(`controller ${idx}`, async t => {
-      t.test('pre-abort', async t => {
-        const controller = new Controller()
-        controller.abort()
-        t.rejects(fetch(url, { signal: controller.signal }), {
-          message: 'The user aborted a request.',
-        })
-      })
-
-      t.test('post-abort', async t => {
-        const controller = new Controller()
-        t.rejects(fetch(url, { signal: controller.signal }), {
-          message: 'The user aborted a request.',
-        })
-        controller.abort()
-      })
-
-      t.test('cannot abort after first tick', t => {
-        const controller = new Controller()
-        const testPromise = t.resolves(fetch(url, { signal: controller.signal }))
-        process.nextTick(() => {
-          controller.abort()
-        })
-        return testPromise
-      })
-    })
-  })
-})
-
-t.test('redirect changes host header', t =>
-  fetch(`http://${local.hostname}:${local.port}/host-redirect`, {
-    redirect: 'follow',
-    headers: { host: 'foo' },
-  })
-    .then(r => r.text())
-    .then(text => t.equal(text, `${base}host-redirect`)))
-
-t.test('never apply backpressure to the underlying response stream', t => {
-  const { request } = http
-  t.teardown(() => http.request = request)
-  http.request = (...args) => {
-    const req = request(...args)
-    const { emit } = req
-    req.emit = (ev, ...emitArgs) => {
-      if (ev === 'response') {
-        const res = emitArgs[0]
-        res.pause = () => {
-          throw new Error('should not pause the response')
-        }
-      }
-      return emit.call(req, ev, ...emitArgs)
-    }
-    return req
-  }
-
-  const dest = new Minipass()
-  return fetch(`${base}hello`)
-    .then(res => {
-      // read it a bit later, so we'll see if any backpressure happens.
-      setTimeout(() => dest.read())
-      return res.body.pipe(dest).promise()
-    })
-})