react-code-smell-detector 1.4.2 → 1.5.1

package/dist/__tests__/detectors/index.test.js

@@ -0,0 +1,1012 @@
+import { describe, it, expect } from 'vitest';
+import { detectDebugStatements } from '../../detectors/debug.js';
+import { detectJavascriptIssues } from '../../detectors/javascript.js';
+import { detectComplexity } from '../../detectors/complexity.js';
+import { detectUseEffectOveruse } from '../../detectors/useEffect.js';
+import { detectHooksRulesViolations } from '../../detectors/hooksRules.js';
+import { detectUnmemoizedCalculations } from '../../detectors/memoization.js';
+import { detectServerComponentIssues, detectAsyncComponentIssues } from '../../detectors/serverComponents.js';
+import { detectAccessibilityIssues } from '../../detectors/accessibility.js';
+import { detectSecurityIssues } from '../../detectors/security.js';
+import { detectPropDrilling, analyzePropDrillingDepth } from '../../detectors/propDrilling.js';
+import { detectMemoryLeaks } from '../../detectors/memoryLeak.js';
+import { detectMissingKeys } from '../../detectors/missingKey.js';
+import { detectNestedTernaries } from '../../detectors/nestedTernary.js';
+import { detectLargeComponent } from '../../detectors/largeComponent.js';
+import { detectMagicValues } from '../../detectors/magicValues.js';
+import { detectDeadCode } from '../../detectors/deadCode.js';
+import { detectDependencyArrayIssues } from '../../detectors/dependencyArray.js';
+import { detectImportIssues, analyzeImports } from '../../detectors/imports.js';
+import { detectUnusedCode } from '../../detectors/unusedCode.js';
+import { detectNextjsIssues } from '../../detectors/nextjs.js';
+import { detectTypescriptIssues } from '../../detectors/typescript.js';
+import { detectNodejsIssues } from '../../detectors/nodejs.js';
+import { detectReactNativeIssues } from '../../detectors/reactNative.js';
+import { parseCode } from '../../parser/index.js';
+import { DEFAULT_CONFIG } from '../../types/index.js';
+describe('Detectors Integration', () => {
+    // Helper to get first component from code
+    const getFirstComponent = (code) => {
+        const { components } = parseCode(code, 'test.tsx');
+        return components[0];
+    };
+    describe('detectDebugStatements', () => {
+        it('should detect console.log in component', () => {
+            const code = `
+        function TestComponent() {
+          console.log('test');
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectDebugStatements(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+            expect(smells.length).toBeGreaterThanOrEqual(1);
+            expect(smells[0].type).toBe('debug-statement');
+        });
+        it('should not flag clean component', () => {
+            const code = `
+        function CleanComponent() {
+          const value = 1;
+          return <div>{value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectDebugStatements(component, '/test.tsx', code);
+            expect(smells.length).toBe(0);
+        });
+    });
+    describe('detectJavascriptIssues', () => {
+        it('should detect var usage', () => {
+            const code = `
+        function VarComponent() {
+          var x = 1;
+          return <div>{x}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectJavascriptIssues(component, '/test.tsx', code);
+            const varSmells = smells.filter(s => s.type === 'js-var-usage');
+            expect(varSmells.length).toBe(1);
+        });
+        it('should detect loose equality', () => {
+            const code = `
+        function EqualityComponent({ a, b }) {
+          if (a == b) return <div>Equal</div>;
+          return <div>Not</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectJavascriptIssues(component, '/test.tsx', code);
+            const eqSmells = smells.filter(s => s.type === 'js-loose-equality');
+            expect(eqSmells.length).toBe(1);
+        });
+    });
+    describe('detectComplexity', () => {
+        it('should return array for component', () => {
+            const code = `
+        function SimpleComponent() {
+          return <div>Simple</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectComplexity(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    describe('detectUseEffectOveruse', () => {
+        it('should return array for component', () => {
+            const code = `
+        function EffectComponent() {
+          return <div>Effect</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectUseEffectOveruse(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    describe('detectHooksRulesViolations', () => {
+        it('should return array for component', () => {
+            const code = `
+        function HooksComponent() {
+          return <div>Hooks</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectHooksRulesViolations(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    describe('detectUnmemoizedCalculations', () => {
+        it('should return array for component', () => {
+            const code = `
+        function MemoComponent() {
+          return <div>Memo</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectUnmemoizedCalculations(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    describe('detectServerComponentIssues', () => {
+        it('should return array for component', () => {
+            const code = `
+        function ServerComponent() {
+          return <div>Server</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectServerComponentIssues(component, '/app/page.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('should not flag client component', () => {
+            const code = `
+        "use client";
+        function ClientComponent() {
+          return <div>Client</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectServerComponentIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            // Client components should not have server component issues
+            const serverSmells = smells.filter(s => s.type === 'server-component-hooks' ||
+                s.type === 'server-component-events');
+            expect(serverSmells.length).toBe(0);
+        });
+    });
+    describe('detectAsyncComponentIssues', () => {
+        it('should return array for component', () => {
+            const code = `
+        function SyncComponent() {
+          return <div>Sync</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            expect(component).toBeDefined();
+            const smells = detectAsyncComponentIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    // ============ ACCESSIBILITY TESTS ============
+    describe('detectAccessibilityIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkAccessibility: true };
+        it('should detect img without alt', () => {
+            const code = `
+        function ImgComponent() {
+          return <img src="photo.jpg" />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectAccessibilityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'a11y-missing-alt')).toBe(true);
+        });
+        it('should not flag img with alt', () => {
+            const code = `
+        function ImgComponent() {
+          return <img src="photo.jpg" alt="A photo" />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectAccessibilityIssues(component, '/test.tsx', code, config);
+            const altSmells = smells.filter(s => s.type === 'a11y-missing-alt' && s.severity === 'error');
+            expect(altSmells.length).toBe(0);
+        });
+        it('should detect input without label', () => {
+            const code = `
+        function FormComponent() {
+          return <input type="text" />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectAccessibilityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'a11y-missing-label')).toBe(true);
+        });
+        it('should detect clickable div without role', () => {
+            const code = `
+        function ClickDiv() {
+          return <div onClick={() => {}}>Click me</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectAccessibilityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'a11y-interactive-role')).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function ImgComponent() {
+          return <img src="photo.jpg" />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkAccessibility: false };
+            const smells = detectAccessibilityIssues(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ SECURITY TESTS ============
+    describe('detectSecurityIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkSecurity: true };
+        it('should detect dangerouslySetInnerHTML', () => {
+            const code = `
+        function XSSComponent() {
+          return <div dangerouslySetInnerHTML={{ __html: userInput }} />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectSecurityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'security-xss')).toBe(true);
+        });
+        it('should detect eval usage', () => {
+            const code = `
+        function EvalComponent() {
+          const result = eval('1 + 1');
+          return <div>{result}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectSecurityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'security-eval')).toBe(true);
+        });
+        it('should detect new Function', () => {
+            const code = `
+        function FunctionComponent() {
+          const fn = new Function('return 1');
+          return <div>{fn()}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectSecurityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'security-eval')).toBe(true);
+        });
+        it('should detect innerHTML assignment', () => {
+            const code = `
+        function InnerHTMLComponent() {
+          const ref = useRef();
+          ref.current.innerHTML = userContent;
+          return <div ref={ref} />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectSecurityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'security-xss')).toBe(true);
+        });
+        it('should detect javascript: URL', () => {
+            const code = `
+        function LinkComponent() {
+          return <a href="javascript:alert('xss')">Click</a>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectSecurityIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'security-xss')).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function EvalComponent() {
+          const result = eval('1 + 1');
+          return <div>{result}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkSecurity: false };
+            const smells = detectSecurityIssues(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ PROP DRILLING TESTS ============
+    describe('detectPropDrilling', () => {
+        it('should detect too many props', () => {
+            const code = `
+        function ManyPropsComponent({ a, b, c, d, e, f, g, h, i }) {
+          return <div>{a}{b}{c}{d}{e}{f}{g}{h}{i}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, maxPropsCount: 5 };
+            const smells = detectPropDrilling(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'prop-drilling')).toBe(true);
+        });
+        it('should detect drilling pattern props', () => {
+            const code = `
+        function DrillComponent({ userData, configData, settingsData }) {
+          return <div>{userData}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectPropDrilling(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(smells.some(s => s.type === 'prop-drilling')).toBe(true);
+        });
+        it('should not flag few props', () => {
+            const code = `
+        function FewPropsComponent({ name, age }) {
+          return <div>{name}: {age}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectPropDrilling(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(smells.length).toBe(0);
+        });
+    });
+    describe('analyzePropDrillingDepth', () => {
+        it('should detect props passed through multiple components', () => {
+            const code = `
+        function Parent({ userId }) { return <Child userId={userId} />; }
+        function Child({ userId }) { return <GrandChild userId={userId} />; }
+        function GrandChild({ userId }) { return <div>{userId}</div>; }
+      `;
+            const { components } = parseCode(code, 'test.tsx');
+            const config = { ...DEFAULT_CONFIG, maxPropDrillingDepth: 2 };
+            const smells = analyzePropDrillingDepth(components, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'prop-drilling')).toBe(true);
+        });
+    });
+    // ============ MEMORY LEAK TESTS ============
+    describe('detectMemoryLeaks', () => {
+        const config = { ...DEFAULT_CONFIG, checkMemoryLeaks: true };
+        it('should detect setInterval without cleanup', () => {
+            const code = `
+        function TimerComponent() {
+          useEffect(() => {
+            setInterval(() => console.log('tick'), 1000);
+          }, []);
+          return <div>Timer</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectMemoryLeaks(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'memory-leak-timer')).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function TimerComponent() {
+          setInterval(() => console.log('tick'), 1000);
+          return <div>Timer</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkMemoryLeaks: false };
+            const smells = detectMemoryLeaks(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ MISSING KEY TESTS ============
+    describe('detectMissingKeys', () => {
+        const config = { ...DEFAULT_CONFIG, checkMissingKeys: true };
+        it('should detect map without key', () => {
+            const code = `
+        function ListComponent({ items }) {
+          return <ul>{items.map(item => <li>{item}</li>)}</ul>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectMissingKeys(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'missing-key')).toBe(true);
+        });
+        it('should not flag map with key', () => {
+            const code = `
+        function ListComponent({ items }) {
+          return <ul>{items.map(item => <li key={item.id}>{item.name}</li>)}</ul>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectMissingKeys(component, '/test.tsx', code, config);
+            expect(smells.filter(s => s.type === 'missing-key').length).toBe(0);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function ListComponent({ items }) {
+          return <ul>{items.map(item => <li>{item}</li>)}</ul>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkMissingKeys: false };
+            const smells = detectMissingKeys(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ NESTED TERNARY TESTS ============
+    describe('detectNestedTernaries', () => {
+        it('should detect deeply nested ternaries', () => {
+            const code = `
+        function TernaryComponent({ a, b, c }) {
+          return <div>{a ? 'A' : b ? 'B' : c ? 'C' : 'D'}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, maxTernaryDepth: 1 };
+            const smells = detectNestedTernaries(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'nested-ternary')).toBe(true);
+        });
+        it('should not flag simple ternary', () => {
+            const code = `
+        function SimpleTernaryComponent({ show }) {
+          return <div>{show ? 'Yes' : 'No'}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, maxTernaryDepth: 2 };
+            const smells = detectNestedTernaries(component, '/test.tsx', code, config);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ LARGE COMPONENT TESTS ============
+    describe('detectLargeComponent', () => {
+        it('should detect large component', () => {
+            // Generate a component with many lines using unique variable names
+            const lines = Array(150).fill(null).map((_, i) => `const x${i} = ${i};`).join('\n');
+            const code = `
+        function LargeComponent() {
+          ${lines}
+          return <div>Large</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, maxComponentLines: 100 };
+            const smells = detectLargeComponent(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'large-component')).toBe(true);
+        });
+        it('should not flag small component', () => {
+            const code = `
+        function SmallComponent() {
+          return <div>Small</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectLargeComponent(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ MAGIC VALUES TESTS ============
+    describe('detectMagicValues', () => {
+        const config = { ...DEFAULT_CONFIG, checkMagicValues: true, magicNumberThreshold: 10 };
+        it('should detect magic numbers', () => {
+            const code = `
+        function MagicComponent() {
+          const width = 800;
+          const height = 600;
+          return <div>{width + height}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectMagicValues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'magic-value')).toBe(true);
+        });
+        it('should not flag common numbers', () => {
+            const code = `
+        function CommonComponent() {
+          const x = 0;
+          const y = 1;
+          const z = -1;
+          return <div>{x}{y}{z}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectMagicValues(component, '/test.tsx', code, config);
+            expect(smells.length).toBe(0);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function MagicComponent() {
+          const x = 42;
+          return <div>{x}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkMagicValues: false };
+            const smells = detectMagicValues(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ DEAD CODE TESTS ============
+    describe('detectDeadCode', () => {
+        const config = { ...DEFAULT_CONFIG, checkDeadCode: true };
+        it('should detect unused variables', () => {
+            const code = `
+        function DeadCodeComponent() {
+          const unusedVar = 42;
+          const usedVar = 10;
+          return <div>{usedVar}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectDeadCode(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'dead-code' && s.message.includes('unusedVar'))).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function DeadCodeComponent() {
+          const unused = 42;
+          return <div>Done</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkDeadCode: false };
+            const smells = detectDeadCode(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ DEPENDENCY ARRAY TESTS ============
+    describe('detectDependencyArrayIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkDependencyArrays: true };
+        it('should detect empty dependency array with external deps', () => {
+            const code = `
+        function DepComponent({ value }) {
+          useEffect(() => {
+            console.log(value);
+          }, []);
+          return <div>{value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectDependencyArrayIssues(component, '/test.tsx', code, config);
+            // Should detect missing dependency
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function DepComponent({ value }) {
+          useEffect(() => {
+            console.log(value);
+          }, []);
+          return <div>{value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkDependencyArrays: false };
+            const smells = detectDependencyArrayIssues(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ IMPORT ISSUES TESTS ============
+    describe('detectImportIssues', () => {
+        it('should analyze imports', () => {
+            const code = `
+        import React, { useState, useEffect, useCallback } from 'react';
+        import * as lodash from 'lodash';
+        
+        function TestComponent() {
+          const [x, setX] = useState(0);
+          return <div>{x}</div>;
+        }
+      `;
+            const { components } = parseCode(code, 'test.tsx');
+            const component = components[0];
+            const smells = detectImportIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('should detect namespace imports', () => {
+            const code = `
+        import * as everything from 'some-lib';
+        
+        function TestComponent() {
+          return <div>{everything.value}</div>;
+        }
+      `;
+            const { components } = parseCode(code, 'test.tsx');
+            const component = components[0];
+            const config = { ...DEFAULT_CONFIG, checkImports: true };
+            const smells = detectImportIssues(component, '/test.tsx', code, config);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    describe('analyzeImports', () => {
+        it('should be an async function', () => {
+            // analyzeImports is async and takes (files[], rootDir, config)
+            expect(typeof analyzeImports).toBe('function');
+        });
+    });
+    // ============ UNUSED CODE TESTS ============
+    describe('detectUnusedCode', () => {
+        const config = { ...DEFAULT_CONFIG, checkUnusedCode: true };
+        it('should return array', () => {
+            const code = `
+        function TestComponent() {
+          const unused = 42;
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectUnusedCode(component, '/test.tsx', code, config);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function TestComponent() {
+          const unused = 42;
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkUnusedCode: false };
+            const smells = detectUnusedCode(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ MORE COMPLEXITY TESTS ============
+    describe('detectComplexity (extended)', () => {
+        it('should detect high cyclomatic complexity', () => {
+            const code = `
+        function ComplexComponent({ a, b, c, d, e }) {
+          if (a) { return <div>A</div>; }
+          if (b) { return <div>B</div>; }
+          if (c) { return <div>C</div>; }
+          if (d) { return <div>D</div>; }
+          if (e) { return <div>E</div>; }
+          switch(a) {
+            case 1: return <div>1</div>;
+            case 2: return <div>2</div>;
+            case 3: return <div>3</div>;
+            case 4: return <div>4</div>;
+            default: return <div>Default</div>;
+          }
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, maxComplexity: 5 };
+            const smells = detectComplexity(component, '/test.tsx', code, config);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    // ============ MORE USEEFFECT TESTS ============
+    describe('detectUseEffectOveruse (extended)', () => {
+        it('should detect multiple useEffects', () => {
+            const code = `
+        function EffectsComponent() {
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          return <div>Effects</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectUseEffectOveruse(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    // ============ MORE HOOKS RULES TESTS ============
+    describe('detectHooksRulesViolations (extended)', () => {
+        const config = { ...DEFAULT_CONFIG, checkHooksRules: true };
+        it('should detect hooks in conditional', () => {
+            const code = `
+        function ConditionalHook({ show }) {
+          if (show) {
+            const [x, setX] = useState(0);
+          }
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectHooksRulesViolations(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'hooks-rules-violation')).toBe(true);
+        });
+        it('should detect hooks in loop', () => {
+            const code = `
+        function LoopHook({ items }) {
+          for (const item of items) {
+            const [x, setX] = useState(0);
+          }
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectHooksRulesViolations(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'hooks-rules-violation')).toBe(true);
+        });
+    });
+    // ============ MORE MEMOIZATION TESTS ============
+    describe('detectUnmemoizedCalculations (extended)', () => {
+        it('should detect expensive calculations', () => {
+            const code = `
+        function ExpensiveComponent({ items }) {
+          const sorted = items.sort((a, b) => a - b);
+          const filtered = items.filter(x => x > 5);
+          const mapped = items.map(x => x * 2);
+          return <div>{sorted.length}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectUnmemoizedCalculations(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+    // ============ NEXTJS TESTS ============
+    describe('detectNextjsIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkNextjs: true };
+        it('should detect native img usage', () => {
+            const code = `
+        function PageComponent() {
+          return <img src="/photo.jpg" alt="Photo" />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectNextjsIssues(component, '/app/page.tsx', code, config, ['next/image']);
+            expect(smells.some(s => s.type === 'nextjs-image-unoptimized')).toBe(true);
+        });
+        it('should detect client hooks without use client', () => {
+            const code = `
+        function PageComponent() {
+          const [count, setCount] = useState(0);
+          return <div>{count}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectNextjsIssues(component, '/app/page.tsx', code, config, []);
+            expect(smells.some(s => s.type === 'nextjs-client-server-boundary')).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function PageComponent() {
+          return <img src="/photo.jpg" alt="Photo" />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkNextjs: false };
+            const smells = detectNextjsIssues(component, '/app/page.tsx', code, disabledConfig, []);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ TYPESCRIPT TESTS ============
+    describe('detectTypescriptIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkTypescript: true };
+        it('should detect any type usage', () => {
+            const code = `
+        function TypedComponent(props: any) {
+          return <div>{props.value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectTypescriptIssues(component, '/test.tsx', code, config);
+            expect(smells.some(s => s.type === 'ts-any-usage')).toBe(true);
+        });
+        it('should not run on non-TypeScript files', () => {
+            const code = `
+        function Component(props) {
+          return <div>{props.value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectTypescriptIssues(component, '/test.jsx', code, config);
+            expect(smells.length).toBe(0);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function TypedComponent(props: any) {
+          return <div>{props.value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkTypescript: false };
+            const smells = detectTypescriptIssues(component, '/test.tsx', code, disabledConfig);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ NODEJS TESTS ============
+    describe('detectNodejsIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkNodejs: true };
+        it('should detect sync fs operations', () => {
+            const code = `
+        function ServerComponent() {
+          const data = fs.readFileSync('file.txt');
+          return <div>{data}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectNodejsIssues(component, '/api/route.ts', code, config, ['fs']);
+            expect(smells.some(s => s.type === 'nodejs-sync-io')).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function ServerComponent() {
+          const data = fs.readFileSync('file.txt');
+          return <div>{data}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkNodejs: false };
+            const smells = detectNodejsIssues(component, '/api/route.ts', code, disabledConfig, ['fs']);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ REACT NATIVE TESTS ============
+    describe('detectReactNativeIssues', () => {
+        const config = { ...DEFAULT_CONFIG, checkReactNative: true };
+        it('should detect inline styles', () => {
+            const code = `
+        function NativeComponent() {
+          return <View style={{ backgroundColor: 'red', padding: 10 }}>Hello</View>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectReactNativeIssues(component, '/App.tsx', code, config, ['react-native']);
+            expect(smells.some(s => s.type === 'rn-inline-style')).toBe(true);
+        });
+        it('should return empty when disabled', () => {
+            const code = `
+        function NativeComponent() {
+          return <View style={{ backgroundColor: 'red' }}>Hello</View>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const disabledConfig = { ...DEFAULT_CONFIG, checkReactNative: false };
+            const smells = detectReactNativeIssues(component, '/App.tsx', code, disabledConfig, ['react-native']);
+            expect(smells.length).toBe(0);
+        });
+    });
+    // ============ ADDITIONAL EDGE CASE TESTS ============
+    describe('Additional import/memoization/complexity tests', () => {
+        it('detectImportIssues should detect barrel imports', () => {
+            const code = `
+        import { Button, Card, Modal } from './components/index';
+        function ImportComponent() {
+          return <Button />;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectImportIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectImportIssues should detect namespace imports', () => {
+            const code = `
+        import * as lodash from 'lodash';
+        function LodashComponent() {
+          return <div>{lodash.get({}, 'a')}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectImportIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectUnmemoizedCalculations should detect expensive map operations', () => {
+            const code = `
+        function MapComponent({ items }) {
+          const mapped = items.map(i => i * 2).filter(x => x > 5).reduce((a, b) => a + b, 0);
+          return <div>{mapped}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectUnmemoizedCalculations(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectComplexity should detect complex conditionals', () => {
+            const code = `
+        function ComplexComponent({ a, b, c, d }) {
+          if (a && b || c && !d) {
+            if (a > b && c < d) {
+              return <div>Complex</div>;
+            }
+          }
+          return <div>Simple</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectComplexity(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectDeadCode should detect unreachable code after return', () => {
+            const code = `
+        function UnreachableComponent() {
+          return <div>Done</div>;
+          const unreachable = 1;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectDeadCode(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectDependencyArrayIssues should detect missing dependency', () => {
+            const code = `
+        function DepComponent({ count }) {
+          useEffect(() => {
+            console.log(count);
+          }, []);
+          return <div>{count}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectDependencyArrayIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectUnusedCode should detect unused imports', () => {
+            const code = `
+        import { useState, useEffect, useCallback } from 'react';
+        function SimpleComponent() {
+          const [val] = useState(0);
+          return <div>{val}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectUnusedCode(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectHooksRulesViolations should detect hook in condition', () => {
+            const code = `
+        function ConditionalHookComponent({ show }) {
+          if (show) {
+            const [val] = useState(0);
+          }
+          return <div>Conditional</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectHooksRulesViolations(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectUseEffectOveruse should detect many effects', () => {
+            const code = `
+        function ManyEffectsComponent() {
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          useEffect(() => {}, []);
+          return <div>Effects</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectUseEffectOveruse(component, '/test.tsx', code);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectMagicValues should detect magic strings', () => {
+            const code = `
+        function MagicStringComponent() {
+          const status = 'PROCESSING_STATE_ACTIVE';
+          return <div className="super-long-class-name-here">{status}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectMagicValues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectMemoryLeaks should detect setInterval without cleanup', () => {
+            const code = `
+        function IntervalComponent() {
+          useEffect(() => {
+            setInterval(() => console.log('tick'), 1000);
+          }, []);
+          return <div>Interval</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, checkMemoryLeaks: true };
+            const smells = detectMemoryLeaks(component, '/test.tsx', code, config);
+            expect(Array.isArray(smells)).toBe(true);
+            expect(smells.some(s => s.type === 'memory-leak-timer')).toBe(true);
+        });
+        it('detectSecurityIssues should detect eval usage', () => {
+            const code = `
+        function EvalComponent({ code }) {
+          const result = eval(code);
+          return <div>{result}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const config = { ...DEFAULT_CONFIG, checkSecurity: true };
+            const smells = detectSecurityIssues(component, '/test.tsx', code, config);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+        it('detectAccessibilityIssues should detect missing button text', () => {
+            const code = `
+        function ButtonComponent() {
+          return <button aria-label=""></button>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectAccessibilityIssues(component, '/test.tsx', code, DEFAULT_CONFIG);
+            expect(Array.isArray(smells)).toBe(true);
+        });
+    });
+});