[phpunit] Add NoDoubleConsecutiveTestMockRule (#219)

Author: TomasVotruba

config/phpunit-rules.neon

@@ -7,3 +7,4 @@ rules:
     - Symplify\PHPStanRules\Rules\Doctrine\NoDocumentMockingRule
     - Symplify\PHPStanRules\Rules\Doctrine\NoEntityMockingRule
     - Symplify\PHPStanRules\Rules\PHPUnit\NoMockObjectAndRealObjectPropertyRule
+    - Symplify\PHPStanRules\Rules\PHPUnit\NoDoubleConsecutiveTestMockRule

src/Enum/RuleIdentifier/PHPUnitRuleIdentifier.php

@@ -15,4 +15,6 @@ final class PHPUnitRuleIdentifier
     public const NO_MOCK_OBJECT_AND_REAL_OBJECT_PROPERTY = 'phpunit.noMockObjectAndRealObjectProperty';
 
     public const NO_ASSERT_FUNC_CALL_IN_TESTS = 'phpunit.noAssertFuncCallInTests';
+
+    public const NO_DOUBLE_CONSECUTIVE_TEST_MOCK = 'phpunit.noDoubleConsecutiveTestMock';
 }

src/Rules/PHPUnit/NoDoubleConsecutiveTestMockRule.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Rules\PHPUnit;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\MethodCall;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleError;
+use PHPStan\Rules\RuleErrorBuilder;
+use Rector\PHPUnit\Enum\PHPUnitClassName;
+use Symplify\PHPStanRules\Enum\RuleIdentifier\PHPUnitRuleIdentifier;
+use Symplify\PHPStanRules\Helper\NamingHelper;
+
+/**
+ * @implements Rule<MethodCall>
+ */
+final class NoDoubleConsecutiveTestMockRule implements Rule
+{
+    /**
+     * @var string
+     */
+    public const ERROR_MESSAGE = 'Do not use "willReturnOnConsecutiveCalls()" and "willReturnCallback()" on the same mock. Use "willReturnCallback() only instead to make test more clear.';
+
+    public function getNodeType(): string
+    {
+        return MethodCall::class;
+    }
+
+    /**
+     * @param MethodCall $node
+     * @return RuleError[]
+     */
+    public function processNode(Node $node, Scope $scope): array
+    {
+        // 1. detect if we're in a PHPUnit test case
+        if (! $scope->isInClass()) {
+            return [];
+        }
+
+        $classReflection = $scope->getClassReflection();
+        if (! $classReflection->is(PHPUnitClassName::TEST_CASE)) {
+            return [];
+        }
+
+        // 2. find a phpunit mock call, that uses "willReturnOnConsecutiveCalls" and "willReturnCallback" on the same line
+        if (! $node->var instanceof MethodCall) {
+            return [];
+        }
+
+        $parentCall = $node->var;
+        if (! $this->containsBothMethodCallNames($node, $parentCall)) {
+            return [];
+        }
+
+        $identifierRuleError = RuleErrorBuilder::message(self::ERROR_MESSAGE)
+            ->identifier(PHPUnitRuleIdentifier::NO_DOUBLE_CONSECUTIVE_TEST_MOCK)
+            ->build();
+
+        return [$identifierRuleError];
+    }
+
+    private function containsBothMethodCallNames(MethodCall $firstMethodCall, MethodCall $secondMethodCall): bool
+    {
+        if (NamingHelper::isName($firstMethodCall->name, 'willReturnOnConsecutiveCalls') && NamingHelper::isName($secondMethodCall->name, 'willReturnCallback')) {
+            return true;
+        }
+
+        return NamingHelper::isName($secondMethodCall->name, 'willReturnOnConsecutiveCalls') && NamingHelper::isName($firstMethodCall->name, 'willReturnCallback');
+    }
+}

tests/Rules/PHPUnit/NoDoubleConsecutiveTestMockRule/Fixture/SkipWillReturnCallback.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\PHPUnit\NoDoubleConsecutiveTestMockRule\Fixture;
+
+use PHPUnit\Framework\TestCase;
+
+final class SkipWillReturnCallback extends TestCase
+{
+    public function test()
+    {
+        $this->createMock('SomeClass')
+            ->expects($this->exactly(2))
+            ->method('someMethod')
+            ->willReturnCallback(
+                function () {
+                    return 'first';
+                }
+            );
+    }
+}

tests/Rules/PHPUnit/NoDoubleConsecutiveTestMockRule/Fixture/WillReturnAndWithConsecutive.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Symplify\PHPStanRules\Tests\Rules\PHPUnit\NoDoubleConsecutiveTestMockRule\Fixture;
+
+use PHPUnit\Framework\TestCase;
+
+final class WillReturnAndWithConsecutive extends TestCase
+{
+    public function test()
+    {
+        $this->createMock('SomeClass')
+            ->expects($this->exactly(2))
+            ->method('someMethod')
+            ->willReturnCallback(
+                function () {
+                    return 'first';
+                }
+            )
+            ->willReturnOnConsecutiveCalls('first');
+    }
+}

tests/Rules/PHPUnit/NoDoubleConsecutiveTestMockRule/NoDoubleConsecutiveTestMockRuleTest.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Symplify\PHPStanRules\Tests\Rules\PHPUnit\NoDoubleConsecutiveTestMockRule;
+
+use Iterator;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Symplify\PHPStanRules\Rules\PHPUnit\NoDoubleConsecutiveTestMockRule;
+
+final class NoDoubleConsecutiveTestMockRuleTest extends RuleTestCase
+{
+    #[DataProvider('provideData')]
+    public function testRule(string $filePath, array $expectedErrorsWithLines): void
+    {
+        $this->analyse([$filePath], $expectedErrorsWithLines);
+    }
+
+    public static function provideData(): Iterator
+    {
+        yield [__DIR__ . '/Fixture/WillReturnAndWithConsecutive.php', [[NoDoubleConsecutiveTestMockRule::ERROR_MESSAGE, 11]]];
+
+        yield [__DIR__ . '/Fixture/SkipWillReturnCallback.php', []];
+    }
+
+    protected function getRule(): Rule
+    {
+        return new NoDoubleConsecutiveTestMockRule();
+    }
+}