concurrently 6.5.0 → 7.1.0

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 };
-    }
-};

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)).toMatchObject({ commands });
-});
-
-it('logs the close event of each command', () => {
-    controller.handle(commands);
-
-    commands[0].close.next({ exitCode: 0 });
-    commands[1].close.next({ exitCode: '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)).toMatchObject({ 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/log-timings.js

@@ -1,64 +0,0 @@
-const formatDate = require('date-fns/format');
-const Rx = require('rxjs');
-const { bufferCount, take } = require('rxjs/operators');
-const _ = require('lodash');
-const BaseHandler = require('./base-handler');
-
-module.exports = class LogTimings extends BaseHandler {
-    constructor({ logger, timestampFormat }) {
-        super({ logger });
-
-        this.timestampFormat = timestampFormat;
-    }
-
-    printExitInfoTimingTable(exitInfos) {
-        const exitInfoTable = _(exitInfos)
-            .sortBy(({ timings }) => timings.durationSeconds)
-            .reverse()
-            .map(({ command, timings, killed, exitCode }) => {
-                const readableDurationMs = (timings.endDate - timings.startDate).toLocaleString();
-                return {
-                    name: command.name,
-                    duration: `${readableDurationMs}ms`,
-                    'exit code': exitCode,
-                    killed,
-                    command: command.command,
-                };
-            })
-            .value();
-
-        this.logger.logGlobalEvent('Timings:');
-        this.logger.logTable(exitInfoTable);
-        return exitInfos;
-    };
-
-    handle(commands) {
-        if (!this.logger) {
-            return { commands };
-        }
-
-        // individual process timings
-        commands.forEach(command => {
-            command.timer.subscribe(({ startDate, endDate }) => {
-                if (!endDate) {
-                    const formattedStartDate = formatDate(startDate, this.timestampFormat);
-                    this.logger.logCommandEvent(`${command.command} started at ${formattedStartDate}`, command);
-                } else {
-                    const durationMs = endDate.getTime() - startDate.getTime();
-                    const formattedEndDate = formatDate(endDate, this.timestampFormat);
-                    this.logger.logCommandEvent(`${command.command} stopped at ${formattedEndDate} after ${durationMs.toLocaleString()}ms`, command);
-                }
-            });
-        });
-
-        // overall summary timings
-        const closeStreams = commands.map(command => command.close);
-        this.allProcessesClosed = Rx.merge(...closeStreams).pipe(
-            bufferCount(closeStreams.length),
-            take(1),
-        );
-        this.allProcessesClosed.subscribe((exitInfos) => this.printExitInfoTimingTable(exitInfos));
-
-        return { commands };
-    }
-};

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

@@ -1,137 +0,0 @@
-const { createMockInstance } = require('jest-create-mock-instance');
-const formatDate = require('date-fns/format');
-const Logger = require('../logger');
-const LogTimings = require( './log-timings' );
-const createFakeCommand = require('./fixtures/fake-command');
-
-// shown in timing order
-const startDate0 = new Date();
-const startDate1 = new Date(startDate0.getTime() + 1000);
-const endDate1 = new Date(startDate0.getTime() + 3000);
-const endDate0 = new Date(startDate0.getTime() + 5000);
-
-const timestampFormat = 'yyyy-MM-dd HH:mm:ss.SSS';
-const getDurationText = (startDate, endDate) => `${(endDate.getTime() - startDate.getTime()).toLocaleString()}ms`;
-const command0DurationTextMs = getDurationText(startDate0, endDate0);
-const command1DurationTextMs = getDurationText(startDate1, endDate1);
-
-const exitInfoToTimingInfo = ({ command, timings, killed, exitCode }) => {
-    const readableDurationMs = getDurationText(timings.startDate, timings.endDate);
-    return {
-        name: command.name,
-        duration: readableDurationMs,
-        'exit code': exitCode,
-        killed,
-        command: command.command,
-    };
-};
-
-let controller, logger, commands, command0ExitInfo, command1ExitInfo;
-
-beforeEach(() => {
-    commands = [
-        createFakeCommand('foo', 'command 1', 0),
-        createFakeCommand('bar', 'command 2', 1),
-    ];
-
-    command0ExitInfo = {
-        command: commands[0].command,
-        timings: {
-            startDate: startDate0,
-            endDate: endDate0,
-        },
-        index: commands[0].index,
-        killed: false,
-        exitCode: 0,
-    };
-
-    command1ExitInfo = {
-        command: commands[1].command,
-        timings: {
-            startDate: startDate1,
-            endDate: endDate1,
-        },
-        index: commands[1].index,
-        killed: false,
-        exitCode: 0,
-    };
-
-    logger = createMockInstance(Logger);
-    controller = new LogTimings({ logger, timestampFormat });
-});
-
-it('returns same commands', () => {
-    expect(controller.handle(commands)).toMatchObject({ commands });
-});
-
-it('does not log timings and doesn\'t throw if no logger is provided', () => {
-    controller = new LogTimings({  });
-    controller.handle(commands);
-
-    commands[0].timer.next({ startDate: startDate0 });
-    commands[1].timer.next({ startDate: startDate1 });
-    commands[1].timer.next({ startDate: startDate1, endDate: endDate1 });
-    commands[0].timer.next({ startDate: startDate0, endDate: endDate0 });
-
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(0);
-});
-
-it('logs the timings at the start and end (ie complete or error) event of each command', () => {
-    controller.handle(commands);
-
-    commands[0].timer.next({ startDate: startDate0 });
-    commands[1].timer.next({ startDate: startDate1 });
-    commands[1].timer.next({ startDate: startDate1, endDate: endDate1 });
-    commands[0].timer.next({ startDate: startDate0, endDate: endDate0 });
-
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(4);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
-        `${commands[0].command} started at ${formatDate(startDate0, timestampFormat)}`,
-        commands[0]
-    );
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
-        `${commands[1].command} started at ${formatDate(startDate1, timestampFormat)}`,
-        commands[1]
-    );
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
-        `${commands[1].command} stopped at ${formatDate(endDate1, timestampFormat)} after ${command1DurationTextMs}`,
-        commands[1]
-    );
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
-        `${commands[0].command} stopped at ${formatDate(endDate0, timestampFormat)} after ${command0DurationTextMs}`,
-        commands[0]
-    );
-});
-
-it('does not log timings summary if there was an error', () => {
-    controller.handle(commands);
-
-    commands[0].close.next(command0ExitInfo);
-    commands[1].error.next();
-
-    expect(logger.logTable).toHaveBeenCalledTimes(0);
-
-});
-
-it('logs the sorted timings summary when all processes close successfully', () => {
-    jest.spyOn(controller, 'printExitInfoTimingTable');
-    controller.handle(commands);
-
-    commands[0].close.next(command0ExitInfo);
-    commands[1].close.next(command1ExitInfo);
-
-    expect(logger.logTable).toHaveBeenCalledTimes(1);
-
-    // un-sorted ie by finish order
-    expect(controller.printExitInfoTimingTable).toHaveBeenCalledWith([
-        command0ExitInfo,
-        command1ExitInfo
-    ]);
-
-    // sorted by duration
-    expect(logger.logTable).toHaveBeenCalledWith([
-        exitInfoToTimingInfo(command1ExitInfo),
-        exitInfoToTimingInfo(command0ExitInfo)
-    ]);
-
-});

