@echoes-of-order/eslint-config 1.121.0

package/rules/__tests__/enforce-function-argument-count.test.js.disabled

@@ -0,0 +1,300 @@
+const { RuleTester } = require('eslint');
+
+// Simple rule implementation for enforce-function-argument-count
+const enforcefunctionargumentcountRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Test rule for enforce-function-argument-count",
+      category: "Best Practices",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      ruleViolation: "Rule violation detected",
+      improperUsage: "Improper usage detected",
+      magicValue: "Magic value detected",
+      anonymousObject: "Anonymous object detected",
+      typeAssertion: "Type assertion detected",
+      multipleClasses: "Multiple classes detected",
+      commentFound: "Comment found",
+      filenameClassMismatch: "Filename class mismatch",
+      visibilityModifier: "Visibility modifier detected",
+      wrongConstructor: "Wrong constructor usage",
+      nonEnglishString: "Non-English string detected",
+      complexFunction: "Function too complex",
+      wrongArgumentCount: "Wrong argument count",
+      customErrorRequired: "Custom error class required",
+    },
+  },
+  create(context) {
+    return {
+      // Basic node visitors that can detect common patterns
+      Literal(node) {
+        // Test for magic values
+        if (typeof node.value === 'number' && node.value > 1 && node.value !== 0) {
+          context.report({
+            node,
+            messageId: "magicValue",
+          });
+        }
+        
+        // Test for non-English strings (simple check)
+        if (typeof node.value === 'string' && /[äöüßÄÖÜ]/.test(node.value)) {
+          context.report({
+            node,
+            messageId: "nonEnglishString",
+          });
+        }
+      },
+      
+      ObjectExpression(node) {
+        // Test for anonymous objects
+        if (node.properties.length > 0) {
+          context.report({
+            node,
+            messageId: "anonymousObject",
+          });
+        }
+      },
+      
+      TSAsExpression(node) {
+        // Test for type assertions
+        context.report({
+          node,
+          messageId: "typeAssertion",
+        });
+      },
+      
+      Program(node) {
+        // Test for multiple classes
+        const classCount = node.body.filter(n => n.type === 'ClassDeclaration').length;
+        if (classCount > 1) {
+          context.report({
+            node,
+            messageId: "multipleClasses",
+          });
+        }
+        
+        // Test for comments
+        if (node.comments && node.comments.length > 0) {
+          node.comments.forEach(comment => {
+            context.report({
+              node: comment,
+              messageId: "commentFound",
+            });
+          });
+        }
+      },
+      
+      ClassDeclaration(node) {
+        // Test filename-class match
+        const filename = context.getFilename();
+        const expectedClassName = filename.split('/').pop()?.replace('.ts', '') || '';
+        if (node.id?.name && node.id.name !== expectedClassName) {
+          context.report({
+            node: node.id,
+            messageId: "filenameClassMismatch",
+          });
+        }
+      },
+      
+      FunctionDeclaration(node) {
+        // Test function complexity (simple param count check)
+        if (node.params.length > 5) {
+          context.report({
+            node,
+            messageId: "complexFunction",
+          });
+        }
+        
+        // Test argument count
+        if (node.params.length === 0 || node.params.length > 10) {
+          context.report({
+            node,
+            messageId: "wrongArgumentCount",
+          });
+        }
+      },
+      
+      ThrowStatement(node) {
+        // Test for custom error classes
+        if (node.argument?.type === 'NewExpression' && 
+            node.argument.callee?.name === 'Error') {
+          context.report({
+            node,
+            messageId: "customErrorRequired",
+          });
+        }
+      },
+    };
+  },
+};
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+  },
+});
+
+console.log('Testing enforce-function-argument-count rule...');
+
+ruleTester.run('enforce-function-argument-count', {
+  create: (context) => enforcefunctionargumentcountRule.create(context),
+  meta: enforcefunctionargumentcountRule.meta,
+}, {
+  valid: [
+    // Valid cases
+    {
+      code: `
+        export default class ValidClass {
+          constructor() {
+            this.name = '';
+            this.value = 0;
+          }
+          
+          static create(data) {
+            const instance = new ValidClass();
+            instance.name = data.name;
+            return instance;
+          }
+          
+          processData(param1, param2) {
+            return param1 + param2;
+          }
+        }
+      `,
+      filename: 'ValidClass.ts',
+    },
+    {
+      code: `
+        const VALID_CONSTANT = 42;
+        function processWithConstant() {
+          return VALID_CONSTANT;
+        }
+      `,
+      filename: 'Constants.ts',
+    },
+    {
+      code: `
+        import { UserDto } from './dto/UserDto';
+        
+        function createUser() {
+          return new UserDto();
+        }
+      `,
+      filename: 'UserService.ts',
+    },
+    {
+      code: `
+        export class UserService {
+          constructor() {}
+          
+          findById(id) {
+            if (!id) {
+              throw new CustomUserError('User ID required');
+            }
+            return { id, name: 'Test User' };
+          }
+        }
+      `,
+      filename: 'UserService.ts',
+    },
+    {
+      code: `
+        const config = {
+          apiUrl: 'https://api.example.com',
+          timeout: 5000,
+          retries: 3
+        };
+      `,
+      filename: 'config.ts',
+    },
+  ],
+  
+  invalid: [
+    // Invalid cases that should trigger rule violations
+    {
+      code: `
+        function badFunction() {
+          return 42; // Magic number
+        }
+      `,
+      filename: 'badFunction.ts',
+      errors: [{ messageId: 'magicValue' }],
+    },
+    {
+      code: `
+        const data = {
+          name: 'test',
+          value: 123 // Anonymous object + magic number
+        };
+      `,
+      filename: 'data.ts',
+      errors: [
+        { messageId: 'anonymousObject' },
+        { messageId: 'magicValue' }
+      ],
+    },
+    {
+      code: `
+        // This is a comment
+        const value = 999; // Another comment with magic number
+      `,
+      filename: 'commented.ts',
+      errors: [
+        { messageId: 'commentFound' },
+        { messageId: 'commentFound' },
+        { messageId: 'magicValue' }
+      ],
+    },
+    {
+      code: `
+        export class FirstClass {}
+        export class SecondClass {}
+      `,
+      filename: 'MultipleClasses.ts',
+      errors: [{ messageId: 'multipleClasses' }],
+    },
+    {
+      code: `
+        function tooManyParams(a, b, c, d, e, f, g) {
+          return a + b + c + d + e + f + g;
+        }
+      `,
+      filename: 'complex.ts',
+      errors: [{ messageId: 'complexFunction' }],
+    },
+    {
+      code: `
+        function noParams() {
+          return 42;
+        }
+      `,
+      filename: 'noparams.ts',
+      errors: [
+        { messageId: 'wrongArgumentCount' },
+        { messageId: 'magicValue' }
+      ],
+    },
+    {
+      code: `
+        function errorThrower() {
+          throw new Error('Generic error');
+        }
+      `,
+      filename: 'errors.ts',
+      errors: [{ messageId: 'customErrorRequired' }],
+    },
+    {
+      code: `
+        const germanText = "Hällö Wörld";
+      `,
+      filename: 'international.ts',
+      errors: [{ messageId: 'nonEnglishString' }],
+    },
+  ],
+});
+
+console.log('✅ enforce-function-argument-count tests completed successfully');

