@servicetitan/startup 33.1.1 → 34.0.0

package/src/cli/commands/__tests__/build.test.ts

@@ -1,12 +1,14 @@
 /**
  * @jest-environment node
  */
-import { Package, PackageType, getPackages, log } from '../../../utils';
 import { createPackage } from '../../../__mocks__';
-import { lernaExec, compile, typeCheck } from '../../utils';
+import { Package, PackageType, getPackages, log } from '../../../utils';
+import { compile, lernaExec, typeCheck } from '../../utils';
+import { Build } from '../build';
 import { kendoUILicense } from '../kendo-ui-license';
 
-import { Build } from '../build';
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
@@ -60,6 +62,25 @@ describe(`[startup] ${Build.name}`, () => {
         });
     }
 
+    function itRunsPrebuildScript() {
+        describe('when package has "precompile" script', () => {
+            beforeEach(() => {
+                packages[0].scripts = { precompile: 'foo' };
+            });
+
+            test('runs precompile script', async () => {
+                await subject();
+
+                expect(lernaExec).toHaveBeenCalledWith({
+                    cmd: 'npm run precompile',
+                    scope: [packages[0].name],
+                    parallel: true,
+                    stream: true,
+                });
+            });
+        });
+    }
+
     test('command is greedy', () => {
         expect(Build.greedy).toBe(true);
     });
