@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

package/src/plugin/rules/prefer-enum-over-string-union.spec.ts

@@ -1,583 +0,0 @@
-import preferEnumRule from './prefer-enum-over-string-union';
-
-describe('| prefer-enum-over-string-union', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(preferEnumRule.meta.type).toBe('suggestion');
-    expect(preferEnumRule.meta.docs.description).toBe('Suggest using enums instead of union types of string literals');
-    expect(preferEnumRule.meta.fixable).toBe('code');
-  });
-
-  it('| should not report when union has less than threshold values', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Status' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: 'active' } },
-          { type: 'TSLiteralType', literal: { value: 'inactive' } },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report when union has threshold or more string literals', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferEnum');
-        expect(options.data.count).toBe('3');
-        expect(options.fix).toBeDefined();
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => 'type Status = \'active\' | \'inactive\' | \'pending\'',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Status' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: 'active' } },
-          { type: 'TSLiteralType', literal: { value: 'inactive' } },
-          { type: 'TSLiteralType', literal: { value: 'pending' } },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report when union contains non-string literals', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Value' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: 'active' } },
-          { type: 'TSLiteralType', literal: { value: 'inactive' } },
-          { type: 'TSNumberKeyword' },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report when allowTypeAliases is true', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ minValues: 3, allowTypeAliases: true }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Status' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: 'active' } },
-          { type: 'TSLiteralType', literal: { value: 'inactive' } },
-          { type: 'TSLiteralType', literal: { value: 'pending' } },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report on interface properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferEnum');
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSPropertySignature',
-      key: { name: 'role' },
-      typeAnnotation: {
-        typeAnnotation: {
-          type: 'TSUnionType',
-          types: [
-            { type: 'TSLiteralType', literal: { value: 'admin' } },
-            { type: 'TSLiteralType', literal: { value: 'user' } },
-            { type: 'TSLiteralType', literal: { value: 'guest' } },
-          ],
-        },
-      },
-      parent: { type: 'TSInterfaceDeclaration' },
-    } as any;
-
-    rule.TSPropertySignature(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report on class properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferEnum');
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'PropertyDefinition',
-      key: { name: 'status' },
-      typeAnnotation: {
-        typeAnnotation: {
-          type: 'TSUnionType',
-          types: [
-            { type: 'TSLiteralType', literal: { value: 'active' } },
-            { type: 'TSLiteralType', literal: { value: 'inactive' } },
-            { type: 'TSLiteralType', literal: { value: 'pending' } },
-          ],
-        },
-      },
-      parent: { type: 'ClassDeclaration' },
-    } as any;
-
-    rule.PropertyDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report on function parameters', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferEnum');
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'FunctionDeclaration',
-      id: { name: 'setStatus' },
-      params: [
-        {
-          type: 'Identifier',
-          name: 'status',
-          typeAnnotation: {
-            typeAnnotation: {
-              type: 'TSUnionType',
-              types: [
-                { type: 'TSLiteralType', literal: { value: 'active' } },
-                { type: 'TSLiteralType', literal: { value: 'inactive' } },
-                { type: 'TSLiteralType', literal: { value: 'pending' } },
-              ],
-            },
-          },
-        },
-      ],
-    } as any;
-
-    rule.FunctionDeclaration(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report on arrow function parameters', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferEnum');
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'ArrowFunctionExpression',
-      params: [
-        {
-          type: 'Identifier',
-          name: 'status',
-          typeAnnotation: {
-            typeAnnotation: {
-              type: 'TSUnionType',
-              types: [
-                { type: 'TSLiteralType', literal: { value: 'active' } },
-                { type: 'TSLiteralType', literal: { value: 'inactive' } },
-                { type: 'TSLiteralType', literal: { value: 'pending' } },
-              ],
-            },
-          },
-        },
-      ],
-    } as any;
-
-    rule.ArrowFunctionExpression(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report on variable declarations', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferEnum');
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'VariableDeclarator',
-      id: { name: 'status' },
-      typeAnnotation: {
-        typeAnnotation: {
-          type: 'TSUnionType',
-          types: [
-            { type: 'TSLiteralType', literal: { value: 'active' } },
-            { type: 'TSLiteralType', literal: { value: 'inactive' } },
-            { type: 'TSLiteralType', literal: { value: 'pending' } },
-          ],
-        },
-      },
-      parent: { type: 'VariableDeclaration' },
-    } as any;
-
-    rule.VariableDeclarator(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report on Angular @Input() properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'PropertyDefinition',
-      key: { name: 'mode' },
-      decorators: [
-        {
-          expression: {
-            type: 'CallExpression',
-            callee: { name: 'Input' },
-          },
-        },
-      ],
-      typeAnnotation: {
-        typeAnnotation: {
-          type: 'TSUnionType',
-          types: [
-            { type: 'TSLiteralType', literal: { value: 'light' } },
-            { type: 'TSLiteralType', literal: { value: 'dark' } },
-            { type: 'TSLiteralType', literal: { value: 'auto' } },
-          ],
-        },
-      },
-      parent: { type: 'ClassDeclaration' },
-    } as any;
-
-    rule.PropertyDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report on Angular input() signal properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'PropertyDefinition',
-      key: { name: 'size' },
-      value: {
-        type: 'CallExpression',
-        callee: { name: 'input' },
-      },
-      typeAnnotation: {
-        typeAnnotation: {
-          type: 'TSUnionType',
-          types: [
-            { type: 'TSLiteralType', literal: { value: 'small' } },
-            { type: 'TSLiteralType', literal: { value: 'medium' } },
-            { type: 'TSLiteralType', literal: { value: 'large' } },
-          ],
-        },
-      },
-      parent: { type: 'ClassDeclaration' },
-    } as any;
-
-    rule.PropertyDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report on Angular input.required() signal properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'PropertyDefinition',
-      key: { name: 'theme' },
-      value: {
-        type: 'CallExpression',
-        callee: {
-          type: 'MemberExpression',
-          object: { name: 'input' },
-          property: { name: 'required' },
-        },
-      },
-      typeAnnotation: {
-        typeAnnotation: {
-          type: 'TSUnionType',
-          types: [
-            { type: 'TSLiteralType', literal: { value: 'light' } },
-            { type: 'TSLiteralType', literal: { value: 'dark' } },
-            { type: 'TSLiteralType', literal: { value: 'auto' } },
-          ],
-        },
-      },
-      parent: { type: 'ClassDeclaration' },
-    } as any;
-
-    rule.PropertyDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should handle custom minValues threshold', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('2');
-      },
-      options: [{ minValues: 2 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Binary' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: 'yes' } },
-          { type: 'TSLiteralType', literal: { value: 'no' } },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle edge cases with empty strings and special characters', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('3');
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Special' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: '' } },
-          { type: 'TSLiteralType', literal: { value: 'hello-world' } },
-          { type: 'TSLiteralType', literal: { value: 'test_value' } },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should provide auto-fix for type aliases', () => {
-    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).toContain('Status');
-
-            return [];
-          },
-        });
-        
-        expect(Array.isArray(fixResult)).toBe(true);
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => 'type Status = \'active\' | \'inactive\' | \'pending\'',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeAliasDeclaration',
-      id: { name: 'Status' },
-      typeAnnotation: {
-        type: 'TSUnionType',
-        types: [
-          { type: 'TSLiteralType', literal: { value: 'active' } },
-          { type: 'TSLiteralType', literal: { value: 'inactive' } },
-          { type: 'TSLiteralType', literal: { value: 'pending' } },
-        ],
-      },
-    } as any;
-
-    rule.TSTypeAliasDeclaration(mockNode, undefined, undefined);
-  });
-
-  it('| should handle errors gracefully', () => {
-    const mockContext = {
-      report: (options: any) => {
-        // Should not throw
-      },
-      options: [{ minValues: 3 }],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = preferEnumRule.create(mockContext);
-
-    // Test with malformed nodes
-    const malformedNode = {
-      type: 'TSTypeAliasDeclaration',
-      // Missing required properties
-    } as any;
-
-    expect(() => {
-      rule.TSTypeAliasDeclaration(malformedNode, undefined, undefined);
-    }).not.toThrow();
-  });
-});