@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

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

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