react-code-smell-detector 1.5.0 → 1.5.2

package/dist/__tests__/htmlReporter.test.js

@@ -0,0 +1,258 @@
+import { describe, it, expect } from 'vitest';
+import { generateHTMLReport } from '../htmlReporter.js';
+import { DEFAULT_CONFIG } from '../types/index.js';
+describe('HTML Reporter', () => {
+    const createMockResult = (overrides = {}) => {
+        const defaultSmellsByType = Object.fromEntries(Object.keys(DEFAULT_CONFIG).filter(k => k !== 'customRulesPath').map(k => [k, 0]));
+        // Add all required smell types
+        const smellsByType = {
+            'useEffect-overuse': 0,
+            'prop-drilling': 0,
+            'large-component': 0,
+            'unmemoized-calculation': 0,
+            'missing-dependency': 0,
+            'state-in-loop': 0,
+            'inline-function-prop': 0,
+            'deep-nesting': 0,
+            'missing-key': 0,
+            'hooks-rules-violation': 0,
+            'dependency-array-issue': 0,
+            'nested-ternary': 0,
+            'dead-code': 0,
+            'magic-value': 0,
+            'nextjs-client-server-boundary': 0,
+            'nextjs-missing-metadata': 0,
+            'nextjs-image-unoptimized': 0,
+            'nextjs-router-misuse': 0,
+            'rn-inline-style': 0,
+            'rn-missing-accessibility': 0,
+            'rn-performance-issue': 0,
+            'nodejs-callback-hell': 0,
+            'nodejs-unhandled-promise': 0,
+            'nodejs-sync-io': 0,
+            'nodejs-missing-error-handling': 0,
+            'js-var-usage': 0,
+            'js-loose-equality': 0,
+            'js-implicit-coercion': 0,
+            'js-global-pollution': 0,
+            'ts-any-usage': 0,
+            'ts-missing-return-type': 0,
+            'ts-non-null-assertion': 0,
+            'ts-type-assertion': 0,
+            'debug-statement': 0,
+            'todo-comment': 0,
+            'security-xss': 0,
+            'security-eval': 0,
+            'security-secrets': 0,
+            'a11y-missing-alt': 0,
+            'a11y-missing-label': 0,
+            'a11y-interactive-role': 0,
+            'a11y-keyboard': 0,
+            'a11y-semantic': 0,
+            'high-cyclomatic-complexity': 0,
+            'high-cognitive-complexity': 0,
+            'memory-leak-event-listener': 0,
+            'memory-leak-subscription': 0,
+            'memory-leak-timer': 0,
+            'memory-leak-async': 0,
+            'circular-dependency': 0,
+            'barrel-file-import': 0,
+            'namespace-import': 0,
+            'excessive-imports': 0,
+            'unused-export': 0,
+            'dead-import': 0,
+            'server-component-hooks': 0,
+            'server-component-events': 0,
+            'server-component-browser-api': 0,
+            'async-client-component': 0,
+            'mixed-directives': 0,
+            // Context API issues
+            'context-overuse': 0,
+            'context-in-loop': 0,
+            'missing-context-memo': 0,
+            'large-context-value': 0,
+            // Error Boundary issues
+            'missing-error-boundary': 0,
+            'error-boundary-missing-fallback': 0,
+            'suspense-missing-fallback': 0,
+            // Form validation issues
+            'uncontrolled-form': 0,
+            'missing-form-validation': 0,
+            'form-without-onsubmit': 0,
+            'input-without-label': 0,
+            // State management issues
+            'redux-in-render': 0,
+            'excessive-redux-selectors': 0,
+            'state-sync-anti-pattern': 0,
+            'derived-state-in-state': 0,
+            // Testing gaps
+            'complex-untestable': 0,
+            'side-effect-heavy': 0,
+            'tightly-coupled': 0,
+            'custom-rule': 0,
+        };
+        return {
+            files: [],
+            summary: {
+                totalFiles: 0,
+                totalComponents: 0,
+                totalSmells: 0,
+                smellsByType,
+                smellsBySeverity: {
+                    error: 0,
+                    warning: 0,
+                    info: 0,
+                },
+            },
+            debtScore: {
+                score: 100,
+                grade: 'A',
+                breakdown: {
+                    useEffectScore: 100,
+                    propDrillingScore: 100,
+                    componentSizeScore: 100,
+                    memoizationScore: 100,
+                },
+                estimatedRefactorTime: '< 30 minutes',
+            },
+            ...overrides,
+        };
+    };
+    describe('generateHTMLReport', () => {
+        it('should generate valid HTML document', () => {
+            const result = createMockResult();
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('<!DOCTYPE html>');
+            expect(html).toContain('<html');
+            expect(html).toContain('</html>');
+        });
+        it('should include title', () => {
+            const result = createMockResult();
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('<title>');
+            expect(html).toContain('Code Smell');
+        });
+        it('should include CSS styles', () => {
+            const result = createMockResult();
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('<style>');
+            expect(html).toContain('</style>');
+        });
+        it('should display technical debt grade', () => {
+            const result = createMockResult();
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('A'); // Grade A
+        });
+        it('should display summary statistics', () => {
+            const result = createMockResult({
+                summary: {
+                    ...createMockResult().summary,
+                    totalFiles: 10,
+                    totalComponents: 25,
+                    totalSmells: 5,
+                },
+            });
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('10');
+            expect(html).toContain('25');
+        });
+        it('should handle smells with various severities', () => {
+            const result = createMockResult({
+                summary: {
+                    ...createMockResult().summary,
+                    smellsBySeverity: {
+                        error: 3,
+                        warning: 5,
+                        info: 2,
+                    },
+                    totalSmells: 10,
+                },
+            });
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('error');
+        });
+        it('should include breakdown scores', () => {
+            const result = createMockResult();
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('100'); // Perfect scores
+        });
+        it('should handle files with smells', () => {
+            const result = createMockResult({
+                files: [
+                    {
+                        file: '/root/src/App.tsx',
+                        components: [
+                            {
+                                name: 'App',
+                                file: '/root/src/App.tsx',
+                                startLine: 1,
+                                endLine: 20,
+                                lineCount: 20,
+                                useEffectCount: 1,
+                                useStateCount: 2,
+                                useMemoCount: 0,
+                                useCallbackCount: 0,
+                                propsCount: 3,
+                                propsDrillingDepth: 0,
+                                hasExpensiveCalculation: false,
+                            },
+                        ],
+                        smells: [
+                            {
+                                type: 'debug-statement',
+                                severity: 'warning',
+                                message: 'Console.log found',
+                                file: '/root/src/App.tsx',
+                                line: 10,
+                                column: 5,
+                                suggestion: 'Remove debug statement',
+                            },
+                        ],
+                        imports: [],
+                    },
+                ],
+            });
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('App.tsx');
+        });
+        it('should handle all grade levels', () => {
+            const grades = ['A', 'B', 'C', 'D', 'F'];
+            for (const grade of grades) {
+                const result = createMockResult({
+                    debtScore: {
+                        ...createMockResult().debtScore,
+                        grade,
+                        score: grade === 'A' ? 95 : grade === 'B' ? 85 : grade === 'C' ? 75 : grade === 'D' ? 65 : 50,
+                    },
+                });
+                const html = generateHTMLReport(result, '/root');
+                expect(html).toContain(grade);
+            }
+        });
+        it('should escape HTML in file paths', () => {
+            const result = createMockResult({
+                files: [
+                    {
+                        file: '/root/src/<Component>.tsx',
+                        components: [],
+                        smells: [],
+                        imports: [],
+                    },
+                ],
+            });
+            const html = generateHTMLReport(result, '/root');
+            // Should still generate valid HTML
+            expect(html).toContain('<!DOCTYPE html>');
+        });
+        it('should include estimated refactor time', () => {
+            const result = createMockResult({
+                debtScore: {
+                    ...createMockResult().debtScore,
+                    estimatedRefactorTime: '2-4 hours',
+                },
+            });
+            const html = generateHTMLReport(result, '/root');
+            expect(html).toContain('2-4 hours');
+        });
+    });
+});

