concurrently 10.0.0 → 10.0.3

package/dist/lib/flow-control/kill-others.spec.js

@@ -1,98 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { createFakeCloseEvent, createFakeProcess, FakeCommand, } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { KillOthers } from './kill-others.js';
-let commands;
-let logger;
-let abortController;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand()];
-    logger = createMockInstance(Logger);
-    abortController = new AbortController();
-});
-const createWithConditions = (conditions, opts) => new KillOthers({
-    logger,
-    abortController,
-    conditions,
-    killSignal: undefined,
-    ...opts,
-});
-const assignProcess = (command) => {
-    const process = createFakeProcess(1);
-    command.pid = process.pid;
-    command.process = process;
-};
-const unassignProcess = (command) => {
-    command.pid = undefined;
-    command.process = undefined;
-};
-it('returns same commands', () => {
-    expect(createWithConditions(['success']).handle(commands)).toMatchObject({ commands });
-    expect(createWithConditions(['failure']).handle(commands)).toMatchObject({ commands });
-});
-it('does not kill others if condition does not match', () => {
-    createWithConditions(['failure']).handle(commands);
-    assignProcess(commands[1]);
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
-    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
-    expect(commands[0].kill).not.toHaveBeenCalled();
-    expect(commands[1].kill).not.toHaveBeenCalled();
-});
-describe.each(['success', 'failure'])('on %s', (condition) => {
-    const exitCode = condition === 'success' ? 0 : 1;
-    const inversedCode = exitCode === 1 ? 0 : 1;
-    it('kills other processes', () => {
-        createWithConditions([condition]).handle(commands);
-        assignProcess(commands[1]);
-        commands[0].close.next(createFakeCloseEvent({ exitCode }));
-        expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Sending SIGTERM to other processes..');
-        expect(commands[0].kill).not.toHaveBeenCalled();
-        expect(commands[1].kill).toHaveBeenCalledWith(undefined);
-    });
-    it('kills other processes, with specified signal', () => {
-        createWithConditions([condition], { killSignal: 'SIGKILL' }).handle(commands);
-        assignProcess(commands[1]);
-        commands[0].close.next(createFakeCloseEvent({ exitCode }));
-        expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Sending SIGKILL to other processes..');
-        expect(commands[0].kill).not.toHaveBeenCalled();
-        expect(commands[1].kill).toHaveBeenCalledWith('SIGKILL');
-    });
-    it('sends abort signal on condition match', () => {
-        createWithConditions([condition]).handle(commands);
-        commands[0].close.next(createFakeCloseEvent({ exitCode }));
-        expect(abortController.signal.aborted).toBe(true);
-    });
-    it('does not send abort signal on condition mismatch', () => {
-        createWithConditions([condition]).handle(commands);
-        commands[0].close.next(createFakeCloseEvent({ exitCode: inversedCode }));
-        expect(abortController.signal.aborted).toBe(false);
-    });
-});
-it('does nothing if called without conditions', () => {
-    createWithConditions([]).handle(commands);
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
-    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
-    expect(commands[0].kill).not.toHaveBeenCalled();
-    expect(commands[1].kill).not.toHaveBeenCalled();
-});
-it('does not try to kill processes already dead', () => {
-    createWithConditions(['failure']).handle(commands);
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-    expect(logger.logGlobalEvent).not.toHaveBeenCalled();
-    expect(commands[0].kill).not.toHaveBeenCalled();
-    expect(commands[1].kill).not.toHaveBeenCalled();
-});
-it('force kills misbehaving processes after a timeout', () => {
-    vi.useFakeTimers();
-    commands.push(new FakeCommand());
-    createWithConditions(['failure'], { timeoutMs: 500 }).handle(commands);
-    assignProcess(commands[1]);
-    assignProcess(commands[2]);
-    commands[2].kill = vi.fn(() => unassignProcess(commands[2]));
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-    vi.advanceTimersByTime(500);
-    expect(commands[1].kill).toHaveBeenCalledTimes(2);
-    expect(commands[1].kill).toHaveBeenCalledWith('SIGKILL');
-    expect(commands[2].kill).toHaveBeenCalledTimes(1);
-});

