From 47db8947909ce0f8e31872e533869ff3f4f679df Mon Sep 17 00:00:00 2001
From: Phillip9587 <barta.phillip@gmail.com>
Date: Mon, 31 Mar 2025 21:12:41 +0200
Subject: [PATCH] test: modernize test suite and remove obsolete tests

---
 test/support/sws.js   |  17 +-
 test/support/utils.js | 143 +++++++----------
 test/test.js          | 361 +++++++++++++++++-------------------------
 3 files changed, 212 insertions(+), 309 deletions(-)

diff --git a/test/support/sws.js b/test/support/sws.js
index 7be774e..51d9a95 100644
--- a/test/support/sws.js
+++ b/test/support/sws.js
@@ -1,14 +1,9 @@
-var stream = require('stream')
-var util = require('util')
+const { Writable } = require('node:stream')
 
-module.exports = SlowWriteStream
-
-function SlowWriteStream () {
-  stream.Writable.call(this)
+class SlowWriteStream extends Writable {
+  _write (chunk, encoding, callback) {
+    setTimeout(callback, 1000)
+  }
 }
 
-util.inherits(SlowWriteStream, stream.Writable)
-
-SlowWriteStream.prototype._write = function _write (chunk, encoding, callback) {
-  setTimeout(callback, 1000)
-}
+module.exports = SlowWriteStream
diff --git a/test/support/utils.js b/test/support/utils.js
index f6d4370..d6575f7 100644
--- a/test/support/utils.js
+++ b/test/support/utils.js
@@ -1,28 +1,23 @@
-var assert = require('assert')
-var finalhandler = require('../..')
-var http = require('http')
-var http2 = require('http2')
+const finalhandler = require('../..')
+const SlowWriteStream = require('./sws')
 
-var request = require('supertest')
-var SlowWriteStream = require('./sws')
+const assert = require('node:assert')
+const http = require('node:http')
+const http2 = require('node:http2')
+const supertest = require('supertest')
 
-exports.assert = assert
 exports.createError = createError
-exports.createHTTPServer = createHTTPServer
-exports.createHTTP2Server = createHTTP2Server
-exports.createSlowWriteStream = createSlowWriteStream
-exports.rawrequest = rawrequest
-exports.rawrequestHTTP2 = rawrequestHTTP2
-exports.request = request
+exports.getTestHelpers = getTestHelpers
+exports.SlowWriteStream = SlowWriteStream
 exports.shouldHaveStatusMessage = shouldHaveStatusMessage
 exports.shouldNotHaveBody = shouldNotHaveBody
 exports.shouldNotHaveHeader = shouldNotHaveHeader
 
 function createError (message, props) {
-  var err = new Error(message)
+  const err = new Error(message)
 
   if (props) {
-    for (var prop in props) {
+    for (const prop in props) {
       err[prop] = props[prop]
     }
   }
@@ -30,39 +25,29 @@ function createError (message, props) {
   return err
 }
 
-function createHTTPServer (err, opts) {
-  return http.createServer(function (req, res) {
-    var done = finalhandler(req, res, opts)
+function getTestHelpers (type) {
+  const { createServer } = type === 'http2' ? http2 : http
 
-    if (typeof err === 'function') {
-      err(req, res, done)
-      return
-    }
-
-    done(err)
-  })
-}
-
-function createHTTP2Server (err, opts) {
-  return http2.createServer(function (req, res) {
-    var done = finalhandler(req, res, opts)
-
-    if (typeof err === 'function') {
-      err(req, res, done)
-      return
-    }
+  return {
+    createServer: (err, opts) =>
+      createServer((req, res) => {
+        const done = finalhandler(req, res, opts)
 
-    done(err)
-  })
-}
+        if (typeof err === 'function') {
+          err(req, res, done)
+          return
+        }
 
-function createSlowWriteStream () {
-  return new SlowWriteStream()
+        done(err)
+      }),
+    request: (server, options) => supertest(server, { ...options, http2: type === 'http2' }),
+    rawrequest: type === 'http2' ? rawrequestHTTP2 : rawrequest
+  }
 }
 
 function rawrequest (server) {
-  var _headers = {}
-  var _path
+  const _headers = {}
+  let _path
 
   function expect (status, body, callback) {
     if (arguments.length === 2) {
@@ -71,25 +56,25 @@ function rawrequest (server) {
     }
 
     server.listen(function onlisten () {
-      var addr = this.address()
-      var port = addr.port
+      const addr = this.address()
+      const port = addr.port
 
-      var req = http.get({
+      const req = http.get({
         host: '127.0.0.1',
         path: _path,
         port: port
       })
       req.on('error', callback)
       req.on('response', function onresponse (res) {
-        var buf = ''
+        let buf = ''
 
         res.setEncoding('utf8')
-        res.on('data', function ondata (s) { buf += s })
-        res.on('end', function onend () {
-          var err = null
+        res.on('data', (s) => { buf += s })
+        res.on('end', () => {
+          let err = null
 
           try {
-            for (var key in _headers) {
+            for (const key in _headers) {
               assert.strictEqual(res.headers[key], _headers[key])
             }
 
@@ -111,22 +96,18 @@ function rawrequest (server) {
     })
   }
 
-  function get (path) {
-    _path = path
+  return {
+    get: (path) => {
+      _path = path
 
-    return {
-      expect: expect
+      return { expect }
     }
   }
-
-  return {
-    get: get
-  }
 }
 
 function rawrequestHTTP2 (server) {
-  var _headers = {}
-  var _path
+  const _headers = {}
+  let _path
 
   function expect (status, body, callback) {
     if (arguments.length === 2) {
@@ -135,26 +116,24 @@ function rawrequestHTTP2 (server) {
     }
 
     server.listen(function onlisten () {
-      var buf = ''
-      var resHeaders
-      var addr = this.address()
-      var port = addr.port
+      let buf = ''
+      let resHeaders
+      const addr = this.address()
+      const port = addr.port
 
-      var client = http2.connect('http://127.0.0.1:' + port)
-      var req = client.request({
+      const client = http2.connect('http://127.0.0.1:' + port)
+      const req = client.request({
         ':method': 'GET',
         ':path': _path.replace(/http:\/\/localhost/, '')
       })
       req.on('error', callback)
-      req.on('response', function onresponse (responseHeaders) {
-        resHeaders = responseHeaders
-      })
-      req.on('data', function ondata (s) { buf += s })
-      req.on('end', function onend () {
-        var err = null
+      req.on('response', (responseHeaders) => { resHeaders = responseHeaders })
+      req.on('data', (s) => { buf += s })
+      req.on('end', () => {
+        let err = null
 
         try {
-          for (var key in _headers) {
+          for (const key in _headers) {
             assert.strictEqual(resHeaders[key], _headers[key])
           }
 
@@ -177,33 +156,29 @@ function rawrequestHTTP2 (server) {
     })
   }
 
-  function get (path) {
-    _path = path
+  return {
+    get: (path) => {
+      _path = path
 
-    return {
-      expect: expect
+      return { expect }
     }
   }
-
-  return {
-    get: get
-  }
 }
 
 function shouldHaveStatusMessage (statusMessage) {
-  return function (test) {
+  return (test) => {
     assert.strictEqual(test.res.statusMessage, statusMessage, 'should have statusMessage "' + statusMessage + '"')
   }
 }
 
 function shouldNotHaveBody () {
-  return function (res) {
+  return (res) => {
     assert.ok(res.text === '' || res.text === undefined)
   }
 }
 
 function shouldNotHaveHeader (header) {
-  return function (test) {
+  return (test) => {
     assert.ok(test.res.headers[header] === undefined, 'response does not have header "' + header + '"')
   }
 }
diff --git a/test/test.js b/test/test.js
index 516e088..2241e96 100644
--- a/test/test.js
+++ b/test/test.js
@@ -1,190 +1,181 @@
-var finalhandler = require('..')
-var http = require('http')
-
-var utils = require('./support/utils')
-
-var assert = utils.assert
-var createError = utils.createError
-var createHTTPServer = utils.createHTTPServer
-var createHTTP2Server = utils.createHTTP2Server
-var createSlowWriteStream = utils.createSlowWriteStream
-var rawrequest = utils.rawrequest
-var rawrequestHTTP2 = utils.rawrequestHTTP2
-var request = utils.request
-var shouldHaveStatusMessage = utils.shouldHaveStatusMessage
-var shouldNotHaveBody = utils.shouldNotHaveBody
-var shouldNotHaveHeader = utils.shouldNotHaveHeader
-
-var topDescribe = function (type, createServer) {
-  var wrapper = function wrapper (req) {
-    if (type === 'http2') {
-      return req.http2()
-    }
-
-    return req
-  }
+const finalhandler = require('..')
+
+const assert = require('node:assert')
+
+const {
+  createError,
+  getTestHelpers,
+  shouldHaveStatusMessage,
+  shouldNotHaveBody,
+  shouldNotHaveHeader,
+  SlowWriteStream
+} = require('./support/utils')
+
+runTestSuite('http')
+runTestSuite('http2')
+
+function runTestSuite (type) {
+  const { createServer, request, rawrequest } = getTestHelpers(type)
 
   describe('headers', function () {
     it('should ignore err.headers without status code', function (done) {
-      wrapper(request(createServer(createError('oops!', {
+      request(createServer(createError('oops!', {
         headers: { 'X-Custom-Header': 'foo' }
       })))
-        .get('/'))
+        .get('/')
         .expect(shouldNotHaveHeader('X-Custom-Header'))
         .expect(500, done)
     })
 
     it('should ignore err.headers with invalid res.status', function (done) {
-      wrapper(request(createServer(createError('oops!', {
+      request(createServer(createError('oops!', {
         headers: { 'X-Custom-Header': 'foo' },
         status: 601
       })))
-        .get('/'))
+        .get('/')
         .expect(shouldNotHaveHeader('X-Custom-Header'))
         .expect(500, done)
     })
 
     it('should ignore err.headers with invalid res.statusCode', function (done) {
-      wrapper(request(createServer(createError('oops!', {
+      request(createServer(createError('oops!', {
         headers: { 'X-Custom-Header': 'foo' },
         statusCode: 601
       })))
-        .get('/'))
+        .get('/')
         .expect(shouldNotHaveHeader('X-Custom-Header'))
         .expect(500, done)
     })
 
     it('should include err.headers with err.status', function (done) {
-      wrapper(request(createServer(createError('oops!', {
+      request(createServer(createError('oops!', {
         headers: { 'X-Custom-Header': 'foo=500', 'X-Custom-Header2': 'bar' },
         status: 500
       })))
-        .get('/'))
+        .get('/')
         .expect('X-Custom-Header', 'foo=500')
         .expect('X-Custom-Header2', 'bar')
         .expect(500, done)
     })
 
     it('should include err.headers with err.statusCode', function (done) {
-      wrapper(request(createServer(createError('too many requests', {
+      request(createServer(createError('too many requests', {
         headers: { 'Retry-After': '5' },
         statusCode: 429
       })))
-        .get('/'))
+        .get('/')
         .expect('Retry-After', '5')
         .expect(429, done)
     })
 
     it('should ignore err.headers when not an object', function (done) {
-      wrapper(request(createServer(createError('oops!', {
+      request(createServer(createError('oops!', {
         headers: 'foobar',
         statusCode: 500
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
   })
 
   describe('status code', function () {
     it('should 404 on no error', function (done) {
-      wrapper(request(createServer())
-        .get('/'))
+      request(createServer())
+        .get('/')
         .expect(404, done)
     })
 
     it('should 500 on error', function (done) {
-      wrapper(request(createServer(createError()))
-        .get('/'))
+      request(createServer(createError()))
+        .get('/')
         .expect(500, done)
     })
 
     it('should use err.statusCode', function (done) {
-      wrapper(request(createServer(createError('nope', {
+      request(createServer(createError('nope', {
         statusCode: 400
       })))
-        .get('/'))
+        .get('/')
         .expect(400, done)
     })
 
     it('should ignore non-error err.statusCode code', function (done) {
-      wrapper(request(createServer(createError('created', {
+      request(createServer(createError('created', {
         statusCode: 201
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
 
     it('should ignore non-numeric err.statusCode', function (done) {
-      wrapper(request(createServer(createError('oops', {
+      request(createServer(createError('oops', {
         statusCode: 'oh no'
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
 
     it('should use err.status', function (done) {
-      wrapper(request(createServer(createError('nope', {
+      request(createServer(createError('nope', {
         status: 400
       })))
-        .get('/'))
+        .get('/')
         .expect(400, done)
     })
 
     it('should use err.status over err.statusCode', function (done) {
-      wrapper(request(createServer(createError('nope', {
+      request(createServer(createError('nope', {
         status: 400,
         statusCode: 401
       })))
-        .get('/'))
+        .get('/')
         .expect(400, done)
     })
 
     it('should set status to 500 when err.status < 400', function (done) {
-      wrapper(request(createServer(createError('oops', {
+      request(createServer(createError('oops', {
         status: 202
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
 
     it('should set status to 500 when err.status > 599', function (done) {
-      wrapper(request(createServer(createError('oops', {
+      request(createServer(createError('oops', {
         status: 601
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
 
     it('should use err.statusCode over invalid err.status', function (done) {
-      wrapper(request(createServer(createError('nope', {
+      request(createServer(createError('nope', {
         status: 50,
         statusCode: 410
       })))
-        .get('/'))
+        .get('/')
         .expect(410, done)
     })
 
     it('should ignore non-error err.status code', function (done) {
-      wrapper(request(createServer(createError('created', {
+      request(createServer(createError('created', {
         status: 201
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
 
     it('should ignore non-numeric err.status', function (done) {
-      wrapper(request(createServer(createError('oops', {
+      request(createServer(createError('oops', {
         status: 'oh no'
       })))
-        .get('/'))
+        .get('/')
         .expect(500, done)
     })
   })
 
   // http2 does not support status message
-  var describeStatusMessage = !/statusMessage/.test(http.IncomingMessage.toString()) || type === 'http2'
-    ? describe.skip
-    : describe
+  const describeStatusMessage = type === 'http2' ? describe.skip : describe
 
   describeStatusMessage('status message', function () {
     it('should be "Not Found" on no error', function (done) {
@@ -225,73 +216,73 @@ var topDescribe = function (type, createServer) {
 
   describe('404 response', function () {
     it('should include method and pathname', function (done) {
-      wrapper(request(createServer())
-        .get('/foo'))
+      request(createServer())
+        .get('/foo')
         .expect(404, /<pre>Cannot GET \/foo<\/pre>/, done)
     })
 
     it('should escape method and pathname characters', function (done) {
-      (type === 'http2' ? rawrequestHTTP2 : rawrequest)(createServer())
+      rawrequest(createServer())
         .get('/<la\'me>')
         .expect(404, /<pre>Cannot GET \/%3Cla&#39;me%3E<\/pre>/, done)
     })
 
     it('should fallback to generic pathname without URL', function (done) {
-      var server = createServer(function (req, res, next) {
+      const server = createServer(function (req, res, next) {
         req.url = undefined
         next()
       })
 
-      wrapper(request(server)
-        .get('/foo'))
+      request(server)
+        .get('/foo')
         .expect(404, /<pre>Cannot GET resource<\/pre>/, done)
     })
 
     it('should include original pathname', function (done) {
-      var server = createServer(function (req, res, next) {
-        var parts = req.url.split('/')
+      const server = createServer(function (req, res, next) {
+        const parts = req.url.split('/')
         req.originalUrl = req.url
         req.url = '/' + parts.slice(2).join('/')
         next()
       })
 
-      wrapper(request(server)
-        .get('/foo/bar'))
+      request(server)
+        .get('/foo/bar')
         .expect(404, /<pre>Cannot GET \/foo\/bar<\/pre>/, done)
     })
 
     it('should include pathname only', function (done) {
-      (type === 'http2' ? rawrequestHTTP2 : rawrequest)(createServer())
+      rawrequest(createServer())
         .get('http://localhost/foo?bar=1')
         .expect(404, /<pre>Cannot GET \/foo<\/pre>/, done)
     })
 
     it('should handle HEAD', function (done) {
-      wrapper(request(createServer())
-        .head('/foo'))
+      request(createServer())
+        .head('/foo')
         .expect(404)
         .expect(shouldNotHaveBody())
         .end(done)
     })
 
     it('should include X-Content-Type-Options header', function (done) {
-      wrapper(request(createServer())
-        .get('/foo'))
+      request(createServer())
+        .get('/foo')
         .expect('X-Content-Type-Options', 'nosniff')
         .expect(404, done)
     })
 
     it('should include Content-Security-Policy header', function (done) {
-      wrapper(request(createServer())
-        .get('/foo'))
+      request(createServer())
+        .get('/foo')
         .expect('Content-Security-Policy', "default-src 'none'")
         .expect(404, done)
     })
 
     it('should not hang/error if there is a request body', function (done) {
-      var buf = Buffer.alloc(1024 * 16, '.')
-      var server = createServer()
-      var test = wrapper(request(server).post('/foo'))
+      const buf = Buffer.alloc(1024 * 16, '.')
+      const server = createServer()
+      const test = request(server).post('/foo')
       test.write(buf)
       test.write(buf)
       test.write(buf)
@@ -301,61 +292,61 @@ var topDescribe = function (type, createServer) {
 
   describe('error response', function () {
     it('should include error stack', function (done) {
-      wrapper(request(createServer(createError('boom!')))
-        .get('/foo'))
+      request(createServer(createError('boom!')))
+        .get('/foo')
         .expect(500, /<pre>Error: boom!<br> &nbsp; &nbsp;at/, done)
     })
 
     it('should handle HEAD', function (done) {
-      wrapper(request(createServer(createError('boom!')))
-        .head('/foo'))
+      request(createServer(createError('boom!')))
+        .head('/foo')
         .expect(500)
         .expect(shouldNotHaveBody())
         .end(done)
     })
 
     it('should include X-Content-Type-Options header', function (done) {
-      wrapper(request(createServer(createError('boom!')))
-        .get('/foo'))
+      request(createServer(createError('boom!')))
+        .get('/foo')
         .expect('X-Content-Type-Options', 'nosniff')
         .expect(500, done)
     })
 
     it('should includeContent-Security-Policy header', function (done) {
-      wrapper(request(createServer(createError('boom!')))
-        .get('/foo'))
+      request(createServer(createError('boom!')))
+        .get('/foo')
         .expect('Content-Security-Policy', "default-src 'none'")
         .expect(500, done)
     })
 
     it('should handle non-error-objects', function (done) {
-      wrapper(request(createServer('lame string'))
-        .get('/foo'))
+      request(createServer('lame string'))
+        .get('/foo')
         .expect(500, /<pre>lame string<\/pre>/, done)
     })
 
     it('should handle null prototype objects', function (done) {
-      wrapper(request(createServer(Object.create(null)))
-        .get('/foo'))
+      request(createServer(Object.create(null)))
+        .get('/foo')
         .expect(500, /<pre>Internal Server Error<\/pre>/, done)
     })
 
-    it('should send staus code name when production', function (done) {
-      var err = createError('boom!', {
+    it('should send status code name when production', function (done) {
+      const err = createError('boom!', {
         status: 501
       })
-      wrapper(request(createServer(err, {
+      request(createServer(err, {
         env: 'production'
       }))
-        .get('/foo'))
+        .get('/foo')
         .expect(501, /<pre>Not Implemented<\/pre>/, done)
     })
 
     describe('when there is a request body', function () {
       it('should not hang/error when unread', function (done) {
-        var buf = Buffer.alloc(1024 * 16, '.')
-        var server = createServer(new Error('boom!'))
-        var test = wrapper(request(server).post('/foo'))
+        const buf = Buffer.alloc(1024 * 16, '.')
+        const server = createServer(new Error('boom!'))
+        const test = request(server).post('/foo')
         test.write(buf)
         test.write(buf)
         test.write(buf)
@@ -363,15 +354,15 @@ var topDescribe = function (type, createServer) {
       })
 
       it('should not hang/error when actively piped', function (done) {
-        var buf = Buffer.alloc(1024 * 16, '.')
-        var server = createServer(function (req, res, next) {
+        const buf = Buffer.alloc(1024 * 16, '.')
+        const server = createServer(function (req, res, next) {
           req.pipe(stream)
           process.nextTick(function () {
             next(new Error('boom!'))
           })
         })
-        var stream = createSlowWriteStream()
-        var test = wrapper(request(server).post('/foo'))
+        const stream = new SlowWriteStream()
+        const test = request(server).post('/foo')
         test.write(buf)
         test.write(buf)
         test.write(buf)
@@ -379,15 +370,15 @@ var topDescribe = function (type, createServer) {
       })
 
       it('should not hang/error when read', function (done) {
-        var buf = Buffer.alloc(1024 * 16, '.')
-        var server = createServer(function (req, res, next) {
+        const buf = Buffer.alloc(1024 * 16, '.')
+        const server = createServer(function (req, res, next) {
           // read off the request
           req.once('end', function () {
             next(new Error('boom!'))
           })
           req.resume()
         })
-        var test = wrapper(request(server).post('/foo'))
+        const test = request(server).post('/foo')
         test.write(buf)
         test.write(buf)
         test.write(buf)
@@ -397,14 +388,14 @@ var topDescribe = function (type, createServer) {
 
     describe('when res.statusCode set', function () {
       it('should keep when >= 400', function (done) {
-        var server = createServer(function (req, res) {
-          var done = finalhandler(req, res)
+        const server = createServer(function (req, res) {
+          const done = finalhandler(req, res)
           res.statusCode = 503
           done(new Error('oops'))
         })
 
-        wrapper(request(server)
-          .get('/foo'))
+        request(server)
+          .get('/foo')
           .expect(503, done)
       })
 
@@ -415,40 +406,40 @@ var topDescribe = function (type, createServer) {
           return
         }
 
-        var server = createServer(function (req, res) {
-          var done = finalhandler(req, res)
+        const server = createServer(function (req, res) {
+          const done = finalhandler(req, res)
           res.statusCode = 'oh no'
           done(new Error('oops'))
         })
 
-        wrapper(request(server)
-          .get('/foo'))
+        request(server)
+          .get('/foo')
           .expect(500, done)
       })
 
       it('should override with err.status', function (done) {
-        var server = createServer(function (req, res) {
-          var done = finalhandler(req, res)
-          var err = createError('oops', {
+        const server = createServer(function (req, res) {
+          const done = finalhandler(req, res)
+          const err = createError('oops', {
             status: 414,
             statusCode: 503
           })
           done(err)
         })
 
-        wrapper(request(server)
-          .get('/foo'))
+        request(server)
+          .get('/foo')
           .expect(414, done)
       })
 
       it('should default body to status message in production', function (done) {
-        var err = createError('boom!', {
+        const err = createError('boom!', {
           status: 509
         })
-        wrapper(request(createServer(err, {
+        request(createServer(err, {
           env: 'production'
         }))
-          .get('/foo'))
+          .get('/foo')
           .expect(509, /<pre>Bandwidth Limit Exceeded<\/pre>/, done)
       })
     })
@@ -461,14 +452,14 @@ var topDescribe = function (type, createServer) {
           return
         }
 
-        var server = createServer(function (req, res) {
-          var done = finalhandler(req, res)
+        const server = createServer(function (req, res) {
+          const done = finalhandler(req, res)
           res.statusCode = undefined
           done(new Error('oops'))
         })
 
-        wrapper(request(server)
-          .get('/foo'))
+        request(server)
+          .get('/foo')
           .expect(500, done)
       })
     })
@@ -476,29 +467,29 @@ var topDescribe = function (type, createServer) {
 
   describe('headers set', function () {
     it('should persist set headers', function (done) {
-      var server = createServer(function (req, res) {
-        var done = finalhandler(req, res)
+      const server = createServer(function (req, res) {
+        const done = finalhandler(req, res)
         res.setHeader('Server', 'foobar')
         done()
       })
 
-      wrapper(request(server)
-        .get('/foo'))
+      request(server)
+        .get('/foo')
         .expect(404)
         .expect('Server', 'foobar')
         .end(done)
     })
 
     it('should override content-type and length', function (done) {
-      var server = createServer(function (req, res) {
-        var done = finalhandler(req, res)
+      const server = createServer(function (req, res) {
+        const done = finalhandler(req, res)
         res.setHeader('Content-Type', 'image/png')
         res.setHeader('Content-Length', '50')
         done()
       })
 
-      wrapper(request(server)
-        .get('/foo'))
+      request(server)
+        .get('/foo')
         .expect(404)
         .expect('Content-Type', 'text/html; charset=utf-8')
         .expect('Content-Length', '142')
@@ -506,16 +497,16 @@ var topDescribe = function (type, createServer) {
     })
 
     it('should remove other content headers', function (done) {
-      var server = createServer(function (req, res) {
-        var done = finalhandler(req, res)
+      const server = createServer(function (req, res) {
+        const done = finalhandler(req, res)
         res.setHeader('Content-Encoding', 'gzip')
         res.setHeader('Content-Language', 'jp')
         res.setHeader('Content-Range', 'bytes 0-2/10')
         done()
       })
 
-      wrapper(request(server)
-        .get('/foo'))
+      request(server)
+        .get('/foo')
         .expect(404)
         .expect(shouldNotHaveHeader('Content-Encoding'))
         .expect(shouldNotHaveHeader('Content-Language'))
@@ -526,8 +517,8 @@ var topDescribe = function (type, createServer) {
 
   describe('request started', function () {
     it('should not respond', function (done) {
-      var server = createServer(function (req, res) {
-        var done = finalhandler(req, res)
+      const server = createServer(function (req, res) {
+        const done = finalhandler(req, res)
         res.statusCode = 301
         res.write('0')
         process.nextTick(function () {
@@ -536,14 +527,14 @@ var topDescribe = function (type, createServer) {
         })
       })
 
-      wrapper(request(server)
-        .get('/foo'))
+      request(server)
+        .get('/foo')
         .expect(301, '01', done)
     })
 
     it('should terminate on error', function (done) {
-      var server = createServer(function (req, res) {
-        var done = finalhandler(req, res)
+      const server = createServer(function (req, res) {
+        const done = finalhandler(req, res)
         res.statusCode = 301
         res.write('0')
         process.nextTick(function () {
@@ -555,8 +546,8 @@ var topDescribe = function (type, createServer) {
         })
       })
 
-      wrapper(request(server)
-        .get('/foo'))
+      request(server)
+        .get('/foo')
         .on('request', function onrequest (test) {
           test.req.on('response', function onresponse (res) {
             if (res.listeners('error').length > 0) {
@@ -578,15 +569,15 @@ var topDescribe = function (type, createServer) {
 
   describe('onerror', function () {
     it('should be invoked when error', function (done) {
-      var err = new Error('boom!')
-      var error
+      const err = new Error('boom!')
+      let error
 
       function log (e) {
         error = e
       }
 
-      wrapper(request(createServer(err, { onerror: log }))
-        .get('/'))
+      request(createServer(err, { onerror: log }))
+        .get('/')
         .end(function () {
           assert.equal(error, err)
           done()
@@ -597,7 +588,7 @@ var topDescribe = function (type, createServer) {
   if (parseInt(process.version.split('.')[0].replace(/^v/, ''), 10) > 11) {
     describe('req.socket', function () {
       it('should not throw when socket is null', function (done) {
-        wrapper(request(createServer(function (req, res, next) {
+        request(createServer(function (req, res, next) {
           res.statusCode = 200
           res.end('ok')
           process.nextTick(function () {
@@ -605,7 +596,7 @@ var topDescribe = function (type, createServer) {
             next(new Error())
           })
         }))
-          .get('/'))
+          .get('/')
           .expect(200)
           .end(function (err) {
             done(err)
@@ -613,62 +604,4 @@ var topDescribe = function (type, createServer) {
       })
     })
   }
-
-  describe('no deprecation warnings', function () {
-    it('should respond 404 on no error', function (done) {
-      var warned = false
-
-      process.once('warning', function (warning) {
-        if (/The http2 module is an experimental API/.test(warning)) return
-        assert.fail(warning)
-      })
-
-      wrapper(request(createServer())
-        .head('/foo'))
-        .expect(404)
-        .end(function (err) {
-          assert.strictEqual(warned, false)
-          done(err)
-        })
-    })
-
-    it('should respond 500 on error', function (done) {
-      var warned = false
-
-      process.once('warning', function (warning) {
-        if (/The http2 module is an experimental API/.test(warning)) return
-        assert.fail(warning)
-      })
-
-      var err = createError()
-
-      wrapper(request(createServer(function (req, res) {
-        var done = finalhandler(req, res)
-
-        if (typeof err === 'function') {
-          err(req, res, done)
-          return
-        }
-
-        done(err)
-      }))
-        .head('/foo'))
-        .expect(500)
-        .end(function (err, res) {
-          assert.strictEqual(warned, false)
-          done(err)
-        })
-    })
-  })
-}
-
-var servers = [
-  ['http', createHTTPServer],
-  ['http2', createHTTP2Server]
-]
-
-for (var i = 0; i < servers.length; i++) {
-  var tests = topDescribe.bind(undefined, servers[i][0], servers[i][1])
-
-  describe(servers[i][0], tests)
 }