@servicetitan/startup 30.3.0 → 31.0.0

package/src/cli/utils/__tests__/pipe-stdout.test.ts

@@ -0,0 +1,39 @@
+import execa from 'execa';
+import { pipeStdout } from '../pipe-stdout';
+
+describe(`${pipeStdout.name}`, () => {
+    const proc = {
+        stdout: { on: jest.fn(), off: jest.fn() },
+    } as unknown as execa.ExecaChildProcess;
+
+    const subject = () => pipeStdout(proc);
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+    });
+
+    test('subscribes to stdout', () => {
+        subject();
+
+        expect(proc.stdout!.on).toHaveBeenCalledWith('data', expect.any(Function));
+    });
+
+    test('unsubscribes from stdout', () => {
+        const unsubscribe = subject();
+        const handler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+        unsubscribe();
+
+        expect(proc.stdout!.off).toHaveBeenCalledWith('data', handler);
+    });
+
+    test('handler writes output to stdout', () => {
+        subject();
+
+        const handler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+        handler('output');
+
+        expect(globalThis.process.stdout.write).toHaveBeenCalledWith('output');
+    });
+});

package/src/cli/utils/__tests__/process-tree.test.ts

@@ -0,0 +1,175 @@
+import { HandlerResult, ProcessTree } from '../process-tree';
+
+enum TestProcesses {
+    A,
+    B,
+    C,
+}
+
+describe(`[startup] ${ProcessTree.name}`, () => {
+    const createProcess = (
+        name: number,
+        timeout: number,
+        { watchMode = false, returnObject }: { watchMode?: boolean; returnObject?: boolean } = {}
+    ) => {
+        output.push(`started:${name}`);
+        if (watchMode) {
+            return {
+                process: new Promise(() => {}),
+                onComplete: new Promise<void>(resolve =>
+                    setTimeout(() => {
+                        output.push(`completed:${name}`);
+                        resolve();
+                    }, timeout)
+                ),
+            };
+        }
+        const promise = new Promise<void>(resolve =>
+            setTimeout(() => {
+                output.push(`finished:${name}`);
+                resolve();
+            }, timeout)
+        );
+        return returnObject ? promise : { process: promise };
+    };
+
+    const subject = async () => {
+        const processTree = new ProcessTree<typeof TestProcesses>();
+
+        [TestProcesses.A, TestProcesses.B, TestProcesses.C].forEach(id => {
+            processTree.add(id, handlers[id], {
+                ...(dependsOn[id] ? { dependsOn: dependsOn[id] } : {}),
+            });
+        });
+
+        processTree.run();
+
+        await jest.runAllTimersAsync();
+
+        return processTree;
+    };
+
+    let handlers: Record<TestProcesses, () => HandlerResult>;
+    let dependsOn: { [key in TestProcesses]?: TestProcesses[] };
+    let output: string[] = [];
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+        jest.clearAllMocks();
+        output = [];
+        handlers = {
+            [TestProcesses.A]: () => {
+                return createProcess(TestProcesses.A, 3000);
+            },
+            [TestProcesses.B]: () => {
+                return createProcess(TestProcesses.B, 2000);
+            },
+            [TestProcesses.C]: () => {
+                return createProcess(TestProcesses.C, 1000);
+            },
+        };
+        dependsOn = {};
+    });
+
+    function itRunsProcessesInParallel() {
+        test('runs processes in parallel', async () => {
+            await subject();
+            expect(output).toEqual([
+                `started:${TestProcesses.A}`,
+                `started:${TestProcesses.B}`,
+                `started:${TestProcesses.C}`,
+                `finished:${TestProcesses.C}`,
+                `finished:${TestProcesses.B}`,
+                `finished:${TestProcesses.A}`,
+            ]);
+        });
+    }
+
+    itRunsProcessesInParallel();
+
+    describe('when handler returns an object', () => {
+        beforeEach(() => {
+            handlers[TestProcesses.A] = () =>
+                createProcess(TestProcesses.A, 3000, { returnObject: true });
+        });
+
+        itRunsProcessesInParallel();
+    });
+
+    describe('when processes have dependencies', () => {
+        beforeEach(() => (dependsOn[TestProcesses.B] = [TestProcesses.A]));
+
+        test('waits for dependency to finish', async () => {
+            await subject();
+            expect(output).toEqual([
+                `started:${TestProcesses.A}`,
+                `started:${TestProcesses.C}`,
+                `finished:${TestProcesses.C}`,
+                `finished:${TestProcesses.A}`,
+                `started:${TestProcesses.B}`,
+                `finished:${TestProcesses.B}`,
+            ]);
+        });
+
+        describe('when dependency is in watch mode', () => {
+            beforeEach(() => {
+                handlers[TestProcesses.A] = () =>
+                    createProcess(TestProcesses.A, 3000, { watchMode: true });
+            });
+
+            test('waits for dependency to complete initialization', async () => {
+                await subject();
+                expect(output).toEqual([
+                    `started:${TestProcesses.A}`,
+                    `started:${TestProcesses.C}`,
+                    `finished:${TestProcesses.C}`,
+                    `completed:${TestProcesses.A}`,
+                    `started:${TestProcesses.B}`,
+                    `finished:${TestProcesses.B}`,
+                ]);
+            });
+        });
+
+        describe('when more than one process depends on another', () => {
+            beforeEach(() => (dependsOn[TestProcesses.C] = [TestProcesses.A]));
+
+            test('processes wait for dependencies to finish', async () => {
+                await subject();
+                expect(output).toEqual([
+                    `started:${TestProcesses.A}`,
+                    `finished:${TestProcesses.A}`,
+                    `started:${TestProcesses.B}`,
+                    `started:${TestProcesses.C}`,
+                    `finished:${TestProcesses.C}`,
+                    `finished:${TestProcesses.B}`,
+                ]);
+            });
+        });
+
+        describe('when process depends on multiple processes', () => {
+            beforeEach(() => {
+                dependsOn[TestProcesses.C] = [TestProcesses.A, TestProcesses.B];
+            });
+            test('waits for all dependencies to finish', async () => {
+                await subject();
+                expect(output).toEqual([
+                    `started:${TestProcesses.A}`,
+                    `finished:${TestProcesses.A}`,
+                    `started:${TestProcesses.B}`,
+                    `finished:${TestProcesses.B}`,
+                    `started:${TestProcesses.C}`,
+                    `finished:${TestProcesses.C}`,
+                ]);
+            });
+        });
+    });
+
+    test("throws when dependency doesn't exist", () => {
+        const processTree = new ProcessTree<typeof TestProcesses>();
+        expect(() =>
+            processTree.add(TestProcesses.A, handlers[TestProcesses.A], {
+                dependsOn: [TestProcesses.B],
+            })
+        ).toThrow(/Unknown process dependency/);
+    });
+});

