@futdevpro/dynamo-eslint 1.14.6 → 1.14.7

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

@@ -0,0 +1,583 @@
+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);
+
+    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);
+
+    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);
+
+    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);
+
+    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);
+
+    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);
+
+    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);
+
+    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);
+  });
+
+  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);
+    }).not.toThrow();
+  });
+});