rector_rules_overview.md

47 Rules Overview

AddDoesNotPerformAssertionToNonAssertingTestRector

Tests without assertion will have @doesNotPerformAssertion

• class: Rector\PHPUnit\PHPUnit60\Rector\ClassMethod\AddDoesNotPerformAssertionToNonAssertingTestRector

 use PHPUnit\Framework\TestCase;

 class SomeClass extends TestCase
 {
+    /**
+     * @doesNotPerformAssertions
+     */
     public function test()
     {
         $nothing = 5;
     }
 }

AddProphecyTraitRector

Add Prophecy trait for method using $this->prophesize()

• class: Rector\PHPUnit\PHPUnit100\Rector\Class_\AddProphecyTraitRector

 use PHPUnit\Framework\TestCase;
+use Prophecy\PhpUnit\ProphecyTrait;

 final class ExampleTest extends TestCase
 {
+    use ProphecyTrait;
+
     public function testOne(): void
     {
         $prophecy = $this->prophesize(\AnInterface::class);
     }
 }

AddSeeTestAnnotationRector

Add @see annotation test of the class for faster jump to test. Make it FQN, so it stays in the annotation, not in the PHP source code.

• class: Rector\PHPUnit\CodeQuality\Rector\Class_\AddSeeTestAnnotationRector

+/**
+ * @see \SomeServiceTest
+ */
 class SomeService
 {
 }

 use PHPUnit\Framework\TestCase;

 class SomeServiceTest extends TestCase
 {
 }

AnnotationWithValueToAttributeRector

Change annotations with value to attribute

🔧 configure it!

• class: Rector\PHPUnit\AnnotationsToAttributes\Rector\Class_\AnnotationWithValueToAttributeRector

 use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\BackupGlobals;

-/**
- * @backupGlobals enabled
- */
+#[BackupGlobals(true)]
 final class SomeTest extends TestCase
 {
 }

AssertCompareToSpecificMethodRector

Turns vague php-only method in PHPUnit TestCase to more specific

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertCompareToSpecificMethodRector

-$this->assertSame(10, count($anything), "message");
+$this->assertCount(10, $anything, "message");

-$this->assertNotEquals(get_class($value), SomeInstance::class);
+$this->assertNotInstanceOf(SomeInstance::class, $value);

AssertComparisonToSpecificMethodRector

Turns comparison operations to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertComparisonToSpecificMethodRector

-$this->assertTrue($foo === $bar, "message");
+$this->assertSame($bar, $foo, "message");

-$this->assertFalse($foo >= $bar, "message");
+$this->assertLessThanOrEqual($bar, $foo, "message");

AssertEqualsParameterToSpecificMethodsTypeRector

Change assertEquals()/assertNotEquals() method parameters to new specific alternatives

• class: Rector\PHPUnit\PHPUnit80\Rector\MethodCall\AssertEqualsParameterToSpecificMethodsTypeRector

 final class SomeTest extends \PHPUnit\Framework\TestCase
 {
     public function test()
     {
         $value = 'value';
-        $this->assertEquals('string', $value, 'message', 5.0);
+        $this->assertEqualsWithDelta('string', $value, 5.0, 'message');

-        $this->assertEquals('string', $value, 'message', 0.0, 20);
+        $this->assertEquals('string', $value, 'message', 0.0);

-        $this->assertEquals('string', $value, 'message', 0.0, 10, true);
+        $this->assertEqualsCanonicalizing('string', $value, 'message');

-        $this->assertEquals('string', $value, 'message', 0.0, 10, false, true);
+        $this->assertEqualsIgnoringCase('string', $value, 'message');
     }
 }

AssertEqualsToSameRector

Turns assertEquals() into stricter assertSame() for scalar values in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertEqualsToSameRector

-$this->assertEquals(2, $result);
+$this->assertSame(2, $result);

AssertFalseStrposToContainsRector

Turns strpos/stripos comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertFalseStrposToContainsRector

-$this->assertFalse(strpos($anything, "foo"), "message");
+$this->assertNotContains("foo", $anything, "message");

AssertInstanceOfComparisonRector

Turns instanceof comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertInstanceOfComparisonRector

-$this->assertTrue($foo instanceof Foo, "message");
+$this->assertInstanceOf("Foo", $foo, "message");

-$this->assertFalse($foo instanceof Foo, "message");
+$this->assertNotInstanceOf("Foo", $foo, "message");

AssertIssetToSpecificMethodRector

Turns isset comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertIssetToSpecificMethodRector

