concurrently 6.0.2 → 6.2.2

package/src/command.spec.js

@@ -0,0 +1,183 @@
+const EventEmitter = require('events');
+const Command = require('./command');
+
+const createProcess = () => {
+    const process = new EventEmitter();
+    process.pid = 1;
+    return process;
+};
+
+const createProcessWithIO = () => {
+    const process = createProcess();
+    return Object.assign(process, {
+        stdout: new EventEmitter(),
+        stderr: new EventEmitter(),
+        stdin: new EventEmitter()
+    });
+};
+
+describe('#start()', () => {
+    it('spawns process with given command and options', () => {
+        const spawn = jest.fn().mockReturnValue(createProcess());
+        const command = new Command({
+            spawn,
+            spawnOpts: { bla: true },
+            command: 'echo foo',
+        });
+        command.start();
+
+        expect(spawn).toHaveBeenCalledTimes(1);
+        expect(spawn).toHaveBeenCalledWith(command.command, { bla: true });
+    });
+
+    it('sets stdin, process and PID', () => {
+        const process = createProcessWithIO();
+        const command = new Command({ spawn: () => process });
+
+        command.start();
+        expect(command.process).toBe(process);
+        expect(command.pid).toBe(process.pid);
+        expect(command.stdin).toBe(process.stdin);
+    });
+
+    it('shares errors to the error stream', done => {
+        const process = createProcess();
+        const command = new Command({ spawn: () => process });
+
+        command.error.subscribe(data => {
+            expect(data).toBe('foo');
+            expect(command.process).toBeUndefined();
+            done();
+        });
+
+        command.start();
+        process.emit('error', 'foo');
+    });
+
+    it('shares closes to the close stream with exit code', done => {
+        const process = createProcess();
+        const command = new Command({ spawn: () => process });
+
+        command.close.subscribe(data => {
+            expect(data.exitCode).toBe(0);
+            expect(data.killed).toBe(false);
+            expect(command.process).toBeUndefined();
+            done();
+        });
+
+        command.start();
+        process.emit('close', 0, null);
+    });
+
+    it('shares closes to the close stream with signal', done => {
+        const process = createProcess();
+        const command = new Command({ spawn: () => process });
+
+        command.close.subscribe(data => {
+            expect(data.exitCode).toBe('SIGKILL');
+            expect(data.killed).toBe(false);
+            done();
+        });
+
+        command.start();
+        process.emit('close', null, 'SIGKILL');
+    });
+
+    it('shares closes to the close stream with command info and index', done => {
+        const process = createProcess();
+        const commandInfo = {
+            command: 'cmd',
+            name: 'name',
+            prefixColor: 'green',
+            env: { VAR: 'yes' },
+        };
+        const command = new Command(
+            Object.assign({
+                index: 1,
+                spawn: () => process
+            }, commandInfo)
+        );
+
+        command.close.subscribe(data => {
+            expect(data.command).toEqual(commandInfo);
+            expect(data.killed).toBe(false);
+            expect(data.index).toBe(1);
+            done();
+        });
+
+        command.start();
+        process.emit('close', 0, null);
+    });
+
+    it('shares stdout to the stdout stream', done => {
+        const process = createProcessWithIO();
+        const command = new Command({ spawn: () => process });
+
+        command.stdout.subscribe(data => {
+            expect(data.toString()).toBe('hello');
+            done();
+        });
+
+        command.start();
+        process.stdout.emit('data', Buffer.from('hello'));
+    });
+
+    it('shares stderr to the stdout stream', done => {
+        const process = createProcessWithIO();
+        const command = new Command({ spawn: () => process });
+
+        command.stderr.subscribe(data => {
+            expect(data.toString()).toBe('dang');
+            done();
+        });
+
+        command.start();
+        process.stderr.emit('data', Buffer.from('dang'));
+    });
+});
+
+describe('#kill()', () => {
+    let process, killProcess, command;
+    beforeEach(() => {
+        process = createProcess();
+        killProcess = jest.fn();
+        command = new Command({ spawn: () => process, killProcess });
+    });
+
+    it('kills process', () => {
+        command.start();
+        command.kill();
+
+        expect(killProcess).toHaveBeenCalledTimes(1);
+        expect(killProcess).toHaveBeenCalledWith(command.pid, undefined);
+    });
+
+    it('kills process with some signal', () => {
+        command.start();
+        command.kill('SIGKILL');
+
+        expect(killProcess).toHaveBeenCalledTimes(1);
+        expect(killProcess).toHaveBeenCalledWith(command.pid, 'SIGKILL');
+    });
+
+    it('does not try to kill inexistent process', () => {
+        command.start();
+        process.emit('error');
+        command.kill();
+
+        expect(killProcess).not.toHaveBeenCalled();
+    });
+
+    it('marks the command as killed', done => {
+        command.start();
+        
+        command.close.subscribe(data => {
+            expect(data.exitCode).toBe(1);
+            expect(data.killed).toBe(true);
+            done();
+        });
+
+        command.kill();
+        process.emit('close', 1, null);
+    });
+});

package/src/completion-listener.js

@@ -1,5 +1,5 @@
 const Rx = require('rxjs');
