@servicetitan/startup 22.14.0 → 22.16.0

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

@@ -0,0 +1,114 @@
+const lernaExec = require('@lerna/exec');
+import { Lint } from '../lint';
+import { eslint } from '../../utils';
+import { getPackages } from '../../../utils';
+
+jest.mock('@lerna/exec', () => jest.fn());
+jest.mock('execa', () => jest.fn());
+jest.mock('stylelint', () => ({ lint: jest.fn(() => ({ output: '' })) }));
+
+jest.mock('../../utils', () => ({ eslint: jest.fn() }));
+jest.mock('../../../utils', () => ({
+    log: { info: jest.fn() },
+    getConfiguration: jest.fn(() => ({})),
+    getDestinationFolders: jest.fn(() => []),
+    getPackages: jest.fn(() => []),
+    getStylelintConfiguration: jest.fn(() => ({})),
+}));
+
+describe(`[startup] ${Lint.name}`, () => {
+    const packages = ['package-a', 'package-b'];
+    let args: ConstructorParameters<typeof Lint>[0];
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        args = { _: [] };
+        (getPackages as jest.Mock).mockReturnValue(packages.map(name => ({ name })));
+    });
+
+    const subject = async () => new Lint(args).execute();
+
+    test('runs styles-check', async () => {
+        await subject();
+
+        expect(lernaExec).toHaveBeenCalledWith(
+            expect.objectContaining({
+                cmd: 'startup styles-check',
+                scope: packages,
+            })
+        );
+    });
+
+    test('runs eslint directly', async () => {
+        await subject();
+
+        expect(eslint).toHaveBeenCalledWith({ paths: [] });
+    });
+
+    describe('when instructed to fix issues', () => {
+        beforeEach(() => (args.fix = true));
+
+        test('instructs eslint to fix issues', async () => {
+            await subject();
+
+            expect(eslint).toHaveBeenCalledWith({ fix: true, paths: [] });
+        });
+    });
+
+    function itRunsLernaExec() {
+        test('runs @lerna/exec instead of eslint', async () => {
+            await subject();
+
+            expect(eslint).not.toHaveBeenCalled();
+            expect(lernaExec).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    cmd: 'startup eslint',
+                    scope: packages,
+                })
+            );
+        });
+    }
+
+    describe('when instructed to isolate packages', () => {
+        beforeEach(() => (args.isolated = true));
+
+        itRunsLernaExec();
+
+        describe('when instructed to fix errors', () => {
+            beforeEach(() => (args.fix = true));
+
+            test('adds instruction to fix errors', async () => {
+                await subject();
+
+                expect(lernaExec).toHaveBeenCalledWith(
+                    expect.objectContaining({ args: ['--fix'] })
+                );
+            });
+        });
+
+        describe('with a list of paths to lint', () => {
+            beforeEach(() => (args._ = ['path/a', 'path/b']));
+
+            test('runs eslint directly', async () => {
+                await subject();
+
+                expect(eslint).toHaveBeenCalledWith({
+                    paths: args._,
+                });
+            });
+        });
+    });
+
+    describe('with a list of packages to lint', () => {
+        beforeEach(() => (args.scope = ['package-a']));
+
+        itRunsLernaExec();
+    });
+
+    describe('with a list of packages to ignore', () => {
+        beforeEach(() => (args.ignore = ['package-a']));
+
+        itRunsLernaExec();
+    });
+});

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

