@servicetitan/startup 22.14.0 → 22.16.0

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

@@ -0,0 +1,91 @@
+import mockFS from 'mock-fs';
+import { ESLint } from 'eslint';
+
+import { eslint } from '../eslint';
+
+jest.mock('eslint');
+
+describe(`[startup] utils:${eslint.name}`, () => {
+    const mockResult = { filePath: 'foo' } as ESLint.LintResult;
+
+    let mockESLint: Partial<ESLint>;
+    let eslintArgs: Parameters<typeof eslint>[0];
+    let eslintResults: ESLint.LintResult[];
+    let eslintErrors: ESLint.LintResult[];
+
+    beforeEach(() => jest.resetAllMocks());
+
+    beforeEach(() => {
+        mockESLint = {
+            lintFiles: jest.fn(() => Promise.resolve(eslintResults)),
+            loadFormatter: () => Promise.resolve({ format: () => '' }),
+        };
+        (ESLint as any).mockImplementation(() => mockESLint);
+        ESLint.getErrorResults = jest.fn(() => eslintErrors);
+        ESLint.outputFixes = jest.fn();
+    });
+
+    beforeEach(() => {
+        eslintArgs = { paths: ['foo', 'bar'] };
+        eslintResults = [mockResult];
+        eslintErrors = [];
+    });
+
+    const subject = async () => eslint(eslintArgs);
+
+    test('lints .ts and .tsx files', async () => {
+        await subject();
+
+        expect(ESLint).toHaveBeenCalledWith(
+            expect.objectContaining({
+                extensions: ['.ts', '.tsx'],
+            })
+        );
+        expect(mockESLint.lintFiles).toHaveBeenCalledWith(eslintArgs.paths);
+    });
+
+    describe('when instructed to fix issues', () => {
+        beforeEach(() => (eslintArgs.fix = true));
+
+        test('applies fixes', async () => {
+            await subject();
+
+            expect(ESLint.outputFixes).toHaveBeenCalledWith(eslintResults);
+        });
+    });
+
+    describe('when there are errors', () => {
+        beforeEach(() => (eslintErrors = [mockResult]));
+
+        test('sets process exitCode', async () => {
+            await subject();
+
+            expect(process.exitCode).toBeGreaterThan(0);
+        });
+    });
+
+    describe('with no paths', () => {
+        beforeEach(() => (eslintArgs.paths = []));
+
+        test('lints the current directory', async () => {
+            await subject();
+
+            expect(mockESLint.lintFiles).toHaveBeenCalledWith([process.cwd()]);
+        });
+    });
+
+    describe('when disabled', () => {
+        const config = JSON.stringify({
+            cli: { lint: { eslint: { disabled: true } } },
+        });
+
+        beforeEach(() => mockFS({ 'package.json': config }));
+        afterEach(() => mockFS.restore());
+
+        test('does nothing', async () => {
+            await subject();
+
+            expect(mockESLint.lintFiles).not.toHaveBeenCalled();
+        });
+    });
+});

package/src/cli/utils/__tests__/get-module-type.test.ts

@@ -0,0 +1,56 @@
+import mockFS from 'mock-fs';
+import { getModuleType } from '../get-module-type';
+
+describe('[startup] Cli Utils', () => {
+    describe(`${getModuleType.name}`, () => {
+        const tsconfig = 'tsconfig.json';
+
+        beforeEach(() => mockFS({ [tsconfig]: JSON.stringify({}) }));
+
+        afterEach(() => mockFS.restore());
+
+        const subject = (configPath?: string) => getModuleType(configPath ?? `./${tsconfig}`);
+
+        test('returns commonjs', () => {
+            expect(subject()).toBe('commonjs');
+        });
+
+        describe('when config file contains compilerOptions.module', () => {
+            const module = 'foo';
+
+            beforeEach(() => {
+                mockFS({ [tsconfig]: JSON.stringify({ compilerOptions: { module } }) });
+            });
+
+            test('returns configured module', () => {
+                expect(subject()).toBe(module);
+            });
+        });
+
+        describe('when config extends another', () => {
+            const module = 'bar';
+
+            beforeEach(() => {
+                mockFS({
+                    'tsconfig.json': JSON.stringify({
+                        extends: '@servicetitan/startup/tsconfig/base',
+                    }),
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    'node_modules': {
+                        '@servicetitan': {
+                            startup: {
+                                tsconfig: {
+                                    'base.json': JSON.stringify({ compilerOptions: { module } }),
+                                },
+                            },
+                        },
+                    },
+                });
+            });
+
+            test("returns extended config's module", () => {
+                expect(subject()).toBe(module);
+            });
+        });
+    });
+});

