@servicetitan/startup 33.1.1 → 34.0.1

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

@@ -0,0 +1,346 @@
+import { fs, vol } from 'memfs';
+import path from 'node:path';
+import * as utils from '../../../utils';
+import { MfeCheck } from '../mfe-check';
+
+jest.mock('fs', () => fs);
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { info: jest.fn(), error: jest.fn(), warning: jest.fn() },
+}));
+
+describe(`[startup] ${MfeCheck.name}`, () => {
+    let stdoutWriteSpy: jest.SpyInstance;
+    let processExitCodeSpy: jest.SpyInstance;
+    let mfeCheckArgs:
+        | {
+              metadata?: string;
+              hostPackageJson?: string[];
+              json?: boolean;
+          }
+        | undefined;
+
+    const defaultMfeCheckArgs = {
+        metadata: '/path/to/metadata.json',
+        hostPackageJson: ['/path/to/host/package.json'],
+        json: false,
+    };
+
+    const mockMetadata = {
+        name: 'test-mfe',
+        version: '1.0.0',
+        bundledWith: { '@servicetitan/startup': '33.0.0' },
+        sharedDependencies: {
+            react: 'SharedDependencies.React',
+            mobx: 'SharedDependencies.MobX',
+        },
+        dependencies: { react: '^18.0.0', mobx: '^6.0.0' },
+        entrypoints: {},
+    };
+
+    const mockHostPackageJson = {
+        name: 'host-app',
+        cli: {
+            webpack: {
+                'expose-shared-dependencies': true,
+            },
+        },
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mfeCheckArgs = undefined;
+        stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+        processExitCodeSpy = jest.spyOn(process, 'exitCode', 'set').mockImplementation(() => {});
+
+        vol.fromJSON({
+            '/path/to/metadata.json': JSON.stringify(mockMetadata),
+            '/path/to/host/package.json': JSON.stringify(mockHostPackageJson),
+        });
+    });
+
+    afterEach(() => {
+        vol.reset();
+        stdoutWriteSpy.mockRestore();
+        processExitCodeSpy.mockRestore();
+    });
+
+    const subject = () => new MfeCheck({ ...defaultMfeCheckArgs, ...mfeCheckArgs }).execute();
+
+    function itSetsErrorExitCode() {
+        test('sets exit code to 1', async () => {
+            await subject();
+
+            expect(processExitCodeSpy).toHaveBeenCalledWith(1);
+        });
+    }
+
+    test('allows running from global location', () => {
+        expect(MfeCheck.allowRunFromGlobal).toBe(true);
+    });
+
+    describe('when compatible', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                '/path/to/host/package.json': JSON.stringify({
+                    ...mockHostPackageJson,
+                    dependencies: mockMetadata.dependencies,
+                }),
+            });
+        });
+
+        test('outputs human-readable compatible message', async () => {
+            await subject();
+
+            expect(utils.log.info).toHaveBeenCalledWith('Compatible: light bundle can be used');
+        });
+
+        test('does not set exit code', async () => {
+            await subject();
+
+            expect(processExitCodeSpy).not.toHaveBeenCalled();
+        });
+
+        describe('with --json option', () => {
+            beforeEach(() => {
+                mfeCheckArgs = {
+                    json: true,
+                };
+            });
+
+            test('outputs JSON', async () => {
+                await subject();
+
+                const output = stdoutWriteSpy.mock.calls[0][0];
+                const result = JSON.parse(output);
+
+                expect(result).toEqual({
+                    name: 'test-mfe',
+                    compatible: true,
+                    bundleType: 'light',
+                    isSharedDependenciesEnabled: true,
+                    isHostMfe: false,
+                });
+            });
+        });
+    });
+
+    describe('when incompatible', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                '/path/to/host/package.json': JSON.stringify({
+                    ...mockHostPackageJson,
+                    dependencies: { react: '19.0.0' },
+                }),
+            });
+        });
+
+        test('outputs dependency mismatch found error', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith('Dependency mismatch found:');
+        });
+
+        test('outputs individual dependency mismatch error', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith('  react: host=19.0.0, package=^18.0.0');
+        });
+
+        test('outputs full bundle required error', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith('Result: full bundle required');
+        });
+
+        itSetsErrorExitCode();
+
+        describe('with --json option', () => {
+            beforeEach(() => {
+                mfeCheckArgs = {
+                    json: true,
+                };
+            });
+
+            test('outputs JSON', async () => {
+                await subject();
+
+                const output = stdoutWriteSpy.mock.calls[0][0];
+                const result = JSON.parse(output);
+
+                expect(result).toEqual({
+                    name: 'test-mfe',
+                    compatible: false,
+                    bundleType: 'full',
+                    isSharedDependenciesEnabled: true,
+                    isHostMfe: false,
+                    mismatches: {
+                        react: { host: '19.0.0', package: '^18.0.0' },
+                        mobx: { host: 'missing', package: '^6.0.0' },
+                    },
+                });
+            });
+        });
+    });
+
+    describe('when metadata file does not exist', () => {
+        const missingMetadataPath = '/path/to/missing.json';
+
+        beforeEach(() => {
+            mfeCheckArgs = {
+                metadata: missingMetadataPath,
+            };
+        });
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(
+                `ENOENT: no such file or directory, open '${path.resolve(missingMetadataPath)}`
+            );
+        });
+    });
+
+    describe('when multiple host package.json files are provided', () => {
+        const mockHostPackage1 = {
+            name: 'host-app-1',
+            dependencies: { react: '17.0.0' },
+            cli: {
+                webpack: {
+                    'expose-shared-dependencies': true,
+                },
+            },
+        };
+
+        const mockHostPackage2 = {
+            name: 'host-app-2',
+            dependencies: { react: '18.2.0' },
+        };
+
+        beforeEach(() => {
+            mfeCheckArgs = {
+                hostPackageJson: ['/path/to/package1.json', '/path/to/package2.json'],
+            };
+
+            vol.fromJSON({
+                '/path/to/package1.json': JSON.stringify(mockHostPackage1),
+                '/path/to/package2.json': JSON.stringify(mockHostPackage2),
+            });
+        });
+
+        test('first host package.json dependencies prevail', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith('  react: host=17.0.0, package=^18.0.0');
+        });
+    });
+
+    describe('when expose-shared-dependencies is not enabled', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                '/path/to/host/package.json': JSON.stringify({
+                    ...mockHostPackageJson,
+                    cli: { webpack: {} },
+                }),
+            });
+        });
+
+        test('logs expose-shared-dependencies is not enabled error', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith(
+                'expose-shared-dependencies is not enabled in host package.json'
+            );
+        });
+
+        test('logs full bundle required', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith('Result: full bundle required');
+        });
+
+        itSetsErrorExitCode();
+
+        describe('with --json option', () => {
+            beforeEach(() => {
+                mfeCheckArgs = {
+                    json: true,
+                };
+            });
+
+            test('outputs JSON', async () => {
+                await subject();
+
+                const output = stdoutWriteSpy.mock.calls[0][0];
+                const result = JSON.parse(output);
+
+                expect(result).toEqual(
+                    expect.objectContaining({
+                        name: 'test-mfe',
+                        compatible: false,
+                        bundleType: 'full',
+                        isSharedDependenciesEnabled: false,
+                        isHostMfe: false,
+                    })
+                );
+            });
+        });
+    });
+
+    describe('when host package.json has no dependencies', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                '/path/to/host/package.json': JSON.stringify({
+                    name: 'host-app',
+                    cli: {
+                        webpack: {
+                            'expose-shared-dependencies': true,
+                        },
+                    },
+                }),
+            });
+        });
+
+        test('outputs individual dependency mismatch error', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith('  react: host=missing, package=^18.0.0');
+        });
+    });
+
+    describe('when host is an MFE', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                '/path/to/host/package.json': JSON.stringify({
+                    cli: { 'web-component': true },
+                }),
+            });
+        });
+
+        test('logs an error', async () => {
+            await subject();
+
+            expect(utils.log.error).toHaveBeenCalledWith(
+                'Skipping compatibility check because host is an MFE'
+            );
+        });
+
+        describe('with --json option', () => {
+            beforeEach(() => {
+                mfeCheckArgs = {
+                    json: true,
+                };
+            });
+
+            test('outputs JSON', async () => {
+                await subject();
+
+                const output = stdoutWriteSpy.mock.calls[0][0];
+                const result = JSON.parse(output);
+
+                expect(result).toEqual(
+                    expect.objectContaining({ compatible: false, isHostMfe: true })
+                );
+            });
+        });
+    });
+});