@@ -0,0 +1,193 @@
+import mockFS from 'mock-fs';
+import { isWebComponent, log } from '../../../utils';
+import { npmGetPackageVersionDates, npmUnpublish } from '../../utils/cli-npm';
+
+import { MFEPackageClean } from '../mfe-publish';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    isWebComponent: jest.fn(),
+    log: { error: jest.fn(), info: jest.fn() },
+}));
+jest.mock('../../utils/cli-npm', () => ({
+    npmGetPackageVersionDates: jest.fn(),
+    npmUnpublish: jest.fn(),
+}));
+
+const DEFAULT_VERSIONS_TO_KEEP = 5;
+
+describe(`[startup] ${MFEPackageClean.name}`, () => {
+    const registry = 'https://verdaccio.servicetitan.com';
+    const packageName = '@servicetitan/foo';
+    let args: ConstructorParameters<typeof MFEPackageClean>[0];
+    let versions: Record<string, Date>;
+
+    beforeEach(() => {
+        args = {};
+        versions = Object.fromEntries(
+            Array.from({ length: 10 }).map((_, index) => [
+                `0.0.0-master.${(0xff000000 + index).toString(16)}`,
+                dayAgo(index + 1), // tests assume versions are in reverse chronological order
+            ])
+        );
+
+        jest.resetAllMocks();
+        jest.mocked(isWebComponent).mockReturnValue(true);
+        jest.mocked(npmGetPackageVersionDates).mockImplementation(() => Object.entries(versions));
+        mockFS({ 'package.json': JSON.stringify({ name: packageName }) });
+    });
+
+    afterEach(() => mockFS.restore());
+
+    const subject = async () => new MFEPackageClean(args).execute();
+
+    test('fetches package info from registry', async () => {
+        await subject();
+
+        expect(npmGetPackageVersionDates).toHaveBeenCalledWith(registry, packageName);
+    });
+
+    function itLogsAndUnpublishedOldestPackages({ branch = 'master' }: { branch?: string } = {}) {
+        test('logs and unpublishes oldest packages', async () => {
+            const oldest = Object.entries(versions).slice(DEFAULT_VERSIONS_TO_KEEP);
+
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                'found versions for unpublish:',
+                JSON.stringify({ [branch]: oldest }, null, 4)
+            );
+            oldest.forEach(([version]) => {
+                expect(npmUnpublish).toHaveBeenCalledWith(registry, packageName, version);
+            });
+        });
+    }
+
+    itLogsAndUnpublishedOldestPackages();
+
+    describe.each(['dev', 'develop', 'next'])('when branch is %s', branch => {
+        beforeEach(() => {
+            versions = transform(versions, (v: string) => v.replace('master', branch));
+        });
+
+        itLogsAndUnpublishedOldestPackages({ branch });
+    });
+
+    describe('with master versions generated by nerdbank versioning', () => {
+        beforeEach(() => {
+            versions = transform(versions, (v: string, index: number) =>
+                v.replace(/master.*/, `${index}.0.0`)
+            );
+        });
+
+        itLogsAndUnpublishedOldestPackages();
+    });
+
+    describe('with branch versions generated by nerdbank versioning', () => {
+        beforeEach(() => {
+            versions = transform(versions, (v: string, index: number) =>
+                v.replace(/master.*/, `${index}.0.0-next-${index}`)
+            );
+        });
+
+        itLogsAndUnpublishedOldestPackages({ branch: 'next' });
+    });
+
+    describe('with "count" argument', () => {
+        beforeEach(() => (args.count = Object.keys(versions).length - 1));
+
+        test('keeps the specified number of versions', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                'found versions for unpublish:',
+                JSON.stringify({ master: Object.entries(versions).slice(-1) }, null, 4)
+            );
+
+            expect(npmUnpublish).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('when publish fails', () => {
+        beforeEach(() =>
+            jest.mocked(npmUnpublish).mockImplementationOnce(() => {
+                throw new Error('Oops!');
+            })
+        );
+
+        test('logs error', async () => {
+            await subject();
+
+            const firstUnpublishVersion = Object.entries(versions)[DEFAULT_VERSIONS_TO_KEEP][0];
+            expect(log.error).toHaveBeenCalledWith(
+                `error while removing ${packageName} version ${firstUnpublishVersion}`
+            );
+        });
+    });
+
+    function itDoesNotUnpublish() {
+        test('does not unpublish', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith('found versions for unpublish:', '{}');
+            expect(npmUnpublish).not.toHaveBeenCalled();
+        });
+    }
+
+    describe('when version does not start with "0.0.0-"', () => {
+        beforeEach(() => {
+            versions = transform(versions, (v: string) => v.replace('0.0.0-', ''));
+        });
+
+        itDoesNotUnpublish();
+    });
+
+    describe('when branch is not recognized', () => {
+        beforeEach(() => {
+            versions = transform(versions, (v: string) => v.replace('master', 'foo'));
+        });
+
+        itDoesNotUnpublish();
+    });
+
+    describe('when version is not recognized', () => {
+        const unknownVersions = ['0.0.0-master-1^', '0.0.0-master-2^'];
+
+        beforeEach(() => unknownVersions.forEach(version => (versions[version] = new Date())));
+
+        test('logs unrecognized versions', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith('unknown versions:', unknownVersions.join());
+        });
+    });
+
+    describe('when package is not a web component', () => {
+        beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(false));
+
+        test('throws error', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            expect.assertions(1);
+            try {
+                await subject();
+            } catch (error: any) {
+                expect(error.message).toBe('only web-components can be cleaned');
+            }
+        });
+    });
+});
+
+function dayAgo(count: number) {
+    const date = new Date();
+    date.setDate(-count);
+    return date;
+}
+
+function transform(
+    versions: Record<string, Date>,
+    callback: (version: string, index: number) => string
+) {
+    return Object.fromEntries(
+        Object.entries(versions).map(([version, date], index) => [callback(version, index), date])
+    );
+}

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

