@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,459 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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/plugin/rules/ts/data-model-extends.spec.ts

@@ -1,84 +0,0 @@
-import dataModelExtendsRule from './data-model-extends';
-
-describe('| data-model-extends', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(dataModelExtendsRule.meta?.type).toBe('suggestion');
-    expect(dataModelExtendsRule.meta?.messages?.missingExtends).toBeDefined();
-    expect(dataModelExtendsRule.meta?.messages?.parallelDateField).toBeDefined();
-  });
-
-  it('| should skip non-data-model files', () => {
-    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [] };
-    const result: any = dataModelExtendsRule.create(mockContext);
-    expect(result.ClassDeclaration).toBeUndefined();
-  });
-
-  it('| should report when data-model class has no `extends`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'missingExtends') {
-          reportCalled = true;
-          expect(options.data.className).toBe('User_DataModel');
-        }
-      },
-      options: [],
-    };
-    const rule: any = dataModelExtendsRule.create(mockContext);
-    const mockNode: any = {
-      id: { name: 'User_DataModel' },
-      superClass: null,
-      body: { body: [] },
-    };
-    rule.ClassDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report when extending DyFM_Metadata', () => {
-    let missingReported: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'missingExtends') {
-          missingReported = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = dataModelExtendsRule.create(mockContext);
-    const mockNode: any = {
-      id: { name: 'User_DataModel' },
-      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
-      body: { body: [] },
-    };
-    rule.ClassDeclaration(mockNode);
-    expect(missingReported).toBe(false);
-  });
-
-  it('| should report parallel date field `createdAt`', () => {
-    let parallelReported: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.data-model.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'parallelDateField') {
-          parallelReported = true;
-          expect(options.data.fieldName).toBe('createdAt');
-        }
-      },
-      options: [],
-    };
-    const rule: any = dataModelExtendsRule.create(mockContext);
-    const mockNode: any = {
-      id: { name: 'User_DataModel' },
-      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
-      body: {
-        body: [
-          { type: 'PropertyDefinition', key: { type: 'Identifier', name: 'createdAt' } },
-        ],
-      },
-    };
-    rule.ClassDeclaration(mockNode);
-    expect(parallelReported).toBe(true);
-  });
-});