test(server): use test-server.js

Author: hiroppy

test/Server.test.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { relative, sep } = require('path');
-const webpack = require('webpack');
 const request = require('supertest');
 // Mock opn before loading Server
 jest.mock('opn');
@@ -12,66 +11,62 @@ opn.mockImplementation(() => {
     catch: jest.fn(),
   };
 });
-const Server = require('../lib/Server');
+jest.mock('sockjs/lib/transport');
+// eslint-disable-next-line import/newline-after-import
+const sockjs = require('sockjs/lib/transport');
 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, server } = testServer.startFullSetup(config, {
+        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', () => {
+        testServer.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, server } = testServer.startFullSetup(config, {
+        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', () => {
+        testServer.close(done);
       });
+
+      compiler.run(() => {});
     });
   });
 
@@ -85,10 +80,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 +97,17 @@ 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, server } = testServer.startFullSetup(config, {});
 
-          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');
+        testServer.close(done);
       });
+
+      compiler.run(() => {});
+      server.listen(8080, 'localhost');
     });
   });
 
@@ -137,86 +124,62 @@ 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, server } = testServer.startFullSetup(config, {
+              stats,
             });
-        })(allStats[0], 0);
-      });
-    });
 
-    it('should respect warningsFilter', () => {
-      return new Promise((res) => {
-        const compiler = webpack(config);
-        const server = new Server(compiler, {
-          stats: { warningsFilter: 'test' },
+            compiler.hooks.done.tap('webpack-dev-server', (s) => {
+              expect(Object.keys(server.getStats(s))).toMatchSnapshot();
+
+              testServer.close(resolve);
+            });
+
+            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, server } = testServer.startFullSetup(config, {
+        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');
+        testServer.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, server } = testServer.startFullSetup(config, {
+        open: true,
+      });
 
-        compiler.run(() => {});
-        server.listen(8080, 'localhost');
+      compiler.hooks.done.tap('webpack-dev-server', () => {
+        expect(opn.mock.calls[0]).toEqual([
+          'http://localhost:8080/webpack-dev-server/',
+          {},
+        ]);
+        expect(opn.mock.invocationCallOrder[0]).toEqual(1);
+        testServer.close(done);
       });
+
+      compiler.run(() => {});
+      server.listen(8080, 'localhost');
     });
   });