-const { bufferCount, map, switchMap, take } = require('rxjs/operators');
+const { bufferCount, switchMap, take } = require('rxjs/operators');
 
 module.exports = class CompletionListener {
     constructor({ successCondition, scheduler }) {

package/src/completion-listener.spec.js

@@ -0,0 +1,88 @@
+const { TestScheduler } = require('rxjs/testing');
+
+const createFakeCommand = require('./flow-control/fixtures/fake-command');
+const CompletionListener = require('./completion-listener');
+
+let commands, scheduler;
+beforeEach(() => {
+    commands = [createFakeCommand('foo'), createFakeCommand('bar')];
+    scheduler = new TestScheduler();
+});
+
+const createController = successCondition =>
+    new CompletionListener({
+        successCondition,
+        scheduler
+    });
+
+describe('with default success condition set', () => {
+    it('succeeds if all processes exited with code 0', () => {
+        const result = createController().listen(commands);
+
+        commands[0].close.next({ exitCode: 0 });
+        commands[1].close.next({ exitCode: 0 });
+
+        scheduler.flush();
+
+        return expect(result).resolves.toEqual([{ exitCode: 0 }, { exitCode: 0 }]);
+    });
+
+    it('fails if one of the processes exited with non-0 code', () => {
+        const result = createController().listen(commands);
+
+        commands[0].close.next({ exitCode: 0 });
+        commands[1].close.next({ exitCode: 1 });
+
+        scheduler.flush();
+
+        expect(result).rejects.toEqual([{ exitCode: 0 }, { exitCode: 1 }]);
+    });
+});
+
+describe('with success condition set to first', () => {
+    it('succeeds if first process to exit has code 0', () => {
+        const result = createController('first').listen(commands);
+
+        commands[1].close.next({ exitCode: 0 });
+        commands[0].close.next({ exitCode: 1 });
+
+        scheduler.flush();
+
+        return expect(result).resolves.toEqual([{ exitCode: 0 }, { exitCode: 1 }]);
+    });
+
+    it('fails if first process to exit has non-0 code', () => {
+        const result = createController('first').listen(commands);
+
+        commands[1].close.next({ exitCode: 1 });
+        commands[0].close.next({ exitCode: 0 });
+
+        scheduler.flush();
+
+        return expect(result).rejects.toEqual([{ exitCode: 1 }, { exitCode: 0 }]);
+    });
+});
+
+describe('with success condition set to last', () => {
+    it('succeeds if last process to exit has code 0', () => {
+        const result = createController('last').listen(commands);
+
+        commands[1].close.next({ exitCode: 1 });
+        commands[0].close.next({ exitCode: 0 });
+
+        scheduler.flush();
+
+        return expect(result).resolves.toEqual([{ exitCode: 1 }, { exitCode: 0 }]);
+    });
+
+    it('fails if last process to exit has non-0 code', () => {
+        const result = createController('last').listen(commands);
+
+        commands[1].close.next({ exitCode: 0 });
+        commands[0].close.next({ exitCode: 1 });
+
+        scheduler.flush();
+
+        return expect(result).rejects.toEqual([{ exitCode: 0 }, { exitCode: 1 }]);
+    });
+});

package/src/concurrently.js

@@ -49,10 +49,17 @@ module.exports = (commands, options) => {
         ))
         .value();
 
-    commands = options.controllers.reduce(
-        (prevCommands, controller) => controller.handle(prevCommands),
-        commands
+    const handleResult = options.controllers.reduce(
+        ({ commands: prevCommands, onFinishCallbacks }, controller) => {
+            const { commands, onFinish } = controller.handle(prevCommands);
+            return {
+                commands,
+                onFinishCallbacks: _.concat(onFinishCallbacks, onFinish ? [onFinish] : [])
+            };
+        },
+        { commands, onFinishCallbacks: [] }
     );
+    commands = handleResult.commands;
 
     const commandsLeft = commands.slice();
     const maxProcesses = Math.max(1, Number(options.maxProcesses) || commandsLeft.length);
@@ -60,7 +67,11 @@ module.exports = (commands, options) => {
         maybeRunMore(commandsLeft);
     }
 
-    return new CompletionListener({ successCondition: options.successCondition }).listen(commands);
+    return new CompletionListener({ successCondition: options.successCondition })
+        .listen(commands)
+        .finally(() => {
+            handleResult.onFinishCallbacks.forEach((onFinish) => onFinish());
+        });
 };
 
 function mapToCommandInfo(command) {

package/src/concurrently.spec.js

@@ -0,0 +1,186 @@
+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('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

@@ -14,7 +14,7 @@ module.exports = {
     // Which prefix style to use when logging processes output.
     prefix: '',
     // Refer to https://www.npmjs.com/package/chalk
-    prefixColors: 'gray.dim',
+    prefixColors: 'reset',
     // How many bytes we'll show on the command prefix
     prefixLength: 10,
     raw: false,

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

@@ -0,0 +1,16 @@
+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

@@ -2,17 +2,20 @@ 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 });
 
-module.exports = class InputHandler {
-    constructor({ defaultInputTarget, inputStream, logger }) {
         this.defaultInputTarget = defaultInputTarget || defaults.defaultInputTarget;
         this.inputStream = inputStream;
-        this.logger = logger;
+        this.pauseInputStreamOnFinish = pauseInputStreamOnFinish !== false;
     }
 
     handle(commands) {
         if (!this.inputStream) {
-            return commands;
+            return { commands };
         }
 
         Rx.fromEvent(this.inputStream, 'data')
@@ -34,6 +37,14 @@ module.exports = class InputHandler {
                 }
             });
 
-        return commands;
+        return {
+            commands,
+            onFinish: () => {
+                if (this.pauseInputStreamOnFinish) {
+                    // https://github.com/kimmobrunfeldt/concurrently/issues/252
+                    this.inputStream.pause();
+                }
+            },
+        };
     }
 };

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

@@ -0,0 +1,113 @@
+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);
+});