concurrently 6.3.0 → 7.0.0

package/src/concurrently.spec.js

@@ -1,199 +0,0 @@
-const EventEmitter = require('events');
-
-const createFakeCommand = require('./flow-control/fixtures/fake-command');
-const FakeHandler = require('./flow-control/fixtures/fake-handler');
-const concurrently = require('./concurrently');
-
-let spawn, kill, controllers, processes = [];
-const create = (commands, options = {}) => concurrently(
-    commands,
-    Object.assign(options, { controllers, spawn, kill })
-);
-
-beforeEach(() => {
-    processes = [];
-    spawn = jest.fn(() => {
-        const process = new EventEmitter();
-        processes.push(process);
-        process.pid = processes.length;
-        return process;
-    });
-    kill = jest.fn();
-    controllers = [new FakeHandler(), new FakeHandler()];
-});
-
-it('fails if commands is not an array', () => {
-    const bomb = () => create('foo');
-    expect(bomb).toThrowError();
-});
-
-it('fails if no commands were provided', () => {
-    const bomb = () => create([]);
-    expect(bomb).toThrowError();
-});
-
-it('spawns all commands', () => {
-    create(['echo', 'kill']);
-    expect(spawn).toHaveBeenCalledTimes(2);
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({}));
-    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({}));
-});
-
-it('spawns commands up to configured limit at once', () => {
-    create(['foo', 'bar', 'baz', 'qux'], { maxProcesses: 2 });
-    expect(spawn).toHaveBeenCalledTimes(2);
-    expect(spawn).toHaveBeenCalledWith('foo', expect.objectContaining({}));
-    expect(spawn).toHaveBeenCalledWith('bar', expect.objectContaining({}));
-
-    // Test out of order completion picking up new processes in-order
-    processes[1].emit('close', 1, null);
-    expect(spawn).toHaveBeenCalledTimes(3);
-    expect(spawn).toHaveBeenCalledWith('baz', expect.objectContaining({}));
-
-    processes[0].emit('close', null, 'SIGINT');
-    expect(spawn).toHaveBeenCalledTimes(4);
-    expect(spawn).toHaveBeenCalledWith('qux', expect.objectContaining({}));
-
-    // Shouldn't attempt to spawn anything else.
-    processes[2].emit('close', 1, null);
-    expect(spawn).toHaveBeenCalledTimes(4);
-});
-
-it('runs controllers with the commands', () => {
-    create(['echo', '"echo wrapped"']);
-
-    controllers.forEach(controller => {
-        expect(controller.handle).toHaveBeenCalledWith([
-            expect.objectContaining({ command: 'echo', index: 0 }),
-            expect.objectContaining({ command: 'echo wrapped', index: 1 }),
-        ]);
-    });
-});
-
-it('runs commands with a name or prefix color', () => {
-    create([
-        { command: 'echo', prefixColor: 'red', name: 'foo' },
-        'kill'
-    ]);
-
-    controllers.forEach(controller => {
-        expect(controller.handle).toHaveBeenCalledWith([
-            expect.objectContaining({ command: 'echo', index: 0, name: 'foo', prefixColor: 'red' }),
-            expect.objectContaining({ command: 'kill', index: 1, name: '', prefixColor: '' }),
-        ]);
-    });
-});
-
-it('runs commands with a list of colors', () => {
-    create(['echo', 'kill'], {
-        prefixColors: ['red']
-    });
-
-    controllers.forEach(controller => {
-        expect(controller.handle).toHaveBeenCalledWith([
-            expect.objectContaining({ command: 'echo', prefixColor: 'red' }),
-            expect.objectContaining({ command: 'kill', prefixColor: 'red' }),
-        ]);
-    });
-});
-
-it('passes commands wrapped from a controller to the next one', () => {
-    const fakeCommand = createFakeCommand('banana', 'banana');
-    controllers[0].handle.mockReturnValue({ commands: [fakeCommand] });
-
-    create(['echo']);
-
-    expect(controllers[0].handle).toHaveBeenCalledWith([
-        expect.objectContaining({ command: 'echo', index: 0 })
-    ]);
-
-    expect(controllers[1].handle).toHaveBeenCalledWith([fakeCommand]);
-
-    expect(fakeCommand.start).toHaveBeenCalledTimes(1);
-});
-
-it('merges extra env vars into each command', () => {
-    create([
-        { command: 'echo', env: { foo: 'bar' } },
-        { command: 'echo', env: { foo: 'baz' } },
-        'kill'
-    ]);
-
-    expect(spawn).toHaveBeenCalledTimes(3);
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
-        env: expect.objectContaining({ foo: 'bar' })
-    }));
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
-        env: expect.objectContaining({ foo: 'baz' })
-    }));
-    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
-        env: expect.not.objectContaining({ foo: expect.anything() })
-    }));
-});
-
-it('uses cwd from options for each command', () => {
-    create(
-        [
-            { command: 'echo', env: { foo: 'bar' } },
-            { command: 'echo', env: { foo: 'baz' } },
-            'kill'
-        ],
-        {
-            cwd: 'foobar',
-        }
-    );
-
-    expect(spawn).toHaveBeenCalledTimes(3);
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
-        env: expect.objectContaining({ foo: 'bar' }),
-        cwd: 'foobar',
-    }));
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
-        env: expect.objectContaining({ foo: 'baz' }),
-        cwd: 'foobar',
-    }));
-    expect(spawn).toHaveBeenCalledWith('kill', expect.objectContaining({
-        env: expect.not.objectContaining({ foo: expect.anything() }),
-        cwd: 'foobar',
-    }));
-});
-
-it('uses overridden cwd option for each command if specified', () => {
-    create(
-        [
-            { command: 'echo', env: { foo: 'bar' }, cwd: 'baz' },
-            { command: 'echo', env: { foo: 'baz' } },
-        ],
-        {
-            cwd: 'foobar',
-        }
-    );
-
-    expect(spawn).toHaveBeenCalledTimes(2);
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
-        env: expect.objectContaining({ foo: 'bar' }),
-        cwd: 'baz',
-    }));
-    expect(spawn).toHaveBeenCalledWith('echo', expect.objectContaining({
-        env: expect.objectContaining({ foo: 'baz' }),
-        cwd: 'foobar',
-    }));
-});
-
-it('runs onFinish hook after all commands run', async () => {
-    const promise = create(['foo', 'bar'], { maxProcesses: 1 });
-    expect(spawn).toHaveBeenCalledTimes(1);
-    expect(controllers[0].onFinish).not.toHaveBeenCalled();
-    expect(controllers[1].onFinish).not.toHaveBeenCalled();
-
-    processes[0].emit('close', 0, null);
-    expect(spawn).toHaveBeenCalledTimes(2);
-    expect(controllers[0].onFinish).not.toHaveBeenCalled();
-    expect(controllers[1].onFinish).not.toHaveBeenCalled();
-
-    processes[1].emit('close', 0, null);
-    await promise;
-
-    expect(controllers[0].onFinish).toHaveBeenCalled();
-    expect(controllers[1].onFinish).toHaveBeenCalled();
-});

