concurrently 6.0.0 → 6.2.0

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)).toBe(commands);
+    expect(createWithConditions(['failure']).handle(commands)).toBe(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.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)).toBe(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.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)).toBe(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.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)).toBe(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

@@ -7,6 +7,7 @@ module.exports = class RestartProcess {
     constructor({ delay, tries, logger, scheduler }) {
         this.delay = +delay || defaults.restartDelay;
         this.tries = +tries || defaults.restartTries;
+        this.tries = this.tries < 0 ? Infinity : this.tries;
         this.logger = logger;
         this.scheduler = scheduler;
     }

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)).toBe(commands);
+    });
+
+    it('are not the same, but with same length if 1+ tries are to be attempted', () => {
+        const newCommands = controller.handle(commands);
+        expect(newCommands).not.toBe(commands);
+        expect(newCommands).toHaveLength(commands.length);
+    });
+
+    it('skip close events followed by restarts', () => {
+        const 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 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) {

package/src/logger.spec.js

@@ -0,0 +1,195 @@
+const { Writable } = require('stream');
+const chalk = require('chalk');
+const { createMockInstance } = require('jest-create-mock-instance');
+const Logger = require('./logger');
+
+let outputStream;
+beforeEach(() => {
+    outputStream = createMockInstance(Writable);
+    // Force chalk to use colours, otherwise tests may pass when they were supposed to be failing.
+    chalk.level = 3;
+});
+
+const createLogger = options => {
+    const logger = new Logger(Object.assign({ outputStream }, options));
+    jest.spyOn(logger, 'log');
+    return logger;
+};
+
+describe('#log()', () => {
+    it('writes prefix + text to the output stream', () => {
+        const logger = new Logger({ outputStream });
+        logger.log('foo', 'bar');
+
+        expect(outputStream.write).toHaveBeenCalledTimes(2);
+        expect(outputStream.write).toHaveBeenCalledWith('foo');
+        expect(outputStream.write).toHaveBeenCalledWith('bar');
+    });
+
+    it('writes multiple lines of text with prefix on each', () => {
+        const logger = new Logger({ outputStream });
+        logger.log('foo', 'bar\nbaz\n');
+
+        expect(outputStream.write).toHaveBeenCalledTimes(2);
+        expect(outputStream.write).toHaveBeenCalledWith('foo');
+        expect(outputStream.write).toHaveBeenCalledWith('bar\nfoobaz\n');
+    });
+
+    it('does not prepend prefix if last call did not finish with a LF', () => {
+        const logger = new Logger({ outputStream });
+        logger.log('foo', 'bar');
+        outputStream.write.mockClear();
+        logger.log('foo', 'baz');
+
+        expect(outputStream.write).toHaveBeenCalledTimes(1);
+        expect(outputStream.write).toHaveBeenCalledWith('baz');
+    });
+
+    it('does not prepend prefix or handle text if logger is in raw mode', () => {
+        const logger = new Logger({ outputStream, raw: true });
+        logger.log('foo', 'bar\nbaz\n');
+
+        expect(outputStream.write).toHaveBeenCalledTimes(1);
+        expect(outputStream.write).toHaveBeenCalledWith('bar\nbaz\n');
+    });
+});
+
+describe('#logGlobalEvent()', () => {
+    it('does nothing if in raw mode', () => {
+        const logger = createLogger({ raw: true });
+        logger.logGlobalEvent('foo');
+
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+
+    it('logs in gray dim style with arrow prefix', () => {
+        const logger = createLogger();
+        logger.logGlobalEvent('foo');
+
+        expect(logger.log).toHaveBeenCalledWith(
+            chalk.reset('-->') + ' ',
+            chalk.reset('foo') + '\n'
+        );
+    });
+});
+
+describe('#logCommandText()', () => {
+    it('logs with name if no prefixFormat is set', () => {
+        const logger = createLogger();
+        logger.logCommandText('foo', { name: 'bla' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[bla]') + ' ', 'foo');
+    });
+
+    it('logs with index if no prefixFormat is set, and command has no name', () => {
+        const logger = createLogger();
+        logger.logCommandText('foo', { index: 2 });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[2]') + ' ', 'foo');
+    });
+
+    it('logs with prefixFormat set to pid', () => {
+        const logger = createLogger({ prefixFormat: 'pid' });
+        logger.logCommandText('foo', {
+            pid: 123,
+            info: {}
+        });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[123]') + ' ', 'foo');
+    });
+
+    it('logs with prefixFormat set to name', () => {
+        const logger = createLogger({ prefixFormat: 'name' });
+        logger.logCommandText('foo', { name: 'bar' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[bar]') + ' ', 'foo');
+    });
+
+    it('logs with prefixFormat set to index', () => {
+        const logger = createLogger({ prefixFormat: 'index' });
+        logger.logCommandText('foo', { index: 3 });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[3]') + ' ', 'foo');
+    });
+
+    it('logs with prefixFormat set to time (with timestampFormat)', () => {
+        const logger = createLogger({ prefixFormat: 'time', timestampFormat: 'yyyy' });
+        logger.logCommandText('foo', {});
+
+        const year = new Date().getFullYear();
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset(`[${year}]`) + ' ', 'foo');
+    });
+
+    it('logs with templated prefixFormat', () => {
+        const logger = createLogger({ prefixFormat: '{index}-{name}' });
+        logger.logCommandText('foo', { index: 0, name: 'bar' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('0-bar') + ' ', 'foo');
+    });
+
+    it('does not strip spaces from beginning or end of prefixFormat', () => {
+        const logger = createLogger({ prefixFormat: ' {index}-{name} ' });
+        logger.logCommandText('foo', { index: 0, name: 'bar' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset(' 0-bar ') + ' ', 'foo');
+    });
+
+    it('logs with no prefix', () => {
+        const logger = createLogger({ prefixFormat: 'none' });
+        logger.logCommandText('foo', { command: 'echo foo' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset(''), 'foo');
+    });
+
+    it('logs prefix using command line itself', () => {
+        const logger = createLogger({ prefixFormat: 'command' });
+        logger.logCommandText('foo', { command: 'echo foo' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[echo foo]') + ' ', 'foo');
+    });
+
+    it('logs prefix using command line itself, capped at prefixLength bytes', () => {
+        const logger = createLogger({ prefixFormat: 'command', prefixLength: 6 });
+        logger.logCommandText('foo', { command: 'echo foo' });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[ec..oo]') + ' ', 'foo');
+    });
+
+    it('logs prefix using prefixColor from command', () => {
+        const logger = createLogger();
+        logger.logCommandText('foo', { prefixColor: 'blue', index: 1 });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.blue('[1]') + ' ', 'foo');
+    });
+
+    it('logs prefix in gray dim if prefixColor from command does not exist', () => {
+        const logger = createLogger();
+        logger.logCommandText('foo', { prefixColor: 'blue.fake', index: 1 });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[1]') + ' ', 'foo');
+    });
+
+    it('logs prefix using prefixColor from command if prefixColor is a hex value', () => {
+        const logger = createLogger();
+        const prefixColor = '#32bd8a';
+        logger.logCommandText('foo', {prefixColor, index: 1});
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.hex(prefixColor)('[1]') + ' ', 'foo');
+    });
+});
+
+describe('#logCommandEvent()', () => {
+    it('does nothing if in raw mode', () => {
+        const logger = createLogger({ raw: true });
+        logger.logCommandEvent('foo');
+
+        expect(logger.log).not.toHaveBeenCalled();
+    });
+
+    it('logs text in gray dim', () => {
+        const logger = createLogger();
+        logger.logCommandEvent('foo', { index: 1 });
+
+        expect(logger.log).toHaveBeenCalledWith(chalk.reset('[1]') + ' ', chalk.reset('foo') + '\n');
+    });
+});

package/src/flow-control/fixtures/fake-command.js

@@ -1,16 +0,0 @@
-const { createMockInstance } = require('jest-create-mock-instance');
-const { Writable } = require('stream');
-const { Subject } = require('rxjs');
-
-module.exports = (name = 'foo', command = 'echo foo', index = 0) => ({
-    index,
-    name,
-    command,
-    close: new Subject(),
-    error: new Subject(),
-    stderr: new Subject(),
-    stdout: new Subject(),
-    stdin: createMockInstance(Writable),
-    start: jest.fn(),
-    kill: jest.fn()
-});