-$this->assertTrue(isset($anything->foo));
+$this->assertObjectHasAttribute("foo", $anything);

-$this->assertFalse(isset($anything["foo"]), "message");
+$this->assertArrayNotHasKey("foo", $anything, "message");

AssertNotOperatorRector

Turns not-operator comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertNotOperatorRector

-$this->assertTrue(!$foo, "message");
+$this->assertFalse($foo, "message");

-$this->assertFalse(!$foo, "message");
+$this->assertTrue($foo, "message");

AssertPropertyExistsRector

Turns property_exists comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertPropertyExistsRector

-$this->assertFalse(property_exists(new Class, "property"));
-$this->assertTrue(property_exists(new Class, "property"));
+$this->assertClassHasAttribute("property", "Class");
+$this->assertClassNotHasAttribute("property", "Class");

AssertRegExpRector

Turns preg_match comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertRegExpRector

-$this->assertSame(1, preg_match("/^Message for ".*"\.$/", $string), $message);
+$this->assertRegExp("/^Message for ".*"\.$/", $string, $message);

-$this->assertEquals(false, preg_match("/^Message for ".*"\.$/", $string), $message);
+$this->assertNotRegExp("/^Message for ".*"\.$/", $string, $message);

AssertSameBoolNullToSpecificMethodRector

Turns same bool and null comparisons to their method name alternatives in PHPUnit TestCase

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertSameBoolNullToSpecificMethodRector

-$this->assertSame(null, $anything);
+$this->assertNull($anything);

-$this->assertNotSame(false, $anything);
+$this->assertNotFalse($anything);

AssertSameTrueFalseToAssertTrueFalseRector

Change $this->assertSame(true, ...) to assertTrue()

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertSameTrueFalseToAssertTrueFalseRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function test()
     {
         $value = (bool) mt_rand(0, 1);
-        $this->assertSame(true, $value);
+        $this->assertTrue($value);
     }
 }

AssertTrueFalseToSpecificMethodRector

Turns true/false comparisons to their method name alternatives in PHPUnit TestCase when possible

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\AssertTrueFalseToSpecificMethodRector

-$this->assertTrue(is_readable($readmeFile), "message");
+$this->assertIsReadable($readmeFile, "message");

ConstructClassMethodToSetUpTestCaseRector

Change __construct() method in tests of PHPUnit\Framework\TestCase to setUp(), to prevent dangerous override

• class: Rector\PHPUnit\CodeQuality\Rector\Class_\ConstructClassMethodToSetUpTestCaseRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     private $someValue;

-    public function __construct(?string $name = null, array $data = [], string $dataName = '')
+    protected function setUp()
     {
+        parent::setUp();
+
         $this->someValue = 1000;
-        parent::__construct($name, $data, $dataName);
     }
 }

CoversAnnotationWithValueToAttributeRector

Change covers annotations with value to attribute

• class: Rector\PHPUnit\AnnotationsToAttributes\Rector\Class_\CoversAnnotationWithValueToAttributeRector

 use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\CoversFunction;

-/**
- * @covers SomeClass
- */
+#[CoversClass(SomeClass::class)]
 final class SomeTest extends TestCase
 {
-    /**
-     * @covers ::someFunction
-     */
+    #[CoversFunction('someFunction')]
     public function test()
     {
     }
 }

CreateMockToAnonymousClassRector

Change $this->createMock() with methods to direct anonymous class

• class: Rector\PHPUnit\Rector\ClassMethod\CreateMockToAnonymousClassRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function test()
     {
-        $someMockObject = $this->createMock(SomeClass::class);
-
-        $someMockObject->method('someMethod')
-            ->willReturn(100);
+        $someMockObject = new class extends SomeClass {
+            public function someMethod()
+            {
+                return 100;
+            }
+        };
     }
 }

DataProviderAnnotationToAttributeRector

Change dataProvider annotations to attribute

• class: Rector\PHPUnit\AnnotationsToAttributes\Rector\ClassMethod\DataProviderAnnotationToAttributeRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
-    /**
-     * @dataProvider someMethod()
-     */
+    #[\PHPUnit\Framework\Attributes\DataProvider('test')]
     public function test(): void
     {
     }
 }

DelegateExceptionArgumentsRector

Takes setExpectedException() 2nd and next arguments to own methods in PHPUnit.

