@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

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

@@ -1,459 +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);
-  });
-});
+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);
+  });
+});