package/src/defaults.js

@@ -1,31 +0,0 @@
-/**
- * This file is meant to be a shared place for default configs.
- * It's read by the flow controllers, the executable, etc.
- *
- * Refer to tests for the meaning of the different possible values.
- */
-module.exports = {
-    defaultInputTarget: 0,
-    // Whether process.stdin should be forwarded to child processes
-    handleInput: false,
-    // How many processes to run at once
-    maxProcesses: 0,
-    nameSeparator: ',',
-    // Which prefix style to use when logging processes output.
-    prefix: '',
-    // Refer to https://www.npmjs.com/package/chalk
-    prefixColors: 'reset',
-    // How many bytes we'll show on the command prefix
-    prefixLength: 10,
-    raw: false,
-    // Number of attempts of restarting a process, if it exits with non-0 code
-    restartTries: 0,
-    // How many milliseconds concurrently should wait before restarting a process.
-    restartDelay: 0,
-    // Condition of success for concurrently itself.
-    success: 'all',
-    // Refer to https://date-fns.org/v2.0.1/docs/format
-    timestampFormat: 'yyyy-MM-dd HH:mm:ss.SSS',
-    // Current working dir passed as option to spawn command. Default: process.cwd()
-    cwd: undefined
-};

package/src/flow-control/base-handler.js

