diff --git a/test/Server.test.js b/test/Server.test.js
index 08ca5c1fe0..7e05d0e968 100644
--- a/test/Server.test.js
+++ b/test/Server.test.js
@@ -12,66 +12,65 @@ opn.mockImplementation(() => {
     catch: jest.fn(),
   };
 });
+jest.mock('sockjs/lib/transport');
+// eslint-disable-next-line import/newline-after-import
+const sockjs = require('sockjs/lib/transport');
 const Server = require('../lib/Server');
 const config = require('./fixtures/simple-config/webpack.config');
 const testServer = require('./helpers/test-server');
 
 describe('Server', () => {
+  describe('sockjs', () => {
+    it('add decorateConnection', () => {
+      expect(typeof sockjs.Session.prototype.decorateConnection).toEqual(
+        'function'
+      );
+    });
+  });
+
   describe('addEntries', () => {
-    it('add hot option', () => {
-      return new Promise((res) => {
-        // eslint-disable-next-line
-        const Server = require('../lib/Server');
-        const compiler = webpack(config);
-        const server = new Server(compiler, {
-          hot: true,
-        });
+    it('add hot option', (done) => {
+      const compiler = webpack(config);
+      const server = new Server(compiler, {
+        hot: true,
+      });
 
-        expect(
-          server.middleware.context.compiler.options.entry.map((p) => {
-            return relative('.', p).split(sep);
-          })
-        ).toMatchSnapshot();
-        expect(
-          server.middleware.context.compiler.options.plugins
-        ).toMatchSnapshot();
-
-        compiler.hooks.done.tap('webpack-dev-server', () => {
-          server.close(() => {
-            res();
-          });
-        });
+      expect(
+        server.middleware.context.compiler.options.entry.map((p) => {
+          return relative('.', p).split(sep);
+        })
+      ).toMatchSnapshot();
+      expect(
+        server.middleware.context.compiler.options.plugins
+      ).toMatchSnapshot();
 
-        compiler.run(() => {});
+      compiler.hooks.done.tap('webpack-dev-server', () => {
+        server.close(done);
       });
+
+      compiler.run(() => {});
     });
 
-    it('add hotOnly option', () => {
-      return new Promise((res) => {
-        // eslint-disable-next-line
-        const Server = require('../lib/Server');
-        const compiler = webpack(config);
-        const server = new Server(compiler, {
-          hotOnly: true,
-        });
+    it('add hotOnly option', (done) => {
+      const compiler = webpack(config);
+      const server = new Server(compiler, {
+        hotOnly: true,
+      });
 
-        expect(
-          server.middleware.context.compiler.options.entry.map((p) => {
-            return relative('.', p).split(sep);
-          })
-        ).toMatchSnapshot();
-        expect(
-          server.middleware.context.compiler.options.plugins
-        ).toMatchSnapshot();
-
-        compiler.hooks.done.tap('webpack-dev-server', () => {
-          server.close(() => {
-            res();
-          });
-        });
+      expect(
+        server.middleware.context.compiler.options.entry.map((p) => {
+          return relative('.', p).split(sep);
+        })
+      ).toMatchSnapshot();
+      expect(
+        server.middleware.context.compiler.options.plugins
+      ).toMatchSnapshot();
 
-        compiler.run(() => {});
+      compiler.hooks.done.tap('webpack-dev-server', () => {
+        server.close(done);
       });
+
+      compiler.run(() => {});
     });
   });
 
@@ -85,10 +84,7 @@ describe('Server', () => {
       jest.unmock('express');
     });
 
-    it("should success even if mine.types doesn't exist", () => {
-      // eslint-disable-next-line
-      const Server = require('../lib/Server');
-
+    it("should success even if mine.types doesn't exist", (done) => {
       jest.mock('express', () => {
         const data = jest.requireActual('express');
         const { static: st } = data;
@@ -105,22 +101,18 @@ describe('Server', () => {
         });
       });
 
-      return new Promise((res) => {
-        const compiler = webpack(config);
-        const server = new Server(compiler);
-
-        compiler.hooks.done.tap('webpack-dev-server', (s) => {
-          const output = server.getStats(s);
-          expect(output.errors.length).toEqual(0);
+      const compiler = webpack(config);
+      const server = new Server(compiler);
 
-          server.close(() => {
-            res();
-          });
-        });
+      compiler.hooks.done.tap('webpack-dev-server', (s) => {
+        const output = server.getStats(s);
+        expect(output.errors.length).toEqual(0);
 
-        compiler.run(() => {});
-        server.listen(8080, 'localhost');
+        server.close(done);
       });
+
+      compiler.run(() => {});
+      server.listen(8080, 'localhost');
     });
   });
 
@@ -137,86 +129,60 @@ describe('Server', () => {
         },
       ];
 
-      return new Promise((resolve, reject) => {
-        (function iterate(stats, i) {
-          if (i === allStats.length) {
-            return resolve();
-          }
-
-          // Iterate to cover each case.
-          Promise.resolve()
-            .then(
-              () =>
-                new Promise((res) => {
-                  const compiler = webpack(config);
-                  const server = new Server(compiler, { stats });
-
-                  compiler.hooks.done.tap('webpack-dev-server', (s) => {
-                    expect(Object.keys(server.getStats(s))).toMatchSnapshot();
-
-                    server.close(() => {
-                      res();
-                    });
-                  });
-
-                  compiler.run(() => {});
-                  server.listen(8080, 'localhost');
-                })
-            )
-            .then(() => {
-              i += 1;
-              iterate(allStats[i], i);
-            })
-            .catch((e) => {
-              reject(e);
+      return allStats.reduce((p, stats) => {
+        return p.then(() => {
+          return new Promise((resolve) => {
+            const compiler = webpack(config);
+            const server = new Server(compiler, { stats });
+
+            compiler.hooks.done.tap('webpack-dev-server', (s) => {
+              expect(Object.keys(server.getStats(s))).toMatchSnapshot();
+
+              server.close(resolve);
             });
-        })(allStats[0], 0);
-      });
-    });
 
-    it('should respect warningsFilter', () => {
-      return new Promise((res) => {
-        const compiler = webpack(config);
-        const server = new Server(compiler, {
-          stats: { warningsFilter: 'test' },
+            compiler.run(() => {});
+            server.listen(8080, 'localhost');
+          });
         });
+      }, Promise.resolve());
+    });
 
-        compiler.hooks.done.tap('webpack-dev-server', (s) => {
-          s.compilation.warnings = ['test', 'another warning'];
+    it('should respect warningsFilter', (done) => {
+      const compiler = webpack(config);
+      const server = new Server(compiler, {
+        stats: { warningsFilter: 'test' },
+      });
 
-          const output = server.getStats(s);
+      compiler.hooks.done.tap('webpack-dev-server', (s) => {
+        s.compilation.warnings = ['test', 'another warning'];
 
-          expect(output.warnings.length).toBe(1);
-          expect(output.warnings[0]).toBe('another warning');
+        const output = server.getStats(s);
 
-          server.close(() => {
-            res();
-          });
-        });
+        expect(output.warnings.length).toBe(1);
+        expect(output.warnings[0]).toBe('another warning');
 
-        compiler.run(() => {});
-        server.listen(8080, 'localhost');
+        server.close(done);
       });
-    });
 
-    it('should open', () => {
-      return new Promise((res) => {
-        const compiler = webpack(config);
-        const server = new Server(compiler, {
-          open: true,
-        });
+      compiler.run(() => {});
+      server.listen(8080, 'localhost');
+    });
 
-        compiler.hooks.done.tap('webpack-dev-server', () => {
-          expect(opn.mock.calls[0]).toEqual(['http://localhost:8080/', {}]);
-          expect(opn.mock.invocationCallOrder[0]).toEqual(1);
-          server.close(() => {
-            res();
-          });
-        });
+    it('should open', (done) => {
+      const compiler = webpack(config);
+      const server = new Server(compiler, {
+        open: true,
+      });
 
-        compiler.run(() => {});
-        server.listen(8080, 'localhost');
+      compiler.hooks.done.tap('webpack-dev-server', () => {
+        expect(opn.mock.calls[0]).toEqual(['http://localhost:8080/', {}]);
+        expect(opn.mock.invocationCallOrder[0]).toEqual(1);
+        server.close(done);
       });
+
+      compiler.run(() => {});
+      server.listen(8080, 'localhost');
     });
   });
 
diff --git a/test/helpers/run-server.js b/test/helpers/run-server.js
deleted file mode 100644
index dc8624f292..0000000000
--- a/test/helpers/run-server.js
+++ /dev/null
@@ -1,116 +0,0 @@
-'use strict';
-
-/* eslint-disable
-  no-undefined
-*/
-const webpack = require('webpack');
-const Server = require('../../lib/Server');
-
-let server;
-
-// start server, returning the full setup of the server
-// (both the server and the compiler)
-function startFullSetup(config, options, done) {
-  if (options.quiet === undefined) {
-    options.quiet = true;
-  }
-
-  // originally, inline was not working by default for tests with the API
-  // if you need to test inline, it should be set explicitly,
-  // rather than expecting it to be defaulted to
-  // (the only test that relied on inline before this point was Client.test.js)
-  if (
-    options.inline === undefined &&
-    options.hot === undefined &&
-    options.hotOnly === undefined
-  ) {
-    options.inline = false;
-  }
-
-  // defaulting to this will hopefully help with problems on OSX in tests
-  if (options.watchOptions === undefined) {
-    options.watchOptions = {
-      poll: true,
-    };
-  }
-
-  const compiler = webpack(config);
-
-  server = new Server(compiler, options);
-
-  const port = Object.prototype.hasOwnProperty.call(options, 'port')
-    ? options.port
-    : 8080;
-  const host = Object.prototype.hasOwnProperty.call(options, 'host')
-    ? options.host
-    : 'localhost';
-
-  server.listen(port, host, (err) => {
-    if (err) {
-      return done(err);
-    }
-
-    done();
-  });
-
-  return {
-    server,
-    compiler,
-  };
-}
-
-function startAwaitingCompilationFullSetup(config, options, done) {
-  let readyCount = 0;
-  const ready = () => {
-    readyCount += 1;
-    if (readyCount === 2) {
-      done();
-    }
-  };
-
-  const fullSetup = startFullSetup(config, options, ready);
-
-  // wait for compilation, since dev server can start before this
-  // https://github.com/webpack/webpack-dev-server/issues/847
-  fullSetup.compiler.hooks.done.tap('done', ready);
-
-  return fullSetup;
-}
-
-function startAwaitingCompilation(config, options, done) {
-  return startAwaitingCompilationFullSetup(config, options, done).server;
-}
-
-function start(config, options, done) {
-  // I suspect that almost all tests need to wait for compilation to
-  // finish, because not doing so leaves open handles for jest,
-  // in the case where a compilation didn't finish before destroying
-  // the server and moving on. Thus, the default "start" should wait
-  // for compilation, and only special cases where you don't expect
-  // a compilation happen should use startBeforeCompilation
-  return startAwaitingCompilation(config, options, done);
-}
-
-function startBeforeCompilation(config, options, done) {
-  return startFullSetup(config, options, done).server;
-}
-
-function close(done) {
-  if (server) {
-    server.close(() => {
-      server = null;
-      done();
-    });
-  } else {
-    done();
-  }
-}
-
-module.exports = {
-  startFullSetup,
-  startAwaitingCompilation,
-  startAwaitingCompilationFullSetup,
-  startBeforeCompilation,
-  start,
-  close,
-};
diff --git a/test/helpers/test-server.js b/test/helpers/test-server.js
index dc8624f292..8193107136 100644
--- a/test/helpers/test-server.js
+++ b/test/helpers/test-server.js
@@ -46,11 +46,13 @@ function startFullSetup(config, options, done) {
     : 'localhost';
 
   server.listen(port, host, (err) => {
-    if (err) {
+    if (err && done) {
       return done(err);
     }
 
-    done();
+    if (done) {
+      done();
+    }
   });
 
   return {