concurrently 3.1.0 → 3.5.0

package/test/test-functional.js

@@ -5,8 +5,8 @@ var assert = require('assert');
 var run = require('./utils').run;
 var IS_WINDOWS = /^win/.test(process.platform);
 
-// If true, output of commands are shown
-var DEBUG_TESTS = process.env.DEBUG_TESTS === 'true';
+// Note: Set the DEBUG_TESTS environment variable to `true` to see output of test commands.
+
 var TEST_DIR = 'dir/';
 
 // Abs path to test directory
@@ -17,7 +17,7 @@ describe('concurrently', function() {
     this.timeout(5000);
 
     it('help should be successful', () => {
-        return run('node ./src/main.js --help', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js --help')
             .then(function(exitCode) {
                 // exit code 0 means success
                 assert.strictEqual(exitCode, 0);
@@ -25,36 +25,69 @@ describe('concurrently', function() {
     });
 
     it('version should be successful', () => {
-        return run('node ./src/main.js -V', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -V')
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
             });
     });
 
     it('two successful commands should exit 0', () => {
-        return run('node ./src/main.js "echo test" "echo test"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js "echo test" "echo test"')
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
             });
     });
 
     it('at least one unsuccessful commands should exit non-zero', () => {
-        return run('node ./src/main.js "echo test" "nosuchcmd" "echo test"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js "echo test" "nosuchcmd" "echo test"')
             .then(function(exitCode) {
                 assert.notStrictEqual(exitCode, 0);
             });
     });
 
     it('--kill-others should kill other commands if one dies', () => {
-        // This test would timeout if kill others option does not work
-        return run('node ./src/main.js --kill-others "sleep 1000" "echo test" "sleep 1000"', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js --kill-others "sleep 1" "echo test" "sleep 0.1 && nosuchcmd"')
             .then(function(exitCode) {
                 assert.notStrictEqual(exitCode, 0);
             });
     });
 
+    it('--kill-others-on-fail should kill other commands if one exits with non-zero status code', () => {
+        return run('node ./src/main.js --kill-others-on-fail "sleep 1" "exit 1" "sleep 1"')
+            .then(function(exitCode) {
+                assert.notStrictEqual(exitCode, 0);
+            });
+    });
+
+    it('--kill-others-on-fail should NOT kill other commands if none of them exits with non-zero status code', (done) => {
+        var readline = require('readline');
+        var exits = 0;
+        var sigtermInOutput = false;
+
+        run('node ./src/main.js --kill-others-on-fail "echo killTest1" "echo killTest2" "echo killTest3"', {
+            onOutputLine: function(line) {
+                if (/SIGTERM/.test(line)) {
+                    sigtermInOutput = true;
+                }
+
+                // waiting for exits
+                if (/killTest\d$/.test(line)) {
+                    exits++;
+                }
+            }
+        }).then(function() {
+            if(sigtermInOutput) {
+                done(new Error('There was a "SIGTERM" in console output'));
+            } else if (exits !== 3) {
+                done(new Error('There was wrong number of echoes(' + exits + ') from executed commands'));
+            } else {
+                done();
+            }
+        });
+    });
+
     it('--success=first should return first exit code', () => {
-        return run('node ./src/main.js -k --success first "echo test" "sleep 1000" ', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -k --success first "echo test" "sleep 0.1 && nosuchcmd"')
             // When killed, sleep returns null exit code
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 0);
@@ -63,19 +96,138 @@ describe('concurrently', function() {
 
     it('--success=last should return last exit code', () => {
         // When killed, sleep returns null exit code
-        return run('node ./src/main.js -k --success last "echo test" "sleep 1000" ', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js -k --success last "echo test" "sleep 0.1 && nosuchcmd"')
             .then(function(exitCode) {
                 assert.notStrictEqual(exitCode, 0);
             });
     });
 
     it('&& nosuchcmd should return non-zero exit code', () => {
-        return run('node ./src/main.js "echo 1 && nosuchcmd" "echo 1 && nosuchcmd" ', {pipe: DEBUG_TESTS})
+        return run('node ./src/main.js "echo 1 && nosuchcmd" "echo 1 && nosuchcmd" ')
             .then(function(exitCode) {
                 assert.strictEqual(exitCode, 1);
             });
     });
 
+    it('--prefix-colors should handle non-existent colors without failing', () => {
+        return run('node ./src/main.js -c "not.a.color" "echo colors"')
+            .then(function(exitCode) {
+                assert.strictEqual(exitCode, 0);
+            });
+    });
+
+    it('--prefix should default to "index"', () => {
+        var collectedLines = []
+
+        return run('node ./src/main.js "echo one" "echo two"', {
+            onOutputLine: (line) => {
+                if (/(one|two)$/.exec(line)) {
+                    collectedLines.push(line)
+                }
+            }
+        })
+            .then(function(exitCode) {
+                assert.strictEqual(exitCode, 0);
+
+                collectedLines.sort()
+                assert.deepEqual(collectedLines, [
+                    '[0] one',
+                    '[1] two'
+                ])
+            });
+    });
+
+    it('--names should set a different default prefix', () => {
+        var collectedLines = []
+
+        return run('node ./src/main.js -n aa,bb "echo one" "echo two"', {
+            onOutputLine: (line) => {
+                if (/(one|two)$/.exec(line)) {
+                    collectedLines.push(line)
+                }
+            }
+        })
+            .then(function(exitCode) {
+                assert.strictEqual(exitCode, 0);
+
+                collectedLines.sort()
+                assert.deepEqual(collectedLines, [
+                    '[aa] one',
+                    '[bb] two'
+                ])
+            });
+    });
+
+    it('--allow-restart should restart a proccess with non-zero exit code', (done) => {
+        var readline = require('readline');
+        var exitedWithOne = false;
+        var restarted = false;
+
+        run('node ./src/main.js --allow-restart "sleep 0.1 && exit 1" "sleep 1"', {
+            pipe: false,
+            onOutputLine: (line) => {
+                var re = /exited with code (.+)/.exec(line);
+                if (re && re[1] === '1') {
+                    exitedWithOne = true
+                }
+
+                if (/restarted/.test(line)) {
+                    restarted = true;
+                }
+            }
+        }).then(function() {
+            if (exitedWithOne && restarted) {
+                done();
+            } else {
+                done(new Error('No restarted process exited with code 1'));
+            }
+        });
+    });
+
+    it('--restart-after=n should restart a proccess after n miliseconds', (done) => {
+        var readline = require('readline');
+        var start, end;
+
+        run('node ./src/main.js --allow-restart --restart-after 300 "exit 1" "sleep 1"', {
+            pipe: false,
+            onOutputLine: (line) => {
+                if (!start && /exited with code (.+)/.test(line)) {
+                    start = new Date().getTime();
+                }
+
+                if (!end && /restarted/.test(line)) {
+                    end = new Date().getTime();
+                }
+            }
+        }).then(function() {
+            // we accept 100 miliseconds of error
+            if (end - start >= 300 && end - start < 400) {
+                done();
+            } else {
+                done(new Error('No restarted process after 300 miliseconds'));
+            }
+        });
+    });
+    it('--restart-tries=n should restart a proccess at most n times', (done) => {
+        var readline = require('readline');
+        var restartedTimes = 0;
+
+        run('node ./src/main.js --allow-restart --restart-tries 2 "exit 1" "sleep 1"', {
+            pipe: false,
+            onOutputLine: (line) => {
+                if (/restarted/.test(line)) {
+                    restartedTimes++;
+                }
+            }
+        }).then(function() {
+            if (restartedTimes == 2) {
+                done();
+            } else {
+                done(new Error('No restarted process twice'));
+            }
+        });
+    });
+
     ['SIGINT', 'SIGTERM'].forEach((signal) => {
       if (IS_WINDOWS) {
           console.log('IS_WINDOWS=true');
@@ -97,32 +249,20 @@ describe('concurrently', function() {
         }
 
         run('node ./src/main.js "node ./test/support/signal.js" "node ./test/support/signal.js"', {
-          pipe: false,
-          callback: function(child) {
-            var rl = readline.createInterface({
-              input: child.stdout,
-              output: null
-            });
+          onOutputLine: function(line, child) {
+            // waiting for startup
+            if (/STARTED/.test(line)) {
+              waitingStart--;
+            }
+            if (!waitingStart) {
+              // both processes are started
+              child.kill(signal);
+            }
 
-            rl.on('line', function(line) {
-              if (DEBUG_TESTS) {
-                console.log(line);
-              }
-
-              // waiting for startup
-              if (/STARTED/.test(line)) {
-                waitingStart--;
-              }
-              if (!waitingStart) {
-                // both processes are started
-                child.kill(signal);
-              }
-
-              // waiting for signal
-              if (new RegExp(signal).test(line)) {
-                waitingSignal--;
-              }
-            });
+            // waiting for signal
+            if (new RegExp(signal).test(line)) {
+              waitingSignal--;
+            }
           }
         }).then(function() {
           waitForSignal(done);

package/test/utils.js

@@ -1,32 +1,31 @@
 var childProcess = require('child_process');
 var _ = require('lodash');
-var Promise = require('bluebird');
+var readline = require('readline')
 var shellQuote = require('shell-quote');
 
+// If true, output of commands are shown
+var DEBUG_TESTS = process.env.DEBUG_TESTS === 'true';
+
 function run(cmd, opts) {
     opts = _.merge({
-        pipe: true,
-        cwd: undefined,
-        callback: function(child) {
-            // Since we return promise, we need to provide
-            // this callback if one wants to access the child
-            // process reference
-            // Called immediately after successful child process
-            // spawn
-        }
+        // If set to a function, it will be called for each line
+        // written to the child process's stdout as (line, child)
+        onOutputLine: undefined,
     }, opts);
 
     var child;
     var parts = shellQuote.parse(cmd);
     try {
         child = childProcess.spawn(_.head(parts), _.tail(parts), {
-            cwd: opts.cwd,
-            stdio: opts.pipe ? "inherit" : null
+            stdio: DEBUG_TESTS && !opts.onOutputLine ? 'inherit': null,
         });
     } catch (e) {
         return Promise.reject(e);
     }
-    opts.callback(child);
+
+    if (opts.onOutputLine) {
+        readLines(child, opts.onOutputLine);
+    }
 
     return new Promise(function(resolve, reject) {
         child.on('error', function(err) {
@@ -39,6 +38,21 @@ function run(cmd, opts) {
     });
 }
 
+function readLines(child, callback) {
+    var rl = readline.createInterface({
+        input: child.stdout,
+        output: null
+    });
+
+    rl.on('line', function(line) {
+        if (DEBUG_TESTS) {
+            console.log(line);
+        }
+
+        callback(line, child)
+    });
+}
+
 module.exports = {
     run: run
-};
+};