@@ -0,0 +1,192 @@
+import mockFS from 'mock-fs';
+import { isWebComponent, log } from '../../../utils';
+import { gitGetBranch, gitGetCommitHash } from '../../utils/cli-git';
+import {
+    npmGetPackageVersions,
+    npmPackageSet,
+    npmPublish,
+    npmPublishDry,
+} from '../../utils/cli-npm';
+import { MFEPackagePublish } from '../mfe-publish';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    isWebComponent: jest.fn(),
+    log: { info: jest.fn() },
+}));
+jest.mock('../../utils/cli-git', () => ({
+    gitGetBranch: jest.fn(),
+    gitGetCommitHash: jest.fn(),
+}));
+jest.mock('../../utils/cli-npm', () => ({
+    npmGetPackageVersions: jest.fn(),
+    npmPackageSet: jest.fn(),
+    npmPublish: jest.fn(),
+    npmPublishDry: jest.fn(),
+}));
+
+describe(`[startup] ${MFEPackagePublish.name}`, () => {
+    const branch = 'master';
+    const commitHash = '6c461f1a';
+    const packageName = '@servicetitan/foo';
+    let args: ConstructorParameters<typeof MFEPackagePublish>[0];
+
+    const defaultPackageVersion = () => `0.0.0-${branch}.${commitHash}`;
+
+    beforeEach(() => {
+        args = {};
+        jest.resetAllMocks();
+        jest.mocked(isWebComponent).mockReturnValue(true);
+        jest.mocked(gitGetBranch).mockReturnValue(branch);
+        jest.mocked(gitGetCommitHash).mockReturnValue(commitHash);
+        jest.mocked(npmGetPackageVersions).mockReturnValue([]);
+        mockFS({ 'package.json': JSON.stringify({ name: packageName, files: [] }) });
+    });
+
+    afterEach(() => mockFS.restore());
+
+    const subject = async () => new MFEPackagePublish(args).execute();
+
+    test('sets package version', async () => {
+        await subject();
+
+        expect(npmPackageSet).toHaveBeenCalledWith('version', defaultPackageVersion());
+    });
+
+    test('sets package registry', async () => {
+        await subject();
+
+        expect(npmPackageSet).toHaveBeenCalledWith(
+            'publishConfig.registry',
+            'https://verdaccio.servicetitan.com'
+        );
+    });
+
+    test('publishes package and logs message', async () => {
+        await subject();
+
+        expect(npmPublish).toHaveBeenCalledWith('prod');
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringContaining(
+                `packages ${packageName} is published with version ${defaultPackageVersion()}`
+            )
+        );
+    });
+
+    Object.entries({ dev: ['dev', 'develop'], next: ['next'], prod: ['master'] }).forEach(
+        ([tag, branches]) => {
+            describe.each(branches)('when branch is %s', branch => {
+                beforeEach(() => (args.branch = branch));
+
+                test(`uses tag ${tag}`, async () => {
+                    await subject();
+
+                    expect(npmPublish).toHaveBeenCalledWith(tag);
+                });
+            });
+        }
+    );
+
+    describe('with "tag" argument', () => {
+        beforeEach(() => (args.tag = 'foo'));
+
+        test('uses specified tag', async () => {
+            await subject();
+
+            expect(npmPublish).toHaveBeenCalledWith(args.tag);
+        });
+    });
+
+    describe('when "tag" is false', () => {
+        beforeEach(() => (args.tag = false));
+
+        test('omits the tag', async () => {
+            await subject();
+
+            expect(npmPublish).toHaveBeenCalledWith('');
+        });
+    });
+
+    describe('with "build" argument', () => {
+        beforeEach(() => (args.build = '42'));
+
+        test('uses build in package version', async () => {
+            await subject();
+
+            expect(npmPackageSet).toHaveBeenCalledWith('version', `0.0.0-${args.build}`);
+        });
+    });
+
+    describe('with "dry" argument', () => {
+        beforeEach(() => (args.dry = true));
+
+        test('does dry run and logs message', async () => {
+            await subject();
+
+            expect(npmPublishDry).toHaveBeenCalled();
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringContaining(
+                    `packages ${packageName} is published (dry) with version ${defaultPackageVersion()}`
+                )
+            );
+        });
+    });
+
+    describe('when package has no files', () => {
+        beforeEach(() => mockFS({ 'package.json': JSON.stringify({ name: packageName }) }));
+
+        test('sets package files to "package.json"', async () => {
+            await subject();
+
+            expect(npmPackageSet).toHaveBeenCalledWith('files[0]', 'dist');
+            expect(npmPackageSet).toHaveBeenCalledWith('files[1]', 'package.json');
+        });
+    });
+
+    function itLogsMessageAndSkipsPublishing(message: RegExp) {
+        test('logs message and skips publishing', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(expect.stringMatching(message));
+            expect(npmPublish).not.toHaveBeenCalled();
+        });
+    }
+
+    describe('when version is already published', () => {
+        beforeEach(() =>
+            jest.mocked(npmGetPackageVersions).mockReturnValue([defaultPackageVersion()])
+        );
+
+        itLogsMessageAndSkipsPublishing(/is already published/);
+    });
+
+    describe('with unrecognized branch', () => {
+        beforeEach(() => jest.mocked(gitGetBranch).mockReturnValue('foo'));
+
+        itLogsMessageAndSkipsPublishing(/branch is not configured for publishing/);
+
+        describe('with "force" argument"', () => {
+            beforeEach(() => (args.force = true));
+
+            test('publishes the package', async () => {
+                await subject();
+
+                expect(npmPublish).toHaveBeenCalledWith('');
+            });
+        });
+    });
+
+    describe('when package is not web component', () => {
+        beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(false));
+
+        test('throws error', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            expect.assertions(1);
+            try {
+                await subject();
+            } catch (error: any) {
+                expect(error.message).toMatch(/only web-components can be published/);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,172 @@
+const exec = require('@lerna/exec');
+import mockFS from 'mock-fs';
+import { Package, PackageType, getPackages } from '../../../utils';
+import { createPackage } from '../../__mocks__';
+
+import { MFEPublish } from '../mfe-publish';
+
+jest.mock('@lerna/exec', () => jest.fn());
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getPackages: jest.fn(),
+}));
+
+describe(`[startup] ${MFEPublish.name}`, () => {
+    let args: ConstructorParameters<typeof MFEPublish>[0];
+    let packages: Package[];
+
+    beforeEach(() => {
+        args = {};
+        packages = [];
+        jest.resetAllMocks();
+        jest.mocked(getPackages).mockReturnValue(packages);
+    });
+
+    afterEach(() => mockFS.restore());
+
+    const subject = async () => new MFEPublish(args).execute();
+
+    function itReportsError() {
+        test('reports there are no packages to publish', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            expect.assertions(1);
+            try {
+                await subject();
+            } catch (error: any) {
+                expect(error.message).toMatch(/no packages found/);
+            }
+        });
+    }
+
+    describe('with TSC package', () => {
+        beforeEach(() => packages.push(createPackage({ type: PackageType.TSC })));
+
+        itReportsError();
+    });
+
+    describe('with Webpack package', () => {
+        function mockPackageJson(
+            packages: Package[],
+            json: Record<string, any> = { cli: { 'web-component': true } }
+        ) {
+            mockFS(
+                packages.reduce(
+                    (result, { location }) => ({
+                        ...result,
+                        [`${location}/package.json`]: JSON.stringify(json),
+                    }),
+                    {}
+                )
+            );
+        }
+
+        beforeEach(() => {
+            packages.push(createPackage({ type: PackageType.Webpack }));
+            mockPackageJson(packages);
+        });
+
+        test('publishes the package', async () => {
+            await subject();
+
+            expect(exec).toHaveBeenCalledWith({
+                'cmd': 'startup mfe-package-publish',
+                'scope': packages.map(({ name }) => name),
+                'stream': true,
+                '--': [],
+            });
+        });
+
+        describe('when package is not a web component', () => {
+            beforeEach(() => mockPackageJson(packages, {}));
+
+            itReportsError();
+        });
+
+        describe('with "{clean: true}"', () => {
+            beforeEach(() => (args.clean = true));
+
+            test('cleans the package', async () => {
+                await subject();
+
+                expect(exec).toHaveBeenCalledWith(
+                    expect.objectContaining({ cmd: 'startup mfe-package-clean' })
+                );
+            });
+        });
+
+        type ArgumentName = keyof typeof args;
+        const testArgs: { name: ArgumentName; value: any; expected?: string }[] = [
+            { name: 'build', value: true },
+            { name: 'branch', value: 'foo-123' },
+            { name: 'tag', value: 'foo' },
+            { name: 'tag', value: false, expected: '--no-tag' },
+            { name: 'dry', value: true, expected: '--dry' },
+            { name: 'force', value: true, expected: '--force' },
+            { name: 'count', value: 42 },
+        ];
+
+        describe.each(testArgs)('with "{$name: $value}"', ({ name, value, expected }) => {
+            beforeEach(() => (args[name] = value));
+
+            test(`runs publish with "${expected ?? `--${name} ${value}`}"`, async () => {
+                await subject();
+
+                expect(exec).toHaveBeenCalledWith(
+                    expect.objectContaining({ '--': [expected ?? `--${name} ${value}`] })
+                );
+            });
+        });
+
+        describe('with multiple packages', () => {
+            beforeEach(() => {
+                packages.push(
+                    createPackage({
+                        name: '@servicetitan/bar',
+                        type: PackageType.Webpack,
+                        location: 'packages/bar',
+                    }),
+                    createPackage({
+                        name: '@servicetitan/baz',
+                        type: PackageType.Webpack,
+                        location: 'packages/baz',
+                    })
+                );
+                mockPackageJson(packages);
+            });
+
+            test('publishes the packages', async () => {
+                await subject();
+
+                expect(exec).toHaveBeenCalledWith(
+                    expect.objectContaining({ scope: packages.map(({ name }) => name) })
+                );
+            });
+
+            describe('with "{scope: string}"', () => {
+                beforeEach(() => (args.scope = packages[0].name));
+
+                test('publishes specified packages', async () => {
+                    await subject();
+
+                    expect(exec).toHaveBeenCalledWith(
+                        expect.objectContaining({ scope: [packages[0].name] })
+                    );
+                });
+            });
+
+            describe('with "{scope: Array<string>}"', () => {
+                beforeEach(() => (args.scope = packages.slice(1).map(({ name }) => name)));
+
+                test('publishes the specified packages', async () => {
+                    await subject();
+
+                    expect(exec).toHaveBeenCalledWith(
+                        expect.objectContaining({
+                            scope: packages.slice(1).map(({ name }) => name),
+                        })
+                    );
+                });
+            });
+        });
+    });
+});