package/src/cli/commands/__tests__/mfe-generate-metadata.test.ts

@@ -0,0 +1,160 @@
+import { fs, vol } from 'memfs';
+import path from 'node:path';
+import { getPackageData, getStartupVersion, loadSharedDependencies, log } from '../../../utils';
+import { getLaunchDarklySdkVersion } from '../../../webpack/configs/utils/get-launchdarkly-sdk-version';
+import { getWebComponentsVersion } from '../../../webpack/configs/utils/get-web-components-version';
+import { MfeGenerateMetadata } from '../mfe-generate-metadata';
+
+jest.mock('fs', () => fs);
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    log: { info: jest.fn() },
+}));
+jest.mock('../../../webpack/configs/utils/get-web-components-version', () => ({
+    getWebComponentsVersion: jest.fn(() => '1.0.0'),
+}));
+jest.mock('../../../utils/get-startup-version', () => ({
+    getStartupVersion: jest.fn(() => '33.0.0'),
+}));
+jest.mock('../../../webpack/configs/utils/get-launchdarkly-sdk-version', () => ({
+    getLaunchDarklySdkVersion: jest.fn(() => '3.4.5'),
+}));
+
+describe(`[startup] ${MfeGenerateMetadata.name}`, () => {
+    let stdoutWriteSpy: jest.SpyInstance;
+    let mfeGenerateMetadataArgs: { output?: string } | undefined;
+
+    const mockPackageJson = {
+        name: 'test-mfe',
+        version: '1.0.0',
+        dependencies: { react: '^18.0.0', mobx: '^6.0.0' },
+        cli: {
+            'web-component': true,
+        },
+    };
+
+    const mockParentPackageJson = {
+        name: 'parent-package',
+        dependencies: { 'some-dep': '^1.0.0' },
+    };
+
+    const mockTsConfig = {
+        compilerOptions: {
+            rootDir: 'src',
+            outDir: 'dist',
+        },
+    };
+
+    function getMetadataFromStdout() {
+        const output = stdoutWriteSpy.mock.calls[0][0];
+        return JSON.parse(output);
+    }
+
+    function getMetadataFromFile(path: string) {
+        const content = vol.readFileSync(path, 'utf8') as string;
+        return JSON.parse(content);
+    }
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        mfeGenerateMetadataArgs = undefined;
+        stdoutWriteSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+
+        vol.fromJSON({
+            './package.json': JSON.stringify(mockPackageJson),
+            '../../package.json': JSON.stringify(mockParentPackageJson),
+            './tsconfig.json': JSON.stringify(mockTsConfig),
+        });
+    });
+
+    afterEach(() => {
+        vol.reset();
+        stdoutWriteSpy.mockRestore();
+    });
+
+    const subject = () => new MfeGenerateMetadata({ ...mfeGenerateMetadataArgs }).execute();
+
+    test('allows running from global location', () => {
+        expect(MfeGenerateMetadata.allowRunFromGlobal).toBe(true);
+    });
+
+    test('outputs valid JSON metadata', async () => {
+        await subject();
+
+        const packageData = getPackageData();
+
+        expect(getMetadataFromStdout()).toEqual({
+            ...packageData,
+            bundledWith: {
+                '@servicetitan/startup': getStartupVersion(),
+                '@servicetitan/web-components': getWebComponentsVersion(),
+                'launchdarkly-js-client-sdk': getLaunchDarklySdkVersion(),
+            },
+            sharedDependencies: loadSharedDependencies(
+                packageData.dependencies,
+                packageData.sharedDependencies
+            ),
+            entrypoints: {},
+        });
+    });
+
+    describe('when package is not a web component', () => {
+        beforeEach(() => {
+            vol.fromJSON({
+                './package.json': JSON.stringify({
+                    ...mockPackageJson,
+                    cli: {},
+                }),
+            });
+        });
+
+        test('throws error', async () => {
+            await expect(subject()).rejects.toThrow(
+                'this command must be run inside a web-component directory'
+            );
+        });
+    });
+
+    describe('with --output option', () => {
+        const outputDir = '/tmp/existing-dir';
+        const outputPath = `${outputDir}/metadata.json`;
+
+        beforeEach(() => {
+            vol.mkdirSync(outputDir, { recursive: true });
+            mfeGenerateMetadataArgs = {
+                output: outputPath,
+            };
+        });
+
+        test('writes metadata to file', async () => {
+            await subject();
+
+            expect(getMetadataFromFile(outputPath).name).toBe('test-mfe');
+        });
+
+        test('logs message', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                `Metadata written to ${path.resolve(outputPath)}`
+            );
+        });
+
+        describe('when output directory does not exist', () => {
+            beforeEach(() => fs.rmSync(outputDir, { recursive: true, force: true }));
+
+            test('creates directory', async () => {
+                await subject();
+
+                expect(vol.existsSync(outputDir)).toBe(true);
+            });
+
+            test('creates file', async () => {
+                await subject();
+
+                expect(vol.existsSync(outputPath)).toBe(true);
+            });
+        });
+    });
+});

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

@@ -13,6 +13,9 @@ jest.mock('fs', () => require('memfs').fs);
 jest.mock('readline/promises', () => ({
     createInterface: jest.fn(),
 }));
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     isTTY: jest.fn(),
@@ -150,6 +153,10 @@ describe(`[startup] ${MFEList.name}`, () => {
         });
     }
 
+    test('allows running from global location', () => {
+        expect(MFEList.allowRunFromGlobal).toBe(true);
+    });
+
     test(`outputs table with last ${DEFAULT_LIMIT} published versions`, async () => {
         await subject();
 
@@ -307,7 +314,7 @@ describe(`[startup] ${MFEList.name}`, () => {
         });
 
         describe('with --ignore', () => {
-            beforeEach(() => (args.ignore = mfeName));
+            beforeEach(() => (args.ignore = [mfeName]));
 
             test('omits specified MFE', async () => {
                 await subject();

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, npmGetPackageVersionsDetails, npmUnpublish, Version } from '../../utils';
-
 import { MFEPackageClean } from '../mfe-package-clean';
 
 jest.mock('fs', () => fs);