concurrently 6.0.2 → 6.2.2

package/src/flow-control/kill-on-signal.js

@@ -1,8 +1,11 @@
 const { map } = require('rxjs/operators');
 
+const BaseHandler = require('./base-handler');
 
-module.exports = class KillOnSignal {
+module.exports = class KillOnSignal extends BaseHandler {
     constructor({ process }) {
+        super();
+
         this.process = process;
     }
 
@@ -15,16 +18,18 @@ module.exports = class KillOnSignal {
             });
         });
 
-        return commands.map(command => {
-            const closeStream = command.close.pipe(map(exitInfo => {
-                const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
-                return Object.assign({}, exitInfo, { exitCode });
-            }));
-            return new Proxy(command, {
-                get(target, prop) {
-                    return prop === 'close' ? closeStream : target[prop];
-                }
-            });
-        });
+        return {
+            commands: commands.map(command => {
+                const closeStream = command.close.pipe(map(exitInfo => {
+                    const exitCode = caughtSignal === 'SIGINT' ? 0 : exitInfo.exitCode;
+                    return Object.assign({}, exitInfo, { exitCode });
+                }));
+                return new Proxy(command, {
+                    get(target, prop) {
+                        return prop === 'close' ? closeStream : target[prop];
+                    }
+                });
+            })
+        };
     }
 };

package/src/flow-control/kill-on-signal.spec.js

@@ -0,0 +1,79 @@
+const EventEmitter = require('events');
+
+const createFakeCommand = require('./fixtures/fake-command');
+const KillOnSignal = require('./kill-on-signal');
+
+let commands, controller, process;
+beforeEach(() => {
+    process = new EventEmitter();
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+    controller = new KillOnSignal({ process });
+});
+
+it('returns commands that keep non-close streams from original commands', () => {
+    const { commands: newCommands } = controller.handle(commands);
+    newCommands.forEach((newCommand, i) => {
+        expect(newCommand.close).not.toBe(commands[i].close);
+        expect(newCommand.error).toBe(commands[i].error);
+        expect(newCommand.stdout).toBe(commands[i].stdout);
+        expect(newCommand.stderr).toBe(commands[i].stderr);
+    });
+});
+
+it('returns commands that map SIGINT to exit code 0', () => {
+    const { commands: newCommands } = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+
+    const callback = jest.fn();
+    newCommands[0].close.subscribe(callback);
+    process.emit('SIGINT');
+
+    // A fake command's .kill() call won't trigger a close event automatically...
+    commands[0].close.next({ exitCode: 1 });
+
+    expect(callback).not.toHaveBeenCalledWith({ exitCode: 'SIGINT' });
+    expect(callback).toHaveBeenCalledWith({ exitCode: 0 });
+});
+
+it('returns commands that keep non-SIGINT exit codes', () => {
+    const { commands: newCommands } = controller.handle(commands);
+    expect(newCommands).not.toBe(commands);
+    expect(newCommands).toHaveLength(commands.length);
+
+    const callback = jest.fn();
+    newCommands[0].close.subscribe(callback);
+    commands[0].close.next({ exitCode: 1 });
+
+    expect(callback).toHaveBeenCalledWith({ exitCode: 1 });
+});
+
+it('kills all commands on SIGINT', () => {
+    controller.handle(commands);
+    process.emit('SIGINT');
+
+    expect(process.listenerCount('SIGINT')).toBe(1);
+    expect(commands[0].kill).toHaveBeenCalledWith('SIGINT');
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGINT');
+});
+
+it('kills all commands on SIGTERM', () => {
+    controller.handle(commands);
+    process.emit('SIGTERM');
+
+    expect(process.listenerCount('SIGTERM')).toBe(1);
+    expect(commands[0].kill).toHaveBeenCalledWith('SIGTERM');
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGTERM');
+});
+
+it('kills all commands on SIGHUP', () => {
+    controller.handle(commands);
+    process.emit('SIGHUP');
+
+    expect(process.listenerCount('SIGHUP')).toBe(1);
+    expect(commands[0].kill).toHaveBeenCalledWith('SIGHUP');
+    expect(commands[1].kill).toHaveBeenCalledWith('SIGHUP');
+});

