concurrently 5.0.0 → 5.2.0

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

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

@@ -1,36 +0,0 @@
-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(0);
-    commands[1].close.next('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

@@ -1,41 +0,0 @@
-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.spec.js

@@ -1,129 +0,0 @@
-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(0);
-    commands[1].close.next(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(1);
-    commands[1].close.next(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(1);
-    commands[0].close.next('SIGTERM');
-    commands[0].close.next('SIGTERM');
-    commands[1].close.next(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('restarts processes until they succeed', () => {
-    controller.handle(commands);
-
-    commands[0].close.next(1);
-    commands[0].close.next(0);
-    commands[1].close.next(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(1);
-        commands[0].close.next(1);
-        commands[0].close.next(1);
-        commands[1].close.next(1);
-        commands[1].close.next(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

@@ -1,18 +0,0 @@
-const getSpawnOpts = require('./get-spawn-opts');
-
-it('sets detached mode to false for Windows platform', () => {
-    expect(getSpawnOpts({ process: { platform: 'win32' } }).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' } };
-    expect(getSpawnOpts({ process, colorSupport: false }).env).toBeUndefined();
-    expect(getSpawnOpts({ process, colorSupport: { level: 1 } }).env).toEqual({
-        FORCE_COLOR: 1,
-        foo: 'bar'
-    });
-});