Add TooManyArgumentsClass and related tests for argument validation

- Introduced TooManyArgumentsClass with a valid method and two new classes: TooManyArgsService and TooManyArgsOther, each containing methods with excessive arguments.
- Updated TooManyArgumentsRuleTest to include tests for the new classes, ensuring proper error reporting for methods exceeding the allowed argument limit.
- Enhanced ClassMustBeReadonlyRuleTest with a test for valid readonly classes to prevent false positives.

Author: Florian Krämer

data/Controller/ValidReadonlyController.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Controller;
+
+readonly class ValidReadonlyController
+{
+    // This class is already readonly, so no error should be reported
+}
+

data/MaxLineLengthMultipleLines.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace App;
+
+class MaxLineLengthMultipleLines // This line is exactly 95 characters long to test multiple violations in one file
+{
+    public function methodWithMultipleVeryLongLinesThatExceedTheMaximumAllowedLengthOfEightyCharacters(): void
+    {
+        $variable = 'This is a short line';
+        // All good here
+    }
+}
+

data/TooManyArgumentsClass.php

@@ -8,4 +8,29 @@ public function methodWithTooManyArguments(int $arg1, int $arg2, int $arg3, int
     {
         // Method implementation
     }
+
+    public function validMethod(int $arg1, int $arg2): void
+    {
+        // Valid method with acceptable number of arguments
+    }
+}
+
+namespace App\Service;
+
+class TooManyArgsService
+{
+    public function methodWithTooManyArguments(int $a, int $b, int $c, int $d, int $e): void
+    {
+        // This should trigger error when pattern matches Service
+    }
+}
+
+namespace App\Other;
+
+class TooManyArgsOther
+{
+    public function methodWithTooManyArguments(int $a, int $b, int $c, int $d, int $e): void
+    {
+        // This should NOT trigger error when pattern doesn't match
+    }
 }

tests/TestCases/Architecture/ClassMustBeFinalRuleWithAbstractNotIgnoredTest.php

@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\PHPStanRules\Tests\TestCases\Architecture;
+
+use Phauthentic\PHPStanRules\Architecture\ClassMustBeFinalRule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<ClassMustBeFinalRule>
+ */
+class ClassMustBeFinalRuleWithAbstractNotIgnoredTest extends RuleTestCase
+{
+    protected function getRule(): \PHPStan\Rules\Rule
+    {
+        // Do NOT ignore abstract classes
+        return new ClassMustBeFinalRule(
+            patterns: ['/Service$/'],
+            ignoreAbstractClasses: false
+        );
+    }
+
+    public function testConcreteClassMustBeFinal(): void
+    {
+        // Test that concrete (non-abstract) classes are checked when ignoreAbstractClasses is false
+        // This ensures the flag doesn't prevent checking of regular classes
+        $this->analyse([__DIR__ . '/../../../data/Service/MissingFinalRuleService.php'], [
+            [
+                'Class App\Service\MissingFinalRuleService must be final.',
+                5,
+            ],
+        ]);
+    }
+}
+

tests/TestCases/Architecture/ClassMustBeReadonlyRuleTest.php

@@ -34,4 +34,10 @@ public function testRule(): void
         // the test fails, if the expected error does not occur,
         // or if there are other errors reported beside the expected one
     }
+
+    public function testValidReadonlyClass(): void
+    {
+        // Test that readonly classes don't trigger errors
+        $this->analyse([__DIR__ . '/../../../data/Controller/ValidReadonlyController.php'], []);
+    }
 }

tests/TestCases/CleanCode/MaxLineLengthRuleIgnoreUseTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\PHPStanRules\Tests\TestCases\CleanCode;
+
+use Phauthentic\PHPStanRules\CleanCode\MaxLineLengthRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<MaxLineLengthRule>
+ */
+class MaxLineLengthRuleIgnoreUseTest extends RuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        // Ignore use statements (3rd parameter is true)
+        return new MaxLineLengthRule(80, [], true);
+    }
+
+    public function testUseStatementsAreIgnored(): void
+    {
+        // All use statements in this file are very long, but should be ignored
+        $this->analyse([__DIR__ . '/../../../data/MaxLineLengthUseStatementsClass.php'], []);
+    }
+}
+

