should keep order

Author: samsonasik

rules-tests/CodeQuality/Rector/MethodCall/AssertComparisonToSpecificMethodRector/Fixture/assert_true_to_greater_than.php.inc

@@ -8,8 +8,8 @@ final class AssertTrueToGreaterThan extends TestCase
 {
     public function some(int $param)
     {
-        self::assertTrue(0 < $param);
-        self::assertTrue(0 <= $param);
+        self::assertTrue(0 > $param);
+        self::assertTrue(0 >= $param);
     }
 }
 
@@ -25,8 +25,8 @@ final class AssertTrueToGreaterThan extends TestCase
 {
     public function some(int $param)
     {
-        self::assertGreaterThan(0, $param);
-        self::assertGreaterThanOrEqual(0, $param);
+        self::assertGreaterThan($param, 0);
+        self::assertGreaterThanOrEqual($param, 0);
     }
 }
 

rules-tests/CodeQuality/Rector/MethodCall/AssertComparisonToSpecificMethodRector/Fixture/assert_true_to_less_than.php.inc

@@ -8,8 +8,8 @@ final class AssertTrueToLessThan extends TestCase
 {
     public function some(int $param)
     {
-        self::assertTrue(0 > $param);
-        self::assertTrue(0 >= $param);
+        self::assertTrue(0 < $param);
+        self::assertTrue(0 <= $param);
     }
 }
 
@@ -25,8 +25,8 @@ final class AssertTrueToLessThan extends TestCase
 {
     public function some(int $param)
     {
-        self::assertLessThan(0, $param);
-        self::assertLessThanOrEqual(0, $param);
+        self::assertLessThan($param, 0);
+        self::assertLessThanOrEqual($param, 0);
     }
 }
 

rules-tests/CodeQuality/Rector/MethodCall/AssertComparisonToSpecificMethodRector/Fixture/fixture.php.inc

@@ -26,8 +26,8 @@ final class MyEqualsTest extends \PHPUnit\Framework\TestCase
 {
     public function test()
     {
-        $this->assertLessThan(2, count($something));
-        $this->assertLessThan($something[1]['foo'], $something[0]['foo']);
+        $this->assertGreaterThan(2, count($something));
+        $this->assertGreaterThan($something[1]['foo'], $something[0]['foo']);
         $this->assertNotEquals(__DIR__, $something, 'message');
         $this->assertSame(1.0, $something);
         $this->assertNotSame(true, in_array('foo', ['bar', 'baz'], true));

rules/CodeQuality/Rector/MethodCall/AssertComparisonToSpecificMethodRector.php

@@ -46,17 +46,17 @@ public function __construct(
             new BinaryOpWithAssertMethod(NotIdentical::class, 'assertNotSame', 'assertSame'),
             new BinaryOpWithAssertMethod(Equal::class, 'assertEquals', 'assertNotEquals'),
             new BinaryOpWithAssertMethod(NotEqual::class, 'assertNotEquals', 'assertEquals'),
-            new BinaryOpWithAssertMethod(Greater::class, 'assertLessThan', 'assertGreaterThan'),
-            new BinaryOpWithAssertMethod(Smaller::class, 'assertGreaterThan', 'assertLessThan'),
+            new BinaryOpWithAssertMethod(Greater::class, 'assertGreaterThan', 'assertLessThan'),
+            new BinaryOpWithAssertMethod(Smaller::class, 'assertLessThan', 'assertGreaterThan'),
             new BinaryOpWithAssertMethod(
                 GreaterOrEqual::class,
-                'assertLessThanOrEqual',
-                'assertGreaterThanOrEqual'
+                'assertGreaterThanOrEqual',
+                'assertLessThanOrEqual'
             ),
             new BinaryOpWithAssertMethod(
                 SmallerOrEqual::class,
-                'assertGreaterThanOrEqual',
-                'assertLessThanOrEqual'
+                'assertLessThanOrEqual',
+                'assertGreaterThanOrEqual'
             ),
         ];
     }
@@ -122,22 +122,27 @@ private function processCallWithBinaryOp(MethodCall|StaticCall $node, BinaryOp $
                 'assertFalse' => $binaryOpWithAssertMethod->getNotAssertMethodName(),
             ]);
 
-            $this->changeArgumentsOrder($node);
+            $shouldKeepOrder = $binaryOp instanceof Greater
+                || $binaryOp instanceof GreaterOrEqual
+                || $binaryOp instanceof Smaller
+                || $binaryOp instanceof SmallerOrEqual;
+
+            $this->changeArgumentsOrder($node, $shouldKeepOrder);
 
             return $node;
         }
 
         return null;
     }
 
-    private function changeArgumentsOrder(MethodCall|StaticCall $node): void
+    private function changeArgumentsOrder(MethodCall|StaticCall $node, bool $shouldKeepOrder): void
     {
         $oldArguments = $node->getArgs();
 
         /** @var BinaryOp $expression */
         $expression = $oldArguments[0]->value;
 
-        if ($this->isConstantValue($expression->left)) {
+        if ($this->isConstantValue($expression->left) && ! $shouldKeepOrder) {
             $firstArgument = new Arg($expression->left);
             $secondArgument = new Arg($expression->right);
         } else {