[code-quality] Add AssertArrayCastedObjectToAssertSameRector

Author: TomasVotruba

composer.json

@@ -7,17 +7,17 @@
         "php": ">=8.2"
     },
     "require-dev": {
-        "phpecs/phpecs": "^2.1.1",
+        "phpecs/phpecs": "^2.2",
         "phpstan/extension-installer": "^1.4",
-        "phpstan/phpstan": "^2.1.8",
+        "phpstan/phpstan": "^2.1.31",
         "phpstan/phpstan-deprecation-rules": "^2.0",
         "phpstan/phpstan-webmozart-assert": "^2.0",
         "phpunit/phpunit": "^11.5",
         "rector/rector-src": "dev-main",
         "rector/swiss-knife": "^1.0",
-        "rector/type-perfect": "^2.0",
+        "rector/type-perfect": "^2.1",
         "symplify/phpstan-extensions": "^12.0",
-        "symplify/vendor-patches": "^11.4",
+        "symplify/vendor-patches": "^11.5",
         "tomasvotruba/class-leak": "^1.2",
         "tracy/tracy": "^2.10"
     },

config/sets/phpunit-code-quality.php

@@ -17,6 +17,7 @@
 use Rector\PHPUnit\CodeQuality\Rector\ClassMethod\DataProviderArrayItemsNewLinedRector;
 use Rector\PHPUnit\CodeQuality\Rector\ClassMethod\RemoveEmptyTestMethodRector;
 use Rector\PHPUnit\CodeQuality\Rector\ClassMethod\ReplaceTestAnnotationWithPrefixedFunctionRector;
+use Rector\PHPUnit\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector;
 use Rector\PHPUnit\CodeQuality\Rector\Foreach_\SimplifyForeachInstanceOfRector;
 use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertCompareOnCountableWithMethodToAssertCountRector;
 use Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertComparisonToSpecificMethodRector;
@@ -97,6 +98,7 @@
 
         // avoid call on nullable object
         AddInstanceofAssertForNullableInstanceRector::class,