tests/TestCases/CleanCode/MaxLineLengthRuleTest.php

@@ -28,28 +28,18 @@ public function testRule(): void
         ]);
     }
 
-    public function testRuleWithExcludePatterns(): void
+    public function testMultipleLongLinesInFile(): void
     {
-        $rule = new MaxLineLengthRule(80, ['/.*Excluded.*/']);
-
-        $this->analyse([__DIR__ . '/../../../data/MaxLineLengthExcludedClass.php'], [
+        // Test that multiple long lines in the same file are all detected
+        $this->analyse([__DIR__ . '/../../../data/MaxLineLengthMultipleLines.php'], [
             [
-                'Line 7 exceeds the maximum length of 80 characters (found 81 characters).',
-                7,
+                'Line 5 exceeds the maximum length of 80 characters (found 115 characters).',
+                5,
             ],
             [
-                'Line 9 exceeds the maximum length of 80 characters (found 86 characters).',
-                9,
+                'Line 7 exceeds the maximum length of 80 characters (found 110 characters).',
+                7,
             ],
         ]);
     }
-
-
-
-    public function testRuleWithIgnoreUseStatements(): void
-    {
-        $rule = new MaxLineLengthRule(80, [], true);
-
-        $this->analyse([__DIR__ . '/../../../data/MaxLineLengthUseStatementsClass.php'], []);
-    }
 }

tests/TestCases/CleanCode/MaxLineLengthRuleWithExclusionTest.php

@@ -0,0 +1,39 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\PHPStanRules\Tests\TestCases\CleanCode;
+
+use Phauthentic\PHPStanRules\CleanCode\MaxLineLengthRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<MaxLineLengthRule>
+ */
+class MaxLineLengthRuleWithExclusionTest extends RuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        // Exclude files matching "Excluded" in their path
+        return new MaxLineLengthRule(80, ['/.*Excluded.*/']);
+    }
+
+    public function testExcludedFileIsNotChecked(): void
+    {
+        // This file should be excluded, so no errors should be reported
+        $this->analyse([__DIR__ . '/../../../data/MaxLineLengthExcludedClass.php'], []);
+    }
+
+    public function testNonExcludedFileIsChecked(): void
+    {
+        // This file is NOT excluded, so errors should be reported
+        $this->analyse([__DIR__ . '/../../../data/MaxLineLengthTestClass.php'], [
+            [
+                'Line 7 exceeds the maximum length of 80 characters (found 84 characters).',
+                7,
+            ],
+        ]);
+    }
+}
+

tests/TestCases/CleanCode/TooManyArgumentsRuleTest.php

@@ -25,6 +25,14 @@ public function testRule(): void
                 'Method App\TooManyArgumentsClass::methodWithTooManyArguments has too many arguments (4). Maximum allowed is 3.',
                 7,
             ],
+            [
+                'Method App\Service\TooManyArgsService::methodWithTooManyArguments has too many arguments (5). Maximum allowed is 3.',
+                22,
+            ],
+            [
+                'Method App\Other\TooManyArgsOther::methodWithTooManyArguments has too many arguments (5). Maximum allowed is 3.',
+                32,
+            ],
         ]);
     }
 }

tests/TestCases/CleanCode/TooManyArgumentsRuleWithPatternsTest.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Phauthentic\PHPStanRules\Tests\TestCases\CleanCode;
+
+use Phauthentic\PHPStanRules\CleanCode\TooManyArgumentsRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<TooManyArgumentsRule>
+ */
+class TooManyArgumentsRuleWithPatternsTest extends RuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        // Only apply to classes ending with "Service"
+        return new TooManyArgumentsRule(3, ['/Service$/']);
+    }
+
+    public function testRuleWithPatterns(): void
+    {
+        $this->analyse([__DIR__ . '/../../../data/TooManyArgumentsClass.php'], [
+            [
+                'Method App\Service\TooManyArgsService::methodWithTooManyArguments has too many arguments (5). Maximum allowed is 3.',
+                22,
+            ],
+            // TooManyArgumentsClass and TooManyArgsOther should NOT trigger errors because patterns don't match
+        ]);
+    }
+}
+