package/src/flow-control/kill-others.js

@@ -1,9 +1,12 @@
 const _ = require('lodash');
 const { filter, map } = require('rxjs/operators');
 
-module.exports = class KillOthers {
+const BaseHandler = require('./base-handler');
+
+module.exports = class KillOthers extends BaseHandler {
     constructor({ logger, conditions }) {
-        this.logger = logger;
+        super({ logger });
+
         this.conditions = _.castArray(conditions);
     }
 
@@ -14,7 +17,7 @@ module.exports = class KillOthers {
         ));
 
         if (!conditions.length) {
-            return commands;
+            return { commands };
         }
 
         const closeStates = commands.map(command => command.close.pipe(
@@ -30,6 +33,6 @@ module.exports = class KillOthers {
             }
         }));
 
-        return commands;
+        return { commands };
     }
 };

package/src/flow-control/kill-others.spec.js

@@ -0,0 +1,66 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+
+const Logger = require('../logger');
+const createFakeCommand = require('./fixtures/fake-command');
+const KillOthers = require('./kill-others');
+
+let commands, logger;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand()
+    ];
+
+    logger = createMockInstance(Logger);
+});
+
+const createWithConditions = conditions => new KillOthers({
+    logger,
+    conditions
+});
+
+it('returns same commands', () => {
+    expect(createWithConditions(['foo']).handle(commands)).toMatchObject({ commands });
+    expect(createWithConditions(['failure']).handle(commands)).toMatchObject({ commands });
+});
+
+it('does not kill others if condition does not match', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[1].killable = true;
+    commands[0].close.next({ exitCode: 0 });
+
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});
+
+it('kills other killable processes on success', () => {
+    createWithConditions(['success']).handle(commands);
+    commands[1].killable = true;
+    commands[0].close.next({ exitCode: 0 });
+
+    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Sending SIGTERM to other processes..');
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).toHaveBeenCalled();
+});
+
+it('kills other killable processes on failure', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[1].killable = true;
+    commands[0].close.next({ exitCode: 1 });
+
+    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Sending SIGTERM to other processes..');
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).toHaveBeenCalled();
+});
+
+it('does not try to kill processes already dead', () => {
+    createWithConditions(['failure']).handle(commands);
+    commands[0].close.next({ exitCode: 1 });
+
+    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
+    expect(commands[0].kill).not.toHaveBeenCalled();
+    expect(commands[1].kill).not.toHaveBeenCalled();
+});

package/src/flow-control/log-error.js

@@ -1,10 +1,8 @@
 const { of } = require('rxjs');
 
