@servicetitan/startup 22.14.0 → 22.16.0

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

@@ -0,0 +1,361 @@
+import fs from 'fs';
+import mockFS from 'mock-fs';
+import path from 'path';
+import webpack from 'webpack';
+import WebpackDevServer from 'webpack-dev-server';
+import { getFolders, getPackageData, loadSharedDependencies } from '../../../utils';
+import { createWebpackConfig } from '../../../webpack';
+import { createPackage } from '../../__mocks__';
+
+import {
+    bundle,
+    bundleWatch,
+    webpackDevConfigFileName,
+    webpackProdConfigFileName,
+} from '../bundle';
+
+jest.mock('webpack', () => jest.fn());
+jest.mock('webpack-dev-server');
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getFolders: jest.fn(),
+    getPackageData: jest.fn(),
+    loadSharedDependencies: jest.fn(),
+    log: { info: jest.fn() }, // suppress test output
+}));
+jest.mock('../../../webpack', () => ({ createWebpackConfig: jest.fn() }));
+
+describe('[startup] Cli Utils', () => {
+    const pkg = createPackage({});
+    const createWebpackResult = { stats: { all: true } };
+    let compiler: Partial<ReturnType<typeof webpack>>;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.mocked(createWebpackConfig).mockReturnValue(createWebpackResult);
+        jest.mocked(webpack).mockImplementation((): any => compiler);
+        compiler = { close: jest.fn(callback => callback()) };
+    });
+
+    afterEach(() => mockFS.restore());
+
+    function expectPackageName() {
+        const name = pkg.name.replace(/\//g, '-').replace(/[^\w-]/g, '');
+        return expect.stringContaining(name);
+    }
+
+    function generatedMetadata(destination: string) {
+        return JSON.parse(fs.readFileSync(`${destination}/metadata.json`, 'utf8'));
+    }
+
+    function packageFS() {
+        return { 'package.json': JSON.stringify(pkg) };
+    }
+
+    function webComponentFS(startupVersion: string) {
+        return {
+            'package.json': JSON.stringify({ ...pkg, cli: { 'web-component': true } }),
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            'node_modules': {
+                '@servicetitan': {
+                    'package.json': JSON.stringify({ version: startupVersion }),
+                    'startup': { 'index.js': '' },
+                },
+            },
+        };
+    }
+
+    describe(`${bundle.name}`, () => {
+        const customProdConfig = { configuration: { foo: 'bar' }, plugins: { baz: 'qux' } };
+        const stats: Partial<webpack.Stats> = { hasErrors: () => false, toString: () => 'foo' };
+        let buildStat: boolean;
+        let stdoutSpy: jest.SpyInstance;
+
+        beforeEach(() => {
+            mockFS(packageFS());
+            // Allows config file to be loaded with require(...)
+            jest.doMock(path.resolve(webpackProdConfigFileName), () => customProdConfig, {
+                virtual: true,
+            });
+            buildStat = false;
+            stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
+            compiler.run = jest.fn(callback => callback(null, stats as any));
+        });
+
+        const subject = async () => bundle(buildStat);
+
+        test('runs webpack and outputs stats', async () => {
+            const toStringSpy = jest.spyOn(stats, 'toString');
+
+            await subject();
+
+            expect(createWebpackConfig).toHaveBeenCalledWith(
+                { configuration: { mode: 'production' } },
+                { buildStat, name: expectPackageName() }
+            );
+            expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+            expect(compiler.run).toHaveBeenCalled();
+            expect(toStringSpy).toHaveBeenCalledWith(createWebpackResult.stats);
+            expect(stdoutSpy).toHaveBeenCalledWith(`${stats.toString!()}\n`);
+        });
+
+        describe('when webpack completes with errors', () => {
+            const stats = { hasErrors: () => true, toString: () => 'Oops!' };
+
+            beforeEach(() => {
+                jest.mocked(compiler.run)!.mockImplementation(callback =>
+                    callback(null, stats as any)
+                );
+            });
+
+            test('returns errors', () => {
+                const toStringSpy = jest.spyOn(stats, 'toString');
+                expect(subject).rejects.toBe(stats.toString());
+                expect(toStringSpy).toHaveBeenCalledWith('errors-only');
+            });
+        });
+
+        describe('when webpack fails', () => {
+            const error = new Error('Oops!');
+
+            beforeEach(() => {
+                jest.mocked(compiler.run)!.mockImplementation(callback => callback(error));
+            });
+
+            test('returns error', () => {
+                expect(subject).rejects.toBe(error);
+            });
+        });
+
+        describe('when webpack reports unexpected results', () => {
+            beforeEach(() => {
+                jest.mocked(compiler.run)!.mockImplementation(callback => callback());
+            });
+
+            test('returns error', () => {
+                expect(subject).rejects.toThrowError(/something went wrong/i);
+            });
+        });
+
+        describe(`with ${webpackProdConfigFileName} config`, () => {
+            beforeEach(() => mockFS({ ...packageFS(), [webpackProdConfigFileName]: '' }));
+
+            test('uses config', async () => {
+                await subject();
+
+                expect(webpack).toHaveBeenCalledWith(customProdConfig);
+            });
+        });
+
+        describe('when package is a web component', () => {
+            const source = 'src';
+            const destination = 'dist';
+            const startupVersion = '1.0.0';
+            const dependencies = { foo: '1.0.1' };
+            const sharedDependencies = { react: 'SharedDependencies.React' };
+
+            beforeEach(() => {
+                mockFS(webComponentFS(startupVersion));
+                jest.mocked(getFolders).mockReturnValue({ source, destination });
+                jest.mocked(getPackageData).mockReturnValue({ dependencies });
+                jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
+            });
+
+            test('builds full and "embed" packages', async () => {
+                const options = { buildStat, name: expectPackageName() };
+                const overrides = { configuration: { mode: 'production' } };
+
+                await subject();
+
+                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                    ...options,
+                    embed: true,
+                });
+                expect(compiler.run).toHaveBeenCalledTimes(2);
+            });
+
+            test('generates package metadata', async () => {
+                await subject();
+
+                expect(generatedMetadata(destination)).toEqual({
+                    name: expectPackageName(),
+                    bundledWith: { '@servicetitan/startup': startupVersion },
+                    dependencies,
+                    sharedDependencies,
+                    entrypoints: {},
+                });
+            });
+
+            describe('when package has entrypoints', () => {
+                const full = { css: 'foo', js: 'bar ' };
+                const light = { css: 'baz', js: 'qux' };
+
+                beforeEach(() => {
+                    mockFS({
+                        ...webComponentFS(startupVersion),
+                        dist: {
+                            bundle: {
+                                full: { 'entrypoints.json': JSON.stringify(full) },
+                                light: { 'entrypoints.json': JSON.stringify(light) },
+                            },
+                        },
+                    });
+                });
+
+                test('adds entrypoints to package metadata', async () => {
+                    await subject();
+
+                    expect(generatedMetadata(destination)).toEqual(
+                        expect.objectContaining({ entrypoints: { full, light } })
+                    );
+                });
+            });
+
+            describe(`with ${webpackProdConfigFileName} config`, () => {
+                beforeEach(() => {
+                    mockFS({ ...webComponentFS(startupVersion), [webpackProdConfigFileName]: '' });
+                });
+
+                test('uses config', async () => {
+                    const options = { buildStat, name: expectPackageName() };
+                    const overrides = {
+                        configuration: { mode: 'production', ...customProdConfig.configuration },
+                        plugins: customProdConfig.plugins,
+                    };
+
+                    await subject();
+
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                        ...options,
+                        embed: true,
+                    });
+                });
+            });
+        });
+    });
+
+    describe(`${bundleWatch.name}`, () => {
+        const customDevConfig = {
+            devServer: { host: 'http://127.0.0.0', port: '9000' },
+            configuration: { foo: 'bar' },
+            plugins: { baz: 'qux' },
+        };
+
+        function stopWatching(callback?: Function) {
+            setTimeout(() => callback?.(new Error('stopped')), 0);
+        }
+
+        beforeEach(() => {
+            mockFS(packageFS());
+            // Allows config file to be loaded with require(...)
+            jest.doMock(path.resolve(webpackDevConfigFileName), () => customDevConfig, {
+                virtual: true,
+            });
+            jest.mocked(WebpackDevServer).mockImplementation((): any => ({
+                listen: jest.fn((_0: number, _1: string, callback?: (error?: Error) => void) =>
+                    stopWatching(callback)
+                ),
+                close: compiler.close,
+            }));
+            compiler.watch = jest.fn((_, callback): any => {
+                stopWatching(callback);
+                return { compiler, close: compiler.close };
+            });
+        });
+
+        const subject = async () => {
+            await expect(bundleWatch()).rejects.toThrowError('stopped');
+        };
+
+        test('runs webpack development server', async () => {
+            await subject();
+
+            expect(createWebpackConfig).toHaveBeenCalledWith(
+                { configuration: { mode: 'development' } },
+                { name: expectPackageName() }
+            );
+            expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+            expect(WebpackDevServer).toHaveBeenCalledWith(compiler, {});
+        });
+
+        describe(`with ${webpackDevConfigFileName} config`, () => {
+            beforeEach(() => mockFS({ ...packageFS(), [webpackDevConfigFileName]: '' }));
+
+            test('uses config', async () => {
+                const { devServer, ...config } = customDevConfig;
+
+                await subject();
+
+                expect(webpack).toHaveBeenCalledWith(config);
+                expect(WebpackDevServer).toHaveBeenCalledWith(compiler, devServer);
+            });
+        });
+
+        describe('when package is a web component', () => {
+            const source = 'src';
+            const destination = 'dist';
+            const startupVersion = '1.0.0';
+            const dependencies = { foo: '1.0.1' };
+            const sharedDependencies = { react: 'SharedDependencies.React' };
+
+            beforeEach(() => {
+                mockFS(webComponentFS(startupVersion));
+                jest.mocked(getFolders).mockReturnValue({ source, destination });
+                jest.mocked(getPackageData).mockReturnValue({ dependencies });
+                jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
+            });
+
+            test('generates package metadata', async () => {
+                await subject();
+
+                expect(generatedMetadata(destination)).toEqual({
+                    name: expectPackageName(),
+                    bundledWith: { '@servicetitan/startup': startupVersion },
+                    dependencies,
+                    sharedDependencies,
+                    entrypoints: {},
+                });
+            });
+
+            test('runs webpack and webpack development server', async () => {
+                const options = { name: expectPackageName() };
+                const overrides = { configuration: { mode: 'development' } };
+
+                await subject();
+
+                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                    ...options,
+                    embed: true,
+                });
+                expect(webpack).toHaveBeenCalledWith(createWebpackResult);
+                expect(compiler.watch).toHaveBeenCalled();
+                expect(WebpackDevServer).toHaveBeenCalledWith(compiler, {});
+            });
+
+            describe(`with ${webpackDevConfigFileName} config`, () => {
+                beforeEach(() => {
+                    mockFS({ ...webComponentFS(startupVersion), [webpackDevConfigFileName]: '' });
+                });
+
+                test('uses config', async () => {
+                    const options = { name: expectPackageName() };
+                    const overrides = {
+                        configuration: { mode: 'development', ...customDevConfig.configuration },
+                        plugins: customDevConfig.plugins,
+                    };
+
+                    await subject();
+
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, options);
+                    expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
+                        ...options,
+                        embed: true,
+                    });
+                });
+            });
+        });
+    });
+});

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