package/src/cli/utils/__tests__/set-node-options.test.ts

@@ -1,6 +1,6 @@
 import os from 'os';
 import { getConfigurationSafe } from '../../../utils';
-import { CommandName } from '../../../utils/get-configuration';
+import { Command } from '../../commands';
 
 import { setNodeOptions } from '../set-node-options';
 
@@ -13,21 +13,37 @@ jest.mock('../../../utils', () => ({
     getConfigurationSafe: jest.fn(() => ({})),
 }));
 
+class MockCommand implements Command {
+    get greedy() {
+        return true;
+    }
+
+    description() {
+        return 'mock command';
+    }
+
+    async execute() {
+        return Promise.resolve();
+    }
+}
+
 describe(`[startup] utils:${setNodeOptions.name}`, () => {
     const MB = 1024 * 1024;
     const DEFAULT_SIZE = 8192;
     const originalNodeOptions = process.env.NODE_OPTIONS;
     const maxOldSpaceSize = `--max_old_space_size=${DEFAULT_SIZE}`;
-    const command = CommandName.build;
+    const commandName: any = 'mock';
+    const command = new MockCommand();
 
     beforeEach(() => {
         delete process.env.NODE_OPTIONS;
         (os.totalmem as jest.Mock).mockReturnValue(16384 * MB);
+        jest.spyOn(command, 'greedy', 'get').mockReturnValue(true);
     });
 
     afterAll(() => (process.env.NODE_OPTIONS = originalNodeOptions));
 
-    const subject = () => setNodeOptions(command);
+    const subject = () => setNodeOptions(commandName, command);
 
     test(`returns true and adds ${maxOldSpaceSize} to process.env.NODE_OPTIONS`, () => {
         expect(subject()).toBe(true);
@@ -35,6 +51,16 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
         expect(process.env.NODE_OPTIONS).toEqual(maxOldSpaceSize);
     });
 
+    describe('when the command is not greedy', () => {
+        beforeEach(() => jest.spyOn(command, 'greedy', 'get').mockReturnValue(false));
+
+        test('returns false and does not set NODE_OPTIONS', () => {
+            expect(subject()).toBe(false);
+
+            expect(process.env.NODE_OPTIONS).toBeUndefined();
+        });
+    });
+
     describe('when system has insufficient memory', () => {
         const totalMem = 4096 * MB;
 
@@ -104,11 +130,11 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
 
             beforeEach(() => (process.env.NODE_OPTIONS = envOptions));
 
-            test("prepends cli's NODE_OPTIONS to existing NODE_OPTIONS", () => {
+            test("appends cli's NODE_OPTIONS to existing NODE_OPTIONS", () => {
                 expect(subject()).toBe(true);
 
                 expect(process.env.NODE_OPTIONS).toEqual(
-                    [maxOldSpaceSize, ...options, envOptions].join(' ')
+                    [maxOldSpaceSize, envOptions, ...options].join(' ')
                 );
             });
         });
@@ -120,7 +146,7 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
         beforeEach(() =>
             (getConfigurationSafe as jest.Mock).mockReturnValue({
                 // eslint-disable-next-line @typescript-eslint/naming-convention
-                [command]: { NODE_OPTIONS: options },
+                [commandName]: { NODE_OPTIONS: options },
             })
         );
 
@@ -130,4 +156,23 @@ describe(`[startup] utils:${setNodeOptions.name}`, () => {
             expect(process.env.NODE_OPTIONS).toBe(`${maxOldSpaceSize} ${options.join(' ')}`);
         });
     });
+
+    describe("when cli's and command's config have duplicate NODE_OPTIONS", () => {
+        const options = ['--no-warning', '--test'];
+
+        beforeEach(() => {
+            (getConfigurationSafe as jest.Mock).mockReturnValue({
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                NODE_OPTIONS: options,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                [commandName]: { NODE_OPTIONS: options },
+            });
+        });
+
+        test('drops duplicate NODE_OPTIONS', () => {
+            subject();
+
+            expect(process.env.NODE_OPTIONS).toBe(`${maxOldSpaceSize} ${options.join(' ')}`);
+        });
+    });
 });

