@futdevpro/dynamo-eslint 1.14.4 → 1.14.7

package/src/plugin/rules/require-test-description-prefix.spec.ts

@@ -0,0 +1,459 @@
+import requireTestPrefixRule from './require-test-description-prefix';
+
+describe('| require-test-description-prefix', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(requireTestPrefixRule.meta.type).toBe('suggestion');
+    expect(requireTestPrefixRule.meta.docs.description).toBe('Require "| " prefix in test descriptions');
+    expect(requireTestPrefixRule.meta.fixable).toBe('code');
+  });
+
+  it('| should not report when describe has correct prefix', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Literal', value: '| my test suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report when it has correct prefix', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'it' },
+      arguments: [
+        { type: 'Literal', value: '| should do something' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report when test has correct prefix', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'test' },
+      arguments: [
+        { type: 'Literal', value: '| validates input' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report when describe is missing prefix', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('missingPrefix');
+        expect(options.data.prefix).toBe('| ');
+        expect(options.fix).toBeDefined();
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Literal', value: 'my test suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report when it is missing prefix', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('missingPrefix');
+        expect(options.data.prefix).toBe('| ');
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'it' },
+      arguments: [
+        { type: 'Literal', value: 'should do something' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report when describe has wrong prefix', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('wrongPrefix');
+        expect(options.data.prefix).toBe('| ');
+        expect(options.data.found).toBe('|');
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Literal', value: '|my test suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report when it has only pipe without space', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('wrongPrefix');
+        expect(options.data.found).toBe('|');
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'it' },
+      arguments: [
+        { type: 'Literal', value: '|should do something' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report on non-test functions', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'console' },
+      arguments: [
+        { type: 'Literal', value: 'log message' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report when no arguments provided', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report when first argument is not a string', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Identifier', name: 'myVariable' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should handle beforeEach and afterEach', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('missingPrefix');
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'beforeEach' },
+      arguments: [
+        { type: 'Literal', value: 'setup test data' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle beforeAll and afterAll', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('missingPrefix');
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'beforeAll' },
+      arguments: [
+        { type: 'Literal', value: 'setup suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle custom prefix configuration', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.prefix).toBe('>>> ');
+      },
+      options: [{ prefix: '>>> ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Literal', value: 'my test suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle custom test functions configuration', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ testFunctions: [ 'myTest' ] }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'myTest' },
+      arguments: [
+        { type: 'Literal', value: 'my test description' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should provide auto-fix functionality', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.fix).toBeDefined();
+        expect(typeof options.fix).toBe('function');
+        
+        // Test the fix function
+        const fixResult = options.fix({
+          replaceText: (node: any, text: string) => {
+            expect(text).toBe('\'| my test suite\'');
+
+            return [];
+          },
+        });
+        
+        expect(Array.isArray(fixResult)).toBe(true);
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Literal', value: 'my test suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+  });
+
+  it('| should handle empty string descriptions', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('missingPrefix');
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      callee: { name: 'describe' },
+      arguments: [
+        { type: 'Literal', value: '' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle errors gracefully', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not throw
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    // Test with malformed nodes
+    const malformedNode = {
+      type: 'CallExpression',
+      // Missing required properties
+    } as any;
+
+    expect(() => {
+      rule.CallExpression(malformedNode);
+    }).not.toThrow();
+  });
+
+  it('| should handle missing callee gracefully', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ prefix: '| ' }],
+    } as any;
+
+    const rule = requireTestPrefixRule.create(mockContext);
+
+    const mockNode = {
+      type: 'CallExpression',
+      // Missing callee
+      arguments: [
+        { type: 'Literal', value: 'my test suite' },
+      ],
+    } as any;
+
+    rule.CallExpression(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+});

package/src/plugin/rules/require-test-description-prefix.ts

@@ -0,0 +1,153 @@
+import { Rule } from 'eslint';
+
+interface RuleOptions {
+  prefix?: string;
+  testFunctions?: string[];
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Require "| " prefix in test descriptions',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          prefix: {
+            type: 'string',
+            default: '| ',
+          },
+          testFunctions: {
+            type: 'array',
+            items: {
+              type: 'string',
+            },
+            default: [ 'describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll' ],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      missingPrefix: 'Test description must start with "{{prefix}}"',
+      wrongPrefix: 'Test description must start with "{{prefix}}" but found "{{found}}"',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const options: RuleOptions = context.options[0] || {};
+    const prefix: string = options.prefix || '| ';
+    const testFunctions: string[] = options.testFunctions || [ 'describe', 'it', 'test', 'beforeEach', 'afterEach', 'beforeAll', 'afterAll' ];
+
+    /**
+     * Check if a CallExpression is a test function
+     */
+    function isTestFunction(node: any): boolean {
+      try {
+        return node.type === 'CallExpression' && 
+               node.callee && 
+               node.callee.name && 
+               testFunctions.includes(node.callee.name);
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in isTestFunction:', error);
+
+        return false;
+      }
+    }
+
+    /**
+     * Check if a string has the correct prefix
+     */
+    function hasCorrectPrefix(description: string): boolean {
+      try {
+        return typeof description === 'string' && description.startsWith(prefix);
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in hasCorrectPrefix:', error);
+
+        return false;
+      }
+    }
+
+    /**
+     * Get the actual prefix found in the string
+     */
+    function getFoundPrefix(description: string): string {
+      try {
+        if (typeof description !== 'string' || description.length === 0) {
+          return '';
+        }
+        
+        // Find the first non-alphanumeric character or end of string
+        const match = description.match(/^[^a-zA-Z0-9]*/);
+
+        return match ? match[0] : '';
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in getFoundPrefix:', error);
+
+        return '';
+      }
+    }
+
+    /**
+     * Check and report on test function calls
+     */
+    function checkTestFunction(node: any): void {
+      try {
+        if (!isTestFunction(node)) {
+          return;
+        }
+
+        // Check if there are arguments
+        if (!node.arguments || node.arguments.length === 0) {
+          return;
+        }
+
+        const firstArg = node.arguments[0];
+        
+        // Only check string literals
+        if (firstArg.type !== 'Literal' || typeof firstArg.value !== 'string') {
+          return;
+        }
+
+        const description = firstArg.value;
+        
+        if (!hasCorrectPrefix(description)) {
+          const foundPrefix = getFoundPrefix(description);
+          
+          context.report({
+            node: firstArg,
+            messageId: foundPrefix ? 'wrongPrefix' : 'missingPrefix',
+            data: {
+              prefix,
+              found: foundPrefix,
+            },
+            fix(fixer) {
+              try {
+                const newText = `${prefix}${description}`;
+
+                return fixer.replaceText(firstArg, `'${newText}'`);
+              } catch (fixError) {
+                console.error('[require-test-description-prefix] Error in fix function:', fixError);
+
+                return null;
+              }
+            },
+          });
+        }
+      } catch (error) {
+        console.error('[require-test-description-prefix] Error in checkTestFunction:', error);
+      }
+    }
+
+    return {
+      CallExpression(node: any) {
+        checkTestFunction(node);
+      },
+    };
+  },
+};
+
+export default rule;

package/src/scripts/eslintrc-audit.ts

@@ -46,7 +46,7 @@ type AnyJson = any;
 function safeParse(jsonPath: string): AnyJson | null {
   try {
     const content = readFileSync(jsonPath, 'utf8');
-    
+
     return JSON.parse(content);
   } catch {
     // Return null for any parsing errors (malformed JSON, file not found, etc.)
@@ -73,11 +73,11 @@ function safeParse(jsonPath: string): AnyJson | null {
  * // └─────────┴─────────────────────────┴───────┘
  * ```
  */
-async function main() {
+async function main(): Promise<void> {
   // Find all ESLint configuration files, excluding node_modules
-  const files = await fg([ '**/.eslintrc.json' ], { ignore: [ '**/node_modules/**' ] });
+  const files: string[] = await fg([ '**/.eslintrc.json' ], { ignore: [ '**/node_modules/**' ] });
   const ruleCounts: Record<string, number> = {};
-  const total = files.length;
+  const total: number = files.length;
 
   // Process each configuration file
   for (const p of files) {
@@ -93,7 +93,9 @@ async function main() {
   }
 
   // Sort rules by usage count (most used first)
-  const entries = Object.entries(ruleCounts).sort((a, b) => b[1] - a[1]);
+  const entries = Object.entries(ruleCounts).sort(
+    (a: [ string, number ], b: [ string, number ]): number => b[1] - a[1]
+  );
 
   // Display results
   console.log(`[dynamo-eslintrc-audit] analyzed ${total} files`);
@@ -101,7 +103,7 @@ async function main() {
 }
 
 // Execute the main function and handle any errors
-main().catch((err) => {
+main().catch((err: Error): void => {
   console.error(err);
   process.exit(1);
 });