@@ -75,9 +96,10 @@ describe(`[startup] ${Build.name}`, () => {
 
         itPreparesThePackage();
         itRunsCompileAndTypeCheck();
+        itRunsPrebuildScript();
 
         describe('with --use-tsc flag', () => {
-            beforeEach(() => (args['use-tsc'] = true));
+            beforeEach(() => (args.useTsc = true));
 
             itPreparesThePackage();
             itRunsCompileAndTypeCheck({ useTsc: true });
@@ -89,6 +111,7 @@ describe(`[startup] ${Build.name}`, () => {
 
         itPreparesThePackage();
         itRunsCompileAndTypeCheck();
+        itRunsPrebuildScript();
 
         test('registers Kendo UI license', async () => {
             await subject();
@@ -120,7 +143,7 @@ describe(`[startup] ${Build.name}`, () => {
         });
 
         describe('with "code-coverage"', () => {
-            beforeEach(() => (args['code-coverage'] = true));
+            beforeEach(() => (args.codeCoverage = true));
 
             test('enables code-coverage', async () => {
                 await subject();
@@ -165,20 +188,20 @@ describe(`[startup] ${Build.name}`, () => {
         });
 
         describe('with "cdn-path"', () => {
-            beforeEach(() => (args['cdn-path'] = 'https://example.com/foo'));
+            beforeEach(() => (args.cdnPath = 'https://example.com/foo'));
 
             afterEach(() => delete process.env.CLIENT_CDN_PATH);
 
             test('sets process.env.CLIENT_CDN_PATH', async () => {
                 await subject();
 
-                expect(process.env.CLIENT_CDN_PATH).toBe(args['cdn-path']);
+                expect(process.env.CLIENT_CDN_PATH).toBe(args.cdnPath);
             });
         });
     });
 
     describe('with "scope"', () => {
-        beforeEach(() => (args.scope = 'foo'));
+        beforeEach(() => (args.scope = ['foo']));
 
         test('selects scoped packages', async () => {
             await subject();
@@ -190,7 +213,7 @@ describe(`[startup] ${Build.name}`, () => {
     });
 
     describe('with "ignore"', () => {
-        beforeEach(() => (args.ignore = 'foo'));
+        beforeEach(() => (args.ignore = ['foo']));
 
         test('selectively ignores packages', async () => {
             await subject();

package/src/cli/commands/__tests__/bundle-package.test.ts

@@ -1,10 +1,11 @@
 import { fs, vol } from 'memfs';
 import { log } from '../../../utils';
 import { bundle } from '../../utils';
-
 import { BundlePackage } from '../bundle-package';
 
 jest.mock('fs', () => fs);
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),

package/src/cli/commands/__tests__/clean.test.ts

@@ -1,34 +1,125 @@
-import { exec, execSync } from 'child_process';
+import { fs, vol } from 'memfs';
+import { exec, ExecException, execSync } from 'node:child_process';
 import { log } from '../../../utils';
 import { Clean } from '../clean';
 
-jest.mock('child_process', () => ({
+jest.mock('node:fs', () => fs);
+jest.mock('node:child_process', () => ({
     execSync: jest.fn(),
     exec: jest.fn(),
 }));
 
+type ExecCallback = (error: ExecException | null, stdout: string, stderr: string) => void;
+
 describe(`[startup] ${Clean.name}`, () => {
+    const cachePath = '/test-npm-cache';
+    const npxCacheDirectoryName = '_npx';
+
     beforeEach(() => {
         jest.clearAllMocks();
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress output
+        jest.spyOn(log, 'error').mockImplementation(jest.fn()); // suppress output
+        jest.mocked(execSync).mockImplementation((cmd: string) =>
+            cmd === 'npm config get cache' ? cachePath : ''
+        );
+        // @ts-expect-error this is a valid exec overload but TS shows an error
+        jest.mocked(exec).mockImplementation((_cmd: string, callback?: ExecCallback) => {
+            if (callback) {
+                process.nextTick(() => callback(null, '', ''));
+            }
+            return {} as ReturnType<typeof exec>;
+        });
+        vol.fromNestedJSON({
+            [cachePath]: {
+                [npxCacheDirectoryName]: {
+                    'some-package': {},
+                },
+            },
+        });
+    });
+
+    const subject = async () => new Clean({}).execute();
+
+    test('allows running from global location', () => {
+        expect(Clean.allowRunFromGlobal).toBe(true);
     });
 
-    const subject = async () => new Clean().execute();
+    function itLogsError(expectedMessage: string) {
+        test('logs error', async () => {
+            await subject();
+
+            expect(log.error).toHaveBeenCalledWith(expect.stringContaining(expectedMessage));
+        });
+    }
+
+    function itRunsGitClean() {
+        test('runs "git clean -fdX"', async () => {
+            await subject();
+
+            expect(exec).toHaveBeenCalledWith('git clean -fdX', expect.any(Function));
+        });
+    }
+
+    function failExecOn(command: string) {
+        // @ts-expect-error this is a valid exec overload but TS shows an error
+        jest.mocked(exec).mockImplementation((cmd: string, callback?: ExecCallback) => {
+            if (callback) {
+                process.nextTick(() => {
+                    if (cmd === command) {
+                        callback(new Error(`${command} failed`), '', '');
+                    } else {
+                        callback(null, '', '');
+                    }
+                });
+            }
+            return {} as ReturnType<typeof exec>;
+        });
+    }
 
     test.each(['npx nx reset', 'npx jest --clearCache', 'npm cache clear --force'])(
         'runs "%s"',
         async command => {
             await subject();
 
-            expect(execSync).toHaveBeenCalledWith(command, {
-                stdio: ['ignore', 'ignore', 'inherit'],
-            });
+            expect(exec).toHaveBeenCalledWith(command, expect.any(Function));
         }
     );
 
-    test('runs "git clean -fdX"', async () => {
+    itRunsGitClean();
+
+    test('clears npx cache', async () => {
         await subject();
 
-        expect(exec).toHaveBeenCalledWith('git clean -fdX');
+        expect(vol.existsSync(`${cachePath}/${npxCacheDirectoryName}`)).toBe(false);
+    });
+
+    describe('when "npx nx reset" fails', () => {
+        beforeEach(() => {
+            failExecOn('npx nx reset');
+        });
+
+        itLogsError('Error running npx nx reset');
+        itRunsGitClean();
+
+        test('runs remaining commands', async () => {
+            await subject();
+
+            expect(exec).toHaveBeenCalledWith('npx jest --clearCache', expect.any(Function));
+            expect(exec).toHaveBeenCalledWith('npm cache clear --force', expect.any(Function));
+        });
+    });
+
+    describe('when clearing npx cache fails', () => {
+        beforeEach(() => {
+            jest.mocked(execSync).mockImplementation(cmd => {
+                if (cmd === 'npm config get cache') {
+                    throw new Error('cache path error');
+                }
+                return '';
+            });
+        });
+
+        itLogsError('Error clearing npx cache');
+        itRunsGitClean();
     });
 });

package/src/cli/commands/__tests__/convert-eslint-config.test.ts

@@ -1,9 +1,12 @@
-import execa from 'execa';
 import { fs, vol } from 'memfs';
+import { prettify } from '../../../utils';
 import { ConvertEslintConfig } from '../convert-eslint-config';
 
 jest.mock('fs', () => fs);
-jest.mock('execa', () => jest.fn());
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    prettify: jest.fn(),
+}));
 
 describe(`[startup] ${ConvertEslintConfig.name}`, () => {
     const eslintignoreFile = '.eslintignore';
@@ -17,7 +20,7 @@ describe(`[startup] ${ConvertEslintConfig.name}`, () => {
     });
 
     const subject = async () => {
-        await new ConvertEslintConfig().execute();
+        await new ConvertEslintConfig({}).execute();
         return fs.readFileSync(outputFile, 'utf-8').toString();
     };
 
@@ -37,6 +40,10 @@ describe(`[startup] ${ConvertEslintConfig.name}`, () => {
         vol.fromJSON({ [eslintrcFile]: JSON.stringify(config) });
     }
 
+    test('allows running from global location', () => {
+        expect(ConvertEslintConfig.allowRunFromGlobal).toBe(true);
+    });
+
     describe(`when ${eslintrcFile} does not exist`, () => {
         beforeEach(() => fs.rmSync(eslintrcFile));
 
@@ -413,16 +420,14 @@ describe(`[startup] ${ConvertEslintConfig.name}`, () => {
     test('prettifies the output', async () => {
         await subject();
 
-        expect(execa).toHaveBeenCalledWith('npx', ['prettier', '-w', outputFile], {
-            stdout: 'ignore',
-        });
+        expect(prettify).toHaveBeenCalledWith(outputFile);
     });
 
     describe('when prettier fails', () => {
-        const exitCode = 123;
-
         beforeEach(() => {
-            jest.mocked(execa).mockRejectedValue({ exitCode });
+            jest.mocked(prettify).mockRejectedValue(
+                new Error('prettier failed with exit code 123')
+            );
         });
 
         itReportsError(/prettier failed with exit code/);

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

@@ -25,7 +25,7 @@ describe(`[startup] ${ESLintCommand.name}`, () => {
 
             expect(eslint).toHaveBeenCalledWith({
                 fix: args.fix,
-                paths: [...args._, ...args.paths!],
+                paths: [...(args._ ?? []), ...args.paths!],
             });
         });
     });

package/src/cli/commands/__tests__/get-command.test.ts

@@ -2,9 +2,11 @@
  * @jest-environment node
  */
 import { CommandName } from '../../../utils';
-
 import { getCommand } from '../get-command';
 
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 describe(`${getCommand.name}`, () => {
     const subject = (name: CommandName) => getCommand(name);
 

package/src/cli/commands/__tests__/init.test.ts

@@ -2,7 +2,6 @@ import { gitCloneRepo, gitIsReachable } from '@servicetitan/install';
 import fs from 'fs';
 import { vol } from 'memfs';
 import path from 'path';
-
 import { log } from '../../../utils';
 import { Init } from '../init';
 
@@ -26,6 +25,10 @@ describe(`[startup] ${Init.name}`, () => {
 
     const subject = async () => new Init(args).execute();
 
+    test('allows running from global location', () => {
+        expect(Init.allowRunFromGlobal).toBe(true);
+    });
+
     test('clones "frontend-example" to current directory', async () => {
         const cwd = path.resolve('.');
         await subject();
@@ -42,6 +45,16 @@ describe(`[startup] ${Init.name}`, () => {
     describe('when cloning fails', () => {
         beforeEach(() => jest.mocked(gitCloneRepo).mockReturnValue(false));
 
+        describe('when repo is reachable', () => {
+            beforeEach(() => {
+                jest.mocked(gitIsReachable).mockReturnValue(true);
+            });
+
+            test('resolves without error', async () => {
+                await expect(subject()).resolves.toBeUndefined();
+            });
+        });
+
         describe('when repo is not reachable', () => {
             beforeEach(() => {
                 jest.mocked(gitIsReachable).mockReturnValue(false);

package/src/cli/commands/__tests__/install.test.ts

@@ -1,6 +1,5 @@
 import { execSync } from 'child_process';
 import { getStartupVersion, log } from '../../../utils';
-
 import { Install } from '../install';
 
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
@@ -22,13 +21,18 @@ describe(`${Install.name}`, () => {
 
     const subject = async () => new Install(args).execute();
 
+    test('allows running from global location', () => {
+        expect(Install.allowRunFromGlobal).toBe(true);
+    });
+
     test('runs install', async () => {
         await subject();
 
         expect(execSync).toHaveBeenCalledWith(`npx @servicetitan/install`, { stdio: 'inherit' });
     });
 
-    describe.each(['fix', 'quiet', 'token'])('with --%s', option => {
+    const keys = ['fix', 'quiet', 'token'] satisfies (keyof typeof args)[];
+    describe.each(keys)('with --%s', option => {
         beforeEach(() => (args[option] = true));
 
         test(`runs install with --${option}`, async () => {

package/src/cli/commands/__tests__/kendo-ui-license.test.ts

@@ -1,10 +1,11 @@
 import execa from 'execa';
-
 import { log } from '../../../utils';
 import { isModuleInstalled } from '../../utils';
-import { kendoUILicense } from '../kendo-ui-license';
+import { KendoUILicense, kendoUILicense } from '../kendo-ui-license';
 
 jest.mock('execa', () => jest.fn());
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
@@ -24,6 +25,10 @@ describe(`${kendoUILicense.name}`, () => {
 
     const subject = async () => kendoUILicense();
 
+    test('allows running from global location', () => {
+        expect(KendoUILicense.allowRunFromGlobal).toBe(true);
+    });
+
     test('activates license', async () => {
         await subject();
 

package/src/cli/commands/__tests__/lint.test.ts

@@ -1,9 +1,11 @@
-import { Lint } from '../lint';
-import { eslint, lernaExec } from '../../utils';
 import { getPackages } from '../../../utils';
+import { eslint, lernaExec } from '../../utils';
 import { stylelint } from '../../utils/stylelint';
+import { Lint } from '../lint';
 
 jest.mock('stylelint', () => ({ lint: jest.fn() }));
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../utils');
 jest.mock('../../utils/stylelint');