package/src/flow-control/restart-process.js

@@ -1,56 +0,0 @@
-const Rx = require('rxjs');
-const { defaultIfEmpty, delay, filter, mapTo, skip, take, takeWhile } = require('rxjs/operators');
-
-const defaults = require('../defaults');
-const BaseHandler = require('./base-handler');
-
-module.exports = class RestartProcess extends BaseHandler {
-    constructor({ delay, tries, logger, scheduler }) {
-        super({ logger });
-
-        this.delay = +delay || defaults.restartDelay;
-        this.tries = +tries || defaults.restartTries;
-        this.tries = this.tries < 0 ? Infinity : this.tries;
-        this.scheduler = scheduler;
-    }
-
-    handle(commands) {
-        if (this.tries === 0) {
-            return { commands };
-        }
-
-        commands.map(command => command.close.pipe(
-            take(this.tries),
-            takeWhile(({ exitCode }) => exitCode !== 0)
-        )).map((failure, index) => Rx.merge(
-            // Delay the emission (so that the restarts happen on time),
-            // explicitly telling the subscriber that a restart is needed
-            failure.pipe(delay(this.delay, this.scheduler), mapTo(true)),
-            // Skip the first N emissions (as these would be duplicates of the above),
-            // meaning it will be empty because of success, or failed all N times,
-            // and no more restarts should be attempted.
-            failure.pipe(skip(this.tries), defaultIfEmpty(false))
-        ).subscribe(restart => {
-            const command = commands[index];
-            if (restart) {
-                this.logger.logCommandEvent(`${command.command} restarted`, command);
-                command.start();
-            }
-        }));
-
-        return {
-            commands: commands.map(command => {
-                const closeStream = command.close.pipe(filter(({ exitCode }, emission) => {
-                    // We let all success codes pass, and failures only after restarting won't happen again
-                    return exitCode === 0 || emission >= this.tries;
-                }));
-
-                return new Proxy(command, {
-                    get(target, prop) {
-                        return prop === 'close' ? closeStream : target[prop];
-                    }
-                });
-            })
-        };
-    }
-};