@@ -0,0 +1,28 @@
+import { runCommandOutput } from '../cli-os';
+
+import { gitGetBranch, gitGetCommitHash } from '../cli-git';
+
+jest.mock('../cli-os', () => ({ runCommandOutput: jest.fn() }));
+
+describe('[startup] Cli Utils (Git)', () => {
+    beforeEach(() => jest.resetAllMocks());
+
+    function itRunsCommand(subject: Function, command: string) {
+        test(`runs "${command}"`, () => {
+            const result = ` ${command} result `;
+            jest.mocked(runCommandOutput).mockReturnValue(result);
+
+            expect(subject()).toBe(result.trim());
+
+            expect(runCommandOutput).toHaveBeenCalledWith(command);
+        });
+    }
+
+    describe(`${gitGetBranch.name}`, () => {
+        itRunsCommand(gitGetBranch, 'git rev-parse --abbrev-ref HEAD');
+    });
+
+    describe(`${gitGetCommitHash.name}`, () => {
+        itRunsCommand(gitGetCommitHash, 'git rev-parse --short HEAD');
+    });
+});

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

@@ -0,0 +1,166 @@
+import { runCommand, runCommandOutput } from '../cli-os';
+
+import {
+    npmGetPackageVersionDates,
+    npmGetPackageVersions,
+    npmPackageSet,
+    npmPublish,
+    npmPublishDry,
+    npmUnpublish,
+} from '../cli-npm';
+
+jest.mock('../cli-os', () => ({
+    runCommand: jest.fn().mockResolvedValue(undefined),
+    runCommandOutput: jest.fn(),
+}));
+
+describe('[startup] Cli Utils (Npm)', () => {
+    beforeEach(() => jest.resetAllMocks());
+
+    function getRunCommandArgs(fn: typeof runCommand | typeof runCommandOutput) {
+        const [command, options] = jest.mocked(fn).mock.calls[0];
+        return [
+            (Array.isArray(command) ? command : [command]).filter(str => !!str).join(' '),
+            options,
+        ];
+    }
+
+    function itRunsCommand(subject: Function, command: string, options?: any) {
+        test(`runs "${command}"`, async () => {
+            await subject();
+
+            const [actualCommand, actualOptions] = getRunCommandArgs(runCommand);
+
+            expect(actualCommand).toBe(command);
+            expect(actualOptions).toEqual(options);
+        });
+    }
+
+    function itRunsCommandOutput(subject: Function, command: string, options?: any) {
+        test(`runs "${command}"`, () => {
+            subject();
+
+            const [actualCommand, actualOptions] = getRunCommandArgs(runCommandOutput);
+
+            expect(actualCommand).toBe(command);
+            expect(actualOptions).toEqual(options);
+        });
+    }
+
+    describe(`${npmGetPackageVersions.name}`, () => {
+        let args: Parameters<typeof npmGetPackageVersions>;
+
+        beforeEach(() => (args = ['{registry}', '{packageName}']));
+
+        const subject = () => npmGetPackageVersions(...args);
+
+        itRunsCommandOutput(
+            subject,
+            'npm show {packageName} versions --registry {registry} --json',
+            { timeout: 10000 }
+        );
+
+        test('returns parsed result', () => {
+            const result = [{ foo: 'bar' }];
+
+            jest.mocked(runCommandOutput).mockReturnValue(JSON.stringify(result));
+
+            expect(subject()).toEqual(result);
+        });
+
+        describe('when an error occurs', () => {
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementation(() => {
+                    throw new Error('Oops!');
+                });
+            });
+
+            test('returns []', () => {
+                expect(subject()).toEqual([]);
+            });
+        });
+    });
+
+    describe(`${npmGetPackageVersionDates.name}`, () => {
+        let args: Parameters<typeof npmGetPackageVersionDates>;
+
+        beforeEach(() => (args = ['{registry}', '{packageName}']));
+
+        const subject = () => npmGetPackageVersionDates(...args);
+
+        itRunsCommandOutput(subject, 'npm view {packageName} time --registry {registry} --json', {
+            timeout: 10000,
+        });
+
+        test('converts results to Array<[string, Date]>', () => {
+            function dayAgo(count: number) {
+                const date = new Date();
+                date.setDate(-count);
+                return date;
+            }
+            const result = { '1.0.1': dayAgo(3), '2.1.0': dayAgo(2), '3.0.0': dayAgo(1) };
+
+            jest.mocked(runCommandOutput).mockReturnValue(JSON.stringify(result));
+
+            expect(subject()).toEqual(
+                Object.entries(result).map(([version, date]) => [version, date])
+            );
+        });
+
+        describe('when an error occurs', () => {
+            beforeEach(() => {
+                jest.mocked(runCommandOutput).mockImplementation(() => {
+                    throw new Error('Oops!');
+                });
+            });
+
+            test('returns []', () => {
+                expect(subject()).toEqual([]);
+            });
+        });
+    });
+
+    describe(`${npmPackageSet.name}`, () => {
+        let args: Parameters<typeof npmPackageSet>;
+
+        beforeEach(() => (args = ['{key}', '{value}']));
+
+        const subject = () => npmPackageSet(...args);
+
+        itRunsCommand(subject, 'npm pkg set {key}={value}');
+    });
+
+    describe(`${npmPublish.name}`, () => {
+        let args: Parameters<typeof npmPublish>;
+
+        beforeEach(() => (args = []));
+
+        const subject = async () => npmPublish(...args);
+
+        itRunsCommand(subject, 'npm publish');
+
+        describe('with a tag', () => {
+            beforeEach(() => args.push('{tag}'));
+
+            itRunsCommand(subject, 'npm publish --tag {tag}');
+        });
+    });
+
+    describe(`${npmPublishDry.name}`, () => {
+        itRunsCommand(npmPublishDry, 'npm publish --dry-run');
+    });
+
+    describe(`${npmUnpublish.name}`, () => {
+        let args: Parameters<typeof npmUnpublish>;
+
+        beforeEach(() => (args = ['{registry}', '{packageName}', '{packageVersion}']));
+
+        const subject = () => npmUnpublish(...args);
+
+        itRunsCommand(
+            subject,
+            'npm unpublish {packageName}@{packageVersion} --registry {registry}',
+            { timeout: 10000 }
+        );
+    });
+});

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

