@servicetitan/startup 30.3.0 → 31.0.0

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

@@ -0,0 +1,483 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { fs, vol } from 'memfs';
+import path from 'path';
+import terminalLink from 'terminal-link';
+
+import { findPackages, getReviewConfiguration, log } from '../../../../utils';
+import { expectCalls } from '../__mocks__';
+import { rules } from '../rules';
+import {
+    ErrorSeverity,
+    FixCategory,
+    Level,
+    Package,
+    PackageError,
+    ReviewConfiguration,
+} from '../types';
+import { indent } from '../utils';
+
+import { Review } from '../review';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('fs', () => fs);
+jest.mock('terminal-link', () => jest.fn());
+jest.mock('../../../../utils', () => ({
+    ...jest.requireActual('../../../../utils'),
+    log: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        success: jest.fn(),
+        text: jest.fn(),
+        warning: jest.fn(),
+    },
+    findPackages: jest.fn(),
+    getReviewConfiguration: jest.fn(),
+}));
+jest.mock('../rules', () => ({
+    rules: [
+        { id: 'rule1', run: jest.fn(), fix: jest.fn() },
+        { id: 'rule2', run: jest.fn(), fix: jest.fn() },
+        { id: 'rule3', run: jest.fn(), fix: jest.fn() },
+    ],
+}));
+
+describe(`[startup] ${Review.name}`, () => {
+    let args: ConstructorParameters<typeof Review>[0];
+
+    beforeEach(() => {
+        args = {};
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = async ({ suppressError = true }: { suppressError?: boolean } = {}) => {
+        return new Review(args).execute().catch(e => {
+            if (!suppressError) {
+                throw e;
+            }
+        });
+    };
+
+    function itThrowsError(message: RegExp) {
+        test('throws error', async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementationOnce(jest.fn()); // suppress error output
+            await expect(subject({ suppressError: false })).rejects.toThrow(message);
+        });
+    }
+
+    describe('when not run from workspace root', () => {
+        beforeEach(() => vol.fromJSON({}));
+
+        itThrowsError(/must be run from the workspace root/);
+    });
+
+    describe('when run from workspace root', () => {
+        const rootPackageJSON = { name: 'root', workspaces: ['packages/*'] };
+        const packageLockJSON = { packages: {} };
+        const packages: Package[] = [
+            {
+                name: 'a',
+                dependencies: { foo: '1.0.1', bar: '1.0.0' },
+                devDependencies: { qux: 'file:.yalc/qux' }, // test ignores non-version dependencies
+                location: 'a',
+            },
+            {
+                name: 'b',
+                dependencies: { foo: '1.0.0', bar: '1.0.0' },
+                devDependencies: { baz: '1.0.0' },
+                location: 'b',
+            },
+        ];
+        const expectedDependencies = {
+            bar: { '1.0.0': ['a', 'b'] },
+            baz: { '1.0.0': ['b'] },
+            foo: { '1.0.0': ['b'], '1.0.1': ['a'] },
+        };
+        let config: ReviewConfiguration;
+
+        function project() {
+            return {
+                config: {},
+                packageLock: { ...packageLockJSON, location: './package-lock.json' },
+                packages: [{ ...rootPackageJSON, location: '.' }, ...packages],
+                dependencies: expectedDependencies,
+            };
+        }
+
+        beforeEach(() => {
+            config = {};
+            vol.fromJSON({
+                'package.json': JSON.stringify(rootPackageJSON),
+                'package-lock.json': JSON.stringify(packageLockJSON),
+            });
+            jest.resetAllMocks();
+            jest.mocked(findPackages).mockImplementation(() => packages);
+            jest.mocked(getReviewConfiguration).mockImplementation(() => config);
+        });
+
+        function itReportsNoErrors() {
+            test('reports no errors', async () => {
+                await subject();
+
+                expect(log.success).toHaveBeenCalledWith('0 problems');
+            });
+        }
+
+        test('runs rules', async () => {
+            await subject();
+
+            rules.forEach(rule => expect(rule.run).toHaveBeenCalledWith(project()));
+        });
+
+        itReportsNoErrors();
+
+        describe('with no package-lock.json', () => {
+            beforeEach(() => fs.rmSync('package-lock.json'));
+
+            itThrowsError(/must be run with valid package-lock\.json/);
+        });
+
+        describe('when package-lock.json omits "packages"', () => {
+            beforeEach(() => {
+                vol.fromJSON({
+                    'package.json': JSON.stringify(rootPackageJSON),
+                    'package-lock.json': JSON.stringify({}),
+                });
+            });
+
+            itThrowsError(/must be run with valid package-lock\.json/);
+        });
+
+        describe('with --rule option', () => {
+            beforeEach(() => (args.rule = rules[0].id));
+
+            test('runs only specified rule', async () => {
+                await subject();
+
+                rules.forEach(rule => {
+                    if (args.rule === rule.id) {
+                        expect(rule.run).toHaveBeenCalled();
+                    } else {
+                        expect(rule.run).not.toHaveBeenCalled();
+                    }
+                });
+            });
+        });
+
+        describe('with multiple --rule options', () => {
+            beforeEach(() => (args.rule = [rules[1].id, rules[2].id]));
+
+            test('runs only specified rules', async () => {
+                await subject();
+
+                rules.forEach(rule => {
+                    if ((args.rule as string[]).includes(rule.id)) {
+                        expect(rule.run).toHaveBeenCalled();
+                    } else {
+                        expect(rule.run).not.toHaveBeenCalled();
+                    }
+                });
+            });
+        });
+
+        describe('when rule returns an error', () => {
+            let error: PackageError;
+
+            beforeEach(() => {
+                error = { id: rules[0].id, message: 'Oops!' };
+                jest.mocked(rules[0].run).mockImplementation(() => error);
+            });
+
+            function itReportsError() {
+                test('reports error', async () => {
+                    await subject();
+
+                    expectOutput(message(error));
+                });
+            }
+
+            function itReportsWarning() {
+                test('reports warning', async () => {
+                    await subject();
+
+                    expectOutput(message(error, { label: chalk.yellow('warning') }));
+                });
+            }
+
+            function expectOutput(...text: string[]) {
+                text.filter(line => line !== undefined).forEach((line, index) => {
+                    expect(log.text).toHaveBeenNthCalledWith(index + 1, line);
+                });
+            }
+
+            function location({ location = '' }: PackageError) {
+                return chalk.underline(path.relative('.', path.join(location, 'package.json')));
+            }
+
+            interface MessageOptions {
+                indent?: { details?: number; label?: number };
+                label?: string;
+            }
+
+            function message(error: PackageError, options: MessageOptions = {}) {
+                const { details = '', message } = error;
+                const { indent: indentLevel = {}, label } = options;
+
+                const prefix = indent(label ?? chalk.red('error'), indentLevel.label ?? 0);
+                const suffix = details && `\n${indent(details, indentLevel.details ?? 0)}`;
+                // terminal-link mock doesn't work so expect undefined here and check elsewhere it's called with expected args
+                const link = chalk.dim('undefined');
+
+                return `${prefix} ${message} ${link}${suffix}`;
+            }
+
+            itReportsError();
+
+            test('summarizes problems', async () => {
+                await subject();
+
+                expect(log.error).toHaveBeenCalledWith('1 problem (1 error, 0 warnings)');
+            });
+
+            test('includes link to rule', async () => {
+                await subject();
+
+                const url = `https://docs.st.dev/docs/frontend/uikit/startup/review#${error.id}`;
+                expect(terminalLink).toHaveBeenCalledWith(error.id, url);
+            });
+
+            describe('when problem is fixable', () => {
+                beforeEach(() => (error.fixable = FixCategory.normal));
+
+                test('summarizes fixable problems', async () => {
+                    await subject();
+
+                    expect(log.error).toHaveBeenCalledWith(
+                        '1 error and 0 warnings potentially fixable with --fix option'
+                    );
+                });
+
+                describe('with --fix', () => {
+                    beforeEach(() => (args.fix = true));
+
+                    test('fixes error', async () => {
+                        await subject();
+
+                        expect(rules[0].fix).toHaveBeenCalledWith(error, project());
+                    });
+
+                    test('reports fixes', async () => {
+                        await subject();
+
+                        expectOutput(`Fixing ${message(error)}`);
+                    });
+
+                    test('regenerates lockfile', async () => {
+                        await subject();
+
+                        expect(execSync).toHaveBeenCalledWith('npx startup install --fix --quiet', {
+                            stdio: 'inherit',
+                        });
+                    });
+
+                    test('summarizes fixes and remaining problems', async () => {
+                        await subject();
+
+                        expect(log.info).toHaveBeenCalledWith(
+                            'Fixed 1 problem, 1 problem remains:\n'
+                        );
+                    });
+
+                    describe('when no problems remain', () => {
+                        beforeEach(() => {
+                            jest.mocked(rules[0].run)
+                                .mockImplementationOnce(() => error)
+                                .mockImplementationOnce(() => undefined);
+                        });
+
+                        test('omits summary of remaining problems', async () => {
+                            await subject();
+
+                            expect(log.info).toHaveBeenCalledWith('Fixed 1 problem');
+                        });
+                    });
+                });
+            });
+
+            describe.each(['off', ['off']])(
+                'when rule is configured with severity %s',
+                (level: Level | [Level]) => {
+                    beforeEach(() => (config = { rules: { [error.id]: level } }));
+
+                    itReportsNoErrors();
+                }
+            );
+
+            describe.each(['warn', ['warn']])(
+                'when rule is configured with severity %s',
+                (level: Level | [Level]) => {
+                    beforeEach(() => (config = { rules: { [error.id]: level } }));
+
+                    itReportsWarning();
+                }
+            );
+
+            describe('when error is a warning', () => {
+                beforeEach(() => (error.severity = ErrorSeverity.warning));
+
+                itReportsWarning();
+
+                describe.each(['error', ['error']])(
+                    'when rule is configured with severity %s',
+                    (level: Level | [Level]) => {
+                        beforeEach(() => (config = { rules: { [error.id]: level } }));
+
+                        itReportsError();
+                    }
+                );
+            });
+
+            describe('when error has location', () => {
+                beforeEach(() => (error.location = path.resolve('./foo')));
+
+                test('indents error below location', async () => {
+                    await subject();
+
+                    expectOutput(location(error), message(error, { indent: { label: 1 } }));
+                });
+
+                describe('when location is package-lock.json', () => {
+                    beforeEach(() => (error.location = project().packageLock.location));
+
+                    test('outputs package-lock.json as location', async () => {
+                        await subject();
+
+                        expectOutput(chalk.underline(path.relative('.', error.location!)));
+                    });
+                });
+            });
+
+            describe('when error contains details', () => {
+                beforeEach(() => (error.details = ['detail1', 'detail2']));
+
+                test('indents details below error', async () => {
+                    await subject();
+
+                    expectOutput(message(error, { indent: { details: 1 } }));
+                });
+
+                describe('when error has location', () => {
+                    beforeEach(() => (error.location = path.resolve('./foo')));
+
+                    test('indents error and details below location', async () => {
+                        await subject();
+
+                        expectOutput(
+                            location(error),
+                            message(error, { indent: { details: 2, label: 1 } })
+                        );
+                    });
+                });
+            });
+
+            describe('with multiple errors', () => {
+                let errors: PackageError[];
+
+                beforeEach(() => {
+                    errors = [
+                        {
+                            id: rules[0].id,
+                            location: path.resolve('./foo'),
+                            message: 'Shucks!',
+                            severity: ErrorSeverity.warning,
+                            fixable: FixCategory.lockFile,
+                        },
+                        {
+                            id: rules[1].id,
+                            message: 'Oh oh!',
+                        },
+                        {
+                            id: rules[1].id,
+                            location: path.resolve('./foo'),
+                            message: 'Oops!',
+                            fixable: FixCategory.normal,
+                        },
+                        {
+                            id: rules[1].id,
+                            location: path.resolve('./bar'),
+                            message: 'Nope!',
+                            fixable: FixCategory.isolated,
+                        },
+                    ];
+                    jest.mocked(rules[0].run).mockImplementation(() => errors.slice(0, 1));
+                    jest.mocked(rules[1].run).mockImplementation(() => errors.slice(1));
+                });
+
+                test('groups errors by location', async () => {
+                    await subject();
+
+                    expectOutput(
+                        message(errors[1]), // errors with no location come first
+                        '',
+                        location(errors[3]), // "bar" location precedes "foo"
+                        message(errors[3], { indent: { label: 1 } }),
+                        '',
+                        location(errors[0]),
+                        message(errors[2], { indent: { label: 1 } }), // "error" precedes "warning"
+                        message(errors[0], {
+                            indent: { label: 1 },
+                            label: chalk.yellow('warning'),
+                        })
+                    );
+                });
+
+                describe('with --fix', () => {
+                    beforeEach(() => (args.fix = true));
+
+                    test('fixes errors by category and regenerates lockFile after each category', async () => {
+                        await subject();
+
+                        const fixesForCategory = (category: FixCategory) => {
+                            return errors
+                                .filter(({ fixable }) => fixable === category)
+                                .map(error => [
+                                    rules.find(({ id }) => id === error.id)!.fix!,
+                                    error,
+                                    project(),
+                                ]);
+                        };
+
+                        const execStartupInstallWithFixOption = [
+                            execSync,
+                            'npx startup install --fix --quiet',
+                            { stdio: 'inherit' },
+                        ];
+
+                        expectCalls(
+                            ...fixesForCategory(FixCategory.isolated),
+                            execStartupInstallWithFixOption,
+                            ...fixesForCategory(FixCategory.normal),
+                            execStartupInstallWithFixOption,
+                            ...fixesForCategory(FixCategory.lockFile),
+                            execStartupInstallWithFixOption
+                        );
+                    });
+
+                    describe('with --rule option', () => {
+                        beforeEach(() => (args.rule = rules[1].id));
+
+                        test('fixes only specified rule', async () => {
+                            await subject();
+
+                            expect(rules[0]!.fix).not.toHaveBeenCalled();
+                            expect(rules[1]!.fix).toHaveBeenCalled();
+                        });
+                    });
+                });
+            });
+        });
+    });
+});

package/src/cli/commands/review/index.ts

@@ -0,0 +1,3 @@
+export * from './review';
+
+export type { ReviewConfiguration } from './types';