@servicetitan/startup 29.0.0 → 30.0.0

package/src/cli/commands/__tests__/convert-eslint-config.test.ts

@@ -0,0 +1,455 @@
+import execa from 'execa';
+import { fs, vol } from 'memfs';
+import { ConvertEslintConfig } from '../convert-eslint-config';
+
+jest.mock('fs', () => fs);
+jest.mock('execa', () => jest.fn());
+
+describe(`[startup] ${ConvertEslintConfig.name}`, () => {
+    const eslintignoreFile = '.eslintignore';
+    const eslintrcFile = '.eslintrc.json';
+    const outputFile = 'eslint.config.mjs';
+
+    beforeEach(() => {
+        vol.reset();
+        vol.fromJSON({ [eslintrcFile]: JSON.stringify({}) });
+        jest.clearAllMocks();
+    });
+
+    const subject = async () => {
+        await new ConvertEslintConfig().execute();
+        return fs.readFileSync(outputFile, 'utf-8').toString();
+    };
+
+    function itReportsError(message: string | RegExp) {
+        test(`reports error: ${message}`, 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(message);
+            }
+        });
+    }
+
+    function mockConfig(config: Record<string, any>) {
+        vol.fromJSON({ [eslintrcFile]: JSON.stringify(config) });
+    }
+
+    describe(`when ${eslintrcFile} does not exist`, () => {
+        beforeEach(() => fs.rmSync(eslintrcFile));
+
+        itReportsError(`${eslintrcFile} not found`);
+    });
+
+    describe.each(['eslint.config.js', 'eslint.config.cjs', 'eslint.config.mjs'])(
+        'when %s already exists',
+        filename => {
+            beforeEach(() => fs.writeFileSync(filename, ''));
+
+            itReportsError(`flat config "${filename}" already exists`);
+        }
+    );
+
+    interface EmitOptions {
+        config: string;
+        import: { as: string; from: string };
+        name?: string;
+        files?: string[];
+    }
+
+    const extendsTestCases: Record<string, EmitOptions | null> = {
+        '@servicetitan/eslint-config/mono': {
+            import: { from: '@servicetitan/eslint-config/mono', as: 'mono' },
+            config: 'mono',
+        },
+        '@servicetitan/eslint-config/single': {
+            import: { as: 'single', from: '@servicetitan/eslint-config/single' },
+            config: 'single',
+        },
+        'plugin:chai-friendly/recommended': {
+            import: { as: 'pluginChaiFriendly', from: 'eslint-plugin-chai-friendly' },
+            config: 'pluginChaiFriendly.configs.recommendedFlat',
+        },
+        'plugin:cypress/recommended': {
+            import: { as: 'pluginCypress', from: 'eslint-plugin-cypress/flat' },
+            config: 'pluginCypress.configs.recommended',
+        },
+        'plugin:mocha/recommended': {
+            import: { as: 'pluginMocha', from: 'eslint-plugin-mocha' },
+            config: 'pluginMocha.configs.flat.recommended',
+        },
+        'plugin:storybook/recommended': {
+            import: { as: 'storybook', from: 'eslint-plugin-storybook' },
+            config: "storybook.configs['flat/recommended']",
+        },
+        'plugin:testing-library/react': {
+            import: { as: 'pluginTestingLibrary', from: 'eslint-plugin-testing-library' },
+            config: "pluginTestingLibrary.configs['flat/react']",
+            files: ['**/*.test.*'],
+        },
+        'prettier': null,
+    };
+
+    function itEmitsConfig(options: EmitOptions) {
+        test(`configures ${options.name ?? options.import.from}`, async () => {
+            const config = options.files?.length
+                ? `{ files: ${JSON.stringify(options.files)}, ...${options.config}}`
+                : options.config;
+
+            expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+                    import ${options.import.as} from '${options.import.from}';
+
+                    export default defineConfig([${config}]);
+                `);
+        });
+    }
+
+    function itIgnoresConfig() {
+        test(`ignores config`, async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([]);
+            `);
+        });
+    }
+
+    describe.each(Object.entries(extendsTestCases))(
+        'when config extends %s',
+        (name, emitOptions) => {
+            beforeEach(() => mockConfig({ extends: name }));
+
+            if (emitOptions === null) {
+                itIgnoresConfig();
+            } else {
+                itEmitsConfig(emitOptions);
+            }
+        }
+    );
+
+    describe('when "extends" is a string', () => {
+        const config = { extends: '@servicetitan/eslint-config/mono' };
+
+        beforeEach(() => mockConfig(config));
+
+        itEmitsConfig({ name: 'successfully', ...extendsTestCases[config.extends]! });
+    });
+
+    describe('when "extends" config is not recognized', () => {
+        const extendsArray = ['plugin:foo/recommended', 'foobar'];
+
+        beforeEach(() => mockConfig({ extends: extendsArray }));
+
+        test('emits extends in separate block', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ extends: extendsArray })}
+                ]);
+            `);
+        });
+    });
+
+    describe('when config contains "ignorePatterns"', () => {
+        const ignorePatterns = ['packages/api/**', ''];
+
+        beforeEach(() => mockConfig({ ignorePatterns }));
+
+        test('configures globalIgnores', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig, globalIgnores } from 'eslint/config';
+
+                export default defineConfig([globalIgnores(
+                    ${JSON.stringify(ignorePatterns.filter(glob => !!glob))}
+                )]);
+            `);
+        });
+
+        describe('when pattern is not a glob', () => {
+            const pattern = '*.scss.d.ts';
+
+            beforeEach(() => mockConfig({ ignorePatterns: [pattern] }));
+
+            test('converts ignore pattern to a glob', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig, globalIgnores } from 'eslint/config';
+
+                    export default defineConfig([globalIgnores(
+                        ${JSON.stringify([`**/${pattern}`])}
+                    )]);
+                `);
+            });
+        });
+
+        describe('when pattern has leading slash', () => {
+            beforeEach(() => mockConfig({ ignorePatterns: ['/foo', '!/foo/bar'] }));
+
+            test('removes leading slash', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig, globalIgnores } from 'eslint/config';
+
+                    export default defineConfig([globalIgnores(
+                        ${JSON.stringify(['foo', '!foo/bar'])}
+                    )]);
+                `);
+            });
+        });
+    });
+
+    describe('when config contains "parserOptions"', () => {
+        const parserOptions = { project: ['packages/*/tsconfig*.json', 'tsconfig*.json'] };
+
+        beforeEach(() => mockConfig({ parserOptions }));
+
+        test('moves parserOptions to languageOptions.parserOptions', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ languageOptions: { parserOptions } })}
+                ]);
+            `);
+        });
+    });
+
+    describe('when config contains "overrides"', () => {
+        const overrides = [
+            {
+                files: ['**/*.stories.ts{,x}'],
+                rules: { 'import/no-default-export': 'off' },
+            },
+            {
+                files: ['packages/utils/**/*'],
+                rules: { '@typescript-eslint/no-require-imports': 'off' },
+            },
+        ];
+
+        beforeEach(() => mockConfig({ overrides }));
+
+        test('hoists overrides to top level', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${overrides.map(item => JSON.stringify(item)).join()}
+                ]);
+            `);
+        });
+
+        describe('when "files" pattern it not a glob', () => {
+            const pattern = '*.{test,stories}.ts{,x}';
+
+            beforeEach(() => mockConfig({ overrides: [{ files: [pattern] }] }));
+
+            test('converts pattern to a glob', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([
+                        ${JSON.stringify({ files: [`**/${pattern}`] })}
+                    ]);
+                `);
+            });
+        });
+
+        describe('when override contains parserOptions', () => {
+            const parserOptions = {
+                project: ['./apps/**/tsconfig.json', './libraries/**/tsconfig.json'],
+                projectService: true,
+            };
+
+            beforeEach(() => mockConfig({ overrides: [{ parserOptions }] }));
+
+            test('moves parserOptions to language.parserOptions', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([
+                        ${JSON.stringify({ languageOptions: { parserOptions } })}
+                    ]);
+                `);
+            });
+        });
+    });
+
+    describe('when config contains "plugins"', () => {
+        const name = 'foo-bar';
+        const camelizedName = 'fooBar';
+
+        beforeEach(() => mockConfig({ plugins: [name] }));
+
+        itEmitsConfig({
+            name: 'plugin',
+            import: { as: camelizedName, from: `eslint-plugin-${name}` },
+            config: `{ plugins: { '${name}': ${camelizedName} } }`,
+        });
+    });
+
+    describe('when config contains "rules"', () => {
+        const rules = {
+            'no-restricted-imports': [
+                'error',
+                {
+                    paths: [
+                        {
+                            name: 'lodash',
+                            message: 'Use precise path imports from lodash library.',
+                        },
+                    ],
+                },
+            ],
+        };
+
+        beforeEach(() => mockConfig({ rules }));
+
+        test('adds rules to config', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ rules })}
+                ]);
+            `);
+        });
+
+        describe('when "rules" contains @typescript-eslint', () => {
+            const tsRules = {
+                '@typescript-eslint/no-base-to-string': 'warn',
+                '@typescript-eslint/no-redundant-type-constituents': 'warn',
+            };
+
+            beforeEach(() => mockConfig({ rules: { ...rules, ...tsRules } }));
+
+            test('moves @typescript-eslint rules to separate config with "files"', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([
+                        ${JSON.stringify({ rules })},
+                        ${JSON.stringify({ files: ['**/*.ts{,x}'], rules: tsRules })}
+                    ]);
+                `);
+            });
+        });
+    });
+
+    describe('when config contains "settings"', () => {
+        const settings = { 'import/resolver': 'typescript' };
+
+        beforeEach(() => mockConfig({ settings }));
+
+        test('copies settings to output', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ settings })}
+                ]);
+            `);
+        });
+    });
+
+    describe(`when directory contains ${eslintignoreFile}`, () => {
+        const lines = [
+            'coverage/',
+            '', // NOTE: Test includes blank line
+            'docusaurus/',
+            'packages/**/dist',
+        ];
+
+        beforeEach(() => {
+            vol.fromJSON({ [eslintignoreFile]: lines.join('\n') });
+        });
+
+        test('configures globalIgnores', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig, globalIgnores } from 'eslint/config';
+
+                export default defineConfig([
+                    globalIgnores(
+                        ${JSON.stringify(lines.filter(glob => !!glob))}
+                    )
+                ]);
+            `);
+        });
+
+        describe(`when ${eslintignoreFile} is empty`, () => {
+            beforeEach(() => {
+                vol.fromJSON({ [eslintignoreFile]: '\n  \n' });
+            });
+
+            test('omits globalIgnores', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([]);
+                `);
+            });
+        });
+
+        describe('when config contains "ignorePatterns"', () => {
+            const ignorePatterns = ['packages/api/**'];
+
+            beforeEach(() => mockConfig({ ignorePatterns }));
+
+            test('prepends ignorePatterns to globalIgnores', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig, globalIgnores } from 'eslint/config';
+
+                    export default defineConfig([
+                        globalIgnores(
+                            ${JSON.stringify([...ignorePatterns, ...lines].filter(glob => !!glob))}
+                        )
+                    ]);
+                `);
+            });
+        });
+    });
+
+    test('prettifies the output', async () => {
+        await subject();
+
+        expect(execa).toHaveBeenCalledWith('npx', ['prettier', '-w', outputFile], {
+            stdout: 'ignore',
+        });
+    });
+
+    describe('when prettier fails', () => {
+        const exitCode = 123;
+
+        beforeEach(() => {
+            jest.mocked(execa).mockRejectedValue({ exitCode });
+        });
+
+        itReportsError(/prettier failed with exit code/);
+    });
+});
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace jest {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        interface Matchers<R, T = {}> {
+            toMatchConfig(value: string): CustomMatcherResult;
+        }
+    }
+}
+
+expect.extend({
+    toMatchConfig(actual: string, value: string) {
+        const pass = actual.replace(/\s+/g, '') === value.replace(/\s+/g, '');
+        const message = pass
+            ? () => `expected:\n${actual}\n\nnot to be:\n${unIndent(value)}`
+            : () => `expected:\n${actual}\n\nto be:\n${unIndent(value)}`;
+        return { message, pass };
+    },
+});
+
+function unIndent(text: string) {
+    const indent = /^( +)/m.exec(text.trim())?.[0].length;
+    return indent ? text.trim().replace(new RegExp(`^ {${indent}}`, 'gm'), '') : text;
+}

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

@@ -68,8 +68,8 @@ describe(`[startup] ${Lint.name}`, () => {
         });
     }
 
-    describe('when instructed to isolate packages', () => {
-        beforeEach(() => (args.isolated = true));
+    describe('when instructed to lint packages in parallel', () => {
+        beforeEach(() => (args.parallel = true));
 
         itRunsLernaExec();