@@ -0,0 +1,103 @@
+import { execSync, spawn } from 'child_process';
+
+import { runCommand, runCommandOutput } from '../cli-os';
+
+jest.mock('child_process', () => ({ execSync: jest.fn(), spawn: jest.fn() }));
+jest.mock('../../../utils', () => ({ log: { info: jest.fn() } })); // suppress log output
+
+describe('[startup] Cli Utils (OS)', () => {
+    describe(`${runCommand.name}`, () => {
+        let exitCode: number;
+        let childProcess: ReturnType<typeof spawn>;
+
+        beforeEach(() => {
+            exitCode = 0;
+            childProcess = {
+                stderr: { pipe: jest.fn() },
+                stdout: { pipe: jest.fn() },
+                on: jest.fn((_event: string, callback: Function) => callback(exitCode)),
+            } as any;
+            jest.mocked(spawn).mockReturnValue(childProcess);
+        });
+
+        const subject = async (...args: Parameters<typeof runCommand>) => runCommand(...args);
+
+        test('runs command', () => {
+            expect(subject('foo bar')).resolves.toBe(undefined);
+
+            expect(spawn).toHaveBeenCalledWith('foo', ['bar'], undefined);
+        });
+
+        test('runs command with options', async () => {
+            await subject('foo', { timeout: 10000 });
+
+            expect(spawn).toHaveBeenCalledWith('foo', [], { timeout: 10000 });
+        });
+
+        test('runs command array', async () => {
+            await subject(['foo', 'bar', '--baz']);
+
+            expect(spawn).toHaveBeenCalledWith('foo', ['bar', '--baz'], undefined);
+        });
+
+        test("pipes stdout and stderr to parent's streams", async () => {
+            await subject('foo');
+
+            expect(childProcess.stdout?.pipe).toHaveBeenCalledWith(process.stdout);
+            expect(childProcess.stderr?.pipe).toHaveBeenCalledWith(process.stderr);
+        });
+
+        describe('when child process exits with non-zero code', () => {
+            beforeEach(() => (exitCode = 2));
+
+            test('rejects promise', () => {
+                expect(subject('foo')).rejects.toBeUndefined();
+            });
+        });
+
+        ['', [], ['']].forEach(command =>
+            test(`rejects promise when called with ${JSON.stringify(command)}`, () => {
+                expect(subject(command)).rejects.toBeUndefined();
+            })
+        );
+    });
+
+    describe(`${runCommandOutput.name}`, () => {
+        beforeEach(() => jest.mocked(execSync).mockReturnValue(''));
+
+        const subject = (...args: Parameters<typeof runCommandOutput>) => runCommandOutput(...args);
+
+        test('runs command and returns result', () => {
+            const result = 'baz qux';
+            jest.mocked(execSync).mockReturnValue(result);
+
+            expect(subject('foo bar')).toBe(result);
+
+            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+        });
+
+        test('runs command with options', () => {
+            subject('foo bar', { timeout: 10000 });
+
+            expect(execSync).toHaveBeenCalledWith('foo bar', { timeout: 10000 });
+        });
+
+        test('runs command array', () => {
+            subject(['foo', 'bar']);
+
+            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+        });
+
+        test('ignores false and "" array values', () => {
+            subject(['', 'foo', false, '', 'bar', false]);
+
+            expect(execSync).toHaveBeenCalledWith('foo bar', undefined);
+        });
+
+        ['', [], ['']].forEach(command =>
+            test(`throws error when called with ${JSON.stringify(command)}`, () => {
+                expect(() => subject(command)).toThrowError();
+            })
+        );
+    });
+});