package/dist/__tests__/interactiveFixer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interactiveFixer.test.d.ts.map

package/dist/__tests__/interactiveFixer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactiveFixer.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/interactiveFixer.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/interactiveFixer.test.js

@@ -0,0 +1,231 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { previewFixes } from '../interactiveFixer.js';
+describe('Interactive Fixer', () => {
+    let consoleLogSpy;
+    beforeEach(() => {
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+    });
+    const createFixableSmell = (type, file = '/project/src/test.tsx', line = 10) => ({
+        type: type,
+        severity: 'warning',
+        message: 'Test smell',
+        file,
+        line,
+        column: 5,
+        suggestion: 'Fix this issue',
+        fix: {
+            type: 'replace',
+            oldCode: 'var x = 1',
+            newCode: 'const x = 1',
+        },
+    });
+    const createNonFixableSmell = (type) => ({
+        type: type,
+        severity: 'warning',
+        message: 'Test smell',
+        file: '/project/src/test.tsx',
+        line: 10,
+        column: 5,
+        suggestion: 'Fix this issue',
+    });
+    describe('Fix filtering', () => {
+        it('should identify fixable smells', () => {
+            const fixable = createFixableSmell('js-var-usage');
+            const nonFixable = createNonFixableSmell('large-component');
+            expect(fixable.fix).toBeDefined();
+            expect(nonFixable.fix).toBeUndefined();
+        });
+        it('should filter fixable smells from array', () => {
+            const smells = [
+                createFixableSmell('js-var-usage'),
+                createNonFixableSmell('large-component'),
+                createFixableSmell('debug-statement'),
+                createNonFixableSmell('prop-drilling'),
+            ];
+            const fixable = smells.filter(s => s.fix !== undefined);
+            expect(fixable).toHaveLength(2);
+            expect(fixable[0].type).toBe('js-var-usage');
+            expect(fixable[1].type).toBe('debug-statement');
+        });
+    });
+    describe('Fix preview generation', () => {
+        it('should generate diff preview', () => {
+            const smell = createFixableSmell('js-var-usage');
+            expect(smell.fix?.oldCode).toBe('var x = 1');
+            expect(smell.fix?.newCode).toBe('const x = 1');
+        });
+        it('should handle multi-line fixes', () => {
+            const smell = {
+                type: 'debug-statement',
+                severity: 'warning',
+                message: 'Remove debug',
+                file: '/test.tsx',
+                line: 1,
+                column: 0,
+                suggestion: 'Remove console.log',
+                fix: {
+                    type: 'delete',
+                    oldCode: `console.log('debug');\nconsole.log('more');`,
+                    newCode: '',
+                },
+            };
+            expect(smell.fix?.oldCode).toContain('\n');
+            expect(smell.fix?.newCode).toBe('');
+        });
+        it('should handle insert type fixes', () => {
+            const smell = {
+                type: 'missing-key',
+                severity: 'error',
+                message: 'Missing key prop',
+                file: '/test.tsx',
+                line: 1,
+                column: 0,
+                suggestion: 'Add key prop',
+                fix: {
+                    type: 'insert',
+                    oldCode: '<Item />',
+                    newCode: '<Item key={id} />',
+                },
+            };
+            expect(smell.fix?.type).toBe('insert');
+        });
+    });
+    describe('Fix grouping by file', () => {
+        it('should group smells by file', () => {
+            const smells = [
+                { ...createFixableSmell('js-var-usage'), file: '/a.tsx' },
+                { ...createFixableSmell('debug-statement'), file: '/b.tsx' },
+                { ...createFixableSmell('console-log'), file: '/a.tsx' },
+            ];
+            const grouped = smells.reduce((acc, smell) => {
+                const file = smell.file;
+                if (!acc[file])
+                    acc[file] = [];
+                acc[file].push(smell);
+                return acc;
+            }, {});
+            expect(Object.keys(grouped)).toHaveLength(2);
+            expect(grouped['/a.tsx']).toHaveLength(2);
+            expect(grouped['/b.tsx']).toHaveLength(1);
+        });
+    });
+    describe('Fix statistics', () => {
+        it('should count applied fixes', () => {
+            const smells = [
+                createFixableSmell('js-var-usage'),
+                createFixableSmell('debug-statement'),
+                createFixableSmell('console-log'),
+            ];
+            const applied = smells.filter((_, i) => i < 2);
+            const skipped = smells.filter((_, i) => i >= 2);
+            expect(applied).toHaveLength(2);
+            expect(skipped).toHaveLength(1);
+        });
+        it('should categorize by fix type', () => {
+            const smells = [
+                {
+                    ...createFixableSmell('a'),
+                    fix: { type: 'replace', oldCode: 'a', newCode: 'b' },
+                },
+                {
+                    ...createFixableSmell('b'),
+                    fix: { type: 'delete', oldCode: 'c', newCode: '' },
+                },
+                {
+                    ...createFixableSmell('c'),
+                    fix: { type: 'insert', oldCode: '', newCode: 'd' },
+                },
+            ];
+            const byType = smells.reduce((acc, s) => {
+                const type = s.fix.type;
+                acc[type] = (acc[type] || 0) + 1;
+                return acc;
+            }, {});
+            expect(byType.replace).toBe(1);
+            expect(byType.delete).toBe(1);
+            expect(byType.insert).toBe(1);
+        });
+    });
+    describe('Fix ordering', () => {
+        it('should sort fixes by line number descending for safe application', () => {
+            const smells = [
+                { ...createFixableSmell('a'), line: 5 },
+                { ...createFixableSmell('b'), line: 20 },
+                { ...createFixableSmell('c'), line: 10 },
+            ];
+            // Sort descending so later fixes don't affect earlier line numbers
+            const sorted = [...smells].sort((a, b) => b.line - a.line);
+            expect(sorted[0].line).toBe(20);
+            expect(sorted[1].line).toBe(10);
+            expect(sorted[2].line).toBe(5);
+        });
+        it('should handle multiple fixes on same line by column', () => {
+            const smells = [
+                { ...createFixableSmell('a'), line: 10, column: 5 },
+                { ...createFixableSmell('b'), line: 10, column: 20 },
+                { ...createFixableSmell('c'), line: 10, column: 10 },
+            ];
+            // Sort by column descending for same line
+            const sorted = [...smells].sort((a, b) => {
+                if (a.line !== b.line)
+                    return b.line - a.line;
+                return b.column - a.column;
+            });
+            expect(sorted[0].column).toBe(20);
+            expect(sorted[1].column).toBe(10);
+            expect(sorted[2].column).toBe(5);
+        });
+    });
+    describe('previewFixes', () => {
+        it('should show message when no fixable issues', () => {
+            const nonFixableSmell = {
+                type: 'large-component',
+                severity: 'warning',
+                message: 'Too large',
+                file: '/test.tsx',
+                line: 1,
+                column: 0,
+                suggestion: 'Split component',
+            };
+            previewFixes([nonFixableSmell], '/project');
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+        it('should display fixable issues grouped by type', () => {
+            const smells = [
+                createFixableSmell('debug-statement', '/project/a.tsx', 10),
+                createFixableSmell('debug-statement', '/project/b.tsx', 20),
+                createFixableSmell('js-var-usage', '/project/c.tsx', 30),
+            ];
+            previewFixes(smells, '/project');
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+        it('should handle empty smells array', () => {
+            previewFixes([], '/project');
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+        it('should handle many smells of same type', () => {
+            const smells = Array.from({ length: 10 }, (_, i) => createFixableSmell('debug-statement', `/project/file${i}.tsx`, i + 1));
+            previewFixes(smells, '/project');
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+        it('should handle mixed fixable and non-fixable smells', () => {
+            const smells = [
+                createFixableSmell('debug-statement', '/project/a.tsx', 10),
+                {
+                    type: 'large-component',
+                    severity: 'warning',
+                    message: 'Too large',
+                    file: '/project/b.tsx',
+                    line: 1,
+                    column: 0,
+                    suggestion: 'Split component',
+                },
+            ];
+            previewFixes(smells, '/project');
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+    });
+});