-module.exports = class LogExit {
-    constructor({ logger }) {
-        this.logger = logger;
-    }
+const BaseHandler = require('./base-handler');
 
+module.exports = class LogExit extends BaseHandler {
     handle(commands) {
         commands.forEach(command => command.error.subscribe(event => {
             this.logger.logCommandEvent(
@@ -15,6 +13,6 @@ module.exports = class LogExit {
             this.logger.logCommandEvent(event.stack || event, command);
         }));
 
-        return commands;
+        return { commands };
     }
 };

package/src/flow-control/log-error.spec.js

@@ -0,0 +1,40 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('../logger');
+const LogError = require('./log-error');
+const createFakeCommand = require('./fixtures/fake-command');
+
+let controller, logger, commands;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+
+    logger = createMockInstance(Logger);
+    controller = new LogError({ logger });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+
+it('logs the error event of each command', () => {
+    controller.handle(commands);
+    commands[0].error.next('error from command 0');
+
+    const error = new Error('some error message');
+    commands[1].error.next(error);
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(4);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `Error occurred when executing command: ${commands[0].command}`,
+        commands[0]
+    );
+    expect(logger.logCommandEvent).toHaveBeenCalledWith('error from command 0', commands[0]);
+
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `Error occurred when executing command: ${commands[1].command}`,
+        commands[1]
+    );
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(error.stack, commands[1]);
+});

package/src/flow-control/log-exit.js

@@ -1,13 +1,11 @@
-module.exports = class LogExit {
-    constructor({ logger }) {
-        this.logger = logger;
-    }
+const BaseHandler = require('./base-handler');
 
+module.exports = class LogExit extends BaseHandler {
     handle(commands) {
         commands.forEach(command => command.close.subscribe(({ exitCode }) => {
             this.logger.logCommandEvent(`${command.command} exited with code ${exitCode}`, command);
         }));
 
-        return commands;
+        return { commands };
     }
 };

package/src/flow-control/log-exit.spec.js

@@ -0,0 +1,36 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('../logger');
+const LogExit = require('./log-exit');
+const createFakeCommand = require('./fixtures/fake-command');
+
+let controller, logger, commands;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+
+    logger = createMockInstance(Logger);
+    controller = new LogExit({ logger });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+
+it('logs the close event of each command', () => {
+    controller.handle(commands);
+
+    commands[0].close.next({ exitCode: 0 });
+    commands[1].close.next({ exitCode: 'SIGTERM' });
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} exited with code 0`,
+        commands[0]
+    );
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[1].command} exited with code SIGTERM`,
+        commands[1]
+    );
+});

package/src/flow-control/log-output.js

@@ -1,14 +1,12 @@
-module.exports = class LogOutput {
-    constructor({ logger }) {
-        this.logger = logger;
-    }
+const BaseHandler = require('./base-handler');
 
+module.exports = class LogOutput extends BaseHandler {
     handle(commands) {
         commands.forEach(command => {
             command.stdout.subscribe(text => this.logger.logCommandText(text.toString(), command));
             command.stderr.subscribe(text => this.logger.logCommandText(text.toString(), command));
         });
 
-        return commands;
+        return { commands };
     }
 };

package/src/flow-control/log-output.spec.js

@@ -0,0 +1,41 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('../logger');
+const LogOutput = require('./log-output');
+const createFakeCommand = require('./fixtures/fake-command');
+
+let controller, logger, commands;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand(),
+    ];
+
+    logger = createMockInstance(Logger);
+    controller = new LogOutput({ logger });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toMatchObject({ commands });
+});
+
+it('logs the stdout of each command', () => {
+    controller.handle(commands);
+
+    commands[0].stdout.next(Buffer.from('foo'));
+    commands[1].stdout.next(Buffer.from('bar'));
+
+    expect(logger.logCommandText).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandText).toHaveBeenCalledWith('foo', commands[0]);
+    expect(logger.logCommandText).toHaveBeenCalledWith('bar', commands[1]);
+});
+
+it('logs the stderr of each command', () => {
+    controller.handle(commands);
+
+    commands[0].stderr.next(Buffer.from('foo'));
+    commands[1].stderr.next(Buffer.from('bar'));
+
+    expect(logger.logCommandText).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandText).toHaveBeenCalledWith('foo', commands[0]);
+    expect(logger.logCommandText).toHaveBeenCalledWith('bar', commands[1]);
+});

package/src/flow-control/restart-process.js

@@ -2,18 +2,21 @@ const Rx = require('rxjs');
 const { defaultIfEmpty, delay, filter, mapTo, skip, take, takeWhile } = require('rxjs/operators');
 
 const defaults = require('../defaults');
+const BaseHandler = require('./base-handler');
 
