concurrently 4.1.2 → 5.1.0

package/src/command-parser/expand-npm-shortcut.spec.js

@@ -1,36 +0,0 @@
-const ExpandNpmShortcut = require('./expand-npm-shortcut');
-const parser = new ExpandNpmShortcut();
-
-it('returns same command if no npm: prefix is present', () => {
-    const commandInfo = {
-        name: 'echo',
-        command: 'echo foo'
-    };
-    expect(parser.parse(commandInfo)).toBe(commandInfo);
-});
-
-for (const npmCmd of ['npm', 'yarn']) {
-    describe(`with ${npmCmd}: prefix`, () => {
-        it(`expands to "${npmCmd} run <script> <args>"`, () => {
-            const commandInfo = {
-                name: 'echo',
-                command: `${npmCmd}:foo -- bar`
-            };
-            expect(parser.parse(commandInfo)).toEqual({
-                name: 'echo',
-                command: `${npmCmd} run foo -- bar`
-            });
-        });
-
-        it('sets name to script name if none', () => {
-            const commandInfo = {
-                command: `${npmCmd}:foo -- bar`
-            };
-            expect(parser.parse(commandInfo)).toEqual({
-                name: 'foo',
-                command: `${npmCmd} run foo -- bar`
-            });
-        });
-    });
-
-}

package/src/command-parser/expand-npm-wildcard.spec.js

@@ -1,58 +0,0 @@
-const ExpandNpmWildcard = require('./expand-npm-wildcard');
-
-let parser, readPkg;
-
-beforeEach(() => {
-    readPkg = jest.fn();
-    parser = new ExpandNpmWildcard(readPkg);
-});
-
-it('returns same command if not an npm run command', () => {
-    const commandInfo = {
-        command: 'npm test'
-    };
-
-    expect(readPkg).not.toHaveBeenCalled();
-    expect(parser.parse(commandInfo)).toBe(commandInfo);
-});
-
-it('returns same command if no wildcard present', () => {
-    const commandInfo = {
-        command: 'npm run foo bar'
-    };
-
-    expect(readPkg).not.toHaveBeenCalled();
-    expect(parser.parse(commandInfo)).toBe(commandInfo);
-});
-
-it('expands to nothing if no scripts exist in package.json', () => {
-    readPkg.mockReturnValue({});
-
-    expect(parser.parse({ command: 'npm run foo-*-baz qux' })).toEqual([]);
-});
-
-for (const npmCmd of ['npm', 'yarn']) {
-    describe(`with an ${npmCmd}: prefix`, () => {
-        it('expands to all scripts matching pattern', () => {
-            readPkg.mockReturnValue({
-                scripts: {
-                    'foo-bar-baz': '',
-                    'foo--baz': '',
-                }
-            });
-
-            expect(parser.parse({ command: `${npmCmd} run foo-*-baz qux` })).toEqual([
-                { name: 'foo-bar-baz', command: `${npmCmd} run foo-bar-baz qux` },
-                { name: 'foo--baz', command: `${npmCmd} run foo--baz qux` },
-            ]);
-        });
-
-        it('caches scripts upon calls', () => {
-            readPkg.mockReturnValue({});
-            parser.parse({ command: `${npmCmd} run foo-*-baz qux` });
-            parser.parse({ command: `${npmCmd} run foo-*-baz qux` });
-
-            expect(readPkg).toHaveBeenCalledTimes(1);
-        });
-    });
-}

package/src/command-parser/strip-quotes.spec.js

@@ -1,20 +0,0 @@
-const StripQuotes = require('./strip-quotes');
-const parser = new StripQuotes();
-
-it('returns command as is if no single/double quote at the beginning', () => {
-    expect(parser.parse({ command: 'echo foo' })).toEqual({ command: 'echo foo' });
-});
-
-it('strips single quotes', () => {
-    expect(parser.parse({ command: '\'echo foo\'' })).toEqual({ command: 'echo foo' });
-});
-
-it('strips double quotes', () => {
-    expect(parser.parse({ command: '"echo foo"' })).toEqual({ command: 'echo foo' });
-});
-
-it('does not remove quotes if they are impaired', () => {
-    expect(parser.parse({ command: '"echo foo' })).toEqual({ command: '"echo foo' });
-    expect(parser.parse({ command: 'echo foo\'' })).toEqual({ command: 'echo foo\'' });
-    expect(parser.parse({ command: '"echo foo\'' })).toEqual({ command: '"echo foo\'' });
-});

package/src/command.spec.js

@@ -1,142 +0,0 @@
-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).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).toBe('SIGKILL');
-            done();
-        });
-
-        command.start();
-        process.emit('close', null, 'SIGKILL');
-    });
-
-    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

@@ -1,88 +0,0 @@
-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(0);
-        commands[1].close.next(0);
-
-        scheduler.flush();
-
-        return expect(result).resolves.toBeNull();
-    });
-
-    it('fails if one of the processes exited with non-0 code', () => {
-        const result = createController().listen(commands);
-
-        commands[0].close.next(0);
-        commands[1].close.next(1);
-
-        scheduler.flush();
-
-        expect(result).rejects.toThrowError();
-    });
-});
-
-
-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(0);
-        commands[0].close.next(1);
-
-        scheduler.flush();
-
-        return expect(result).resolves.toBeNull();
-    });
-
-    it('fails if first process to exit has non-0 code', () => {
-        const result = createController('first').listen(commands);
-
-        commands[1].close.next(1);
-        commands[0].close.next(0);
-
-        scheduler.flush();
-
-        return expect(result).rejects.toThrowError();
-    });
-});
-
-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(1);
-        commands[0].close.next(0);
-
-        scheduler.flush();
-
-        return expect(result).resolves.toBeNull();
-    });
-
-    it('fails if last process to exit has non-0 code', () => {
-        const result = createController('last').listen(commands);
-
-        commands[1].close.next(0);
-        commands[0].close.next(1);
-
-        scheduler.flush();
-
-        return expect(result).rejects.toThrowError();
-    });
-});

package/src/concurrently.spec.js

@@ -1,77 +0,0 @@
-const EventEmitter = require('events');
-const { Subject } = require('rxjs');
-
-const createFakeCommand = require('./flow-control/fixtures/fake-command');
-const concurrently = require('./concurrently');
-
-let spawn, kill, controllers;
-beforeEach(() => {
-    const process = new EventEmitter();
-    process.pid = 1;
-
-    spawn = jest.fn(() => process);
-    kill = jest.fn();
-    controllers = [{ handle: jest.fn(arg => arg) }, { handle: jest.fn(arg => arg) }];
-});
-
-const create = (commands, options = {}) => concurrently(
-    commands,
-    Object.assign(options, { controllers, spawn, kill })
-);
-
-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('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);
-});

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

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

@@ -1,70 +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 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(1);
-
-    expect(callback).not.toHaveBeenCalledWith('SIGINT');
-    expect(callback).toHaveBeenCalledWith(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(1);
-
-    expect(callback).toHaveBeenCalledWith(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');
-});

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)).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(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(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(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(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

@@ -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)).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]);
-});