feat(server): add stdin option to API (#2186)

* feat(server): add stdin for api

* test(stdin): switch to async await tests for stdin

* test(cli): use await timer

lib/Server.js

@@ -33,6 +33,7 @@ const createDomain = require('./utils/createDomain');
 const runBonjour = require('./utils/runBonjour');
 const routes = require('./utils/routes');
 const getSocketServerImplementation = require('./utils/getSocketServerImplementation');
+const handleStdin = require('./utils/handleStdin');
 const schema = require('./options.json');
 
 // Workaround for node ^8.6.0, ^9.0.0
@@ -69,6 +70,8 @@ class Server {
 
     normalizeOptions(this.compiler, this.options);
 
+    handleStdin(this.options);
+
     updateCompiler(this.compiler, this.options);
 
     // this.SocketServerImplementation is a class, so it must be instantiated before use

lib/options.json

@@ -382,6 +382,9 @@
         }
       ]
     },
+    "stdin": {
+      "type": "boolean"
+    },
     "useLocalIp": {
       "type": "boolean"
     },
@@ -465,6 +468,7 @@
       "staticOptions": "should be {Object} (https://webpack.js.org/configuration/dev-server/#devserverstaticoptions)",
       "stats": "should be {Object|Boolean} (https://webpack.js.org/configuration/dev-server/#devserverstats-)",
       "transportMode": "should be {String|Object} (https://webpack.js.org/configuration/dev-server/#devservertransportmode)",
+      "stdin": "should be {Boolean} (https://webpack.js.org/configuration/dev-server/#devserverstdin)",
       "useLocalIp": "should be {Boolean} (https://webpack.js.org/configuration/dev-server/#devserveruselocalip)",
       "warn": "should be {Function}",
       "watchContentBase": "should be {Boolean} (https://webpack.js.org/configuration/dev-server/#devserverwatchcontentbase)",

lib/utils/createConfig.js

@@ -81,12 +81,7 @@ function createConfig(config, argv, { port }) {
   }
 
   if (argv.stdin) {
-    process.stdin.on('end', () => {
-      // eslint-disable-next-line no-process-exit
-      process.exit(0);
-    });
-
-    process.stdin.resume();
+    options.stdin = true;
   }
 
   // TODO https://github.com/webpack/webpack-dev-server/issues/616 (v4)

lib/utils/handleStdin.js

@@ -0,0 +1,16 @@
+'use strict';
+
+function handleStdin(options) {
+  if (options.stdin) {
+    // listening for this event only once makes testing easier,
+    // since it prevents event listeners from hanging open
+    process.stdin.once('end', () => {
+      // eslint-disable-next-line no-process-exit
+      process.exit(0);
+    });
+
+    process.stdin.resume();
+  }
+}
+
+module.exports = handleStdin;

test/cli/cli.test.js

@@ -9,6 +9,7 @@ const execa = require('execa');
 const { unlinkAsync } = require('../helpers/fs');
 const testBin = require('../helpers/test-bin');
 const port1 = require('../ports-map').cli[0];
