fix: [rule] require atLeast(1+) (fixes rectorphp/mockstan#1)

README.md

@@ -202,6 +202,35 @@ $this->realService = new Service();
 :+1:
 
 
+<br>
+
+### RequireAtLeastOneRule
+
+Disallow `atLeast(0)` on mock expectations, as it matches any number of calls (including zero) and provides no real verification. Require a value of `1` or higher.
+
+```yaml
+rules:
+    - Rector\Mockstan\Rules\RequireAtLeastOneRule
+```
+
+```php
+$someMock = $this->createMock(Service::class);
+$someMock->expects($this->atLeast(0))
+    ->method('calculate')
+    ->willReturn(10);
+```
+
+:x:
+
+```php
+$someMock = $this->createMock(Service::class);
+$someMock->expects($this->atLeast(1))
+    ->method('calculate')
+    ->willReturn(10);
+```
+
+:+1:
+
 <br>
 
 ### NoMockOnlyTestRule

config/phpunit-mocks-rules.neon

@@ -9,6 +9,7 @@ rules:
     # explicit expects()
     - Rector\Mockstan\Rules\ExplicitExpectsMockMethodRule
     - Rector\Mockstan\Rules\AvoidAnyExpectsRule
+    - Rector\Mockstan\Rules\RequireAtLeastOneRule
 
     # better alternative than mocks
     - Rector\Mockstan\Rules\NoDocumentMockingRule

src/Enum/RuleIdentifier.php

@@ -24,4 +24,6 @@ final class RuleIdentifier
     public const string FORBIDDEN_CLASS_TO_MOCK = 'mockstan.forbiddenClassToMock';
 
     public const string AVOID_ANY_EXPECTS = 'mockstan.avoidAnyExpects';
+
+    public const string REQUIRE_AT_LEAST_ONE = 'mockstan.requireAtLeastOne';
 }

src/Rules/RequireAtLeastOneRule.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Mockstan\Rules;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Scalar\Int_;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use Rector\Mockstan\Enum\RuleIdentifier;
+use Rector\Mockstan\Helper\NamingHelper;
+use Rector\Mockstan\PHPUnit\TestClassDetector;
+
+/**
+ * @implements Rule<MethodCall>
+ *
+ * @see \Rector\Mockstan\Tests\Rules\RequireAtLeastOneRule\RequireAtLeastOneRuleTest
+ */
+final class RequireAtLeastOneRule implements Rule
+{
+    public const string ERROR_MESSAGE = 'Using $this->atLeast(0) is meaningless, as it matches any number of calls. Use 1 or higher';
+
+    public function getNodeType(): string
+    {
+        return MethodCall::class;
+    }
+
+    /**
+     * @param MethodCall $node
+     * @return IdentifierRuleError[]
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        if (! TestClassDetector::isTestClass($scope)) {
+            return [];
+        }
+
+        if (! NamingHelper::isName($node->name, 'atLeast')) {
+            return [];
+        }
+
+        $args = $node->getArgs();
+        if ($args === []) {
+            return [];
+        }
+
+        $firstArgValue = $args[0]->value;
+        if (! $firstArgValue instanceof Int_) {
+            return [];
+        }
+
+        if ($firstArgValue->value >= 1) {
+            return [];
+        }
+
+        $identifierRuleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+            ->identifier(RuleIdentifier::REQUIRE_AT_LEAST_ONE)
+            ->build();
+
+        return [$identifierRuleError];
+    }
+}

tests/Rules/RequireAtLeastOneRule/Fixture/AtLeastZero.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Rector\Mockstan\Tests\Rules\RequireAtLeastOneRule\Fixture;
+
+use PHPUnit\Framework\TestCase;
+
+final class AtLeastZero extends TestCase
+{
+    public function test(): void
+    {
+        $mock = $this->createMock(\stdClass::class);
+
+        $mock->expects($this->atLeast(0))
+            ->method('someMethod')
+            ->willReturn('value');
+    }
+}

tests/Rules/RequireAtLeastOneRule/Fixture/SkipAtLeastOne.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace Rector\Mockstan\Tests\Rules\RequireAtLeastOneRule\Fixture;
+
+use PHPUnit\Framework\TestCase;
+
+final class SkipAtLeastOne extends TestCase
+{
+    public function test(): void
+    {
+        $mock = $this->createMock(\stdClass::class);
+
+        $mock->expects($this->atLeast(1))
+            ->method('someMethod')
+            ->willReturn('value');
+
+        $anotherMock = $this->createMock(\stdClass::class);
+        $anotherMock->expects($this->atLeast(3))
+            ->method('anotherMethod')
+            ->willReturn('value');
+    }
+}

tests/Rules/RequireAtLeastOneRule/RequireAtLeastOneRuleTest.php

@@ -0,0 +1,37 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Mockstan\Tests\Rules\RequireAtLeastOneRule;
+
+use Iterator;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Mockstan\Rules\RequireAtLeastOneRule;
+
+final class RequireAtLeastOneRuleTest extends RuleTestCase
+{
+    /**
+     * @param array<int, array<string|int>> $expectedErrorsWithLines
+     */
+    #[DataProvider('provideData')]
+    public function testRule(string $filePath, array $expectedErrorsWithLines): void
+    {
+        $this->analyse([$filePath], $expectedErrorsWithLines);
+    }
+
+    /**
+     * @return Iterator<array<array<int, mixed>, mixed>>
+     */
+    public static function provideData(): Iterator
+    {
+        yield [__DIR__ . '/Fixture/AtLeastZero.php', [[RequireAtLeastOneRule::ERROR_MESSAGE, 13]]];
+        yield [__DIR__ . '/Fixture/SkipAtLeastOne.php', []];
+    }
+
+    protected function getRule(): Rule
+    {
+        return new RequireAtLeastOneRule();
+    }
+}