@servicetitan/startup 31.6.0 → 32.0.0

package/src/cli/utils/__tests__/cli-git.test.ts

@@ -1,11 +1,16 @@
-import { runCommandOutput } from '../cli-os';
+import { runCommand, runCommandOutput } from '../cli-os';
 
-import { gitGetBranch, gitGetCommitHash } from '../cli-git';
+import { gitCloneRepo, gitGetBranch, gitGetCommitHash, gitIsReachable } from '../cli-git';
+import { isCI } from '../is-ci';
 
-jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
+jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
+jest.mock('../cli-os', () => ({ runCommand: jest.fn(), runCommandOutput: jest.fn() }));
 
 describe('[startup] Cli Utils (Git)', () => {
-    beforeEach(() => jest.resetAllMocks());
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
+    });
 
     function itRunsCommand(subject: Function, command: string) {
         test(`runs "${command}"`, () => {
@@ -18,11 +23,142 @@ describe('[startup] Cli Utils (Git)', () => {
         });
     }
 
-    describe(`${gitGetBranch.name}`, () => {
+    describe(gitGetBranch.name, () => {
         itRunsCommand(gitGetBranch, 'git rev-parse --abbrev-ref HEAD');
     });
 
-    describe(`${gitGetCommitHash.name}`, () => {
+    describe(gitGetCommitHash.name, () => {
         itRunsCommand(gitGetCommitHash, 'git rev-parse --short HEAD');
     });
+
+    describe(gitCloneRepo.name, () => {
+        const destination = 'foo';
+        const name = '{name}';
+
+        const webUrl = `https://github.com/servicetitan/${name}.git`;
+        const sshUrl = `git@github.com:servicetitan/${name}.git`;
+
+        let params: Parameters<typeof gitCloneRepo>[0];
+
+        beforeEach(() => (params = { destination, name }));
+
+        const subject = () => gitCloneRepo(params);
+
+        function itReturns(value: boolean) {
+            test(`it returns ${value}`, async () => {
+                expect(await subject()).toBe(value);
+            });
+        }
+
+        test(`clones ${webUrl} to destination directory`, async () => {
+            await subject();
+
+            expect(runCommand).toHaveBeenCalledWith(`git clone -q ${webUrl} ${destination}`, {
+                quiet: true,
+            });
+        });
+
+        itReturns(true);
+
+        describe(`when cloning ${webUrl} fails`, () => {
+            beforeEach(() => jest.mocked(runCommand).mockRejectedValueOnce('Nope!'));
+
+            test(`clones ${sshUrl} to destination directory`, async () => {
+                await subject();
+
+                expect(runCommand).toHaveBeenCalledWith(
+                    `git clone -q ${sshUrl} ${destination}`,
+                    expect.anything()
+                );
+            });
+
+            itReturns(true);
+
+            describe(`when cloning ${sshUrl} also fails`, () => {
+                beforeEach(() => {
+                    jest.mocked(runCommand).mockRejectedValue('Nope!');
+                });
+
+                itReturns(false);
+            });
+        });
+
+        describe('when running in CI environment with GITHUB_TOKEN', () => {
+            const originalEnv = process.env;
+            const token = 'foo-bar';
+
+            beforeEach(() => {
+                jest.mocked(isCI).mockReturnValue(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} ${destination}`,
+                    expect.anything()
+                );
+            });
+        });
+    });
+
+    describe(gitIsReachable.name, () => {
+        const name = '{name}';
+
+        let params: Parameters<typeof gitIsReachable>[0];
+
+        beforeEach(() => (params = { name }));
+
+        const subject = () => gitIsReachable(params);
+
+        function itReturns(value: boolean) {
+            test(`it returns ${value}`, () => {
+                expect(subject()).toBe(value);
+            });
+        }
+
+        const webUrl = `https://github.com/servicetitan/${name}.git`;
+        const sshUrl = `git@github.com:servicetitan/${name}.git`;
+
+        test(`checks if ${webUrl} is reachable`, () => {
+            subject();
+
+            expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${webUrl}`, {
+                quiet: true,
+            });
+        });
+
+        itReturns(true);
+
+        describe(`when ${webUrl} is not reachable`, () => {
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementationOnce(() => {
+                    throw new Error('Oops!');
+                });
+            });
+
+            test(`checks if ${sshUrl} is reachable`, () => {
+                subject();
+
+                expect(runCommandOutput).toHaveBeenCalledWith(`git ls-remote -qt ${sshUrl}`, {
+                    quiet: true,
+                });
+            });
+
+            itReturns(true);
+
+            describe(`when ${sshUrl} is also unreachable`, () => {
+                beforeEach(() =>
+                    jest.mocked(runCommandOutput).mockImplementation(() => {
+                        throw new Error('Oops');
+                    })
+                );
+
+                itReturns(false);
+            });
+        });
+    });
 });

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

@@ -1,12 +1,13 @@
 import { fs, vol } from 'memfs';
 import { ESLint } from 'eslint';
 
+import { getDestinationFolders } from '../../../utils';
 import { eslint } from '../eslint';
-import { getDestinationFolders } from '../../../utils/get-destination-folders';
 
 jest.mock('fs', () => fs);
 jest.mock('eslint');
-jest.mock('../../../utils/get-destination-folders', () => ({
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
     getDestinationFolders: jest.fn(),
 }));
 

package/src/cli/utils/__tests__/is-ci.test.ts

@@ -0,0 +1,40 @@
+import { isCI } from '../is-ci';
+
+describe(`[startup] Utils ${isCI.name}`, () => {
+    const originalCI = process.env.CI;
+
+    beforeAll(() => delete process.env.CI);
+    afterAll(() => (process.env.CI = originalCI));
+
+    const subject = () => isCI();
+
+    function itReturns(value: boolean) {
+        test(`returns ${value}`, () => {
+            expect(subject()).toBe(value);
+        });
+    }
+
+    itReturns(false);
+
+    describe.each([
+        { value: '', result: false },
+        { value: '1', result: true },
+    ])('when process.env.CI is "$value"', ({ value, result }) => {
+        beforeEach(() => (process.env.CI = value));
+
+        afterEach(() => delete process.env.CI);
+
+        itReturns(result);
+    });
+
+    describe.each([
+        { value: '', result: false },
+        { value: '1', result: true },
+    ])('when process.env.TEAMCITY_VERSION is "$value"', ({ value, result }) => {
+        beforeEach(() => (process.env.TEAMCITY_VERSION = value));
+
+        afterEach(() => delete process.env.TEAMCITY_VERSION);
+
+        itReturns(result);
+    });
+});

package/src/cli/utils/__tests__/lerna-exec.test.ts

@@ -1,9 +1,11 @@
 import execa from 'execa';
 
 import { log } from '../../../utils';
+import { isCI } from '../is-ci';
 import { lernaExec } from '../lerna-exec';
 
 jest.mock('execa');
+jest.mock('../is-ci', () => ({ isCI: jest.fn() }));
 
 const AVAILABLE_PARALLELISM = 2;
 
@@ -17,9 +19,9 @@ describe(`${lernaExec.name}`, () => {
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(isCI).mockReturnValue(false);
         jest.spyOn(log, 'info').mockImplementation(jest.fn()); // suppress log output
         args = { cmd: 'foo' };
-        delete process.env.CI;
     });
 
     const subject = () => lernaExec(args);
@@ -60,10 +62,11 @@ describe(`${lernaExec.name}`, () => {
         itRunsLernaExec(option);
     });
 
-    describe('when process.env.CI=true', () => {
+    describe('when in CI environment', () => {
         beforeEach(() => {
-            process.env.CI = 'true';
+            jest.mocked(isCI).mockReturnValue(true);
         });
+
         describe.each([
             { arg: { parallel: true }, option: `--concurrency=${AVAILABLE_PARALLELISM}` },
             { arg: { parallel: 10 }, option: '--concurrency=10' },

package/src/cli/utils/cli-git.ts

@@ -1,9 +1,59 @@
-import { runCommandOutput } from './cli-os';
+import { log } from '../../utils';
+import { runCommand, runCommandOutput } from './cli-os';
+import { isCI } from './is-ci';
 
-export const gitGetBranch = (): string => {
+export function gitGetBranch(): string {
     return runCommandOutput('git rev-parse --abbrev-ref HEAD').trim();
-};
+}
 
-export const gitGetCommitHash = (): string => {
+export function gitGetCommitHash(): string {
     return runCommandOutput('git rev-parse --short HEAD').trim();
-};
+}
+
+interface Repo {
+    owner?: string;
+    name: string;
+}
+
+export async function gitCloneRepo(params: Repo & { destination: string }) {
+    const { destination, name, owner = 'servicetitan' } = params;
+    const gitUrls = getGitUrls({ owner, name });
+
+    for (const url of gitUrls) {
+        try {
+            const command = `git clone -q ${url} ${destination}`;
+            log.debug('git:clone-repo', `running ${command}`);
+
+            // eslint-disable-next-line no-await-in-loop
+            await runCommand(command, { quiet: true });
+            return true;
+        } catch {
+            // ignore error
+        }
+    }
+
+    return false;
+}
+
+export function gitIsReachable({ owner = 'servicetitan', name }: Repo) {
+    return getGitUrls({ owner, name }).some(url => {
+        try {
+            runCommandOutput(`git ls-remote -qt ${url}`, { quiet: true });
+            return true;
+        } catch {
+            return false;
+        }
+    });
+}
+
+function getGitUrls({ owner, name }: Repo) {
+    const webUrl = `https://github.com/${owner}/${name}.git`;
+    const sshUrl = `git@github.com:${owner}/${name}.git`;
+
+    const urls = [webUrl, sshUrl];
+    if (isCI() && !!process.env.GITHUB_TOKEN) {
+        urls.unshift(webUrl.replace('github.com', `oauth2:${process.env.GITHUB_TOKEN}@github.com`));
+    }
+
+    return urls;
+}

package/src/cli/utils/index.ts

@@ -1,15 +1,21 @@
 export * from './bundle';
 export * from './check-args';
+export * from './cli-git';
+export * from './cli-npm';
+export * from './cli-os';
 export * from './compile';
 export * from './compile-less';
 export * from './compile-sass';
 export * from './copy-files';
 export * from './eslint';
 export * from './get-module-type';
+export * from './is-ci';
 export * from './is-module-installed';
 export * from './lerna-exec';
+export * from './maybe-create-git-folder';
 export * from './pipe-stdout';
 export * from './process-tree';
+export * from './publish';
 export * from './set-node-options';
 export * from './ts-config';
 export * from './type-check';

package/src/cli/utils/is-ci.ts

@@ -0,0 +1,3 @@
+export function isCI() {
+    return !!process.env.CI || !!process.env.TEAMCITY_VERSION;
+}

package/src/cli/utils/lerna-exec.ts

@@ -2,6 +2,7 @@ import execa, { StdioOption } from 'execa';
 import os from 'node:os';
 
 import { log } from '../../utils';
+import { isCI } from './is-ci';
 
 interface Args {
     'bail'?: boolean;
@@ -37,7 +38,7 @@ function getOptions(args: Args) {
         result.push('--no-bail');
     }
     if (args.parallel === true) {
-        result.push(process.env.CI ? `--concurrency=${os.availableParallelism()}` : '--parallel');
+        result.push(isCI() ? `--concurrency=${os.availableParallelism()}` : '--parallel');
     } else if (typeof args.parallel === 'number') {
         result.push(`--concurrency=${args.parallel}`);
     }

package/src/utils/get-branch-configs.ts

@@ -1,4 +1,4 @@
-import { getWebComponentBranchConfigs, WebComponentBranchConfigs } from './index';
+import { getWebComponentBranchConfigs, WebComponentBranchConfigs } from './get-configuration';
 
 function getDefaultConfigs(): Record<string, WebComponentBranchConfigs> {
     return {

package/src/utils/index.ts

@@ -1,6 +1,7 @@
 export * from './find-packages';
 export * from './find-up';
 export * from './format-duration';
+export * from './get-branch-configs';
 export * from './get-configuration';
 export * from './get-destination-folders';
 export * from './get-folders';