package/src/cli/utils/__tests__/tcm.test.ts

@@ -7,8 +7,8 @@ import fs, { Stats } from 'fs';
 import { getFolders, log } from '../../../utils';
 import * as sassModule from '../compile-sass';
 
-import { styleExtensions } from '..';
-import { tcm, tcmWatch } from '../tcm';
+import { styleExtensions } from '../style-extensions';
+import { tcm } from '../tcm';
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
@@ -27,7 +27,7 @@ describe('[startup] Cli Utils', () => {
 
     beforeEach(() => {
         jest.resetAllMocks();
-        jest.mocked(getFolders).mockReturnValue({ source, destination: undefined });
+        jest.mocked(getFolders).mockReturnValue({ source, destination: 'dist' });
         fs.readdirSync(source).forEach(file => fs.rmSync(`${source}/${file}`));
     });
 
@@ -45,7 +45,12 @@ describe('[startup] Cli Utils', () => {
     }
 
     describe(`${tcm.name}`, () => {
-        const subject = async () => tcm();
+        const subject = async () => tcm(options);
+        let options: Parameters<typeof tcm>[0];
+
+        beforeEach(() => {
+            options = undefined;
+        });
 
         describe.each(styleExtensions)('with %s module', extension => {
             const module = `foo.module.${extension}`;
@@ -73,118 +78,117 @@ describe('[startup] Cli Utils', () => {
                 expect(log.error).toHaveBeenCalledWith(expect.stringContaining('Oops!'));
             });
         });
-    });
 
-    describe(`${tcmWatch.name}`, () => {
-        type Listener = (path: string) => Promise<void>;
-        let watchSpy: jest.SpyInstance;
-        let fsWatcher: Partial<ReturnType<typeof chokidar.watch>>;
+        describe(`watch mode`, () => {
+            type Listener = (path: string) => Promise<void>;
+            let watchSpy: jest.SpyInstance;
+            let fsWatcher: Partial<ReturnType<typeof chokidar.watch>>;
 
-        beforeEach(() => {
-            fsWatcher = { on: jest.fn() };
-            watchSpy = jest.spyOn(chokidar, 'watch').mockReturnValue(fsWatcher as any);
-            fs.writeFileSync(`${source}/foo.bar`, '');
-        });
-
-        const subject = () => tcmWatch();
+            beforeEach(() => {
+                options = { watch: true };
+                fsWatcher = { on: jest.fn() };
+                watchSpy = jest.spyOn(chokidar, 'watch').mockReturnValue(fsWatcher as any);
+                fs.writeFileSync(`${source}/foo.bar`, '');
+            });
 
-        test('watches for new and changed style modules', async () => {
-            await subject();
+            test('watches for new and changed style modules', async () => {
+                await subject();
 
-            expect(watchSpy).toHaveBeenCalledWith(source, {
-                ignored: expect.any(Function),
-                ignoreInitial: true,
+                expect(watchSpy).toHaveBeenCalledWith(source, {
+                    ignored: expect.any(Function),
+                    ignoreInitial: true,
+                });
+                expect(fsWatcher.on).toHaveBeenCalledWith('add', expect.any(Function));
+                expect(fsWatcher.on).toHaveBeenCalledWith('change', expect.any(Function));
             });
-            expect(fsWatcher.on).toHaveBeenCalledWith('add', expect.any(Function));
-            expect(fsWatcher.on).toHaveBeenCalledWith('change', expect.any(Function));
-        });
 
-        function getListener(name: string) {
-            const { calls } = jest.mocked(fsWatcher.on)!.mock;
-            return calls.find(([event]) => event === name)![1] as Listener;
-        }
-
-        describe('"ignored" filter', () => {
-            const styleExtensions = ['.module.css', '.module.scss', '.module.less'];
-            let ignored: (path: string, stats?: Partial<Stats>) => boolean;
-            let filePath: string;
-            let stats: Partial<Stats> | undefined;
-
-            beforeEach(async () => {
-                await tcmWatch();
-                const { calls } = watchSpy.mock;
-                ignored = calls[0][1].ignored;
-                stats = { isFile: () => true };
-            });
+            function getListener(name: string) {
+                const { calls } = jest.mocked(fsWatcher.on)!.mock;
+                return calls.find(([event]) => event === name)![1] as Listener;
+            }
 
-            const subject = () => ignored(filePath, stats);
+            describe('"ignored" filter', () => {
+                const styleExtensions = ['.module.css', '.module.scss', '.module.less'];
+                let ignored: (path: string, stats?: Partial<Stats>) => boolean;
+                let filePath: string;
+                let stats: Partial<Stats> | undefined;
+
+                beforeEach(async () => {
+                    await tcm(options);
+                    const { calls } = watchSpy.mock;
+                    ignored = calls[0][1].ignored;
+                    stats = { isFile: () => true };
+                });
 
-            function itReturns(value: boolean) {
-                test(`returns ${value}`, () => expect(subject()).toBe(value));
-            }
+                const subject = () => ignored(filePath, stats);
 
-            describe.each(styleExtensions)('when path ends with %s', ext => {
-                beforeEach(() => (filePath = `foo${ext}`));
+                function itReturns(value: boolean) {
+                    test(`returns ${value}`, () => expect(subject()).toBe(value));
+                }
 
-                itReturns(false);
-            });
+                describe.each(styleExtensions)('when path ends with %s', ext => {
+                    beforeEach(() => (filePath = `foo${ext}`));
 
-            describe.each(styleExtensions)('when path contains %s', ext => {
-                beforeEach(() => (filePath = `foo${ext}.d.ts`));
+                    itReturns(false);
+                });
 
-                itReturns(true);
-            });
+                describe.each(styleExtensions)('when path contains %s', ext => {
+                    beforeEach(() => (filePath = `foo${ext}.d.ts`));
 
-            describe.each(['', '.scss', '.tsx'])('when path ends with "%s"', ext => {
-                beforeEach(() => (filePath = `foo${ext}`));
+                    itReturns(true);
+                });
 
-                itReturns(true);
+                describe.each(['', '.scss', '.tsx'])('when path ends with "%s"', ext => {
+                    beforeEach(() => (filePath = `foo${ext}`));
 
-                describe('when stats is undefined', () => {
-                    beforeEach(() => (stats = undefined));
+                    itReturns(true);
 
-                    itReturns(false);
-                });
+                    describe('when stats is undefined', () => {
+                        beforeEach(() => (stats = undefined));
 
-                describe('when stats.isFile returns false', () => {
-                    beforeEach(() => (stats = { isFile: () => false }));
+                        itReturns(false);
+                    });
 
-                    itReturns(false);
+                    describe('when stats.isFile returns false', () => {
+                        beforeEach(() => (stats = { isFile: () => false }));
+
+                        itReturns(false);
+                    });
                 });
             });
-        });
 
-        describe('when module is added', () => {
-            const module = 'bar.module.scss';
+            describe('when module is added', () => {
+                const module = 'bar.module.scss';
 
-            const setup = async () => {
-                await subject();
-                mockStylesModule(module, 'bar');
-                await getListener('add')(`${source}/${module}`);
-            };
+                const setup = async () => {
+                    await subject();
+                    mockStylesModule(module, 'bar');
+                    await getListener('add')(`${source}/${module}`);
+                };
 
-            test('generates Typescript definitions for new module', async () => {
-                await setup();
+                test('generates Typescript definitions for new module', async () => {
+                    await setup();
 
-                expectTypeDefinitions(module, 'bar');
+                    expectTypeDefinitions(module, 'bar');
+                });
             });
-        });
 
-        describe('when module is changed', () => {
-            const module = 'baz.module.less';
+            describe('when module is changed', () => {
+                const module = 'baz.module.less';
 
-            const setup = async () => {
-                mockStylesModule(module, 'foo');
-                await subject();
+                const setup = async () => {
+                    mockStylesModule(module, 'foo');
+                    await subject();
 
-                mockStylesModule(module, 'baz');
-                await getListener('change')(`${source}/${module}`);
-            };
+                    mockStylesModule(module, 'baz');
+                    await getListener('change')(`${source}/${module}`);
+                };
 
-            test('generates Typescript definitions for changed module', async () => {
-                await setup();
+                test('generates Typescript definitions for changed module', async () => {
+                    await setup();
 
-                expectTypeDefinitions(module, 'baz');
+                    expectTypeDefinitions(module, 'baz');
+                });
             });
         });
     });

package/src/cli/utils/__tests__/type-check.test.ts

@@ -0,0 +1,47 @@
+import execa from 'execa';
+import { typeCheck } from '../type-check';
+
+jest.mock('execa', () => jest.fn());
+
+describe('[startup] Cli Utils', () => {
+    describe(`${typeCheck.name}`, () => {
+        const packages = ['foo', 'bar'];
+        let args: Parameters<typeof typeCheck>[0];
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            args = { packages };
+        });
+
+        function itRunsTscCompile({ watch }: { watch?: boolean } = {}) {
+            expect(execa).toHaveBeenCalledWith(
+                'startup',
+                [
+                    'task',
+                    'tsc-compile',
+                    ...packages.map(name => `--scope=${name}`),
+                    watch ? '--watch' : undefined,
+                ].filter(i => i !== undefined),
+                { stdio: 'inherit' }
+            );
+        }
+
+        const subject = async () => typeCheck(args);
+
+        test('type checks packages', async () => {
+            await subject();
+
+            itRunsTscCompile();
+        });
+
+        describe('with "watch"', () => {
+            beforeEach(() => (args.watch = true));
+
+            test('type checks packages in watch mode', async () => {
+                await subject();
+
+                itRunsTscCompile({ watch: true });
+            });
+        });
+    });
+});

package/src/cli/utils/__tests__/watch-stdout.test.ts

@@ -0,0 +1,68 @@
+import execa from 'execa';
+import { watchStdout } from '../watch-stdout';
+
+describe(`${watchStdout.name}`, () => {
+    const proc = {
+        stdout: { on: jest.fn(), off: jest.fn() },
+    } as unknown as execa.ExecaChildProcess;
+    let indicator = 'indicator';
+    const handler = jest.fn();
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+        indicator = 'indicator';
+    });
+
+    const subject = () => watchStdout(proc, indicator, handler);
+
+    test('subscribes to stdout', () => {
+        subject();
+
+        expect(proc.stdout!.on).toHaveBeenCalledWith('data', expect.any(Function));
+    });
+
+    test('unsubscribes from stdout', () => {
+        const unsubscribe = subject();
+
+        const stdoutHandler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+        unsubscribe();
+
+        expect(proc.stdout!.off).toHaveBeenCalledWith('data', stdoutHandler);
+    });
+
+    describe('when indicator is empty string', () => {
+        beforeEach(() => {
+            indicator = '';
+        });
+
+        test("doesn't subscribe to stdout", () => {
+            subject();
+
+            expect(proc.stdout!.on).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('stdout handler', () => {
+        beforeEach(() => {
+            subject();
+        });
+
+        test('calls the handler when there is match', () => {
+            const stdoutHandler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+            stdoutHandler(indicator);
+
+            expect(handler).toHaveBeenCalledWith(1);
+        });
+
+        test("doesn't call the handler when there is no match", () => {
+            const stdoutHandler = jest.mocked(proc.stdout!.on).mock.calls[0][1];
+
+            stdoutHandler('abc');
+
+            expect(handler).not.toHaveBeenCalled();
+        });
+    });
+});