Introduce AssertClassNameComparisonToInstanceOfRector

config/sets/phpunit-code-quality.php

@@ -13,6 +13,7 @@
 use Rector\PHPUnit\CodeQuality\Rector\ClassMethod\RemoveEmptyTestMethodRector;
 use Rector\PHPUnit\CodeQuality\Rector\ClassMethod\ReplaceTestAnnotationWithPrefixedFunctionRector;
 use Rector\PHPUnit\CodeQuality\Rector\Foreach_\SimplifyForeachInstanceOfRector;
+use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertClassNameComparisonToInstanceOfRector;
 use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertCompareOnCountableWithMethodToAssertCountRector;
 use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertCompareToSpecificMethodRector;
 use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertComparisonToSpecificMethodRector;
@@ -58,6 +59,7 @@
         NarrowUnusedSetUpDefinedPropertyRector::class,
 
         // specific asserts
+        AssertClassNameComparisonToInstanceOfRector::class,
         AssertCompareOnCountableWithMethodToAssertCountRector::class,
         AssertCompareToSpecificMethodRector::class,
         AssertComparisonToSpecificMethodRector::class,

rules-tests/CodeQuality/Rector/MethodCall/AssertClassNameComparisonToInstanceOfRector/AssertClassNameComparisonToInstanceOfRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertCompareToSpecificMethodRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class AssertClassNameComparisonToInstanceOfRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}

rules-tests/CodeQuality/Rector/MethodCall/AssertClassNameComparisonToInstanceOfRector/Fixture/get_class.php.inc

@@ -0,0 +1,33 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertClassNameComparisonToInstanceOfRector\Fixture;
+
+use stdClass;
+
+final class GetClass extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $something = new stdClass();
+        self::assertSame('stdClass', get_class($something));
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertClassNameComparisonToInstanceOfRector\Fixture;
+
+use stdClass;
+
+final class GetClass extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $something = new stdClass();
+        self::assertInstanceOf('stdClass', $something);
+    }
+}
+
+?>

rules-tests/CodeQuality/Rector/MethodCall/AssertClassNameComparisonToInstanceOfRector/Fixture/skip_first_param.inc

@@ -0,0 +1,27 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertClassNameComparisonToInstanceOfRector\Fixture;
+
+final class SkipFirstParam extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $this->assertSame(get_class($something), 'stdClass');
+    }
+}
+
+?>
+    -----
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertClassNameComparisonToInstanceOfRector\Fixture;
+
+final class SkipFirstParam extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $this->assertSame(get_class($something), 'stdClass');
+    }
+}
+
+?>

rules-tests/CodeQuality/Rector/MethodCall/AssertClassNameComparisonToInstanceOfRector/config/configured_rule.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertClassNameComparisonToInstanceOfRector;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->rule(AssertClassNameComparisonToInstanceOfRector::class);
+};

rules/CodeQuality/Rector/MethodCall/AssertClassNameComparisonToInstanceOfRector.php

@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PHPUnit\CodeQuality\Rector\MethodCall;
+
+use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Identifier;
+use Rector\PHPUnit\NodeAnalyzer\TestsNodeAnalyzer;
+use Rector\Rector\AbstractRector;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+/**
+ * @see \Rector\PHPUnit\Tests\CodeQuality\Rector\MethodCall\AssertClassnameComparisonToInstanceOfRector\AssertClassnameComparisonToInstanceOfRectorTest
+ */
+final class AssertClassNameComparisonToInstanceOfRector extends AbstractRector
+{
+    public function __construct(private readonly TestsNodeAnalyzer $testsNodeAnalyzer)
+    {
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Turns class name comparisons to their method name alternatives in PHPUnit TestCase',
+            [
+                new CodeSample(
+                    '$this->assertNotEquals(SomeInstance::class, get_class($value));',
+                    '$this->assertNotInstanceOf(SomeInstance::class, $value);'
+                ),
+            ]
+        );
+    }
+
+    /**
+     * @return array<class-string<Node>>
+     */
+    public function getNodeTypes(): array
+    {
+        return [MethodCall::class, StaticCall::class];
+    }
+
+    /**
+     * @param MethodCall|StaticCall $node
+     */
+    public function refactor(Node $node): ?Node
+    {
+        if (! $this->testsNodeAnalyzer->isPHPUnitMethodCallNames(
+            $node,
+            ['assertSame', 'assertNotSame', 'assertEquals', 'assertNotEquals']
+        )) {
+            return null;
+        }
+
+        if ($node->isFirstClassCallable()) {
+            return null;
+        }
+
+        // we need 2 args
+        if (! isset($node->args[1])) {
+            return null;
+        }
+
+        $secondArgument = $node->getArgs()[1];
+        $secondArgumentValue = $secondArgument->value;
+
+        if ($secondArgumentValue instanceof FuncCall && $this->isName($secondArgumentValue->name, 'get_class')) {
+            $countArg = $secondArgumentValue->getArgs()[0];
+            $assertArgs[1] = new Arg($countArg->value);
+
+            $node->args = $assertArgs;
+            $this->renameMethod($node);
+
+            return $node;
+        }
+
+        return null;
+    }
+
+    private function renameMethod(MethodCall|StaticCall $node): void
+    {
+        if ($this->isNames($node->name, ['assertSame', 'assertEquals'])) {
+            $node->name = new Identifier('assertInstanceOf');
+        } elseif ($this->isNames($node->name, ['assertNotSame', 'assertNotEquals'])) {
+            $node->name = new Identifier('assertNotInstanceOf');
+        }
+    }
+}