+const timer = require('../helpers/timer');
 
 const httpsCertificateDirectory = resolve(
   __dirname,
@@ -119,6 +120,47 @@ describe('CLI', () => {
       .catch(done);
   });
 
+  it('without --stdin, with stdin "end" event should time out', async (done) => {
+    const configPath = resolve(
+      __dirname,
+      '../fixtures/simple-config/webpack.config.js'
+    );
+    const childProcess = testBin(false, configPath, true);
+
+    childProcess.once('exit', () => {
+      expect(childProcess.killed).toBeTruthy();
+      done();
+    });
+
+    await timer(500);
+    // this is meant to confirm that it does not have any effect on the running process
+    // since options.stdin is not enabled
+    childProcess.stdin.emit('end');
+    childProcess.stdin.pause();
+
+    await timer(500);
+
+    childProcess.kill();
+  });
+
+  it('--stdin, with "end" event should exit without time out', async () => {
+    const configPath = resolve(
+      __dirname,
+      '../fixtures/simple-config/webpack.config.js'
+    );
+    const childProcess = testBin('--stdin', configPath);
+
+    await timer(500);
+
+    childProcess.stdin.emit('end');
+    childProcess.stdin.pause();
+
+    const { exitCode, timedOut, killed } = await childProcess;
+    expect(exitCode).toEqual(0);
+    expect(timedOut).toBeFalsy();
+    expect(killed).toBeFalsy();
+  });
+
   it('should accept the promise function of webpack.config.js', async () => {
     try {
       const { exitCode } = await testBin(

test/helpers/test-bin.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const path = require('path');
+const { spawn } = require('child_process');
 const execa = require('execa');
 
 const webpackDevServerPath = path.resolve(
@@ -12,9 +13,12 @@ const basicConfigPath = path.resolve(
   '../fixtures/cli/webpack.config.js'
 );
 
-function testBin(testArgs, configPath) {
+function testBin(testArgs, configPath, useSpawn) {
   const cwd = process.cwd();
-  const env = process.env.NODE_ENV;
+  const env = {
+    NODE_ENV: process.env.NODE_ENV,
+    PATH: process.env.PATH,
+  };
 
   if (!configPath) {
     configPath = basicConfigPath;
@@ -28,7 +32,16 @@ function testBin(testArgs, configPath) {
 
   const args = [webpackDevServerPath, '--config', configPath].concat(testArgs);
 
-  return execa('node', args, { cwd, env, timeout: 10000 });
+  const opts = { cwd, env, timeout: 10000 };
+  let execLib = execa;
+  // use Node's spawn as a workaround for execa issues
+  // https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options
+  if (useSpawn) {
+    execLib = spawn;
+    delete opts.timeout;
+  }
+
+  return execLib('node', args, opts);
 }
 
 module.exports = testBin;

test/options.test.js

@@ -375,6 +375,10 @@ describe('options', () => {
           },
         ],
       },
+      stdin: {
+        success: [false],
+        failure: [''],
+      },
       useLocalIp: {
         success: [false],
         failure: [''],

test/ports-map.js

@@ -43,6 +43,7 @@ const portsList = {
   'progress-option': 1,
   'profile-option': 1,
   Iframe: 1,
+  'stdin-option': 1,
 };
 
 let startPort = 8089;

test/server/stdin-option.test.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const config = require('../fixtures/simple-config/webpack.config');
+const testServer = require('../helpers/test-server');
+const timer = require('../helpers/timer');
+const port = require('../ports-map')['stdin-option'];
+
+describe('stdin', () => {
+  // eslint-disable-next-line no-unused-vars
+  let server;
+  let exitSpy;
+
+  beforeAll(() => {
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+  });
+
+  afterEach((done) => {
+    server = null;
+    exitSpy.mockReset();
+    process.stdin.removeAllListeners('end');
+    testServer.close(done);
+  });
+
+  describe('enabled', () => {
+    beforeAll((done) => {
+      server = testServer.start(
+        config,
+        {
+          port,
+          stdin: true,
+        },
+        done
+      );
+    });
+
+    it('should exit process', async () => {
+      process.stdin.emit('end');
+      await timer(1000);
+      process.stdin.pause();
+      expect(exitSpy.mock.calls[0]).toEqual([0]);
+    });
+  });
+
+  describe('disabled (default)', () => {
+    beforeAll((done) => {
+      server = testServer.start(
+        config,
+        {
+          port,
+        },
+        done
+      );
+    });
+
+    it('should not exit process', async () => {
+      process.stdin.emit('end');
+      await timer(1000);
+      process.stdin.pause();
+      expect(exitSpy.mock.calls.length).toEqual(0);
+    });
+  });
+});

test/server/utils/handleStdin.test.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const timer = require('../../helpers/timer');
+const handleStdin = require('../../../lib/utils/handleStdin');
+
+describe('handleStdin', () => {
+  let exitSpy;
+
+  beforeAll(() => {
+    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.stdin.removeAllListeners('end');
+    exitSpy.mockReset();
+  });
+
+  describe('enabled', () => {
+    it('should exit process', async () => {
+      handleStdin({
+        stdin: true,
+      });
+      process.stdin.emit('end');
+
+      await timer(1000);
+      process.stdin.pause();
+      expect(exitSpy.mock.calls[0]).toEqual([0]);
+    });
+  });
+
+  describe('disabled (default)', () => {
+    it('should not exit process', async () => {
+      handleStdin({});
+      process.stdin.emit('end');
+
+      await timer(1000);
+      process.stdin.pause();
+      expect(exitSpy.mock.calls.length).toEqual(0);
+    });
+  });
+});