+        AssertArrayCastedObjectToAssertSameRector::class,
 
         /**
          * Improve direct testing of your code, without mock creep. Make it simple, clear and easy to maintain:

phpstan.neon

@@ -38,8 +38,14 @@ parameters:
         # see https://github.com/rectorphp/rector-src/actions/runs/11798721617/job/32865546672?pr=6422#step:5:110
         - '#Doing instanceof PHPStan\\Type\\.+ is error\-prone and deprecated#'
 
-        -
-            identifier: instanceof.alwaysTrue
+        - identifier: instanceof.alwaysTrue
+        - identifier: assign.propertyType
+
+        # not relevant
+        - '#Method (.*?)provideMinPhpVersion\(\) never returns \d+ so it can be removed from the return type#'
 
+        # chicken-egg false positive
         -
-            identifier: assign.propertyType
+            message: '#Parameter \#1 \$value of static method Webmozart\\Assert\\Assert\:\:isAOf\(\) expects object\|string, PhpParser\\Node\\Stmt\\Class_\|null given#'
+            path: rules/AnnotationsToAttributes/Rector/Class_/AnnotationWithValueToAttributeRector.php
+

rules-tests/CodeQuality/Rector/Expression/AssertArrayCastedObjectToAssertSameRector/AssertArrayCastedObjectToAssertSameRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class AssertArrayCastedObjectToAssertSameRectorTest 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/Expression/AssertArrayCastedObjectToAssertSameRector/Fixture/fixture.php.inc

@@ -0,0 +1,38 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Fixture;
+
+use Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Source\SomeObjectWithPublicProperties;
+
+final class SomeTest extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $someObject = new SomeObjectWithPublicProperties();
+
+        $this->assertSame([
+            'name' => 'John',
+            'surname' => 'Doe',
+        ], (array) $someObject);
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Fixture;
+
+use Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Source\SomeObjectWithPublicProperties;
+
+final class SomeTest extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $someObject = new SomeObjectWithPublicProperties();
+        $this->assertSame('John', $someObject->name);
+        $this->assertSame('Doe', $someObject->surname);
+    }
+}
+
+?>

rules-tests/CodeQuality/Rector/Expression/AssertArrayCastedObjectToAssertSameRector/Fixture/skip_cast_on_non_object.php.inc

@@ -0,0 +1,18 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Fixture;
+
+use Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Source\SomeObjectWithPublicProperties;
+
+final class SkipCastOnNonObject extends \PHPUnit\Framework\TestCase
+{
+    public function test()
+    {
+        $someObject = 'some string';
+
+        $this->assertSame([
+            'name' => 'John',
+            'surname' => 'Doe',
+        ], (array) $someObject);
+    }
+}

rules-tests/CodeQuality/Rector/Expression/AssertArrayCastedObjectToAssertSameRector/Source/SomeObjectWithPublicProperties.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Expression\AssertArrayCastedObjectToAssertSameRector\Source;
+
+final class SomeObjectWithPublicProperties
+{
+    public $name;
+
+    public $surname;
+}

rules-tests/CodeQuality/Rector/Expression/AssertArrayCastedObjectToAssertSameRector/config/configured_rule.php

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

rules-tests/CodeQuality/Rector/Foreach_/SimplifyForeachInstanceOfRector/Fixture/fixture.php.inc

@@ -1,5 +1,7 @@
 <?php
 
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Foreach_\SimplifyForeachInstanceOfRector\Fixture;
+
 final class MyOtherTest extends \PHPUnit\Framework\TestCase
 {
     public function test()
@@ -27,6 +29,8 @@ final class MyOtherTest extends \PHPUnit\Framework\TestCase
 -----
 <?php
 
+namespace Rector\PHPUnit\Tests\CodeQuality\Rector\Foreach_\SimplifyForeachInstanceOfRector\Fixture;
+
 final class MyOtherTest extends \PHPUnit\Framework\TestCase
 {
     public function test()

rules/CodeQuality/Rector/Expression/AssertArrayCastedObjectToAssertSameRector.php

@@ -0,0 +1,173 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PHPUnit\CodeQuality\Rector\Expression;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\Cast\Array_;
+use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\PropertyFetch;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Stmt\Expression;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\ObjectType;
+use Rector\PhpParser\Node\Value\ValueResolver;
+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\Expression\AssertArrayCastedObjectToAssertSameRector\AssertArrayCastedObjectToAssertSameRectorTest
+ */
+final class AssertArrayCastedObjectToAssertSameRector extends AbstractRector
+{
+    public function __construct(
+        private readonly TestsNodeAnalyzer $testsNodeAnalyzer,
+        private readonly ValueResolver $valueResolver,
+    ) {
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Split object casted to array to assert public properties to standalone assert calls',
+            [
+                new CodeSample(
+                    <<<'CODE_SAMPLE'
+use PHPUnit\Framework\TestCase;
+
+final class SomeTest extends TestClass
+{
+    public function test()
+    {
+        $someObject = new SomeObject();
+
+        $this->assertSame([
+            'name' => 'John',
+            'surname' => 'Doe',
+        ], (array) $someObject));
+    }
+}
+CODE_SAMPLE
+                    ,
+                    <<<'CODE_SAMPLE'
+use PHPUnit\Framework\TestCase;
+
+final class SomeTest extends TestClass
+{
+    public function test()
+    {
+        $someObject = new SomeObject();
+
+        $this->assertSame('John', $someObject->name);
+        $this->assertSame('Doe', $someObject->surname);
+    }
+}
+CODE_SAMPLE
+                ),
+            ]
+        );
+    }
+
+    /**
+     * @return array<class-string<Node>>
+     */
+    public function getNodeTypes(): array
+    {
+        return [Expression::class];
+    }
+
+    /**
+     * @param Expression $node
+     * @return Expression[]|null
+     */
+    public function refactor(Node $node): ?array
+    {
+        if (! $node->expr instanceof MethodCall) {
+            return null;
+        }
+
+        $methodCall = $node->expr;
+        if ($methodCall->isFirstClassCallable()) {
+            return null;
+        }
+
+        if (! $this->isName($methodCall->name, 'assertSame')) {
+            return null;
+        }
+
+        if (! $this->testsNodeAnalyzer->isInTestClass($node)) {
+            return null;
+        }
+
+        $args = $methodCall->getArgs();
+        $firstArg = $args[0];
+        if (! $firstArg->value instanceof Node\Expr\Array_) {
+            return null;
+        }
+
+        // we need assert to non empty arary
+        $array = $firstArg->value;
+        if ($array->items === []) {
+            return null;
+        }
+
+        $arrayType = $this->getType($array);
+        if (! $arrayType instanceof ConstantArrayType) {
+            return null;
+        }
+
+        $secondArg = $args[1];
+
+        if (! $secondArg->value instanceof Array_) {
+            return null;
+        }
+
+        $castArray = $secondArg->value;
+
+        $castedExpr = $castArray->expr;
+
+        $castedExprType = $this->getType($castedExpr);
+        if (! $castedExprType instanceof ObjectType) {
+            return null;
+        }
+
+        $assertedArrayValues = $this->valueResolver->getValue($array);
+        if (! $this->hasAllKeysString($assertedArrayValues)) {
+            return null;
+        }
+
+        $standaloneExpressions = [];
+
+        foreach ($assertedArrayValues as $propertyName => $expectedValue) {
+            $args = $this->nodeFactory->createArgs([
+                $expectedValue,
+                new PropertyFetch($castedExpr, new Identifier($propertyName)),
+            ]);
+
+            $assertSameMethodCall = new MethodCall(new Variable('this'), 'assertSame', $args);
+
+            $standaloneExpressions[] = new Expression($assertSameMethodCall);
+        }
+
+        return $standaloneExpressions;
+    }
+
+    /**
+     * @param array<mixed, mixed> $assertedArrayValues
+     */
+    private function hasAllKeysString(array $assertedArrayValues): bool
+    {
+        // all keys must be string
+        foreach (array_keys($assertedArrayValues) as $key) {
+            if (! is_string($key)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}