@servicetitan/startup 31.6.0 → 32.0.1

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

@@ -2,40 +2,38 @@ import { fs, vol } from 'memfs';
 import { mkdirSync, rmSync } from 'fs';
 import path from 'path';
 
+import { log } from '../../../utils';
+import { gitCloneRepo, gitIsReachable } from '../../utils';
 import { Init } from '../init';
-import { runCommand, runCommandOutput } from '../../utils/cli-os';
 
 jest.mock('fs', () => fs);
-jest.mock('../../utils//cli-os', () => ({ runCommand: jest.fn(), runCommandOutput: jest.fn() }));
+jest.mock('../../utils', () => ({
+    gitCloneRepo: jest.fn(),
+    gitIsReachable: jest.fn(),
+}));
 jest.mock('../../../utils', () => ({
-    log: { info: jest.fn() }, // suppress log output
+    log: { debug: jest.fn(), error: jest.fn(), info: jest.fn() },
 }));
 
-const webUrl = 'https://github.com/servicetitan/frontend-example.git';
-const sshUrl = 'git@github.com:servicetitan/frontend-example.git';
-
 describe(`[startup] ${Init.name}`, () => {
     let args: ConstructorParameters<typeof Init>[0];
 
     beforeEach(() => {
         args = {};
         vol.reset();
-        jest.clearAllMocks();
-        jest.mocked(runCommand).mockImplementation(jest.fn());
-        jest.mocked(runCommandOutput).mockImplementation(jest.fn());
+        jest.mocked(gitCloneRepo).mockResolvedValue(true);
         jest.spyOn(fs, 'mkdirSync').mockImplementation(jest.fn());
         jest.spyOn(fs, 'rmSync').mockImplementation(jest.fn());
+        jest.spyOn(log, 'error').mockImplementation(jest.fn()); // suppress error output
     });
 
     const subject = async () => new Init(args).execute();
 
-    test(`clones ${webUrl} to current directory`, async () => {
+    test('clones "frontend-example" to current directory', async () => {
         const cwd = path.resolve('.');
         await subject();
 
-        expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${cwd}`, {
-            quiet: true,
-        });
+        expect(gitCloneRepo).toHaveBeenCalledWith({ destination: cwd, name: 'frontend-example' });
         expect(rmSync).toHaveBeenCalledWith(path.join(cwd, '.git'), {
             recursive: true,
             force: true,
@@ -44,59 +42,18 @@ describe(`[startup] ${Init.name}`, () => {
         expect(rmSync).toHaveBeenCalledWith(path.join(cwd, 'package-lock.json'));
     });
 
-    describe(`when cloning ${webUrl} fails`, () => {
-        beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
-
-        test(`clones ${sshUrl} to current directory`, async () => {
-            await subject();
-
-            expect(runCommand).toHaveBeenCalledWith(
-                `git clone -q ${sshUrl} ${path.resolve('.')}`,
-                expect.anything()
-            );
-        });
+    describe('when cloning fails', () => {
+        beforeEach(() => jest.mocked(gitCloneRepo).mockResolvedValue(false));
 
-        describe(`when cloning ${sshUrl} also fails`, () => {
+        describe('when repo is not reachable', () => {
             beforeEach(() => {
-                jest.mocked(runCommand).mockRejectedValue('Nope!');
-            });
-
-            test(`checks if ${webUrl} is reachable`, async () => {
-                await subject();
-
-                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
-                    quiet: true,
-                });
+                jest.mocked(gitIsReachable).mockReturnValue(false);
             });
 
-            describe(`when ${webUrl} is not reachable`, () => {
-                beforeEach(() => {
-                    jest.mocked(runCommandOutput).mockImplementationOnce(() => {
-                        throw new Error('Oops!');
-                    });
-                });
-
-                test(`checks if ${sshUrl} is reachable`, async () => {
-                    await subject();
-
-                    expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
-                        quiet: true,
-                    });
-                });
-
-                describe(`when ${sshUrl} is also unreachable`, () => {
-                    beforeEach(() =>
-                        jest.mocked(runCommandOutput).mockImplementation(() => {
-                            throw new Error('Oops');
-                        })
-                    );
-
-                    test('raises error', async () => {
-                        await expect(subject()).rejects.toThrow(
-                            /could not read servicetitan\/frontend-example repository/
-                        );
-                    });
-                });
+            test('raises error', async () => {
+                await expect(subject()).rejects.toThrow(
+                    /could not read servicetitan\/frontend-example repository/
+                );
             });
         });
     });
@@ -104,15 +61,13 @@ describe(`[startup] ${Init.name}`, () => {
     describe('with an output location', () => {
         beforeEach(() => (args.output = 'foo/bar'));
 
-        test(`clones ${webUrl} to output location`, async () => {
+        test('clones repo to output location', async () => {
             const destination = path.resolve(args.output!);
 
             await subject();
 
             expect(mkdirSync).toHaveBeenCalledWith(destination, { recursive: true });
-            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
-                quiet: true,
-            });
+            expect(gitCloneRepo).toHaveBeenCalledWith(expect.objectContaining({ destination }));
         });
 
         describe('when output location is a file', () => {
@@ -131,25 +86,4 @@ describe(`[startup] ${Init.name}`, () => {
             });
         });
     });
-
-    describe('when running in CI environment with GITHUB_TOKEN', () => {
-        const originalEnv = process.env;
-        const token = 'foo-bar';
-
-        beforeEach(() => {
-            process.env.CI = 'true';
-            process.env.GITHUB_TOKEN = token;
-        });
-        afterEach(() => (process.env = originalEnv));
-
-        test(`adds token to ${webUrl}`, async () => {
-            await subject();
-
-            const urlWithToken = webUrl.replace('github.com', `oauth2:${token}@github.com`);
-            expect(runCommand).toHaveBeenCalledWith(
-                `git clone -q ${urlWithToken} ${path.resolve('.')}`,
-                expect.anything()
-            );
-        });
-    });
 });

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

@@ -1,33 +1,92 @@
+import { vol, fs } from 'memfs';
 import { execSync } from 'child_process';
-import { log } from '../../../utils';
+import { getStartupVersion, log } from '../../../utils';
+import { gitCloneRepo, isCI } from '../../utils';
 
 import { Install } from '../install';
 
+jest.mock('fs', () => fs);
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    gitCloneRepo: jest.fn(),
+    isCI: jest.fn(),
+}));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
-    log: { info: jest.fn() }, // suppress log output
+    getStartupVersion: jest.fn(),
+    log: { debug: jest.fn(), info: jest.fn(), warning: jest.fn() }, // suppress log output
 }));
 
 describe(`${Install.name}`, () => {
-    const OLD_ENV = process.env;
-    const options = ['--audit=false', '--fund=false', '--legacy-peer-deps'];
+    const mockNpmToken = 'npm_Foo';
+    const npmOptions = ['--audit=false', '--fund=false', '--legacy-peer-deps'];
+    const startupVersion = '1.2.3';
+    const tempDirPath = 'tempDirPath';
     let args: ConstructorParameters<typeof Install>[0];
 
+    function volFromJSON(overrides?: Record<string, string>) {
+        vol.fromJSON({
+            '.npmrc': '',
+            // Mock cloned Github repo with .npm.json containing readOnlyToken
+            [`${tempDirPath}/.npm.json`]: JSON.stringify({
+                readOnlyToken: Buffer.from(mockNpmToken).toString('base64'),
+            }),
+            ...overrides,
+        });
+    }
+
     beforeEach(() => {
-        process.env = {};
         args = undefined;
         jest.clearAllMocks();
+        jest.mocked(gitCloneRepo).mockResolvedValue(true);
+        jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
+        jest.mocked(isCI).mockReturnValue(false);
+        jest.spyOn(fs, 'mkdtempSync').mockImplementation(() => tempDirPath);
+        volFromJSON();
     });
 
-    afterEach(() => (process.env = OLD_ENV));
+    afterEach(() => vol.reset());
 
     const subject = async () => new Install(args).execute();
 
-    test(`runs npm i ${options.join(' ')}`, async () => {
+    test('clones "frontend-dev-config" repo to temp directory', async () => {
+        await subject();
+
+        expect(gitCloneRepo).toHaveBeenCalledWith({
+            destination: tempDirPath,
+            name: 'frontend-dev-config',
+        });
+    });
+
+    test('configures NPM token with value from cloned repo', async () => {
+        await subject();
+
+        expect(execSync).toHaveBeenCalledWith(
+            `npm config set "//registry.npmjs.org/:_authToken"="${mockNpmToken}"`
+        );
+    });
+
+    test('deletes NPM token from project .npmrc', async () => {
+        await subject();
+
+        expect(execSync).toHaveBeenCalledWith(
+            `npm config delete --location=project "//registry.npmjs.org/:_authToken"`
+        );
+    });
+
+    test('removes temp directory', async () => {
+        const rmSpy = jest.spyOn(fs, 'rmSync');
+
         await subject();
 
-        expect(execSync).toHaveBeenCalledWith(`npm i ${options.join(' ')}`, {
+        expect(rmSpy).toHaveBeenCalledWith(tempDirPath, { recursive: true, force: true });
+    });
+
+    test(`runs npm i ${npmOptions.join(' ')}`, async () => {
+        await subject();
+
+        expect(execSync).toHaveBeenCalledWith(`npm i ${npmOptions.join(' ')}`, {
             stdio: 'inherit',
         });
     });
@@ -35,19 +94,72 @@ describe(`${Install.name}`, () => {
     test('logs progress', async () => {
         await subject();
 
-        expect(log.info).toHaveBeenCalled();
+        [`startup cli v${startupVersion}`, 'Configuring NPM token', 'Running npm'].forEach(
+            message => {
+                expect(log.info).toHaveBeenCalledWith(expect.stringMatching(message));
+            }
+        );
+    });
+
+    function itDoesNotConfigureNpmToken() {
+        test('does not configure NPM token', async () => {
+            await subject();
+
+            expect(execSync).not.toHaveBeenCalledWith(expect.stringMatching(/npm config/));
+        });
+    }
+
+    function itDoesNotDeleteProjectToken() {
+        test('does not delete project token', async () => {
+            await subject();
+
+            expect(execSync).not.toHaveBeenCalledWith(expect.stringMatching(/npm config delete/));
+        });
+    }
+
+    describe('when .npmrc uses an environment variable', () => {
+        beforeEach(() => {
+            volFromJSON({
+                '.npmrc': [
+                    // eslint-disable-next-line no-template-curly-in-string
+                    '#//registry.npmjs.org/:_authToken=${NPM_READONLY_TOKEN}', // should ignore this comment
+                    // eslint-disable-next-line no-template-curly-in-string
+                    '//registry.npmjs.org/:_authToken=${ST_NPM_READONLY_TOKEN}',
+                ].join('\n'),
+            });
+        });
+
+        test('runs npm i with environment variable', async () => {
+            await subject();
+
+            expect(execSync).toHaveBeenCalledWith(`npm i ${npmOptions.join(' ')}`, {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                env: expect.objectContaining({ ST_NPM_READONLY_TOKEN: mockNpmToken }),
+                stdio: 'inherit',
+            });
+        });
+
+        itDoesNotDeleteProjectToken();
+    });
+
+    describe('with no .npmrc', () => {
+        beforeEach(() => fs.rmSync('.npmrc'));
+
+        itDoesNotDeleteProjectToken();
     });
 
     describe('when in CI environment', () => {
-        beforeEach(() => (process.env.CI = 'true'));
+        beforeEach(() => jest.mocked(isCI).mockReturnValue(true));
 
         test('runs npm ci', async () => {
             await subject();
 
-            expect(execSync).toHaveBeenCalledWith(`npm ci ${options.join(' ')}`, {
+            expect(execSync).toHaveBeenCalledWith(`npm ci ${npmOptions.join(' ')}`, {
                 stdio: 'inherit',
             });
         });
+
+        itDoesNotConfigureNpmToken();
     });
 
     describe('with --quite', () => {
@@ -61,7 +173,7 @@ describe(`${Install.name}`, () => {
     });
 
     describe('with --fix', () => {
-        const fixOptions = [...options, '--package-lock-only', '--prefer-dedupe'];
+        const fixOptions = [...npmOptions, '--package-lock-only', '--prefer-dedupe'];
 
         beforeEach(() => (args = { fix: true }));
 
@@ -73,5 +185,55 @@ describe(`${Install.name}`, () => {
                 expect.anything()
             );
         });
+
+        itDoesNotConfigureNpmToken();
+    });
+
+    describe('with --no-token', () => {
+        beforeEach(() => (args = { token: false }));
+
+        itDoesNotConfigureNpmToken();
+    });
+
+    function itLogsError(message: string | RegExp) {
+        test('logs error', async () => {
+            await subject();
+
+            expect(log.warning).toHaveBeenCalledWith(expect.stringMatching(message));
+        });
+    }
+
+    describe('when error occurs fetching token', () => {
+        beforeEach(() => jest.mocked(gitCloneRepo).mockResolvedValue(false));
+
+        itLogsError(/could not clone servicetitan\/frontend-dev-config/);
+    });
+
+    describe('when .npm.json is not an object', () => {
+        beforeEach(() => volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify('') }));
+
+        itLogsError(/is not an object/);
+    });
+
+    describe('when .npm.json omits readOnlyToken', () => {
+        beforeEach(() => volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify({}) }));
+
+        itLogsError(/does not contain auth token/);
+    });
+
+    describe('when readOnlyToken is blank', () => {
+        beforeEach(() =>
+            volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify({ readOnlyToken: '' }) })
+        );
+
+        itLogsError(/does not contain auth token/);
+    });
+
+    describe('when readOnlyToken is not a string', () => {
+        beforeEach(() =>
+            volFromJSON({ [`${tempDirPath}/.npm.json`]: JSON.stringify({ readOnlyToken: {} }) })
+        );
+
+        itLogsError(/token is not a string/);
     });
 });

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

@@ -1,7 +1,6 @@
 import { fs, vol } from 'memfs';
 import { isWebComponent, log } from '../../../utils';
-import { gitGetBranch } from '../../utils/cli-git';
-import { Version, npmGetPackageVersionsDetails, npmUnpublish } from '../../utils/cli-npm';
+import { gitGetBranch, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../../utils';
 
 import { MFEPackageClean } from '../mfe-package-clean';
 
@@ -11,13 +10,11 @@ jest.mock('../../../utils', () => ({
     isWebComponent: jest.fn(),
     log: { error: jest.fn(), info: jest.fn() },
 }));
-jest.mock('../../utils/cli-npm', () => ({
+jest.mock('../../utils', () => ({
+    gitGetBranch: jest.fn(),
     npmGetPackageVersionsDetails: jest.fn(),
     npmUnpublish: jest.fn(),
 }));
-jest.mock('../../utils/cli-git', () => ({
-    gitGetBranch: jest.fn(),
-}));
 
 const DEFAULT_VERSIONS_TO_KEEP = 5;
 

package/src/cli/commands/__tests__/mfe-package-publish.test.ts

@@ -1,14 +1,15 @@
 import { fs, vol } from 'memfs';
 import path from 'path';
 import { isWebComponent, log, readJson, WebComponentBranchConfigs } from '../../../utils';
-import { gitGetBranch, gitGetCommitHash } from '../../utils/cli-git';
 import {
+    gitGetBranch,
+    gitGetCommitHash,
     npmGetPackageVersions,
     npmPackageSet,
     npmPublish,
     npmTagVersion,
-} from '../../utils/cli-npm';
-import { runCommand } from '../../utils/cli-os';
+    runCommand,
+} from '../../utils';
 import { MFEPackagePublish } from '../mfe-package-publish';
 
 jest.mock('fs', () => fs);
@@ -17,17 +18,14 @@ jest.mock('../../../utils', () => ({
     isWebComponent: jest.fn(),
     log: { info: jest.fn(), warning: jest.fn() },
 }));
-jest.mock('../../utils/cli-git', () => ({
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
     gitGetBranch: jest.fn(),
     gitGetCommitHash: jest.fn(),
-}));
-jest.mock('../../utils/cli-npm', () => ({
     npmGetPackageVersions: jest.fn(),
     npmPackageSet: jest.fn(),
     npmPublish: jest.fn(),
     npmTagVersion: jest.fn(),
-}));
-jest.mock('../../utils/cli-os', () => ({
     runCommand: jest.fn(),
 }));
 

package/src/cli/commands/__tests__/upload-sourcemaps.test.ts

@@ -2,11 +2,16 @@ import { execSync } from 'child_process';
 import { vol, fs } from 'memfs';
 import { inspect } from 'node:util';
 import path from 'path';
+import { isCI } from '../../utils';
 import { log } from '../../../utils';
 import { UploadSourcemaps } from '../upload-sourcemaps';
 
 jest.mock('child_process', () => ({ execSync: jest.fn() }));
 jest.mock('fs', () => fs);
+jest.mock('../../utils', () => ({
+    ...jest.requireActual('../../utils'),
+    isCI: jest.fn(),
+}));
 jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     log: { info: jest.fn(), warning: jest.fn() },
@@ -33,6 +38,7 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
 
         // eslint-disable-next-line @typescript-eslint/naming-convention
         process.env = { DATADOG_API_KEY: 'datadog-api-key' };
@@ -91,9 +97,7 @@ describe(`[startup] ${UploadSourcemaps.name}`, () => {
         itThrowsError('DATADOG_API_KEY environment variable is not set');
 
         describe('when in CI environment', () => {
-            beforeEach(() => (process.env.CI = '1'));
-
-            afterEach(() => delete process.env.CI);
+            beforeEach(() => jest.mocked(isCI).mockReturnValue(true));
 
             test('logs warning', async () => {
                 await subject();

package/src/cli/commands/init.ts

@@ -2,15 +2,14 @@ import fs from 'fs';
 import path from 'path';
 
 import { log, logErrors } from '../../utils';
-import { runCommand, runCommandOutput } from '../utils/cli-os';
-import { Command } from './';
+import { gitCloneRepo, gitIsReachable } from '../utils';
+import { Command } from './types';
 
 interface Args {
     output?: string;
 }
 
-const webUrl = 'https://github.com/servicetitan/frontend-example.git';
-const sshUrl = 'git@github.com:servicetitan/frontend-example.git';
+const REPO_NAME = 'frontend-example';
 
 export class Init implements Command {
     constructor(private readonly args: Args) {}
@@ -30,44 +29,25 @@ export class Init implements Command {
             throw new Error(`${destination} is not an empty directory`);
         }
 
-        const gitUrls = [webUrl, sshUrl];
-        if (!!process.env.CI && !!process.env.GITHUB_TOKEN) {
-            gitUrls.unshift(
-                webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`)
-            );
+        if (await this.cloneRepo(destination)) {
+            log.info(`copied example project to ${destination}`);
+            return;
         }
 
-        for (const url of gitUrls) {
-            // eslint-disable-next-line no-await-in-loop
-            if (await cloneRepo(url, destination)) {
-                log.info(`copied example project to ${destination}`);
-                return;
-            }
-        }
-
-        if (!gitUrls.some(isReachable)) {
-            throw new Error('could not read servicetitan/frontend-example repository');
+        if (!gitIsReachable({ name: REPO_NAME })) {
+            throw new Error(`could not read servicetitan/${REPO_NAME} repository`);
         }
     }
-}
 
-async function cloneRepo(url: string, destination: string) {
-    try {
-        await runCommand(`git clone -q ${url} ${destination}`, { quiet: true });
-    } catch {
-        return false;
-    }
-    fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
-    fs.rmSync(path.join(destination, '.github', 'CODEOWNERS'));
-    fs.rmSync(path.join(destination, 'package-lock.json'));
-    return true;
-}
+    async cloneRepo(destination: string) {
+        const ok = await gitCloneRepo({ destination, name: REPO_NAME });
+        if (!ok) {
+            return false;
+        }
 
-function isReachable(url: string) {
-    try {
-        runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
-    } catch {
-        return false;
+        fs.rmSync(path.join(destination, '.git'), { recursive: true, force: true });
+        fs.rmSync(path.join(destination, '.github', 'CODEOWNERS'));
+        fs.rmSync(path.join(destination, 'package-lock.json'));
+        return true;
     }
-    return true;
 }