• class: Rector\PHPUnit\PHPUnit60\Rector\MethodCall\DelegateExceptionArgumentsRector

 use PHPUnit\Framework\TestCase;

 class SomeTest extends TestCase
 {
     public function test()
     {
-        $this->setExpectedException(SomeException::class, "Message", "CODE");
+        $this->setExpectedException(SomeException::class);
+        $this->expectExceptionMessage('Message');
+        $this->expectExceptionCode('CODE');
     }
 }

DependsAnnotationWithValueToAttributeRector

Change depends annotations with value to attribute

• class: Rector\PHPUnit\AnnotationsToAttributes\Rector\ClassMethod\DependsAnnotationWithValueToAttributeRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function testOne() {}
     public function testTwo() {}
-    /**
-     * @depends testOne
-     * @depends testTwo
-     */
+    #[\PHPUnit\Framework\Attributes\Depends('testOne')]
+    #[\PHPUnit\Framework\Attributes\Depends('testTwo')]
     public function testThree(): void
     {
     }
 }

ExceptionAnnotationRector

Changes ``@expectedExceptionannotations toexpectException*()` methods

• class: Rector\PHPUnit\PHPUnit60\Rector\ClassMethod\ExceptionAnnotationRector

-/**
- * @expectedException Exception
- * @expectedExceptionMessage Message
- */
 public function test()
 {
+    $this->expectException('Exception');
+    $this->expectExceptionMessage('Message');
     // tested code
 }

ExplicitPhpErrorApiRector

Use explicit API for expecting PHP errors, warnings, and notices

• class: Rector\PHPUnit\PHPUnit90\Rector\MethodCall\ExplicitPhpErrorApiRector

 final class SomeTest extends \PHPUnit\Framework\TestCase
 {
     public function test()
     {
-        $this->expectException(\PHPUnit\Framework\TestCase\Deprecated::class);
-        $this->expectException(\PHPUnit\Framework\TestCase\Error::class);
-        $this->expectException(\PHPUnit\Framework\TestCase\Notice::class);
-        $this->expectException(\PHPUnit\Framework\TestCase\Warning::class);
+        $this->expectDeprecation();
+        $this->expectError();
+        $this->expectNotice();
+        $this->expectWarning();
     }
 }

GetMockBuilderGetMockToCreateMockRector

Remove getMockBuilder() to createMock()

• class: Rector\PHPUnit\PHPUnit60\Rector\MethodCall\GetMockBuilderGetMockToCreateMockRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function test()
     {
-        $applicationMock = $this->getMockBuilder('SomeClass')
-           ->disableOriginalConstructor()
-           ->getMock();
+        $applicationMock = $this->createMock('SomeClass');
     }
 }

GetMockRector

Turns getMock*() methods to createMock()

• class: Rector\PHPUnit\PHPUnit50\Rector\StaticCall\GetMockRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function test()
     {
-        $classMock = $this->getMock("Class");
+        $classMock = $this->createMock("Class");
     }
 }

PreferPHPUnitSelfCallRector

Changes PHPUnit calls from $this->assert*() to self::assert*()

• class: Rector\PHPUnit\Rector\Class_\PreferPHPUnitSelfCallRector

 use PHPUnit\Framework\TestCase;

 final class SomeClass extends TestCase
 {
     public function run()
     {
-        $this->assertEquals('expected', $result);
+        self::assertEquals('expected', $result);
     }
 }

PreferPHPUnitThisCallRector

Changes PHPUnit calls from self::assert*() to $this->assert*()

• class: Rector\PHPUnit\CodeQuality\Rector\Class_\PreferPHPUnitThisCallRector

 use PHPUnit\Framework\TestCase;

 final class SomeClass extends TestCase
 {
     public function run()
     {
-        self::assertEquals('expected', $result);
+        $this->assertEquals('expected', $result);
     }
 }

PropertyExistsWithoutAssertRector

Turns PHPUnit TestCase assertObjectHasAttribute into property_exists comparisons

• class: Rector\PHPUnit\PHPUnit100\Rector\MethodCall\PropertyExistsWithoutAssertRector

-$this->assertClassHasAttribute("property", "Class");
-$this->assertClassNotHasAttribute("property", "Class");
+$this->assertFalse(property_exists(new Class, "property"));
+$this->assertTrue(property_exists(new Class, "property"));

RemoveDataProviderTestPrefixRector

Data provider methods cannot start with "test" prefix

• class: Rector\PHPUnit\PHPUnit70\Rector\Class_\RemoveDataProviderTestPrefixRector

 class SomeClass extends PHPUnit\Framework\TestCase
 {
     /**
-     * @dataProvider testProvideData()
+     * @dataProvider provideData()
      */
     public function test()
     {
         $nothing = 5;
     }

-    public function testProvideData()
+    public function provideData()
     {
         return ['123'];
     }
 }

RemoveEmptyTestMethodRector

Remove empty test methods

• class: Rector\PHPUnit\CodeQuality\Rector\ClassMethod\RemoveEmptyTestMethodRector

 class SomeTest extends \PHPUnit\Framework\TestCase
 {
-    /**
-     * testGetTranslatedModelField method
-     *
-     * @return void
-     */
-    public function testGetTranslatedModelField()
-    {
-    }
 }

RemoveExpectAnyFromMockRector

Remove expect($this->any()) from mocks as it has no added value

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\RemoveExpectAnyFromMockRector

 use PHPUnit\Framework\TestCase;

 class SomeClass extends TestCase
 {
     public function test()
     {
         $translator = $this->getMock('SomeClass');
-        $translator->expects($this->any())
-            ->method('trans')
+        $translator->method('trans')
             ->willReturn('translated max {{ max }}!');
     }
 }

RemoveSetMethodsMethodCallRector

Remove "setMethods()" method as never used

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\RemoveSetMethodsMethodCallRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function test()
     {
         $someMock = $this->getMockBuilder(SomeClass::class)
-            ->setMethods(['run'])
             ->getMock();
     }
 }

ReplaceTestAnnotationWithPrefixedFunctionRector

Replace @test with prefixed function

• class: Rector\PHPUnit\CodeQuality\Rector\ClassMethod\ReplaceTestAnnotationWithPrefixedFunctionRector

 class SomeTest extends \PHPUnit\Framework\TestCase
 {
-    /**
-     * @test
-     */
-    public function onePlusOneShouldBeTwo()
+    public function testOnePlusOneShouldBeTwo()
     {
         $this->assertSame(2, 1+1);
     }
 }

SimplifyForeachInstanceOfRector

Simplify unnecessary foreach check of instances

• class: Rector\PHPUnit\CodeQuality\Rector\Foreach_\SimplifyForeachInstanceOfRector

-foreach ($foos as $foo) {
-    $this->assertInstanceOf(SplFileInfo::class, $foo);
-}
+$this->assertContainsOnlyInstancesOf(\SplFileInfo::class, $foos);

SpecificAssertContainsRector

Change assertContains()/assertNotContains() method to new string and iterable alternatives

• class: Rector\PHPUnit\PHPUnit80\Rector\MethodCall\SpecificAssertContainsRector

 final class SomeTest extends \PHPUnit\Framework\TestCase
 {
     public function test()
     {
-        $this->assertContains('foo', 'foo bar');
-        $this->assertNotContains('foo', 'foo bar');
+        $this->assertStringContainsString('foo', 'foo bar');
+        $this->assertStringNotContainsString('foo', 'foo bar');
     }
 }

SpecificAssertContainsWithoutIdentityRector

Change assertContains()/assertNotContains() with non-strict comparison to new specific alternatives

• class: Rector\PHPUnit\PHPUnit90\Rector\MethodCall\SpecificAssertContainsWithoutIdentityRector

-final class SomeTest extends \PHPUnit\Framework\TestCase
+final class SomeTest extends TestCase
 {
     public function test()
     {
         $objects = [ new \stdClass(), new \stdClass(), new \stdClass() ];
-        $this->assertContains(new \stdClass(), $objects, 'message', false, false);
-        $this->assertNotContains(new \stdClass(), $objects, 'message', false, false);
+        $this->assertContainsEquals(new \stdClass(), $objects, 'message');
+        $this->assertNotContainsEquals(new \stdClass(), $objects, 'message');
     }
 }

SpecificAssertInternalTypeRector

Change assertInternalType()/assertNotInternalType() method to new specific alternatives

• class: Rector\PHPUnit\PHPUnit80\Rector\MethodCall\SpecificAssertInternalTypeRector

 final class SomeTest extends \PHPUnit\Framework\TestCase
 {
     public function test()
     {
         $value = 'value';
-        $this->assertInternalType('string', $value);
-        $this->assertNotInternalType('array', $value);
+        $this->assertIsString($value);
+        $this->assertIsNotArray($value);
     }
 }

StaticDataProviderClassMethodRector

Change data provider methods to static

• class: Rector\PHPUnit\PHPUnit100\Rector\Class_\StaticDataProviderClassMethodRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     /**
      * @dataProvider provideData()
      */
     public function test()
     {
     }

-    public function provideData()
+    public static function provideData()
     {
         yield [1];
     }
 }

TestListenerToHooksRector

Refactor "*TestListener.php" to particular "*Hook.php" files

• class: Rector\PHPUnit\PHPUnit90\Rector\Class_\TestListenerToHooksRector

 namespace App\Tests;

-use PHPUnit\Framework\TestListener;
-
-final class BeforeListHook implements TestListener
+final class BeforeListHook implements \PHPUnit\Runner\BeforeTestHook, \PHPUnit\Runner\AfterTestHook
 {
-    public function addError(Test $test, \Throwable $t, float $time): void
+    public function executeBeforeTest(Test $test): void
     {
-    }
-
-    public function addWarning(Test $test, Warning $e, float $time): void
-    {
-    }
-
-    public function addFailure(Test $test, AssertionFailedError $e, float $time): void
-    {
-    }
-
-    public function addIncompleteTest(Test $test, \Throwable $t, float $time): void
-    {
-    }
-
-    public function addRiskyTest(Test $test, \Throwable $t, float $time): void
-    {
-    }
-
-    public function addSkippedTest(Test $test, \Throwable $t, float $time): void
-    {
-    }
-
-    public function startTestSuite(TestSuite $suite): void
-    {
-    }
-
-    public function endTestSuite(TestSuite $suite): void
-    {
-    }
-
-    public function startTest(Test $test): void
-    {
         echo 'start test!';
     }

-    public function endTest(Test $test, float $time): void
+    public function executeAfterTest(Test $test, float $time): void
     {
         echo $time;
     }
 }

TestWithAnnotationToAttributeRector

Change @testWith() annotation to #[TestWith] attribute

• class: Rector\PHPUnit\AnnotationsToAttributes\Rector\ClassMethod\TestWithAnnotationToAttributeRector

 use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\TestWith;

 final class SomeFixture extends TestCase
 {
-    /**
-     * @testWith ["foo"]
-     *           ["bar"]
-     */
+    #[TestWith(['foo'])]
+    #[TestWith(['bar'])]
     public function test(): void
     {
     }
 }

TicketAnnotationToAttributeRector

Change annotations with value to attribute

• class: Rector\PHPUnit\AnnotationsToAttributes\Rector\Class_\TicketAnnotationToAttributeRector

 use PHPUnit\Framework\TestCase;
+use PHPUnit\Framework\Attributes\Ticket;

-/**
- * @ticket 123
- */
+#[Ticket('123')]
 final class SomeTest extends TestCase
 {
 }

UseSpecificWillMethodRector

Changes $mock->will() call to more specific method

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\UseSpecificWillMethodRector

 class SomeClass extends PHPUnit\Framework\TestCase
 {
     public function test()
     {
         $translator = $this->createMock('SomeClass');
         $translator->expects($this->any())
             ->method('trans')
-            ->will($this->returnValue('translated max {{ max }}!'));
+            ->willReturnValue('translated max {{ max }}!');
     }
 }

UseSpecificWithMethodRector

Changes ->with() to more specific method

• class: Rector\PHPUnit\CodeQuality\Rector\MethodCall\UseSpecificWithMethodRector

 class SomeClass extends PHPUnit\Framework\TestCase
 {
     public function test()
     {
         $translator = $this->createMock('SomeClass');

         $translator->expects($this->any())
             ->method('trans')
-            ->with($this->equalTo('old max {{ max }}!'));
+            ->with('old max {{ max }}!');
     }
 }

WithConsecutiveRector

Refactor "withConsecutive()" to

• class: Rector\PHPUnit\Rector\StmtsAwareInterface\WithConsecutiveRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest extends TestCase
 {
     public function run()
     {
-        $this->personServiceMock->expects($this->exactly(2))
+        $matcher = $this->exactly(2);
+
+        $this->personServiceMock->expects($matcher)
             ->method('prepare')
-            ->withConsecutive(
-                [1, 2],
-                [3, 4],
-            );
+            ->willReturnCallback(function () use ($matcher) {
+                return match ($matcher->numberOfInvocations()) {
+                    1 => [1, 2],
+                    2 => [3, 4]
+                };
+        });
     }
 }

YieldDataProviderRector

Turns array return to yield in data providers

• class: Rector\PHPUnit\CodeQuality\Rector\Class_\YieldDataProviderRector

 use PHPUnit\Framework\TestCase;

 final class SomeTest implements TestCase
 {
     public static function provideData()
     {
-        return [
-            ['some text']
-        ];
+        yield ['some text'];
     }
 }