package/dist/lib/flow-control/log-error.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/log-error.spec.js

@@ -1,33 +0,0 @@
-import { beforeEach, expect, it } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { FakeCommand } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { LogError } from './log-error.js';
-let controller;
-let logger;
-let commands;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand(), new FakeCommand()];
-    logger = createMockInstance(Logger);
-    controller = new LogError({ logger });
-});
-it('returns same commands', () => {
-    expect(controller.handle(commands)).toMatchObject({ commands });
-});
-it('logs the error event of each command', () => {
-    controller.handle(commands);
-    commands[0].error.next('error from command 0');
-    const error1 = new Error('test');
-    commands[1].error.next(error1);
-    // Testing Error without stack
-    const error2 = new Error('test');
-    error2.stack = '';
-    commands[2].error.next(error2);
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(6);
-    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(error1.stack, commands[1]);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(`Error occurred when executing command: ${commands[2].command}`, commands[2]);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(String(error2), commands[2]);
-});

package/dist/lib/flow-control/log-exit.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/log-exit.spec.js

@@ -1,24 +0,0 @@
-import { beforeEach, expect, it } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { LogExit } from './log-exit.js';
-let controller;
-let logger;
-let commands;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand()];
-    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(createFakeCloseEvent({ exitCode: 0 }));
-    commands[1].close.next(createFakeCloseEvent({ 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/dist/lib/flow-control/log-output.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/log-output.spec.js

@@ -1,33 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { beforeEach, expect, it } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { FakeCommand } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { LogOutput } from './log-output.js';
-let controller;
-let logger;
-let commands;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand()];
-    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/dist/lib/flow-control/log-timings.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/log-timings.spec.js

@@ -1,89 +0,0 @@
-import { beforeEach, expect, it } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
-import { DateFormatter } from '../date-format.js';
-import { Logger } from '../logger.js';
-import { LogTimings } from './log-timings.js';
-// shown in timing order
-const startDate0 = new Date();
-const startDate1 = new Date(startDate0.getTime() + 1000);
-const endDate1 = new Date(startDate0.getTime() + 5000);
-const endDate0 = new Date(startDate0.getTime() + 3000);
-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);
-let controller;
-let logger;
-let commands;
-let command0ExitInfo;
-let command1ExitInfo;
-beforeEach(() => {
-    commands = [new FakeCommand('foo', 'command 1', 0), new FakeCommand('bar', 'command 2', 1)];
-    command0ExitInfo = createFakeCloseEvent({
-        command: commands[0],
-        timings: {
-            startDate: startDate0,
-            endDate: endDate0,
-            durationSeconds: endDate0.getTime() - startDate0.getTime(),
-        },
-        index: commands[0].index,
-    });
-    command1ExitInfo = createFakeCloseEvent({
-        command: commands[1],
-        timings: {
-            startDate: startDate1,
-            endDate: endDate1,
-            durationSeconds: endDate1.getTime() - startDate1.getTime(),
-        },
-        index: commands[1].index,
-    });
-    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({});
-    const { onFinish } = 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 });
-    onFinish?.();
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(0);
-});
-it('logs the timings at the start and end (ie complete or error) event of each command', () => {
-    const formatter = new DateFormatter(timestampFormat);
-    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 ${formatter.format(startDate0)}`, commands[0]);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[1].command} started at ${formatter.format(startDate1)}`, commands[1]);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[1].command} stopped at ${formatter.format(endDate1)} after ${command1DurationTextMs}`, commands[1]);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(`${commands[0].command} stopped at ${formatter.format(endDate0)} after ${command0DurationTextMs}`, commands[0]);
-});
-it('does not log timings summary if there was an error', () => {
-    const { onFinish } = controller.handle(commands);
-    commands[0].close.next(command0ExitInfo);
-    commands[1].error.next(undefined);
-    onFinish?.();
-    expect(logger.logTable).toHaveBeenCalledTimes(0);
-});
-it('logs the sorted timings summary when all processes close successfully after onFinish is called', () => {
-    const { onFinish } = controller.handle(commands);
-    commands[0].close.next(command0ExitInfo);
-    commands[1].close.next(command1ExitInfo);
-    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(0);
-    onFinish?.();
-    expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Timings:');
-    // sorted by duration
-    expect(logger.logTable).toHaveBeenCalledExactlyOnceWith([
-        LogTimings.mapCloseEventToTimingInfo(command1ExitInfo),
-        LogTimings.mapCloseEventToTimingInfo(command0ExitInfo),
-    ]);
-});

package/dist/lib/flow-control/logger-padding.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/logger-padding.spec.js

@@ -1,60 +0,0 @@
-import { beforeEach, expect, it } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { FakeCommand } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { LoggerPadding } from './logger-padding.js';
-let logger;
-let controller;
-let commands;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand()];
-    logger = createMockInstance(Logger);
-    controller = new LoggerPadding({ logger });
-});
-it('returns same commands', () => {
-    expect(controller.handle(commands)).toMatchObject({ commands });
-});
-it('sets the prefix length on handle', () => {
-    controller.handle(commands);
-    expect(logger.setPrefixLength).toHaveBeenCalledTimes(1);
-});
-it('updates the prefix length when commands emit a start timer', () => {
-    controller.handle(commands);
-    commands[0].timer.next({ startDate: new Date() });
-    expect(logger.setPrefixLength).toHaveBeenCalledTimes(2);
-    commands[1].timer.next({ startDate: new Date() });
-    expect(logger.setPrefixLength).toHaveBeenCalledTimes(3);
-});
-it('sets prefix length to the longest prefix of all commands', () => {
-    logger.getPrefixContent
-        .mockReturnValueOnce({ type: 'default', value: 'foobar' })
-        .mockReturnValueOnce({ type: 'default', value: 'baz' });
-    controller.handle(commands);
-    expect(logger.setPrefixLength).toHaveBeenCalledWith(6);
-});
-it('ignores color markers when measuring prefix length', () => {
-    logger.getPrefixContent
-        .mockReturnValueOnce({ type: 'template', value: '{color}foo{/color}' })
-        .mockReturnValueOnce({ type: 'template', value: '{color}abcd{/color}' });
-    controller.handle(commands);
-    expect(logger.setPrefixLength).toHaveBeenCalledWith(4);
-});
-it('does not shorten the prefix length', () => {
-    logger.getPrefixContent
-        .mockReturnValueOnce({ type: 'default', value: '100' })
-        .mockReturnValueOnce({ type: 'default', value: '1' });
-    controller.handle(commands);
-    commands[0].timer.next({ startDate: new Date() });
-    expect(logger.setPrefixLength).toHaveBeenCalledWith(3);
-    commands[0].timer.next({ startDate: new Date() });
-    expect(logger.setPrefixLength).toHaveBeenCalledWith(3);
-});
-it('unsubscribes from start timers on finish', () => {
-    logger.getPrefixContent.mockReturnValue({ type: 'default', value: '1' });
-    const { onFinish } = controller.handle(commands);
-    commands[0].timer.next({ startDate: new Date() });
-    expect(logger.setPrefixLength).toHaveBeenCalledTimes(2);
-    onFinish();
-    commands[0].timer.next({ startDate: new Date() });
-    expect(logger.setPrefixLength).toHaveBeenCalledTimes(2);
-});

package/dist/lib/flow-control/output-error-handler.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/output-error-handler.spec.js

@@ -1,41 +0,0 @@
-import { Writable } from 'node:stream';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { FakeCommand } from '../__fixtures__/fake-command.js';
-import { OutputErrorHandler } from './output-error-handler.js';
-let controller;
-let outputStream;
-let abortController;
-let commands;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand()];
-    abortController = new AbortController();
-    outputStream = new Writable();
-    controller = new OutputErrorHandler({ abortController, outputStream });
-});
-it('returns same commands', () => {
-    expect(controller.handle(commands)).toMatchObject({ commands });
-});
-describe('on output stream error', () => {
-    beforeEach(() => {
-        controller.handle(commands);
-        outputStream.emit('error', new Error('test'));
-    });
-    it('kills every command', () => {
-        expect(commands[0].kill).toHaveBeenCalled();
-        expect(commands[1].kill).toHaveBeenCalled();
-    });
-    it('sends abort signal', () => {
-        expect(abortController.signal.aborted).toBe(true);
-    });
-});
-describe('on finish', () => {
-    it('unsubscribes from output stream error', () => {
-        const { onFinish } = controller.handle(commands);
-        onFinish();
-        outputStream.on('error', vi.fn());
-        outputStream.emit('error', new Error('test'));
-        expect(commands[0].kill).not.toHaveBeenCalled();
-        expect(commands[1].kill).not.toHaveBeenCalled();
-        expect(abortController.signal.aborted).toBe(false);
-    });
-});

package/dist/lib/flow-control/restart-process.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/restart-process.spec.js

@@ -1,127 +0,0 @@
-import { VirtualTimeScheduler } from 'rxjs';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { createFakeCloseEvent, FakeCommand } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { RestartProcess } from './restart-process.js';
-let commands;
-let controller;
-let logger;
-let scheduler;
-beforeEach(() => {
-    commands = [new FakeCommand(), new FakeCommand()];
-    logger = createMockInstance(Logger);
-    // Don't use TestScheduler as it's hardcoded to a max number of "frames" (time),
-    // which don't work for some tests in this suite
-    scheduler = new VirtualTimeScheduler();
-    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(createFakeCloseEvent({ exitCode: 0 }));
-    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
-    scheduler.flush();
-    expect(commands[0].start).toHaveBeenCalledTimes(0);
-    expect(commands[1].start).toHaveBeenCalledTimes(0);
-});
-it('restarts processes that fail immediately, if no delay was passed', () => {
-    controller = new RestartProcess({ logger, scheduler, tries: 1 });
-    controller.handle(commands);
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-    scheduler.flush();
-    expect(scheduler.now()).toBe(0);
-    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(`${commands[0].command} restarted`, commands[0]);
-    expect(commands[0].start).toHaveBeenCalledTimes(1);
-});
-it('restarts processes that fail after delay ms has passed', () => {
-    controller.handle(commands);
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
-    scheduler.flush();
-    expect(scheduler.now()).toBe(100);
-    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(`${commands[0].command} restarted`, commands[0]);
-    expect(commands[0].start).toHaveBeenCalledTimes(1);
-    expect(commands[1].start).not.toHaveBeenCalled();
-});
-it('restarts processes that fail with an exponential back-off', () => {
-    const tries = 4;
-    controller = new RestartProcess({ logger, scheduler, tries, delay: 'exponential' });
-    controller.handle(commands);
-    let time = 0;
-    for (let i = 0; i < tries; i++) {
-        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-        scheduler.flush();
-        time += 2 ** i * 1000;
-        expect(scheduler.now()).toBe(time);
-        expect(logger.logCommandEvent).toHaveBeenCalledTimes(i + 1);
-        expect(commands[0].start).toHaveBeenCalledTimes(i + 1);
-    }
-});
-it('restarts processes up to tries', () => {
-    controller.handle(commands);
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 'SIGTERM' }));
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 'SIGTERM' }));
-    commands[1].close.next(createFakeCloseEvent({ 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(createFakeCloseEvent({ exitCode: 1 }));
-    commands[0].close.next(createFakeCloseEvent({ exitCode: 0 }));
-    commands[1].close.next(createFakeCloseEvent({ exitCode: 0 }));
-    scheduler.flush();
-    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(`${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 = vi.fn();
-        newCommands[0].close.subscribe(callback);
-        newCommands[1].close.subscribe(callback);
-        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-        commands[0].close.next(createFakeCloseEvent({ exitCode: 1 }));
-        commands[1].close.next(createFakeCloseEvent({ exitCode: 1 }));
-        commands[1].close.next(createFakeCloseEvent({ 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/dist/lib/flow-control/teardown.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/lib/flow-control/teardown.spec.js

@@ -1,93 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { createMockInstance } from '../__fixtures__/create-mock-instance.js';
-import { createFakeProcess, FakeCommand } from '../__fixtures__/fake-command.js';
-import { Logger } from '../logger.js';
-import { getSpawnOpts } from '../spawn.js';
-import { Teardown } from './teardown.js';
-let spawn;
-const logger = createMockInstance(Logger);
-const commands = [new FakeCommand()];
-const teardown = 'cowsay bye';
-beforeEach(() => {
-    spawn = vi.fn(() => createFakeProcess(1));
-});
-afterEach(() => {
-    vi.clearAllMocks();
-});
-const create = (teardown) => new Teardown({
-    spawn,
-    logger,
-    commands: teardown,
-});
-it('returns commands unchanged', () => {
-    const { commands: actual } = create([]).handle(commands);
-    expect(actual).toBe(commands);
-});
-describe('onFinish callback', () => {
-    it('does not spawn nothing if there are no teardown commands', () => {
-        create([]).handle(commands).onFinish();
-        expect(spawn).not.toHaveBeenCalled();
-    });
-    it('runs teardown command', () => {
-        create([teardown]).handle(commands).onFinish();
-        expect(spawn).toHaveBeenCalledWith(teardown, getSpawnOpts({ stdio: 'raw' }));
-    });
-    it('waits for teardown command to close', async () => {
-        const child = createFakeProcess(1);
-        spawn.mockReturnValue(child);
-        const result = create([teardown]).handle(commands).onFinish();
-        child.emit('close', 1, null);
-        await expect(result).resolves.toBeUndefined();
-    });
-    it('rejects if teardown command errors (string)', async () => {
-        const child = createFakeProcess(1);
-        spawn.mockReturnValue(child);
-        const result = create([teardown]).handle(commands).onFinish();
-        const error = 'fail';
-        child.emit('error', error);
-        await expect(result).rejects.toBe(error);
-        expect(logger.logGlobalEvent).toHaveBeenLastCalledWith('fail');
-    });
-    it('rejects if teardown command errors (error)', async () => {
-        const child = createFakeProcess(1);
-        spawn.mockReturnValue(child);
-        const result = create([teardown]).handle(commands).onFinish();
-        const error = new Error('fail');
-        child.emit('error', error);
-        await expect(result).rejects.toBe(error);
-        expect(logger.logGlobalEvent).toHaveBeenLastCalledWith(expect.stringMatching(/Error: fail/));
-    });
-    it('rejects if teardown command errors (error, no stack)', async () => {
-        const child = createFakeProcess(1);
-        spawn.mockReturnValue(child);
-        const result = create([teardown]).handle(commands).onFinish();
-        const error = new Error('fail');
-        delete error.stack;
-        child.emit('error', error);
-        await expect(result).rejects.toBe(error);
-        expect(logger.logGlobalEvent).toHaveBeenLastCalledWith('Error: fail');
-    });
-    it('runs multiple teardown commands in sequence', async () => {
-        const child1 = createFakeProcess(1);
-        const child2 = createFakeProcess(2);
-        spawn.mockReturnValueOnce(child1).mockReturnValueOnce(child2);
-        const result = create(['foo', 'bar']).handle(commands).onFinish();
-        expect(spawn).toHaveBeenCalledTimes(1);
-        expect(spawn).toHaveBeenLastCalledWith('foo', getSpawnOpts({ stdio: 'raw' }));
-        child1.emit('close', 1, null);
-        await new Promise((resolve) => setTimeout(resolve));
-        expect(spawn).toHaveBeenCalledTimes(2);
-        expect(spawn).toHaveBeenLastCalledWith('bar', getSpawnOpts({ stdio: 'raw' }));
-        child2.emit('close', 0, null);
-        await expect(result).resolves.toBeUndefined();
-    });
-    it('stops running teardown commands on SIGINT', async () => {
-        const child = createFakeProcess(1);
-        spawn.mockReturnValue(child);
-        const result = create(['foo', 'bar']).handle(commands).onFinish();
-        child.emit('close', null, 'SIGINT');
-        await result;
-        expect(spawn).toHaveBeenCalledTimes(1);
-        expect(spawn).toHaveBeenLastCalledWith('foo', expect.anything());
-    });
-});

package/dist/lib/jsonc.spec.d.ts

@@ -1 +0,0 @@
-export {};