@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/plugin/rules/prefer-interface-over-duplicate-types.spec.ts

@@ -1,404 +1,404 @@
-import preferInterfaceRule from './prefer-interface-over-duplicate-types';
-
-describe('| prefer-interface-over-duplicate-types', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(preferInterfaceRule.meta?.type).toBe('suggestion');
-    expect(preferInterfaceRule.meta?.docs?.description).toContain('Suggest creating interfaces');
-    // BFR-ADVENTOR-009 (2. lépcső): a forrás-megőrző fixer VISSZAKAPCSOLVA auto-fix-re (érvényes kódot ad).
-    expect(preferInterfaceRule.meta?.fixable).toBe('code');
-  });
-
-  it('| should have create function that returns visitor object', () => {
-    const mockContext = {
-      report: () => {},
-      options: [{ threshold: 3 }],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const result = preferInterfaceRule.create(mockContext);
-
-    expect(typeof result).toBe('object');
-    expect(typeof result.TSTypeLiteral).toBe('function');
-    expect(typeof result['Program:exit']).toBe('function');
-  });
-
-  it('| should not report when object type is used less than threshold', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-      },
-      options: [{ threshold: 3 }],
-      sourceCode: {
-        getText: () => '{ name: string; age: number }',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    // Simulate 2 usages (below threshold of 3)
-    const mockNode1 = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-
-    const mockNode2 = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode1);
-    rule.TSTypeLiteral(mockNode2);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report when object type is used at or above threshold', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('preferInterface');
-        expect(options.data.count).toBe('3');
-        expect(options.data.interfaceName).toContain('Interface');
-      },
-      options: [{ threshold: 3 }],
-      sourceCode: {
-        getText: () => '{ name: string; age: number }',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    // Simulate 3 usages (at threshold)
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle custom threshold', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('2');
-      },
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        getText: () => '{ name: string }',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle structural equivalence (different property order)', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('2');
-      },
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    // First object: { name: string, age: number }
-    const mockNode1 = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-
-    // Second object: { age: number, name: string } (different order)
-    const mockNode2 = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode1);
-    rule.TSTypeLiteral(mockNode2);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle optional properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('2');
-      },
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } }, optional: true },
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle readonly properties', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('2');
-      },
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } }, readonly: true },
-        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| auto-fix a FORRÁS-SZÖVEGBŐL épít (BFR-ADVENTOR-009 2. lépcső: komplex típus megőrizve, nem `reference`)', () => {
-    // egy komplex property-t szimulálunk: a member getText-je egy function-type — a régi lossy fixer
-    // ezt `reference`/`complex`-re redukálta (érvénytelen TS); az új fixer EXAKT megőrzi.
-    const complexMember: any = {
-      type: 'TSPropertySignature', key: { name: 'onError' },
-    };
-    const numberMember: any = {
-      type: 'TSPropertySignature', key: { name: 'count' },
-    };
-    const memberTexts: Map<any, string> = new Map([
-      [ complexMember, 'onError: (e: Error) => void' ],
-      [ numberMember, 'count: number' ],
-    ]);
-
-    let insertedText: string = '';
-    const mockFixer: any = {
-      insertTextAfterRange: (_range: unknown, text: string): unknown => { insertedText = text; return {}; },
-      replaceText: (): unknown => ({}),
-    };
-
-    const mockContext = {
-      report: (options: any) => {
-        expect(typeof options.fix).toBe('function'); // auto-fix VISSZA (nem suggestion)
-        options.fix(mockFixer);
-      },
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        // a body-generátor a member-node getText-jét használja; a normalizáló getTypeString nem fut a fixerben
-        getText: (n: any): string => memberTexts.get(n) ?? '{ onError: fn; count: number }',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { ...complexMember, typeAnnotation: { typeAnnotation: { type: 'TSFunctionType' } } },
-        { ...numberMember, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-      ],
-    } as any;
-    // a getText a fenti two member-referenciákat kapja — a mockNode.members MÁSOK, ezért a getText-map
-    // kulcsait használjuk a mockNode.members-ként:
-    mockNode.members = [ complexMember, numberMember ];
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    // a generált interface a MEGŐRZÖTT function-type-ot tartalmazza, NEM `reference`/`complex`-et
-    expect(insertedText).toContain('onError: (e: Error) => void;');
-    expect(insertedText).toContain('count: number;');
-    expect(insertedText).not.toContain('reference');
-    expect(insertedText).not.toContain('complex');
-  });
-
-  it('| should handle default threshold when no options provided', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('3');
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle complex nested types', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.data.count).toBe('2');
-      },
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => ({ variables: [] }),
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { 
-          type: 'TSPropertySignature', 
-          key: { name: 'user' }, 
-          typeAnnotation: { 
-            typeAnnotation: { 
-              type: 'TSTypeLiteral',
-              members: [
-                { type: 'TSPropertySignature', key: { name: 'id' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
-                { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-              ],
-            }, 
-          }, 
-        },
-      ],
-    } as any;
-
-    rule.TSTypeLiteral(mockNode);
-    rule.TSTypeLiteral(mockNode);
-    rule['Program:exit']({} as any);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle error cases gracefully', () => {
-    const mockContext = {
-      report: () => {},
-      options: [{ threshold: 2 }],
-      sourceCode: {
-        getText: () => '',
-        getScope: () => {
-          throw new Error('Scope error'); 
-        },
-        ast: { body: [] },
-      },
-    } as any;
-
-    const rule = preferInterfaceRule.create(mockContext);
-
-    const mockNode = {
-      type: 'TSTypeLiteral',
-      members: [
-        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
-      ],
-    } as any;
-
-    // Should not throw error
-    expect(() => {
-      rule.TSTypeLiteral(mockNode);
-      rule.TSTypeLiteral(mockNode);
-      rule['Program:exit']({} as any);
-    }).not.toThrow();
-  });
-});
+import preferInterfaceRule from './prefer-interface-over-duplicate-types';
+
+describe('| prefer-interface-over-duplicate-types', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(preferInterfaceRule.meta?.type).toBe('suggestion');
+    expect(preferInterfaceRule.meta?.docs?.description).toContain('Suggest creating interfaces');
+    // BFR-ADVENTOR-009 (2. lépcső): a forrás-megőrző fixer VISSZAKAPCSOLVA auto-fix-re (érvényes kódot ad).
+    expect(preferInterfaceRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns visitor object', () => {
+    const mockContext = {
+      report: () => {},
+      options: [{ threshold: 3 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const result = preferInterfaceRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.TSTypeLiteral).toBe('function');
+    expect(typeof result['Program:exit']).toBe('function');
+  });
+
+  it('| should not report when object type is used less than threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+      },
+      options: [{ threshold: 3 }],
+      sourceCode: {
+        getText: () => '{ name: string; age: number }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    // Simulate 2 usages (below threshold of 3)
+    const mockNode1 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    const mockNode2 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode1, undefined, undefined);
+    rule.TSTypeLiteral(mockNode2, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report when object type is used at or above threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('preferInterface');
+        expect(options.data.count).toBe('3');
+        expect(options.data.interfaceName).toContain('Interface');
+      },
+      options: [{ threshold: 3 }],
+      sourceCode: {
+        getText: () => '{ name: string; age: number }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    // Simulate 3 usages (at threshold)
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle custom threshold', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '{ name: string }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle structural equivalence (different property order)', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    // First object: { name: string, age: number }
+    const mockNode1 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    // Second object: { age: number, name: string } (different order)
+    const mockNode2 = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode1, undefined, undefined);
+    rule.TSTypeLiteral(mockNode2, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle optional properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } }, optional: true },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle readonly properties', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } }, readonly: true },
+        { type: 'TSPropertySignature', key: { name: 'age' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| auto-fix a FORRÁS-SZÖVEGBŐL épít (BFR-ADVENTOR-009 2. lépcső: komplex típus megőrizve, nem `reference`)', () => {
+    // egy komplex property-t szimulálunk: a member getText-je egy function-type — a régi lossy fixer
+    // ezt `reference`/`complex`-re redukálta (érvénytelen TS); az új fixer EXAKT megőrzi.
+    const complexMember: any = {
+      type: 'TSPropertySignature', key: { name: 'onError' },
+    };
+    const numberMember: any = {
+      type: 'TSPropertySignature', key: { name: 'count' },
+    };
+    const memberTexts: Map<any, string> = new Map([
+      [ complexMember, 'onError: (e: Error) => void' ],
+      [ numberMember, 'count: number' ],
+    ]);
+
+    let insertedText: string = '';
+    const mockFixer: any = {
+      insertTextAfterRange: (_range: unknown, text: string): unknown => { insertedText = text; return {}; },
+      replaceText: (): unknown => ({}),
+    };
+
+    const mockContext = {
+      report: (options: any) => {
+        expect(typeof options.fix).toBe('function'); // auto-fix VISSZA (nem suggestion)
+        options.fix(mockFixer);
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        // a body-generátor a member-node getText-jét használja; a normalizáló getTypeString nem fut a fixerben
+        getText: (n: any): string => memberTexts.get(n) ?? '{ onError: fn; count: number }',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { ...complexMember, typeAnnotation: { typeAnnotation: { type: 'TSFunctionType' } } },
+        { ...numberMember, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+      ],
+    } as any;
+    // a getText a fenti two member-referenciákat kapja — a mockNode.members MÁSOK, ezért a getText-map
+    // kulcsait használjuk a mockNode.members-ként:
+    mockNode.members = [ complexMember, numberMember ];
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    // a generált interface a MEGŐRZÖTT function-type-ot tartalmazza, NEM `reference`/`complex`-et
+    expect(insertedText).toContain('onError: (e: Error) => void;');
+    expect(insertedText).toContain('count: number;');
+    expect(insertedText).not.toContain('reference');
+    expect(insertedText).not.toContain('complex');
+  });
+
+  it('| should handle default threshold when no options provided', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('3');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle complex nested types', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.data.count).toBe('2');
+      },
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => ({ variables: [] }),
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { 
+          type: 'TSPropertySignature', 
+          key: { name: 'user' }, 
+          typeAnnotation: { 
+            typeAnnotation: { 
+              type: 'TSTypeLiteral',
+              members: [
+                { type: 'TSPropertySignature', key: { name: 'id' }, typeAnnotation: { typeAnnotation: { type: 'TSNumberKeyword' } } },
+                { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+              ],
+            }, 
+          }, 
+        },
+      ],
+    } as any;
+
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule.TSTypeLiteral(mockNode, undefined, undefined);
+    rule['Program:exit']({} as any);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle error cases gracefully', () => {
+    const mockContext = {
+      report: () => {},
+      options: [{ threshold: 2 }],
+      sourceCode: {
+        getText: () => '',
+        getScope: () => {
+          throw new Error('Scope error'); 
+        },
+        ast: { body: [] },
+      },
+    } as any;
+
+    const rule = preferInterfaceRule.create(mockContext);
+
+    const mockNode = {
+      type: 'TSTypeLiteral',
+      members: [
+        { type: 'TSPropertySignature', key: { name: 'name' }, typeAnnotation: { typeAnnotation: { type: 'TSStringKeyword' } } },
+      ],
+    } as any;
+
+    // Should not throw error
+    expect(() => {
+      rule.TSTypeLiteral(mockNode, undefined, undefined);
+      rule.TSTypeLiteral(mockNode, undefined, undefined);
+      rule['Program:exit']({} as any);
+    }).not.toThrow();
+  });
+});