react-code-smell-detector 1.4.2 → 1.5.1

package/dist/__tests__/customRules.test.js

@@ -0,0 +1,283 @@
+import { describe, it, expect, vi } from 'vitest';
+import { parseCustomRules, detectCustomRuleViolations, generateRulesDocumentation, EXAMPLE_CUSTOM_RULES } from '../customRules.js';
+import { parseCode } from '../parser/index.js';
+describe('Custom Rules', () => {
+    const getFirstComponent = (code) => {
+        const { components } = parseCode(code, 'test.tsx');
+        return components[0];
+    };
+    describe('parseCustomRules', () => {
+        it('should return empty array for no custom rules', () => {
+            const rules = parseCustomRules({});
+            expect(rules).toEqual([]);
+        });
+        it('should return empty array for undefined custom rules', () => {
+            const rules = parseCustomRules({ customRules: undefined });
+            expect(rules).toEqual([]);
+        });
+        it('should parse single rule object', () => {
+            const config = {
+                customRules: {
+                    name: 'no-console',
+                    pattern: 'console.log',
+                    patternType: 'text',
+                    severity: 'error',
+                },
+            };
+            const rules = parseCustomRules(config);
+            expect(rules).toHaveLength(1);
+            expect(rules[0].name).toBe('no-console');
+            expect(rules[0].severity).toBe('error');
+        });
+        it('should parse array of rules', () => {
+            const config = {
+                customRules: [
+                    { name: 'rule1', pattern: 'test1', patternType: 'text' },
+                    { name: 'rule2', pattern: 'test2', patternType: 'regex' },
+                ],
+            };
+            const rules = parseCustomRules(config);
+            expect(rules).toHaveLength(2);
+            expect(rules[0].name).toBe('rule1');
+            expect(rules[1].name).toBe('rule2');
+        });
+        it('should filter out invalid rules without name', () => {
+            const config = {
+                customRules: [
+                    { pattern: 'test1' }, // missing name
+                    { name: 'rule2', pattern: 'test2' },
+                ],
+            };
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const rules = parseCustomRules(config);
+            expect(rules).toHaveLength(1);
+            expect(rules[0].name).toBe('rule2');
+            warnSpy.mockRestore();
+        });
+        it('should filter out invalid rules without pattern', () => {
+            const config = {
+                customRules: [
+                    { name: 'rule1' }, // missing pattern
+                    { name: 'rule2', pattern: 'test2' },
+                ],
+            };
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            const rules = parseCustomRules(config);
+            expect(rules).toHaveLength(1);
+            expect(rules[0].name).toBe('rule2');
+            warnSpy.mockRestore();
+        });
+        it('should set defaults for optional fields', () => {
+            const config = {
+                customRules: [{ name: 'test-rule', pattern: 'test' }],
+            };
+            const rules = parseCustomRules(config);
+            expect(rules[0].severity).toBe('warning');
+            expect(rules[0].patternType).toBe('text');
+            expect(rules[0].enabled).toBe(true);
+        });
+        it('should respect enabled flag', () => {
+            const config = {
+                customRules: [
+                    { name: 'enabled-rule', pattern: 'test', enabled: true },
+                    { name: 'disabled-rule', pattern: 'test', enabled: false },
+                ],
+            };
+            const rules = parseCustomRules(config);
+            expect(rules).toHaveLength(2);
+            expect(rules.find(r => r.name === 'enabled-rule')?.enabled).toBe(true);
+            expect(rules.find(r => r.name === 'disabled-rule')?.enabled).toBe(false);
+        });
+        it('should handle regex pattern type', () => {
+            const config = {
+                customRules: [
+                    { name: 'regex-rule', pattern: '\\bconsole\\b', patternType: 'regex' },
+                ],
+            };
+            const rules = parseCustomRules(config);
+            expect(rules[0].patternType).toBe('regex');
+        });
+        it('should preserve custom message', () => {
+            const config = {
+                customRules: [
+                    {
+                        name: 'test-rule',
+                        pattern: 'test',
+                        message: 'Custom error message',
+                    },
+                ],
+            };
+            const rules = parseCustomRules(config);
+            expect(rules[0].message).toBe('Custom error message');
+        });
+        it('should handle non-object customRules', () => {
+            const rules = parseCustomRules({ customRules: 'invalid' });
+            expect(rules).toEqual([]);
+        });
+        it('should handle description field', () => {
+            const config = {
+                customRules: [{
+                        name: 'test-rule',
+                        pattern: 'test',
+                        description: 'This is a test rule',
+                    }],
+            };
+            const rules = parseCustomRules(config);
+            expect(rules[0].description).toBe('This is a test rule');
+        });
+    });
+    describe('detectCustomRuleViolations', () => {
+        it('should detect text pattern violations', () => {
+            const code = `
+        function TestComponent() {
+          const todo = 'hello world';
+          return <div>{todo}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const rules = [{
+                    name: 'no-hello',
+                    pattern: 'hello',
+                    patternType: 'text',
+                    severity: 'warning',
+                    enabled: true,
+                    message: 'Found hello',
+                }];
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, rules);
+            expect(smells.length).toBeGreaterThanOrEqual(1);
+            expect(smells[0].message).toBe('Found hello');
+        });
+        it('should detect regex pattern violations', () => {
+            const code = `
+        function TestComponent() {
+          const value = 12345;
+          return <div>{value}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const rules = [{
+                    name: 'no-numbers',
+                    pattern: '\\d{5}',
+                    patternType: 'regex',
+                    severity: 'error',
+                    enabled: true,
+                    message: 'Found 5-digit number',
+                }];
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, rules);
+            expect(smells.length).toBeGreaterThanOrEqual(1);
+            expect(smells[0].severity).toBe('error');
+        });
+        it('should skip disabled rules', () => {
+            const code = `
+        function TestComponent() {
+          const hello = 'world';
+          return <div>{hello}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const rules = [{
+                    name: 'no-hello',
+                    pattern: 'hello',
+                    patternType: 'text',
+                    severity: 'warning',
+                    enabled: false,
+                    message: 'Found hello',
+                }];
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, rules);
+            expect(smells.length).toBe(0);
+        });
+        it('should handle AST pattern type', () => {
+            const code = `
+        function TestComponent() {
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const rules = [{
+                    name: 'detect-jsx',
+                    pattern: 'JSXElement',
+                    patternType: 'ast',
+                    severity: 'info',
+                    enabled: true,
+                    message: 'Found JSX element',
+                }];
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, rules);
+            expect(smells.length).toBeGreaterThanOrEqual(1);
+        });
+        it('should return empty array for no rules', () => {
+            const code = `
+        function TestComponent() {
+          return <div>Test</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, []);
+            expect(smells).toEqual([]);
+        });
+        it('should include code snippet in violation', () => {
+            const code = `function TestComponent() {
+  const badVar = 'test';
+  return <div>{badVar}</div>;
+}`;
+            const component = getFirstComponent(code);
+            const rules = [{
+                    name: 'no-bad',
+                    pattern: 'badVar',
+                    patternType: 'text',
+                    severity: 'warning',
+                    enabled: true,
+                }];
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, rules);
+            expect(smells.some(s => s.codeSnippet?.includes('badVar'))).toBe(true);
+        });
+        it('should handle RegExp objects', () => {
+            const code = `
+        function Test() {
+          const x = console.debug('test');
+          return <div>{x}</div>;
+        }
+      `;
+            const component = getFirstComponent(code);
+            const rules = [{
+                    name: 'no-console-debug',
+                    pattern: /console\.debug/,
+                    patternType: 'regex',
+                    severity: 'warning',
+                    enabled: true,
+                }];
+            const smells = detectCustomRuleViolations(component, '/test.tsx', code, rules);
+            expect(smells.length).toBeGreaterThanOrEqual(1);
+        });
+    });
+    describe('generateRulesDocumentation', () => {
+        it('should return documentation string', () => {
+            const docs = generateRulesDocumentation();
+            expect(typeof docs).toBe('string');
+            expect(docs.length).toBeGreaterThan(0);
+        });
+        it('should include markdown headers', () => {
+            const docs = generateRulesDocumentation();
+            expect(docs).toContain('#');
+        });
+        it('should include custom rules info', () => {
+            const docs = generateRulesDocumentation();
+            expect(docs).toContain('Custom Rules');
+        });
+    });
+    describe('EXAMPLE_CUSTOM_RULES', () => {
+        it('should be a valid CustomRulesConfig', () => {
+            expect(EXAMPLE_CUSTOM_RULES.enabled).toBe(true);
+            expect(Array.isArray(EXAMPLE_CUSTOM_RULES.rules)).toBe(true);
+        });
+        it('should contain example rules', () => {
+            expect(EXAMPLE_CUSTOM_RULES.rules.length).toBeGreaterThan(0);
+        });
+        it('should have valid rule structure', () => {
+            for (const rule of EXAMPLE_CUSTOM_RULES.rules) {
+                expect(rule.name).toBeDefined();
+                expect(rule.pattern).toBeDefined();
+                expect(rule.severity).toBeDefined();
+            }
+        });
+    });
+});

package/dist/__tests__/detectors/index.test.d.ts

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

package/dist/__tests__/detectors/index.test.d.ts.map

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