@servicetitan/startup 22.14.0 → 22.16.0

package/src/utils/__tests__/get-configuration.test.ts

@@ -1,31 +1,230 @@
-import mock from 'mock-fs';
+import mockFS from 'mock-fs';
+import {
+    getConfiguration,
+    getDevServerConfiguration,
+    getESLintConfiguration,
+    getJestConfiguration,
+    getStylelintConfiguration,
+    isBundle,
+    isCustomStyleRules,
+    isExposeSharedDependencies,
+    isLegacy,
+    isStyleCheckDisabled,
+    isWebComponent,
+} from '../get-configuration';
+import WebpackDevServer from 'webpack-dev-server';
 
-import { isBundle } from '..';
+describe('[startup] Utils', () => {
+    const packageJson = 'package.json';
 
-describe('[Startup] utils:get-configuration', () => {
-    afterAll(() => {
-        mock.restore();
+    function packageJsonFS(content: Record<string, any> = {}) {
+        return { [packageJson]: JSON.stringify(content) };
+    }
+
+    function mockPackageJson(content: Record<string, any> = {}) {
+        mockFS(packageJsonFS(content));
+    }
+
+    function itReturns(subject: Function, value: any) {
+        test(`returns ${JSON.stringify(value)}`, () => expect(subject()).toEqual(value));
+    }
+
+    beforeEach(() => mockPackageJson());
+
+    afterEach(() => mockFS.restore());
+
+    describe(`${getConfiguration.name}`, () => {
+        let location: string | undefined;
+
+        beforeEach(() => (location = undefined));
+
+        const subject = () => getConfiguration(location);
+
+        itReturns(subject, {});
+
+        describe(`when ${packageJson} contains cli`, () => {
+            const cli = { foo: 'bar' };
+
+            beforeEach(() => mockPackageJson({ cli }));
+
+            test('returns cli', () => expect(subject()).toEqual(cli));
+        });
+
+        describe('with a location', () => {
+            const cli = { baz: 'qux' };
+
+            beforeEach(() => {
+                location = 'packages/foo';
+                mockFS({ packages: { foo: { [packageJson]: JSON.stringify({ cli }) } } });
+            });
+
+            test("returns location's cli", () => {
+                expect(subject()).toEqual(cli);
+            });
+        });
+    });
+
+    describe(`${getDevServerConfiguration.name}`, () => {
+        const subject = () => getDevServerConfiguration();
+
+        itReturns(subject, undefined);
+
+        describe('with "cli.webpack"', () => {
+            const webpack: WebpackDevServer.Configuration = {
+                // allowed options
+                contentBase: 'foo',
+                headers: { foo: 'bar' },
+                port: 9000,
+                proxy: { baz: 'qux' },
+                // example disallowed options
+                compress: true,
+                clientLogLevel: 'debug',
+            };
+
+            beforeEach(() => mockPackageJson({ cli: { webpack } }));
+
+            test('returns allowed options from "cli.webpack', () => {
+                const { contentBase, headers, port, proxy } = webpack;
+                expect(subject()).toEqual({ contentBase, headers, port, proxy });
+            });
+
+            describe('when "cli.webpack.proxy" is a path', () => {
+                const proxy = 'proxy.json';
+                const proxyConfig = { cli: { webpack: { ...webpack, proxy } } };
+
+                beforeEach(() => mockPackageJson(proxyConfig));
+
+                describe('when file does not exist', () => {
+                    test('drops the proxy option', () => {
+                        expect(subject()?.proxy).toBeUndefined();
+                    });
+                });
+
+                describe('when file exists', () => {
+                    beforeEach(() => {
+                        mockFS({
+                            ...packageJsonFS(proxyConfig),
+                            [proxy]: JSON.stringify(webpack.proxy),
+                            // Need node_modules so Jest can require() json file
+                            // eslint-disable-next-line @typescript-eslint/naming-convention
+                            node_modules: mockFS.load('./node_modules'),
+                        });
+                    });
+
+                    test('loads proxy option from the file', () => {
+                        expect(subject()?.proxy).toEqual(webpack.proxy);
+                    });
+                });
+            });
+        });
     });
 
-    beforeEach(() => {
-        mock({
-            'package.json': JSON.stringify({}),
+    describe(`${getESLintConfiguration.name}`, () => {
+        const subject = () => getESLintConfiguration();
+
+        itReturns(subject, {});
+
+        describe('with "cli.lint.eslint"', () => {
+            const content = { cli: { lint: { eslint: { foo: 'bar' } } } };
+
+            beforeEach(() => mockPackageJson(content));
+
+            test('returns "cli.lint.eslint"', () => {
+                expect(subject()).toEqual(content.cli.lint.eslint);
+            });
         });
     });
 
-    test('isBundle returns true if not explicitly disabled', () => {
-        expect(isBundle()).toBeTruthy();
+    describe(`${getJestConfiguration.name}`, () => {
+        const subject = () => getJestConfiguration();
 
-        mock({
-            'package.json': JSON.stringify({ cli: { webpack: true } }),
+        itReturns(subject, {});
+
+        describe('with "cli.test"', () => {
+            const content = { cli: { test: { foo: 'bar' } } };
+
+            beforeEach(() => mockPackageJson(content));
+
+            test('returns "cli.test"', () => {
+                expect(subject()).toEqual(content.cli.test);
+            });
         });
+    });
+
+    describe(`${getStylelintConfiguration.name}`, () => {
+        const subject = () => getStylelintConfiguration();
+
+        itReturns(subject, {});
 
-        expect(isBundle()).toBeTruthy();
+        describe('with "cli.lint.stylelint"', () => {
+            const content = { cli: { lint: { stylelint: { foo: 'bar' } } } };
 
-        mock({
-            'package.json': JSON.stringify({ cli: { webpack: false } }),
+            beforeEach(() => mockPackageJson(content));
+
+            test('returns "cli.lint.stylelint"', () => {
+                expect(subject()).toEqual(content.cli.lint.stylelint);
+            });
+        });
+    });
+
+    describe.each([
+        {
+            fn: isBundle,
+            defaultValue: true,
+            trigger: { cli: { webpack: false } },
+        },
+        {
+            fn: isCustomStyleRules,
+            defaultValue: false,
+            trigger: { cli: { webpack: { 'custom-style-rules': true } } },
+        },
+        {
+            fn: isExposeSharedDependencies,
+            defaultValue: false,
+            trigger: { cli: { webpack: { 'expose-shared-dependencies': true } } },
+        },
+        {
+            fn: isLegacy,
+            defaultValue: false,
+            trigger: { cli: { legacy: true } },
+        },
+        {
+            fn: isStyleCheckDisabled,
+            defaultValue: false,
+            trigger: { cli: { webpack: { 'disable-style-check': true } } },
+        },
+        {
+            fn: isWebComponent,
+            defaultValue: false,
+            trigger: { cli: { 'web-component': true } },
+        },
+    ])('$fn.name', ({ fn, defaultValue, trigger }) => {
+        itReturns(fn, defaultValue);
+
+        describe(`when ${packageJson} contains ${JSON.stringify(trigger)}`, () => {
+            beforeEach(() => mockPackageJson(trigger));
+
+            itReturns(fn, !defaultValue);
         });
+    });
+
+    describe(`${isLegacy.name}`, () => {
+        const trigger = { cli: { legacy: true } };
+        let location: string | undefined;
+
+        beforeEach(() => (location = undefined));
 
-        expect(isBundle()).toBeFalsy();
+        const subject = () => isLegacy(location);
+
+        describe('with a location', () => {
+            beforeEach(() => {
+                location = 'packages/foo';
+                mockFS({ packages: { foo: { [packageJson]: JSON.stringify(trigger) } } });
+            });
+
+            test("returns location's status", () => {
+                expect(subject()).toBe(true);
+            });
+        });
     });
 });

package/src/utils/__tests__/get-destination-folders.test.ts

@@ -0,0 +1,65 @@
+import fs from 'fs';
+import mockFS from 'mock-fs';
+import { getPackages } from '../get-packages';
+
+import { getDestinationFolders } from '../get-destination-folders';
+
+jest.mock('../get-packages', () => ({ getPackages: jest.fn() }));
+
+describe('[startup] Utils', () => {
+    describe(`${getDestinationFolders.name}`, () => {
+        let locations: string[];
+
+        beforeEach(() => {
+            locations = ['foo', 'bar'];
+            mockFS(packageFS(locations));
+            jest.mocked(getPackages).mockImplementation((): any =>
+                locations.map(location => ({ location: `packages/${location}` }))
+            );
+        });
+
+        afterEach(() => mockFS.restore());
+
+        const subject = () => getDestinationFolders();
+
+        function packageFS(locations: string[]) {
+            const packages = Object.fromEntries(
+                locations.map(location => [
+                    location,
+                    {
+                        'tsconfig.json': JSON.stringify({
+                            compilerOptions: { outDir: `${location}outDir` },
+                        }),
+                    },
+                ])
+            );
+            return { packages };
+        }
+
+        function expectedOutDirs(locations: string[]) {
+            return locations.map(location => `/packages/${location}/${location}outDir/`);
+        }
+
+        test('returns outDir path for all packages', () => {
+            expect(subject()).toEqual(expectedOutDirs(locations));
+        });
+
+        describe('when package has no tsconfig', () => {
+            beforeEach(() => mockFS(packageFS(locations.slice(1))));
+
+            test('omits location from result', () => {
+                expect(subject()).toEqual(expectedOutDirs(locations.slice(1)));
+            });
+        });
+
+        describe('when tsconfig has no "outDir"', () => {
+            beforeEach(() => {
+                fs.writeFileSync(`packages/${locations[0]}/tsconfig.json`, JSON.stringify({}));
+            });
+
+            test('omits location from result', () => {
+                expect(subject()).toEqual(expectedOutDirs(locations.slice(1)));
+            });
+        });
+    });
+});

package/src/utils/__tests__/get-jest-config.test.ts

@@ -0,0 +1,134 @@
+import { Config } from '@jest/types';
+import { getJestConfiguration } from '../get-configuration';
+import { getDestinationFolders } from '../get-destination-folders';
+
+import { getJestConfig, getJestConfigCLI } from '../get-jest-config';
+
+jest.mock('../get-destination-folders');
+jest.mock('../get-configuration', () => ({
+    ...jest.requireActual('../get-configuration'),
+    getJestConfiguration: jest.fn(),
+}));
+
+describe('[startup] Utils', () => {
+    const destinationFolders = ['dist'];
+    const defaultConfig = {
+        verbose: true,
+        testEnvironment: 'jsdom',
+        testRunner: 'jest-circus/runner',
+        transformIgnorePatterns: ['node_modules/(?!@servicetitan/)'],
+        modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
+        transform: {
+            '^.+\\.jsx?$': [
+                'babel-jest',
+                { presets: [['@babel/preset-env', { targets: { node: 'current' } }]] },
+            ],
+            '^.+\\.tsx?$': 'ts-jest',
+        },
+        moduleNameMapper: {
+            '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
+        },
+        globals: { 'ts-jest': { tsconfig: './tsconfig.test.json' } },
+        testPathIgnorePatterns: ['\\.yalc', ...destinationFolders],
+        setupFiles: [expect.stringMatching(/jest\/setup\.js/)],
+        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$'],
+        coverageReporters: ['html-spa', 'text', 'json', 'cobertura'],
+        collectCoverageFrom: ['**/*.{ts,tsx}'],
+    };
+
+    beforeEach(() => {
+        jest.mocked(getDestinationFolders).mockReturnValue(destinationFolders);
+        jest.mocked(getJestConfiguration).mockReturnValue({});
+    });
+
+    describe(`${getJestConfig.name}`, () => {
+        const subject = () => getJestConfig();
+
+        test('returns default config', () => {
+            expect(subject()).toEqual(defaultConfig);
+        });
+
+        describe.each(['coveragePathIgnorePatterns', 'setupFiles', 'testPathIgnorePatterns'])(
+            'with custom "%s"',
+            (
+                option: keyof Pick<
+                    typeof defaultConfig,
+                    'coveragePathIgnorePatterns' | 'setupFiles' | 'testPathIgnorePatterns'
+                >
+            ) => {
+                const customValue = ['foo', 'bar'];
+
+                beforeEach(() => {
+                    jest.mocked(getJestConfiguration).mockReturnValue({ [option]: customValue });
+                });
+
+                test(`appends custom value to "${option}"`, () => {
+                    expect(subject()).toEqual(
+                        expect.objectContaining({
+                            [option]: [...defaultConfig[option], ...customValue],
+                        })
+                    );
+                });
+            }
+        );
+
+        describe.each(['globals'])(
+            'with custom "%s"',
+            (option: keyof Pick<typeof defaultConfig, 'globals'>) => {
+                const customValue = { foo: 'bar' };
+
+                beforeEach(() => {
+                    jest.mocked(getJestConfiguration).mockReturnValue({ [option]: customValue });
+                });
+
+                test(`merges custom value with "${option}"`, () => {
+                    expect(subject()).toEqual(
+                        expect.objectContaining({
+                            [option]: { ...defaultConfig[option], ...customValue },
+                        })
+                    );
+                });
+            }
+        );
+
+        describe('with other custom options', () => {
+            const customOptions = { resetMocks: true, testEnvironment: 'node' };
+
+            beforeEach(() => jest.mocked(getJestConfiguration).mockReturnValue(customOptions));
+
+            test('merges custom options with default config', () => {
+                expect(subject()).toEqual({ ...defaultConfig, ...customOptions });
+            });
+        });
+    });
+
+    describe(`${getJestConfigCLI.name}`, () => {
+        let args: Config.Argv;
+
+        const subject = () => getJestConfigCLI(args);
+
+        beforeEach(() => {
+            const commandLineOptions: Omit<Config.Argv, '_' | '$0'> = { runInBand: true };
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            args = { _: [], $0: '', ...commandLineOptions };
+        });
+
+        const stringified: (keyof typeof defaultConfig)[] = [
+            'globals',
+            'moduleNameMapper',
+            'transform',
+        ];
+
+        test(`merges command line args with default config and stringifies "${stringified.join(
+            '", "'
+        )}"`, () => {
+            expect(subject()).toEqual({
+                ...defaultConfig,
+                ...args,
+                ...Object.fromEntries(
+                    stringified.map(option => [option, JSON.stringify(defaultConfig[option])])
+                ),
+            });
+        });
+    });
+});

package/src/utils/__tests__/get-package-data.test.ts

@@ -0,0 +1,90 @@
+import { readJson } from '../read-json';
+
+import { getPackageData, getPackageDependencyVersion } from '../get-package-data';
+
+jest.mock('../read-json', () => ({ readJson: jest.fn() }));
+
+describe(`[startup] Utils`, () => {
+    describe(`${getPackageData.name}`, () => {
+        const packageJson = './package.json';
+        const ancestorPackageJson = '../../package.json';
+        let packages: Record<string, Record<string, any>>;
+
+        beforeEach(() => {
+            packages = {
+                [ancestorPackageJson]: { dependencies: { foo: '1.0.0', bar: '2.0.0' } },
+                [packageJson]: { dependencies: { foo: '1.1.0', baz: '3.0.0' } },
+            };
+            jest.mocked(readJson).mockImplementation(path => packages[path] ?? {});
+        });
+
+        const subject = () => getPackageData();
+
+        test(`returns merged dependencies from ${packageJson} and ${ancestorPackageJson}`, () => {
+            expect(subject()).toEqual({
+                dependencies: {
+                    ...packages[ancestorPackageJson].dependencies,
+                    ...packages[packageJson].dependencies,
+                },
+            });
+        });
+
+        describe(`when ${packageJson} contains sharedDependencies`, () => {
+            const sharedDependencies = { react: 'SharedDependencies.React' };
+
+            beforeEach(() => {
+                Object.assign(packages[packageJson], {
+                    cli: { webpack: { 'shared-dependencies': sharedDependencies } },
+                });
+            });
+
+            test('returns sharedDependencies', () => {
+                expect(subject()).toEqual(expect.objectContaining({ sharedDependencies }));
+            });
+        });
+    });
+
+    describe(`${getPackageDependencyVersion.name}`, () => {
+        const dependency = 'foo';
+        let defaultVersion: string | undefined;
+
+        beforeEach(() => (defaultVersion = undefined));
+
+        const subject = () => getPackageDependencyVersion(dependency, defaultVersion);
+
+        function itReturnsUndefinedOrDefaultVersion() {
+            test('returns undefined', () => {
+                expect(subject()).toBe(undefined);
+            });
+
+            describe('with a default version', () => {
+                beforeEach(() => (defaultVersion = '1.2.3'));
+
+                test('returns default version', () => {
+                    expect(subject()).toBe(defaultVersion);
+                });
+            });
+        }
+
+        itReturnsUndefinedOrDefaultVersion();
+
+        describe('when dependency exists', () => {
+            const module: Record<string, any> = {};
+
+            beforeEach(() => {
+                module.version = '2.3.4';
+                jest.doMock(`${dependency}/package.json`, () => module, { virtual: true });
+            });
+
+            test('returns dependency version', () => {
+                expect(subject()).toBe(module.version);
+            });
+
+            describe('when dependency has no version', () => {
+                beforeEach(() => delete module.version);
+
+                itReturnsUndefinedOrDefaultVersion();
+            });
+        });
+    });
+});