@webpieces/eslint-rules 0.0.1 → 0.2.113

package/src/__tests__/catch-error-pattern.test.ts

@@ -1,374 +0,0 @@
-/**
- * Tests for catch-error-pattern ESLint rule
- */
-
-import { RuleTester } from 'eslint';
-import rule from '../rules/catch-error-pattern';
-
-// Use require to load parser at runtime (avoids TypeScript import issues)
-const tsParser = require('@typescript-eslint/parser');
-
-const ruleTester = new RuleTester({
-    languageOptions: {
-        parser: tsParser,
-        parserOptions: {
-            ecmaVersion: 2020,
-            sourceType: 'module',
-        },
-    },
-});
-
-ruleTester.run('catch-error-pattern', rule, {
-    valid: [
-        // Pattern 1: Standard toError usage
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-}`,
-        },
-        // Pattern 1 with additional statements after toError
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-    console.log('Error occurred:', error);
-    throw error;
-}`,
-        },
-        // Pattern 2: Explicitly ignored error
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    //const error = toError(err);
-}`,
-        },
-        // Pattern 2 with extra whitespace
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    // const error = toError(err);
-}`,
-        },
-        // Pattern 3: Nested catch blocks
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-    try {
-        cleanup();
-    } catch (err2: unknown) {
-        const error2 = toError(err2);
-    }
-}`,
-        },
-        // Triple nested
-        {
-            code: `try {
-    operation1();
-} catch (err: unknown) {
-    const error = toError(err);
-    try {
-        operation2();
-    } catch (err2: unknown) {
-        const error2 = toError(err2);
-        try {
-            operation3();
-        } catch (err3: unknown) {
-            const error3 = toError(err3);
-        }
-    }
-}`,
-        },
-        // With finally block
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-} finally {
-    cleanup();
-}`,
-        },
-        // Re-throwing after toError
-        {
-            code: `try {
-    doSomething();
-} catch (err: unknown) {
-    const error = toError(err);
-    logger.error(error);
-    throw error;
-}`,
-        },
-    ],
-
-    invalid: [
-        // Wrong parameter name (e instead of err)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (e: unknown) {
-                    const error = toError(e);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongParameterName',
-                    data: { actual: 'e' },
-                },
-            ],
-        },
-        // Wrong parameter name (error instead of err) AND wrong variable name
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (error: unknown) {
-                    const error2 = toError(error);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongParameterName',
-                    data: { actual: 'error' },
-                },
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error', actual: 'error2' },
-                },
-            ],
-        },
-        // Missing type annotation
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err) {
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Wrong type annotation (Error instead of unknown)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: Error) {
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Wrong type annotation (any instead of unknown)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: any) {
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Empty catch block
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Missing toError call
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    console.log(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Wrong variable name (e instead of error)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const e = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error', actual: 'e' },
-                },
-            ],
-        },
-        // Wrong variable name (myError instead of error)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const myError = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error', actual: 'myError' },
-                },
-            ],
-        },
-        // toError not first statement
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    console.log('caught error');
-                    const error = toError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Using wrong function (not toError)
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const error = handleError(err);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Nested: wrong parameter name for err2
-        {
-            code: `
-                try {
-                    operation1();
-                } catch (err: unknown) {
-                    const error = toError(err);
-                    try {
-                        operation2();
-                    } catch (e: unknown) {
-                        const error2 = toError(e);
-                    }
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongParameterName',
-                    data: { actual: 'e' },
-                },
-            ],
-        },
-        // Nested: wrong variable name for error2
-        {
-            code: `
-                try {
-                    operation1();
-                } catch (err: unknown) {
-                    const error = toError(err);
-                    try {
-                        operation2();
-                    } catch (err2: unknown) {
-                        const err = toError(err2);
-                    }
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'wrongVariableName',
-                    data: { expected: 'error2', actual: 'err' },
-                },
-            ],
-        },
-        // No parameter at all
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch {
-                    console.log('error');
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingTypeAnnotation',
-                },
-            ],
-        },
-        // Variable declared but not initialized
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const error;
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-        // Using new Error instead of toError
-        {
-            code: `
-                try {
-                    doSomething();
-                } catch (err: unknown) {
-                    const error = new Error(err.message);
-                }
-            `,
-            errors: [
-                {
-                    messageId: 'missingToError',
-                },
-            ],
-        },
-    ],
-});
-
-console.log('✅ All catch-error-pattern rule tests passed!');

package/src/__tests__/max-file-lines.test.ts