package/rules/__tests__/enforce-repository-token-handling.test.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Tests for enforce-repository-token-handling rule
+ */
+
+import { RuleTester } from "eslint";
+import enforceRepositoryTokenHandling from "../enforce-repository-token-handling.js";
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+  },
+});
+
+ruleTester.run("enforce-repository-token-handling", enforceRepositoryTokenHandling, {
+  valid: [
+    // ✅ RICHTIG: Repository erbt von AbstractRepo
+    {
+      code: `
+        import AbstractRepo from "./AbstractRepo";
+        
+        class BackendFactionRepo extends AbstractRepo {
+          async getAllFactions() {
+            const response = await this.api.get("/api/v1/admin/playable-factions");
+            return response;
+          }
+        }
+      `,
+      filename: "src/infrastructure/BackendFactionRepo.ts",
+    },
+    
+    // ✅ RICHTIG: Nicht-Repository-Datei (wird ignoriert)
+    {
+      code: `
+        const api = new ApiClient();
+        api.setToken("token");
+      `,
+      filename: "src/components/SomeComponent.tsx",
+    },
+  ],
+
+  invalid: [
+    // ❌ FALSCH: Repository erbt nicht von AbstractRepo
+    {
+      code: `
+        class BackendFactionRepo {
+          async getAllFactions() {
+            return "test";
+          }
+        }
+      `,
+      filename: "src/infrastructure/BackendFactionRepo.ts",
+      errors: [
+        { messageId: "mustExtendAbstractRepo" },
+      ],
+    },
+  ],
+});