-module.exports = class RestartProcess {
+module.exports = class RestartProcess extends BaseHandler {
     constructor({ delay, tries, logger, scheduler }) {
+        super({ logger });
+
         this.delay = +delay || defaults.restartDelay;
         this.tries = +tries || defaults.restartTries;
-        this.logger = logger;
+        this.tries = this.tries < 0 ? Infinity : this.tries;
         this.scheduler = scheduler;
     }
 
     handle(commands) {
         if (this.tries === 0) {
-            return commands;
+            return { commands };
         }
 
         commands.map(command => command.close.pipe(
@@ -35,17 +38,19 @@ module.exports = class RestartProcess {
             }
         }));
 
-        return commands.map(command => {
-            const closeStream = command.close.pipe(filter(({ exitCode }, emission) => {
-                // We let all success codes pass, and failures only after restarting won't happen again
-                return exitCode === 0 || emission >= this.tries;
-            }));
+        return {
+            commands: commands.map(command => {
+                const closeStream = command.close.pipe(filter(({ exitCode }, emission) => {
+                    // We let all success codes pass, and failures only after restarting won't happen again
+                    return exitCode === 0 || emission >= this.tries;
+                }));
 
-            return new Proxy(command, {
-                get(target, prop) {
-                    return prop === 'close' ? closeStream : target[prop];
-                }
-            });
-        });
+                return new Proxy(command, {
+                    get(target, prop) {
+                        return prop === 'close' ? closeStream : target[prop];
+                    }
+                });
+            })
+        };
     }
 };

package/src/flow-control/restart-process.spec.js

@@ -0,0 +1,131 @@
+const { createMockInstance } = require('jest-create-mock-instance');
+const { TestScheduler } = require('rxjs/testing');
+
+const Logger = require('../logger');
+const createFakeCommand = require('./fixtures/fake-command');
+const RestartProcess = require('./restart-process');
+
+let commands, controller, logger, scheduler;
+beforeEach(() => {
+    commands = [
+        createFakeCommand(),
+        createFakeCommand()
+    ];
+
+    logger = createMockInstance(Logger);
+    scheduler = new TestScheduler();
+    controller = new RestartProcess({
+        logger,
+        scheduler,
+        delay: 100,
+        tries: 2
+    });
+});
+
+it('does not restart processes that complete with success', () => {
+    controller.handle(commands);
+
+    commands[0].close.next({ exitCode: 0 });
+    commands[1].close.next({ exitCode: 0 });
+
+    scheduler.flush();
+
+    expect(commands[0].start).toHaveBeenCalledTimes(0);
+    expect(commands[1].start).toHaveBeenCalledTimes(0);
+});
+
+it('restarts processes that fail after delay has passed', () => {
+    controller.handle(commands);
+
+    commands[0].close.next({ exitCode: 1 });
+    commands[1].close.next({ exitCode: 0 });
+
+    scheduler.flush();
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0]
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+    expect(commands[1].start).not.toHaveBeenCalled();
+});
+
+it('restarts processes up to tries', () => {
+    controller.handle(commands);
+
+    commands[0].close.next({ exitCode: 1 });
+    commands[0].close.next({ exitCode: 'SIGTERM' });
+    commands[0].close.next({ exitCode: 'SIGTERM' });
+    commands[1].close.next({ exitCode: 0 });
+
+    scheduler.flush();
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(2);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0]
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(2);
+});
+
+it.todo('restart processes forever, if tries is negative');
+
+it('restarts processes until they succeed', () => {
+    controller.handle(commands);
+
+    commands[0].close.next({ exitCode: 1 });
+    commands[0].close.next({ exitCode: 0 });
+    commands[1].close.next({ exitCode: 0 });
+
+    scheduler.flush();
+
+    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
+    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+        `${commands[0].command} restarted`,
+        commands[0]
+    );
+    expect(commands[0].start).toHaveBeenCalledTimes(1);
+});
+
+describe('returned commands', () => {
+    it('are the same if 0 tries are to be attempted', () => {
+        controller = new RestartProcess({ logger, scheduler });
+        expect(controller.handle(commands)).toMatchObject({ commands });
+    });
+
+    it('are not the same, but with same length if 1+ tries are to be attempted', () => {
+        const { commands: newCommands } = controller.handle(commands);
+        expect(newCommands).not.toBe(commands);
+        expect(newCommands).toHaveLength(commands.length);
+    });
+
+    it('skip close events followed by restarts', () => {
+        const { commands: newCommands } = controller.handle(commands);
+
+        const callback = jest.fn();
+        newCommands[0].close.subscribe(callback);
+        newCommands[1].close.subscribe(callback);
+
+        commands[0].close.next({ exitCode: 1 });
+        commands[0].close.next({ exitCode: 1 });
+        commands[0].close.next({ exitCode: 1 });
+        commands[1].close.next({ exitCode: 1 });
+        commands[1].close.next({ exitCode: 0 });
+
+        scheduler.flush();
+
+        // 1 failure from commands[0], 1 success from commands[1]
+        expect(callback).toHaveBeenCalledTimes(2);
+    });
+
+    it('keep non-close streams from original commands', () => {
+        const { commands: newCommands } = controller.handle(commands);
+        newCommands.forEach((newCommand, i) => {
+            expect(newCommand.close).not.toBe(commands[i].close);
+            expect(newCommand.error).toBe(commands[i].error);
+            expect(newCommand.stdout).toBe(commands[i].stdout);
+            expect(newCommand.stderr).toBe(commands[i].stderr);
+        });
+    });
+});