@@ -1,207 +0,0 @@
-/**
- * Tests for max-file-lines ESLint rule
- */
-
-import { RuleTester } from 'eslint';
-import rule from '../rules/max-file-lines';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// Use require to load parser at runtime (avoids TypeScript import issues)
-const tsParser = require('@typescript-eslint/parser');
-
-const ruleTester = new RuleTester({
-    languageOptions: {
-        parser: tsParser,
-        parserOptions: {
-            ecmaVersion: 2020,
-            sourceType: 'module',
-        },
-    },
-});
-
-ruleTester.run('max-file-lines', rule, {
-    valid: [
-        // Short file (well under limit)
-        {
-            code: `function shortFunc() {
-    return 42;
-}`,
-        },
-        // File with exactly 700 lines (default limit)
-        {
-            code: Array(700)
-                .fill(0)
-                .map((_, i) => `const line${i} = ${i};`)
-                .join('\n'),
-        },
-        // File with 699 lines (just under default limit)
-        {
-            code: Array(699)
-                .fill(0)
-                .map((_, i) => `const line${i} = ${i};`)
-                .join('\n'),
-        },
-        // Custom limit: 10 lines
-        {
-            code: `function shortFunc() {
-    const a = 1;
-    const b = 2;
-    const c = 3;
-    const d = 4;
-    const e = 5;
-    return a + b + c + d + e;
-}`,
-            options: [{ max: 10 }],
-        },
-        // Empty file
-        {
-            code: '',
-        },
-        // File with comments and blank lines (all count)
-        {
-            code: `// Comment line 1
-// Comment line 2
-
-function func() {
-    return 42;
-}
-
-// Another comment`,
-            options: [{ max: 10 }],
-        },
-    ],
-
-    invalid: [
-        // File with 701 lines (exceeds default limit)
-        {
-            code: Array(701)
-                .fill(0)
-                .map((_, i) => `const line${i} = ${i};`)
-                .join('\n'),
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { actual: '701', max: '700' },
-                },
-            ],
-        },
-        // File with 1000 lines (way over limit)
-        {
-            code: Array(1000)
-                .fill(0)
-                .map((_, i) => `const line${i} = ${i};`)
-                .join('\n'),
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { actual: '1000', max: '700' },
-                },
-            ],
-        },
-        // Custom limit: exceed 5 lines
-        {
-            code: `function func() {
-    const a = 1;
-    const b = 2;
-    const c = 3;
-    const d = 4;
-    return a + b + c + d;
-}`,
-            options: [{ max: 5 }],
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { actual: '7', max: '5' },
-                },
-            ],
-        },
-        // Custom limit: exceed 100 lines
-        {
-            code: Array(101)
-                .fill(0)
-                .map((_, i) => `const line${i} = ${i};`)
-                .join('\n'),
-            options: [{ max: 100 }],
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { actual: '101', max: '100' },
-                },
-            ],
-        },
-        // File with blank lines and comments (all lines count)
-        {
-            code: `// Line 1
-// Line 2
-// Line 3
-
-function func() {
-    return 42;
-}
-
-// Line 9
-// Line 10
-// Line 11`,
-            options: [{ max: 10 }],
-            errors: [
-                {
-                    messageId: 'tooLong',
-                    data: { actual: '11', max: '10' },
-                },
-            ],
-        },
-    ],
-});
-
-console.log('All max-file-lines rule tests passed!');
-
-// Test documentation file creation
-const docPath = path.join(process.cwd(), 'tmp', 'webpieces', 'webpieces.filesize.md');
-
-// Ensure tmp directory exists before test
-fs.mkdirSync(path.dirname(docPath), { recursive: true });
-
-// Delete file if it exists (to test creation)
-if (fs.existsSync(docPath)) {
-    fs.unlinkSync(docPath);
-}
-
-// Run a test that triggers violation (will create doc file)
-try {
-    ruleTester.run('max-file-lines-doc-test', rule, {
-        valid: [],
-        invalid: [
-            {
-                code: Array(800)
-                    .fill(0)
-                    .map((_, i) => `const line${i} = ${i};`)
-                    .join('\n'),
-                errors: [{ messageId: 'tooLong' }],
-            },
-        ],
-    });
-    console.log('Doc test passed without errors');
-} catch (err: unknown) {
-    // Test may fail due to too many errors, but file should be created
-    console.log('Doc test threw error (expected):', err instanceof Error ? err.message : String(err));
-}
-
-// Verify file was created - if not, manually create it for the test
-// (The rule should have created it, but Jest test runner might not trigger it properly)
-if (!fs.existsSync(docPath)) {
-    console.warn('Warning: Rule did not create doc file during test, creating manually for verification');
-    // For now, just skip this part of the test since the main rule tests passed
-    console.log('Documentation file creation test skipped (rule functionality verified in main tests)');
-} else {
-    // Verify content has AI directive
-    const content = fs.readFileSync(docPath, 'utf-8');
-    if (!content.includes('READ THIS FILE to fix files that are too long')) {
-        throw new Error('Documentation file missing AI directive');
-    }
-    if (!content.includes('SINGLE COHESIVE UNIT')) {
-        throw new Error('Documentation file missing single cohesive unit principle');
-    }
-
-    console.log('Documentation file creation test passed!');
-}