@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/plugin/rules/no-getter-logic.spec.ts

@@ -1,591 +1,591 @@
-import noGetterLogicRule from './no-getter-logic';
-
-describe('| no-getter-logic', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noGetterLogicRule.meta?.type).toBe('suggestion');
-    expect(noGetterLogicRule.meta?.docs?.description).toContain('Getters should only contain simple property mappings');
-  });
-
-  it('| should have create function that returns visitor object', () => {
-    const mockContext = {
-      report: () => {},
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const result = noGetterLogicRule.create(mockContext);
-
-    expect(typeof result).toBe('object');
-    expect(typeof result.MethodDefinition).toBe('function');
-  });
-
-  it('| should not report for simple property access getter', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: () => {
-        reportCalled = true;
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'selectedTokenPackage' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'MemberExpression',
-                object: {
-                  type: 'MemberExpression',
-                  object: { type: 'ThisExpression' },
-                  property: { type: 'Identifier', name: 'tokenPackages_CS' },
-                },
-                property: {
-                  type: 'MemberExpression',
-                  object: { type: 'Identifier', name: 'tokenPackageByType' },
-                  property: {
-                    type: 'MemberExpression',
-                    object: { type: 'ThisExpression' },
-                    property: { type: 'Identifier', name: 'selectedPackageType' },
-                  },
-                  computed: true,
-                },
-                computed: true,
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report for simple length property access', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: () => {
-        reportCalled = true;
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'runningProgressCount' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'MemberExpression',
-                object: {
-                  type: 'MemberExpression',
-                  object: { type: 'ThisExpression' },
-                  property: { type: 'Identifier', name: '_runningProgresses' },
-                },
-                property: { type: 'Identifier', name: 'length' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report for simple signal property access', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: () => {
-        reportCalled = true;
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'myChannels_$' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'MemberExpression',
-                object: {
-                  type: 'MemberExpression',
-                  object: { type: 'ThisExpression' },
-                  property: { type: 'Identifier', name: 'myChannels_DH' },
-                },
-                property: { type: 'Identifier', name: 'dataList_$' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report for binary expression (multiplication)', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noLogic');
-        expect(options.data.name).toBe('shownHUNVat');
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'shownHUNVat' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'BinaryExpression',
-                operator: '*',
-                left: { type: 'Identifier', name: 'HU_vat' },
-                right: { type: 'Literal', value: 100 },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report for function call', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noLogic');
-        expect(options.data.name).toBe('selectedPackageType');
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'selectedPackageType' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'MemberExpression',
-                object: {
-                  type: 'CallExpression',
-                  callee: {
-                    type: 'MemberExpression',
-                    object: { type: 'ThisExpression' },
-                    property: { type: 'Identifier', name: 'completedPurchaseData$' },
-                  },
-                  arguments: [],
-                },
-                property: { type: 'Identifier', name: 'selectedPackageType' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report for unary expression', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noLogic');
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'negatedValue' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'UnaryExpression',
-                operator: '!',
-                argument: { type: 'Identifier', name: 'someValue' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report for conditional expression (ternary)', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noLogic');
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'conditionalValue' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'ConditionalExpression',
-                test: { type: 'Identifier', name: 'condition' },
-                consequent: { type: 'Literal', value: 'true' },
-                alternate: { type: 'Literal', value: 'false' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report for logical expression', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noLogic');
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'logicalValue' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'LogicalExpression',
-                operator: '&&',
-                left: { type: 'Identifier', name: 'value1' },
-                right: { type: 'Identifier', name: 'value2' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report for non-getter methods', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: () => {
-        reportCalled = true;
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'method',
-      key: { name: 'someMethod' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'CallExpression',
-                callee: { type: 'Identifier', name: 'someFunction' },
-                arguments: [],
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report for setter methods', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: () => {
-        reportCalled = true;
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'set',
-      key: { name: 'someSetter' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ExpressionStatement',
-              expression: {
-                type: 'AssignmentExpression',
-                operator: '=',
-                left: { type: 'Identifier', name: 'this.value' },
-                right: { type: 'Identifier', name: 'value' },
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should handle getter without body gracefully', () => {
-    let reportCalled = false;
-    const mockContext = {
-      report: () => {
-        reportCalled = true;
-      },
-      options: [],
-      sourceCode: {
-        getText: () => '',
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'emptyGetter' },
-      value: {},
-    } as any;
-
-    expect(() => {
-      rule.MethodDefinition(mockNode);
-    }).not.toThrow();
-
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report multi-statement getter body (CCAP-megerősítés)', () => {
-    let reportCalled: boolean = false;
-    const mockContext = {
-      report: (options: any) => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noLogic');
-      },
-      options: [],
-      sourceCode: { getText: () => '' },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'multiStatementGetter' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'VariableDeclaration',
-              declarations: [{ id: { name: 'tmp' }, init: { type: 'Identifier', name: 'foo' }}],
-            },
-            {
-              type: 'ReturnStatement',
-              argument: { type: 'Identifier', name: 'tmp' },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report `if`-statement inside getter (CCAP-megerősítés)', () => {
-    let reportCalled: boolean = false;
-    const mockContext = {
-      report: () => { reportCalled = true; },
-      options: [],
-      sourceCode: { getText: () => '' },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'gateGetter' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'IfStatement',
-              test: { type: 'Identifier', name: 'cond' },
-              consequent: { type: 'ReturnStatement', argument: { type: 'Literal', value: 1 }},
-              alternate: { type: 'ReturnStatement', argument: { type: 'Literal', value: 0 }},
-            },
-          ],
-        },
-      },
-    } as any;
-
-    rule.MethodDefinition(mockNode);
-
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should handle errors gracefully', () => {
-    const mockContext = {
-      report: () => {},
-      options: [],
-      sourceCode: {
-        getText: () => {
-          throw new Error('Test error');
-        },
-      },
-    } as any;
-
-    const rule = noGetterLogicRule.create(mockContext);
-
-    const mockNode = {
-      kind: 'get',
-      key: { name: 'testGetter' },
-      value: {
-        body: {
-          type: 'BlockStatement',
-          body: [
-            {
-              type: 'ReturnStatement',
-              argument: {
-                type: 'CallExpression',
-                callee: { type: 'Identifier', name: 'test' },
-                arguments: [],
-              },
-            },
-          ],
-        },
-      },
-    } as any;
-
-    // Should not throw error
-    expect(() => {
-      rule.MethodDefinition(mockNode);
-    }).not.toThrow();
-  });
-});
+import noGetterLogicRule from './no-getter-logic';
+
+describe('| no-getter-logic', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noGetterLogicRule.meta?.type).toBe('suggestion');
+    expect(noGetterLogicRule.meta?.docs?.description).toContain('Getters should only contain simple property mappings');
+  });
+
+  it('| should have create function that returns visitor object', () => {
+    const mockContext = {
+      report: () => {},
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const result = noGetterLogicRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.MethodDefinition).toBe('function');
+  });
+
+  it('| should not report for simple property access getter', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'selectedTokenPackage' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'MemberExpression',
+                  object: { type: 'ThisExpression' },
+                  property: { type: 'Identifier', name: 'tokenPackages_CS' },
+                },
+                property: {
+                  type: 'MemberExpression',
+                  object: { type: 'Identifier', name: 'tokenPackageByType' },
+                  property: {
+                    type: 'MemberExpression',
+                    object: { type: 'ThisExpression' },
+                    property: { type: 'Identifier', name: 'selectedPackageType' },
+                  },
+                  computed: true,
+                },
+                computed: true,
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report for simple length property access', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'runningProgressCount' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'MemberExpression',
+                  object: { type: 'ThisExpression' },
+                  property: { type: 'Identifier', name: '_runningProgresses' },
+                },
+                property: { type: 'Identifier', name: 'length' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report for simple signal property access', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'myChannels_$' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'MemberExpression',
+                  object: { type: 'ThisExpression' },
+                  property: { type: 'Identifier', name: 'myChannels_DH' },
+                },
+                property: { type: 'Identifier', name: 'dataList_$' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report for binary expression (multiplication)', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+        expect(options.data.name).toBe('shownHUNVat');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'shownHUNVat' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'BinaryExpression',
+                operator: '*',
+                left: { type: 'Identifier', name: 'HU_vat' },
+                right: { type: 'Literal', value: 100 },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for function call', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+        expect(options.data.name).toBe('selectedPackageType');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'selectedPackageType' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'CallExpression',
+                  callee: {
+                    type: 'MemberExpression',
+                    object: { type: 'ThisExpression' },
+                    property: { type: 'Identifier', name: 'completedPurchaseData$' },
+                  },
+                  arguments: [],
+                },
+                property: { type: 'Identifier', name: 'selectedPackageType' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for unary expression', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'negatedValue' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'UnaryExpression',
+                operator: '!',
+                argument: { type: 'Identifier', name: 'someValue' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for conditional expression (ternary)', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'conditionalValue' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'ConditionalExpression',
+                test: { type: 'Identifier', name: 'condition' },
+                consequent: { type: 'Literal', value: 'true' },
+                alternate: { type: 'Literal', value: 'false' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for logical expression', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'logicalValue' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'LogicalExpression',
+                operator: '&&',
+                left: { type: 'Identifier', name: 'value1' },
+                right: { type: 'Identifier', name: 'value2' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report for non-getter methods', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'method',
+      key: { name: 'someMethod' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'CallExpression',
+                callee: { type: 'Identifier', name: 'someFunction' },
+                arguments: [],
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report for setter methods', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'set',
+      key: { name: 'someSetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ExpressionStatement',
+              expression: {
+                type: 'AssignmentExpression',
+                operator: '=',
+                left: { type: 'Identifier', name: 'this.value' },
+                right: { type: 'Identifier', name: 'value' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should handle getter without body gracefully', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'emptyGetter' },
+      value: {},
+    } as any;
+
+    expect(() => {
+      rule.MethodDefinition(mockNode);
+    }).not.toThrow();
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report multi-statement getter body (CCAP-megerősítés)', () => {
+    let reportCalled: boolean = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: { getText: () => '' },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'multiStatementGetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'VariableDeclaration',
+              declarations: [{ id: { name: 'tmp' }, init: { type: 'Identifier', name: 'foo' }}],
+            },
+            {
+              type: 'ReturnStatement',
+              argument: { type: 'Identifier', name: 'tmp' },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report `if`-statement inside getter (CCAP-megerősítés)', () => {
+    let reportCalled: boolean = false;
+    const mockContext = {
+      report: () => { reportCalled = true; },
+      options: [],
+      sourceCode: { getText: () => '' },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'gateGetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'IfStatement',
+              test: { type: 'Identifier', name: 'cond' },
+              consequent: { type: 'ReturnStatement', argument: { type: 'Literal', value: 1 }},
+              alternate: { type: 'ReturnStatement', argument: { type: 'Literal', value: 0 }},
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should handle errors gracefully', () => {
+    const mockContext = {
+      report: () => {},
+      options: [],
+      sourceCode: {
+        getText: () => {
+          throw new Error('Test error');
+        },
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'testGetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'CallExpression',
+                callee: { type: 'Identifier', name: 'test' },
+                arguments: [],
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    // Should not throw error
+    expect(() => {
+      rule.MethodDefinition(mockNode);
+    }).not.toThrow();
+  });
+});