@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

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