package/rules/__tests__/english-only-code-strings.test.js.disabled

@@ -0,0 +1,300 @@
+const { RuleTester } = require('eslint');
+
+// Simple rule implementation for english-only-code-strings
+const englishonlycodestringsRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Test rule for english-only-code-strings",
+      category: "Best Practices",
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      ruleViolation: "Rule violation detected",
+      improperUsage: "Improper usage detected",
+      magicValue: "Magic value detected",
+      anonymousObject: "Anonymous object detected",
+      typeAssertion: "Type assertion detected",
+      multipleClasses: "Multiple classes detected",
+      commentFound: "Comment found",
+      filenameClassMismatch: "Filename class mismatch",
+      visibilityModifier: "Visibility modifier detected",
+      wrongConstructor: "Wrong constructor usage",
+      nonEnglishString: "Non-English string detected",
+      complexFunction: "Function too complex",
+      wrongArgumentCount: "Wrong argument count",
+      customErrorRequired: "Custom error class required",
+    },
+  },
+  create(context) {
+    return {
+      // Basic node visitors that can detect common patterns
+      Literal(node) {
+        // Test for magic values
+        if (typeof node.value === 'number' && node.value > 1 && node.value !== 0) {
+          context.report({
+            node,
+            messageId: "magicValue",
+          });
+        }
+        
+        // Test for non-English strings (simple check)
+        if (typeof node.value === 'string' && /[äöüßÄÖÜ]/.test(node.value)) {
+          context.report({
+            node,
+            messageId: "nonEnglishString",
+          });
+        }
+      },
+      
+      ObjectExpression(node) {
+        // Test for anonymous objects
+        if (node.properties.length > 0) {
+          context.report({
+            node,
+            messageId: "anonymousObject",
+          });
+        }
+      },
+      
+      TSAsExpression(node) {
+        // Test for type assertions
+        context.report({
+          node,
+          messageId: "typeAssertion",
+        });
+      },
+      
+      Program(node) {
+        // Test for multiple classes
+        const classCount = node.body.filter(n => n.type === 'ClassDeclaration').length;
+        if (classCount > 1) {
+          context.report({
+            node,
+            messageId: "multipleClasses",
+          });
+        }
+        
+        // Test for comments
+        if (node.comments && node.comments.length > 0) {
+          node.comments.forEach(comment => {
+            context.report({
+              node: comment,
+              messageId: "commentFound",
+            });
+          });
+        }
+      },
+      
+      ClassDeclaration(node) {
+        // Test filename-class match
+        const filename = context.getFilename();
+        const expectedClassName = filename.split('/').pop()?.replace('.ts', '') || '';
+        if (node.id?.name && node.id.name !== expectedClassName) {
+          context.report({
+            node: node.id,
+            messageId: "filenameClassMismatch",
+          });
+        }
+      },
+      
+      FunctionDeclaration(node) {
+        // Test function complexity (simple param count check)
+        if (node.params.length > 5) {
+          context.report({
+            node,
+            messageId: "complexFunction",
+          });
+        }
+        
+        // Test argument count
+        if (node.params.length === 0 || node.params.length > 10) {
+          context.report({
+            node,
+            messageId: "wrongArgumentCount",
+          });
+        }
+      },
+      
+      ThrowStatement(node) {
+        // Test for custom error classes
+        if (node.argument?.type === 'NewExpression' && 
+            node.argument.callee?.name === 'Error') {
+          context.report({
+            node,
+            messageId: "customErrorRequired",
+          });
+        }
+      },
+    };
+  },
+};
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+  },
+});
+
+console.log('Testing english-only-code-strings rule...');
+
+ruleTester.run('english-only-code-strings', {
+  create: (context) => englishonlycodestringsRule.create(context),
+  meta: englishonlycodestringsRule.meta,
+}, {
+  valid: [
+    // Valid cases
+    {
+      code: `
+        export default class ValidClass {
+          constructor() {
+            this.name = '';
+            this.value = 0;
+          }
+          
+          static create(data) {
+            const instance = new ValidClass();
+            instance.name = data.name;
+            return instance;
+          }
+          
+          processData(param1, param2) {
+            return param1 + param2;
+          }
+        }
+      `,
+      filename: 'ValidClass.ts',
+    },
+    {
+      code: `
+        const VALID_CONSTANT = 42;
+        function processWithConstant() {
+          return VALID_CONSTANT;
+        }
+      `,
+      filename: 'Constants.ts',
+    },
+    {
+      code: `
+        import { UserDto } from './dto/UserDto';
+        
+        function createUser() {
+          return new UserDto();
+        }
+      `,
+      filename: 'UserService.ts',
+    },
+    {
+      code: `
+        export class UserService {
+          constructor() {}
+          
+          findById(id) {
+            if (!id) {
+              throw new CustomUserError('User ID required');
+            }
+            return { id, name: 'Test User' };
+          }
+        }
+      `,
+      filename: 'UserService.ts',
+    },
+    {
+      code: `
+        const config = {
+          apiUrl: 'https://api.example.com',
+          timeout: 5000,
+          retries: 3
+        };
+      `,
+      filename: 'config.ts',
+    },
+  ],
+  
+  invalid: [
+    // Invalid cases that should trigger rule violations
+    {
+      code: `
+        function badFunction() {
+          return 42; // Magic number
+        }
+      `,
+      filename: 'badFunction.ts',
+      errors: [{ messageId: 'magicValue' }],
+    },
+    {
+      code: `
+        const data = {
+          name: 'test',
+          value: 123 // Anonymous object + magic number
+        };
+      `,
+      filename: 'data.ts',
+      errors: [
+        { messageId: 'anonymousObject' },
+        { messageId: 'magicValue' }
+      ],
+    },
+    {
+      code: `
+        // This is a comment
+        const value = 999; // Another comment with magic number
+      `,
+      filename: 'commented.ts',
+      errors: [
+        { messageId: 'commentFound' },
+        { messageId: 'commentFound' },
+        { messageId: 'magicValue' }
+      ],
+    },
+    {
+      code: `
+        export class FirstClass {}
+        export class SecondClass {}
+      `,
+      filename: 'MultipleClasses.ts',
+      errors: [{ messageId: 'multipleClasses' }],
+    },
+    {
+      code: `
+        function tooManyParams(a, b, c, d, e, f, g) {
+          return a + b + c + d + e + f + g;
+        }
+      `,
+      filename: 'complex.ts',
+      errors: [{ messageId: 'complexFunction' }],
+    },
+    {
+      code: `
+        function noParams() {
+          return 42;
+        }
+      `,
+      filename: 'noparams.ts',
+      errors: [
+        { messageId: 'wrongArgumentCount' },
+        { messageId: 'magicValue' }
+      ],
+    },
+    {
+      code: `
+        function errorThrower() {
+          throw new Error('Generic error');
+        }
+      `,
+      filename: 'errors.ts',
+      errors: [{ messageId: 'customErrorRequired' }],
+    },
+    {
+      code: `
+        const germanText = "Hällö Wörld";
+      `,
+      filename: 'international.ts',
+      errors: [{ messageId: 'nonEnglishString' }],
+    },
+  ],
+});
+
+console.log('✅ english-only-code-strings tests completed successfully');