package/src/get-spawn-opts.spec.js

@@ -0,0 +1,30 @@
+const getSpawnOpts = require('./get-spawn-opts');
+
+it('sets detached mode to false for Windows platform', () => {
+    expect(getSpawnOpts({ process: { platform: 'win32', cwd: jest.fn() } }).detached).toBe(false);
+});
+
+it('sets stdio to inherit when raw', () => {
+    expect(getSpawnOpts({ raw: true }).stdio).toBe('inherit');
+});
+
+it('merges FORCE_COLOR into env vars if color supported', () => {
+    const process = { env: { foo: 'bar' }, cwd: jest.fn() };
+    expect(getSpawnOpts({ process, colorSupport: false }).env).toEqual(process.env);
+    expect(getSpawnOpts({ process, colorSupport: { level: 1 } }).env).toEqual({
+        FORCE_COLOR: 1,
+        foo: 'bar'
+    });
+});
+
+it('sets default cwd to process.cwd()', () => {
+    const process = { cwd: jest.fn().mockReturnValue('process-cwd') };
+    expect(getSpawnOpts({
+        process,
+    }).cwd).toBe('process-cwd');
+});
+
+it('overrides default cwd', () => {
+    const cwd = 'foobar';
+    expect(getSpawnOpts({ cwd }).cwd).toBe(cwd);
+});

package/src/logger.js

@@ -61,7 +61,8 @@ module.exports = class Logger {
         if (command.prefixColor && command.prefixColor.startsWith('#')) {
             color = chalk.hex(command.prefixColor);
         } else {
-            color = _.get(chalk, command.prefixColor, chalk.gray.dim);
+            const defaultColor = _.get(chalk, defaults.prefixColors, chalk.reset);
+            color = _.get(chalk, command.prefixColor, defaultColor);
         }
         return color(text);
     }
@@ -71,7 +72,7 @@ module.exports = class Logger {
             return;
         }
 
-        this.logCommandText(chalk.gray.dim(text) + '\n', command);
+        this.logCommandText(chalk.reset(text) + '\n', command);
     }
 
     logCommandText(text, command) {
@@ -84,7 +85,7 @@ module.exports = class Logger {
             return;
         }
 
-        this.log(chalk.gray.dim('-->') + ' ', chalk.gray.dim(text) + '\n');
+        this.log(chalk.reset('-->') + ' ', chalk.reset(text) + '\n');
     }
 
     log(prefix, text) {