@@ -1,16 +0,0 @@
-module.exports = class BaseHandler {
-    constructor(options = {}) {
-        const { logger } = options;
-
-        this.logger = logger;
-    }
-
-    handle(commands) {
-        return {
-            commands,
-            // an optional callback to call when all commands have finished
-            // (either successful or not)
-            onFinish: null,
-        };
-    }
-};

package/src/flow-control/input-handler.js

@@ -1,50 +0,0 @@
-const Rx = require('rxjs');
-const { map } = require('rxjs/operators');
-
-const defaults = require('../defaults');
-const BaseHandler = require('./base-handler');
-
-module.exports = class InputHandler extends BaseHandler {
-    constructor({ defaultInputTarget, inputStream, pauseInputStreamOnFinish, logger }) {
-        super({ logger });
-
-        this.defaultInputTarget = defaultInputTarget || defaults.defaultInputTarget;
-        this.inputStream = inputStream;
-        this.pauseInputStreamOnFinish = pauseInputStreamOnFinish !== false;
-    }
-
-    handle(commands) {
-        if (!this.inputStream) {
-            return { commands };
-        }
-
-        Rx.fromEvent(this.inputStream, 'data')
-            .pipe(map(data => data.toString()))
-            .subscribe(data => {
-                let [targetId, input] = data.split(/:(.+)/);
-                targetId = input ? targetId : this.defaultInputTarget;
-                input = input || data;
-
-                const command = commands.find(command => (
-                    command.name === targetId ||
-                    command.index.toString() === targetId.toString()
-                ));
-
-                if (command && command.stdin) {
-                    command.stdin.write(input);
-                } else {
-                    this.logger.logGlobalEvent(`Unable to find command ${targetId}, or it has no stdin open\n`);
-                }
-            });
-
-        return {
-            commands,
-            onFinish: () => {
-                if (this.pauseInputStreamOnFinish) {
-                    // https://github.com/kimmobrunfeldt/concurrently/issues/252
-                    this.inputStream.pause();
-                }
-            },
-        };
-    }
-};

package/src/flow-control/input-handler.spec.js