package/src/flow-control/restart-process.spec.js

@@ -1,139 +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({ exitCode: 0 });
-    commands[1].close.next({ exitCode: 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({ exitCode: 1 });
-    commands[1].close.next({ exitCode: 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({ exitCode: 1 });
-    commands[0].close.next({ exitCode: 'SIGTERM' });
-    commands[0].close.next({ exitCode: 'SIGTERM' });
-    commands[1].close.next({ exitCode: 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('restart processes forever, if tries is negative', () => {
-    controller = new RestartProcess({
-        logger,
-        scheduler,
-        delay: 100,
-        tries: -1
-    });
-    expect(controller.tries).toBe(Infinity);
-});
-
-it('restarts processes until they succeed', () => {
-    controller.handle(commands);
-
-    commands[0].close.next({ exitCode: 1 });
-    commands[0].close.next({ exitCode: 0 });
-    commands[1].close.next({ exitCode: 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)).toMatchObject({ commands });
-    });
-
-    it('are not the same, but with same length if 1+ tries are to be attempted', () => {
-        const { commands: newCommands } = controller.handle(commands);
-        expect(newCommands).not.toBe(commands);
-        expect(newCommands).toHaveLength(commands.length);
-    });
-
-    it('skip close events followed by restarts', () => {
-        const { commands: newCommands } = controller.handle(commands);
-
-        const callback = jest.fn();
-        newCommands[0].close.subscribe(callback);
-        newCommands[1].close.subscribe(callback);
-
-        commands[0].close.next({ exitCode: 1 });
-        commands[0].close.next({ exitCode: 1 });
-        commands[0].close.next({ exitCode: 1 });
-        commands[1].close.next({ exitCode: 1 });
-        commands[1].close.next({ exitCode: 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 { 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);
-        });
-    });
-});

package/src/get-spawn-opts.js

@@ -1,16 +0,0 @@
-const supportsColor = require('supports-color');
-
-module.exports = ({
-    colorSupport = supportsColor.stdout,
-    cwd,
-    process = global.process,
-    raw = false,
-    env = {},
-}) => Object.assign(
-    {
-        cwd: cwd || process.cwd(),
-    },
-    raw && { stdio: 'inherit' },
-    /^win/.test(process.platform) && { detached: false },
-    { env: Object.assign(colorSupport ? { FORCE_COLOR: colorSupport.level } : {}, process.env, env) }
-);

package/src/get-spawn-opts.spec.js

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