package/src/cli/utils/__tests__/is-module-installed.test.ts

@@ -0,0 +1,24 @@
+import mockFS from 'mock-fs';
+
+import { isModuleInstalled } from '../is-module-installed';
+
+describe(`[startup] Cli Utils`, () => {
+    describe(`${isModuleInstalled.name}`, () => {
+        afterEach(() => mockFS.restore());
+
+        const subject = (name: string) => isModuleInstalled(name);
+
+        test('returns false', () => {
+            expect(subject('foo')).toBe(false);
+        });
+
+        describe('when module exists', () => {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            beforeEach(() => mockFS({ node_modules: { bar: { 'index.js': '' } } }));
+
+            test('returns true', () => {
+                expect(subject('bar')).toBe(true);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,131 @@
+import os from 'os';
+import { getConfiguration } from '../../../utils';
+
+import { setNodeOptions } from '../set-node-options';
+
+jest.mock('os', () => ({
+    totalmem: jest.fn(),
+}));
+
+jest.mock('../../../utils', () => ({
+    getConfiguration: jest.fn(() => ({})),
+}));
+
+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 = 'foo';
+
+    beforeEach(() => {
+        delete process.env.NODE_OPTIONS;
+        (os.totalmem as jest.Mock).mockReturnValue(16384 * MB);
+    });
+
+    afterAll(() => (process.env.NODE_OPTIONS = originalNodeOptions));
+
+    const subject = () => setNodeOptions(command);
+
+    test(`returns true and adds ${maxOldSpaceSize} to process.env.NODE_OPTIONS`, () => {
+        expect(subject()).toBe(true);
+
+        expect(process.env.NODE_OPTIONS).toEqual(maxOldSpaceSize);
+    });
+
+    describe('when system has insufficient memory', () => {
+        const totalMem = 4096 * MB;
+
+        beforeEach(() => (os.totalmem as jest.Mock).mockReturnValue(totalMem));
+
+        test('reduces --max_old_space_size to 512 less than total memory', () => {
+            expect(subject()).toBe(true);
+
+            const match = process.env.NODE_OPTIONS!.match(/max_old_space_size=(?<size>\d+)/);
+            expect(Number(match?.groups!.size)).toBe(totalMem / MB - 512);
+        });
+    });
+
+    describe('with existing process.env.NODE_OPTIONS', () => {
+        const options = '--no-warnings';
+
+        beforeEach(() => (process.env.NODE_OPTIONS = options));
+
+        test('prepends --max_old_space_size to existing NODE_OPTIONS', () => {
+            expect(subject()).toBe(true);
+
+            expect(process.env.NODE_OPTIONS).toEqual(`${maxOldSpaceSize} ${options}`);
+        });
+    });
+
+    describe('with existing NODE_OPTIONS contains --max_old_space_size', () => {
+        const options = '--max_old_space_size=1024';
+
+        beforeEach(() => (process.env.NODE_OPTIONS = options));
+
+        test('returns false and does not change NODE_OPTIONS', () => {
+            expect(subject()).toBe(false);
+
+            expect(process.env.NODE_OPTIONS).toEqual(options);
+        });
+    });
+
+    describe("when cli's config has NODE_OPTIONS", () => {
+        let options: string[];
+
+        beforeEach(() => {
+            options = ['--no-warning', '--test'];
+            (getConfiguration as jest.Mock).mockImplementation(() => ({
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                NODE_OPTIONS: options,
+            }));
+        });
+
+        test("adds --max_old_space_size to cli's NODE_OPTIONS", () => {
+            expect(subject()).toBe(true);
+
+            expect(process.env.NODE_OPTIONS).toBe(`${maxOldSpaceSize} ${options.join(' ')}`);
+        });
+
+        describe("when cli's NODE_OPTIONS contains --max_old_space_size", () => {
+            beforeEach(() => options.push('--max_old_space_size=1024'));
+
+            test("does not change cli's NODE_OPTIONS", () => {
+                expect(subject()).toBe(true);
+
+                expect(process.env.NODE_OPTIONS).toEqual(options.join(' '));
+            });
+        });
+
+        describe('with existing process.env.NODE_OPTIONS', () => {
+            const envOptions = '--inspect-publish-uid=http';
+
+            beforeEach(() => (process.env.NODE_OPTIONS = envOptions));
+
+            test("prepends cli's NODE_OPTIONS to existing NODE_OPTIONS", () => {
+                expect(subject()).toBe(true);
+
+                expect(process.env.NODE_OPTIONS).toEqual(
+                    [maxOldSpaceSize, ...options, envOptions].join(' ')
+                );
+            });
+        });
+    });
+
+    describe("when command's config has NODE_OPTIONS", () => {
+        const options = ['--no-warning', '--test'];
+
+        beforeEach(() =>
+            (getConfiguration as jest.Mock).mockReturnValue({
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                [command]: { NODE_OPTIONS: options },
+            })
+        );
+
+        test("adds --max_old_space_size to command's NODE_OPTIONS", () => {
+            expect(subject()).toBe(true);
+
+            expect(process.env.NODE_OPTIONS).toBe(`${maxOldSpaceSize} ${options.join(' ')}`);
+        });
+    });
+});

package/src/cli/utils/__tests__/styles-copy.test.ts

@@ -1,52 +1,56 @@
-jest.mock('../../../utils/get-folders');
-
-import fs from 'fs';
-import mock from 'mock-fs';
-import { mocked } from 'ts-jest/utils';
-
+import cpx from 'cpx';
 import { getFolders } from '../../../utils';
-import { stylesCopy } from '..';
-
-describe('[Startup] utils:styles-copy', () => {
-    beforeAll(() => {
-        mocked(getFolders).mockReturnValue({ source: 'src', destination: 'dist' });
-    });
-
-    afterAll(() => {
-        mock.restore();
-    });
 
-    test('stylesCopy saves structure', async () => {
-        mock({
-            src: {
-                '1.css': '1.css',
-                'a': { '2.css': '2.css' },
-                'b': { c: { '3.css': '3.css' } },
-            },
+import { stylesCopy, stylesCopyWatch } from '../styles-copy';
+import { styleExtensions } from '../index';
+
+jest.mock('cpx', () => ({
+    copy: jest.fn().mockImplementation((...args: any[]) => {
+        const callback = args[args.length - 1];
+        callback(null);
+    }),
+    watch: jest.fn(() => ({ on: (_eventName: string, listener: Function) => listener() })),
+}));
+jest.mock('../../../utils', () => ({
+    getFolders: jest.fn(),
+    log: { info: jest.fn() }, // suppress log output
+}));
+
+describe('[startup] Cli Utils (Styles)', () => {
+    const source = 'foo';
+    const destination = 'bar';
+
+    beforeEach(() => jest.mocked(getFolders).mockReturnValue({ source, destination }));
+
+    describe(`${stylesCopy.name}`, () => {
+        const subject = async () => stylesCopy();
+
+        test('copies styles from source to destination', async () => {
+            await subject();
+
+            expect(cpx.copy).toHaveBeenCalledWith(
+                `${source}/**/*.{${styleExtensions.join()}}`,
+                destination,
+                expect.anything()
+            );
         });
-
-        await stylesCopy();
-
-        expect(fs.existsSync('./dist/1.css')).toBeTruthy();
-        expect(fs.existsSync('./dist/a/2.css')).toBeTruthy();
-        expect(fs.existsSync('./dist/b/c/3.css')).toBeTruthy();
     });
 
-    test('stylesCopy copies only enabled style files', async () => {
-        mock({
-            src: {
-                '1.css': '1.css',
-                '2.tsx': '2.tsx',
-                '3.scss': '3.scss',
-                '4.less': '4.less',
-                '5.ts': '5.ts',
-            },
+    describe(`${stylesCopyWatch.name}`, () => {
+        const subject = () => stylesCopyWatch();
+
+        test('copies styles from source to destination in watch mode', async () => {
+            try {
+                await subject();
+            } catch (error: any) {
+                // ignore rejected promise that terminates watch()
+            }
+
+            expect(cpx.watch).toHaveBeenCalledWith(
+                `${source}/**/*.{${styleExtensions.join()}}`,
+                destination,
+                { initialCopy: false }
+            );
         });
-
-        await stylesCopy();
-
-        expect(fs.existsSync('./dist/1.css')).toBeTruthy();
-        expect(fs.existsSync('./dist/3.scss')).toBeTruthy();
-        expect(fs.existsSync('./dist/4.less')).toBeTruthy();
     });
 });