concurrently 4.1.2 → 5.1.0

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

package/src/logger.spec.js

@@ -1,178 +0,0 @@
-const { Writable } = require('stream');
-const chalk = require('chalk');
-const { createMockInstance } = require('jest-create-mock-instance');
-const Logger = require('./logger');
-
-let outputStream;
-beforeEach(() => {
-    outputStream = createMockInstance(Writable);
-});
-
-const createLogger = options => {
-    const logger = new Logger(Object.assign({ outputStream }, options));
-    jest.spyOn(logger, 'log');
-    return logger;
-};
-
-describe('#log()', () => {
-    it('writes prefix + text to the output stream', () => {
-        const logger = new Logger({ outputStream });
-        logger.log('foo', 'bar');
-
-        expect(outputStream.write).toHaveBeenCalledTimes(2);
-        expect(outputStream.write).toHaveBeenCalledWith('foo');
-        expect(outputStream.write).toHaveBeenCalledWith('bar');
-    });
-
-    it('writes multiple lines of text with prefix on each', () => {
-        const logger = new Logger({ outputStream });
-        logger.log('foo', 'bar\nbaz\n');
-
-        expect(outputStream.write).toHaveBeenCalledTimes(2);
-        expect(outputStream.write).toHaveBeenCalledWith('foo');
-        expect(outputStream.write).toHaveBeenCalledWith('bar\nfoobaz\n');
-    });
-
-    it('does not prepend prefix if last call did not finish with a LF', () => {
-        const logger = new Logger({ outputStream });
-        logger.log('foo', 'bar');
-        outputStream.write.mockClear();
-        logger.log('foo', 'baz');
-
-        expect(outputStream.write).toHaveBeenCalledTimes(1);
-        expect(outputStream.write).toHaveBeenCalledWith('baz');
-    });
-
-    it('does not prepend prefix or handle text if logger is in raw mode', () => {
-        const logger = new Logger({ outputStream, raw: true });
-        logger.log('foo', 'bar\nbaz\n');
-
-        expect(outputStream.write).toHaveBeenCalledTimes(1);
-        expect(outputStream.write).toHaveBeenCalledWith('bar\nbaz\n');
-    });
-});
-
-describe('#logGlobalEvent()', () => {
-    it('does nothing if in raw mode', () => {
-        const logger = createLogger({ raw: true });
-        logger.logGlobalEvent('foo');
-
-        expect(logger.log).not.toHaveBeenCalled();
-    });
-
-    it('logs in gray dim style with arrow prefix', () => {
-        const logger = createLogger();
-        logger.logGlobalEvent('foo');
-
-        expect(logger.log).toHaveBeenCalledWith(
-            chalk.gray.dim('-->') + ' ',
-            chalk.gray.dim('foo') + '\n'
-        );
-    });
-});
-
-describe('#logCommandText()', () => {
-    it('logs with name if no prefixFormat is set', () => {
-        const logger = createLogger();
-        logger.logCommandText('foo', { name: 'bla' });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[bla]') + ' ', 'foo');
-    });
-
-    it('logs with index if no prefixFormat is set, and command has no name', () => {
-        const logger = createLogger();
-        logger.logCommandText('foo', { index: 2 });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[2]') + ' ', 'foo');
-    });
-
-    it('logs with prefixFormat set to pid', () => {
-        const logger = createLogger({ prefixFormat: 'pid' });
-        logger.logCommandText('foo', {
-            pid: 123,
-            info: {}
-        });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[123]') + ' ', 'foo');
-    });
-
-    it('logs with prefixFormat set to name', () => {
-        const logger = createLogger({ prefixFormat: 'name' });
-        logger.logCommandText('foo', { name: 'bar' });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[bar]') + ' ', 'foo');
-    });
-
-    it('logs with prefixFormat set to index', () => {
-        const logger = createLogger({ prefixFormat: 'index' });
-        logger.logCommandText('foo', { index: 3 });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[3]') + ' ', 'foo');
-    });
-
-    it('logs with prefixFormat set to time (with timestampFormat)', () => {
-        const logger = createLogger({ prefixFormat: 'time', timestampFormat: 'YYYY' });
-        logger.logCommandText('foo', {});
-
-        const year = new Date().getFullYear();
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim(`[${year}]`) + ' ', 'foo');
-    });
-
-    it('logs with templated prefixFormat', () => {
-        const logger = createLogger({ prefixFormat: '{index}-{name}' });
-        logger.logCommandText('foo', { index: 0, name: 'bar' });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('0-bar') + ' ', 'foo');
-    });
-
-    it('logs with no prefix', () => {
-        const logger = createLogger({ prefixFormat: 'none' });
-        logger.logCommandText('foo', { command: 'echo foo' });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim(''), 'foo');
-    });
-
-    it('logs prefix using command line itself', () => {
-        const logger = createLogger({ prefixFormat: 'command' });
-        logger.logCommandText('foo', { command: 'echo foo' });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[echo foo]') + ' ', 'foo');
-    });
-
-    it('logs prefix using command line itself, capped at prefixLength bytes', () => {
-        const logger = createLogger({ prefixFormat: 'command', prefixLength: 6 });
-        logger.logCommandText('foo', { command: 'echo foo' });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[ec..oo]') + ' ', 'foo');
-    });
-
-    it('logs prefix using prefixColor from command', () => {
-        const logger = createLogger();
-        logger.logCommandText('foo', { prefixColor: 'blue', index: 1 });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.blue('[1]') + ' ', 'foo');
-    });
-
-    it('logs prefix in gray dim if prefixColor from command does not exist', () => {
-        const logger = createLogger();
-        logger.logCommandText('foo', { prefixColor: 'blue.fake', index: 1 });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[1]') + ' ', 'foo');
-    });
-});
-
-describe('#logCommandEvent()', () => {
-    it('does nothing if in raw mode', () => {
-        const logger = createLogger({ raw: true });
-        logger.logCommandEvent('foo');
-
-        expect(logger.log).not.toHaveBeenCalled();
-    });
-
-    it('logs text in gray dim', () => {
-        const logger = createLogger();
-        logger.logCommandEvent('foo', { index: 1 });
-
-        expect(logger.log).toHaveBeenCalledWith(chalk.gray.dim('[1]') + ' ', chalk.gray.dim('foo') + '\n');
-    });
-});