concurrently 5.3.0 → 6.1.0

package/src/command.spec.js

@@ -0,0 +1,167 @@
+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(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');
+            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.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();
+    });
+});

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

@@ -16,7 +16,8 @@ const defaults = {
     spawn,
     kill: treeKill,
     raw: false,
-    controllers: []
+    controllers: [],
+    cwd: undefined,
 };
 
 module.exports = (commands, options) => {
@@ -37,7 +38,11 @@ module.exports = (commands, options) => {
         .map((command, index) => new Command(
             Object.assign({
                 index,
-                spawnOpts: getSpawnOpts({ raw: options.raw, env: command.env }),
+                spawnOpts: getSpawnOpts({
+                    raw: options.raw,
+                    env: command.env,
+                    cwd: command.cwd || options.cwd,
+                }),
                 killProcess: options.kill,
                 spawn: options.spawn,
             }, command)
@@ -64,6 +69,7 @@ function mapToCommandInfo(command) {
         name: command.name || '',
         prefixColor: command.prefixColor || '',
         env: command.env || {},
+        cwd: command.cwd || '',
     };
 }
 

package/src/concurrently.spec.js

@@ -0,0 +1,167 @@
+const EventEmitter = require('events');
+
+const createFakeCommand = require('./flow-control/fixtures/fake-command');
+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 = [{ handle: jest.fn(arg => arg) }, { handle: jest.fn(arg => arg) }];
+});
+
+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([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',
+    }));
+});

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,
@@ -25,5 +25,7 @@ module.exports = {
     // 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'
+    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/input-handler.js

@@ -18,7 +18,7 @@ module.exports = class InputHandler {
         Rx.fromEvent(this.inputStream, 'data')
             .pipe(map(data => data.toString()))
             .subscribe(data => {
-                let [targetId, input] = data.split(':', 2);
+                let [targetId, input] = data.split(/:(.+)/);
                 targetId = input ? targetId : this.defaultInputTarget;
                 input = input || data;
 

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

@@ -0,0 +1,91 @@
+const EventEmitter = require('events');
+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 EventEmitter();
+    logger = createMockInstance(Logger);
+    controller = new InputHandler({
+        defaultInputTarget: 0,
+        inputStream,
+        logger
+    });
+});
+
+it('returns same commands', () => {
+    expect(controller.handle(commands)).toBe(commands);
+
+    controller = new InputHandler({ logger });
+    expect(controller.handle(commands)).toBe(commands);
+});
+
+it('forwards input stream to default target ID', () => {
+    controller.handle(commands);
+
+    inputStream.emit('data', Buffer.from('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.emit('data', Buffer.from('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.emit('data', Buffer.from('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.emit('data', Buffer.from('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.emit('data', Buffer.from('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');
+});

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 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 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 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');
+});