@@ -1,113 +0,0 @@
-const stream = require('stream');
-const { createMockInstance } = require('jest-create-mock-instance');
-
-const Logger = require('../logger');
-const createFakeCommand = require('./fixtures/fake-command');
-const InputHandler = require('./input-handler');
-
-let commands, controller, inputStream, logger;
-
-beforeEach(() => {
-    commands = [
-        createFakeCommand('foo', 'echo foo', 0),
-        createFakeCommand('bar', 'echo bar', 1),
-    ];
-    inputStream = new stream.PassThrough();
-    logger = createMockInstance(Logger);
-    controller = new InputHandler({
-        defaultInputTarget: 0,
-        inputStream,
-        logger
-    });
-});
-
-it('returns same commands', () => {
-    expect(controller.handle(commands)).toMatchObject({ commands });
-
-    controller = new InputHandler({ logger });
-    expect(controller.handle(commands)).toMatchObject({ commands });
-});
-
-it('forwards input stream to default target ID', () => {
-    controller.handle(commands);
-
-    inputStream.write('something');
-
-    expect(commands[0].stdin.write).toHaveBeenCalledTimes(1);
-    expect(commands[0].stdin.write).toHaveBeenCalledWith('something');
-    expect(commands[1].stdin.write).not.toHaveBeenCalled();
-});
-
-it('forwards input stream to target index specified in input', () => {
-    controller.handle(commands);
-
-    inputStream.write('1:something');
-
-    expect(commands[0].stdin.write).not.toHaveBeenCalled();
-    expect(commands[1].stdin.write).toHaveBeenCalledTimes(1);
-    expect(commands[1].stdin.write).toHaveBeenCalledWith('something');
-});
-
-it('forwards input stream to target index specified in input when input contains colon', () => {
-    controller.handle(commands);
-
-    inputStream.emit('data', Buffer.from('1::something'));
-    inputStream.emit('data', Buffer.from('1:some:thing'));
-
-    expect(commands[0].stdin.write).not.toHaveBeenCalled();
-    expect(commands[1].stdin.write).toHaveBeenCalledTimes(2);
-    expect(commands[1].stdin.write).toHaveBeenCalledWith(':something');
-    expect(commands[1].stdin.write).toHaveBeenCalledWith('some:thing');
-});
-
-it('forwards input stream to target name specified in input', () => {
-    controller.handle(commands);
-
-    inputStream.write('bar:something');
-
-    expect(commands[0].stdin.write).not.toHaveBeenCalled();
-    expect(commands[1].stdin.write).toHaveBeenCalledTimes(1);
-    expect(commands[1].stdin.write).toHaveBeenCalledWith('something');
-});
-
-it('logs error if command has no stdin open', () => {
-    commands[0].stdin = null;
-    controller.handle(commands);
-
-    inputStream.write('something');
-
-    expect(commands[1].stdin.write).not.toHaveBeenCalled();
-    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Unable to find command 0, or it has no stdin open\n');
-});
-
-it('logs error if command is not found', () => {
-    controller.handle(commands);
-
-    inputStream.write('foobar:something');
-
-    expect(commands[0].stdin.write).not.toHaveBeenCalled();
-    expect(commands[1].stdin.write).not.toHaveBeenCalled();
-    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Unable to find command foobar, or it has no stdin open\n');
-});
-
-it('pauses input stream when finished', () => {
-    expect(inputStream.readableFlowing).toBeNull();
-
-    const { onFinish } = controller.handle(commands);
-    expect(inputStream.readableFlowing).toBe(true);
-
-    onFinish();
-    expect(inputStream.readableFlowing).toBe(false);
-});
-
-it('does not pause input stream when pauseInputStreamOnFinish is set to false', () => {
-    controller = new InputHandler({ inputStream, pauseInputStreamOnFinish: false });
-
-    expect(inputStream.readableFlowing).toBeNull();
-
-    const { onFinish } = controller.handle(commands);
-    expect(inputStream.readableFlowing).toBe(true);
-
-    onFinish();
-    expect(inputStream.readableFlowing).toBe(true);
-});

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

@@ -1,79 +0,0 @@
-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,38 +0,0 @@
-const _ = require('lodash');
-const { filter, map } = require('rxjs/operators');
-
-const BaseHandler = require('./base-handler');
-
-module.exports = class KillOthers extends BaseHandler {
-    constructor({ logger, conditions }) {
-        super({ logger });
-
-        this.conditions = _.castArray(conditions);
-    }
-
-    handle(commands) {
-        const conditions = this.conditions.filter(condition => (
-            condition === 'failure' ||
-            condition === 'success'
-        ));
-
-        if (!conditions.length) {
-            return { commands };
-        }
-
-        const closeStates = commands.map(command => command.close.pipe(
-            map(({ exitCode }) => exitCode === 0 ? 'success' : 'failure'),
-            filter(state => conditions.includes(state))
-        ));
-
-        closeStates.forEach(closeState => closeState.subscribe(() => {
-            const killableCommands = commands.filter(command => command.killable);
-            if (killableCommands.length) {
-                this.logger.logGlobalEvent('Sending SIGTERM to other processes..');
-                killableCommands.forEach(command => command.kill());
-            }
-        }));
-
-        return { commands };
-    }
-};

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

@@ -1,66 +0,0 @@
-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,18 +0,0 @@
-const { of } = require('rxjs');
-
-const BaseHandler = require('./base-handler');
-
-module.exports = class LogExit extends BaseHandler {
-    handle(commands) {
-        commands.forEach(command => command.error.subscribe(event => {
-            this.logger.logCommandEvent(
-                `Error occurred when executing command: ${command.command}`,
-                command
-            );
-
-            this.logger.logCommandEvent(event.stack || event, command);
-        }));
-
-        return { commands };
-    }
-};

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

@@ -1,40 +0,0 @@
-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,11 +0,0 @@
-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 };
-    }
-};