fix: replace static assertion for coding style respect

landure · landure · commit 91e4e75597f2 · 2025-09-05T15:04:18.000+02:00
diff --git a/tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/LtreeTest.php b/tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/LtreeTest.php
@@ -30,7 +30,7 @@ protected function setUp(): void
     #[Test]
     public function has_name(): void
     {
-        self::assertSame('ltree', $this->fixture->getName());
+        $this->assertSame('ltree', $this->fixture->getName());
     }
 
     #[Test]
@@ -39,21 +39,21 @@ public function can_convert_string_to_database_value(): void
         $value = 'alpha.beta.gamma';
         $databaseValue = $this->fixture->convertToDatabaseValue($value, $this->platform);
 
-        self::assertSame($value, $databaseValue);
+        $this->assertSame($value, $databaseValue);
     }
 
     #[DataProvider('provideValidTransformations')]
     #[Test]
     public function can_transform_from_php_value(?LtreeValueObject $ltreeValueObject, ?string $postgresValue): void
     {
-        self::assertSame($postgresValue, $this->fixture->convertToDatabaseValue($ltreeValueObject, $this->platform));
+        $this->assertSame($postgresValue, $this->fixture->convertToDatabaseValue($ltreeValueObject, $this->platform));
     }
 
     #[DataProvider('provideValidTransformations')]
     #[Test]
     public function can_transform_to_php_value(?LtreeValueObject $ltreeValueObject, ?string $postgresValue): void
     {
-        self::assertEquals($ltreeValueObject, $this->fixture->convertToPHPValue($postgresValue, $this->platform));
+        $this->assertEquals($ltreeValueObject, $this->fixture->convertToPHPValue($postgresValue, $this->platform));
     }
 
     /**
diff --git a/tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/LtreeTest.php b/tests/Unit/MartinGeorgiev/Doctrine/DBAL/Types/ValueObject/LtreeTest.php
@@ -16,7 +16,7 @@ final class LtreeTest extends TestCase
     public function can_create_from_list_of_strings(): void
     {
         $ltree = new Ltree(['a', 'b', 'c']);
-        self::assertSame('a.b.c', (string) $ltree);
+        $this->assertSame('a.b.c', (string) $ltree);
     }
 
     /**
@@ -67,8 +67,8 @@ public static function provideInvalidStringRepresentation(): iterable
     public function can_create_from_string(string $value, array $expected): void
     {
         $ltree = Ltree::fromString($value);
-        self::assertSame($expected, $ltree->getPathFromRoot());
-        self::assertSame($value, (string) $ltree);
+        $this->assertSame($expected, $ltree->getPathFromRoot());
+        $this->assertSame($value, (string) $ltree);
     }
 
     /**
@@ -79,7 +79,7 @@ public function can_create_from_string(string $value, array $expected): void
     public function can_convert_to_string(string $expected, array $value): void
     {
         $ltree = new Ltree($value);
-        self::assertSame($expected, (string) $ltree);
+        $this->assertSame($expected, (string) $ltree);
     }
 
     /**
@@ -90,10 +90,10 @@ public function can_convert_to_string(string $expected, array $value): void
     public function can_serialize_to_json(string $value, array $expected): void
     {
         $ltreeFromString = Ltree::fromString($value);
-        self::assertSame($expected, $ltreeFromString->jsonSerialize());
+        $this->assertSame($expected, $ltreeFromString->jsonSerialize());
 
         $ltree = new Ltree($expected);
-        self::assertSame($expected, $ltree->jsonSerialize());
+        $this->assertSame($expected, $ltree->jsonSerialize());
     }
 
     /**
@@ -113,15 +113,15 @@ public function can_encode_to_json_array(): void
     {
         $ltree = new Ltree(['a', 'b', 'c']);
         $json = \json_encode($ltree, \JSON_THROW_ON_ERROR);
-        self::assertSame('["a","b","c"]', $json);
+        $this->assertSame('["a","b","c"]', $json);
     }
 
     #[DataProvider('provideParentRelationship')]
     #[Test]
     public function can_get_parent(Ltree $child, Ltree $parent): void
     {
         $ltree = $child->getParent();
-        self::assertSame((string) $parent, (string) $ltree);
+        $this->assertSame((string) $parent, (string) $ltree);
     }
 
     #[DataProvider('provideParentRelationship')]
@@ -130,8 +130,8 @@ public function respect_immutability_when_getting_parent(Ltree $child, Ltree $pa
     {
         $childAsString = (string) $child;
         $ltree = $child->getParent();
-        self::assertNotSame($child, $ltree, 'getParent() should return a new instance');
-        self::assertSame($childAsString, (string) $child, 'getParent() should not mutate the original instance');
+        $this->assertNotSame($child, $ltree, 'getParent() should return a new instance');
+        $this->assertSame($childAsString, (string) $child, 'getParent() should not mutate the original instance');
     }
 
     /**
@@ -161,10 +161,10 @@ public function throws_exception_when_getting_empty_ltree_parent(): void
     public function can_verify_empty_status(): void
     {
         $ltree = new Ltree([]);
-        self::assertTrue($ltree->isEmpty());
+        $this->assertTrue($ltree->isEmpty());
 
         $ltreeWithNodes = new Ltree(['a', 'b']);
-        self::assertFalse($ltreeWithNodes->isEmpty());
+        $this->assertFalse($ltreeWithNodes->isEmpty());
     }
 
     #[Test]
@@ -173,9 +173,9 @@ public function can_verify_root_status(): void
         $emptyRoot = new Ltree([]);
         $root = new Ltree(['a']);
         $notRoot = new Ltree(['a', 'b']);
-        self::assertFalse($emptyRoot->isRoot());
-        self::assertTrue($root->isRoot());
-        self::assertFalse($notRoot->isRoot());
+        $this->assertFalse($emptyRoot->isRoot());
+        $this->assertTrue($root->isRoot());
+        $this->assertFalse($notRoot->isRoot());
     }
 
     /**
@@ -195,7 +195,7 @@ public function can_verify_relationship(
         array $expected,
     ): void {
         foreach ($expected as $method => $value) {
-            self::assertSame(
+            $this->assertSame(
                 $value,
                 $left->{$method}($right),
                 \sprintf('Failed %s check', $method),
@@ -476,7 +476,7 @@ public static function provideFamilyRelationshipWithExpectedResults(): iterable
     public function can_create_leaf(Ltree $parent, string $leaf, Ltree $expected): void
     {
         $ltree = $parent->withLeaf($leaf);
-        self::assertSame((string) $expected, (string) $ltree);
+        $this->assertSame((string) $expected, (string) $ltree);
     }
 
     /**
@@ -488,8 +488,8 @@ public function respects_immutability_when_creating_leaf(Ltree $parent, string $
     {
         $parentAsString = (string) $parent;
         $ltree = $parent->withLeaf($leaf);
-        self::assertNotSame($parent, $ltree, 'withLeaf() should return a new instance');
-        self::assertSame($parentAsString, (string) $parent, 'withLeaf() should not mutate the original instance');
+        $this->assertNotSame($parent, $ltree, 'withLeaf() should return a new instance');
+        $this->assertSame($parentAsString, (string) $parent, 'withLeaf() should not mutate the original instance');
     }
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ protected function setUp(): void`
`30`	`30`	`#[Test]`
`31`	`31`	`public function has_name(): void`
`32`	`32`	`{`
`33`		`- self::assertSame('ltree', $this->fixture->getName());`
	`33`	`+ $this->assertSame('ltree', $this->fixture->getName());`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`#[Test]`
`@@ -39,21 +39,21 @@ public function can_convert_string_to_database_value(): void`
`39`	`39`	`$value = 'alpha.beta.gamma';`
`40`	`40`	`$databaseValue = $this->fixture->convertToDatabaseValue($value, $this->platform);`
`41`	`41`
`42`		`- self::assertSame($value, $databaseValue);`
	`42`	`+ $this->assertSame($value, $databaseValue);`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`#[DataProvider('provideValidTransformations')]`
`46`	`46`	`#[Test]`
`47`	`47`	`public function can_transform_from_php_value(?LtreeValueObject $ltreeValueObject, ?string $postgresValue): void`
`48`	`48`	`{`
`49`		`- self::assertSame($postgresValue, $this->fixture->convertToDatabaseValue($ltreeValueObject, $this->platform));`
	`49`	`+ $this->assertSame($postgresValue, $this->fixture->convertToDatabaseValue($ltreeValueObject, $this->platform));`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`#[DataProvider('provideValidTransformations')]`
`53`	`53`	`#[Test]`
`54`	`54`	`public function can_transform_to_php_value(?LtreeValueObject $ltreeValueObject, ?string $postgresValue): void`
`55`	`55`	`{`
`56`		`- self::assertEquals($ltreeValueObject, $this->fixture->convertToPHPValue($postgresValue, $this->platform));`
	`56`	`+ $this->assertEquals($ltreeValueObject, $this->fixture->convertToPHPValue($postgresValue, $this->platform));`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ final class LtreeTest extends TestCase`
`16`	`16`	`public function can_create_from_list_of_strings(): void`
`17`	`17`	`{`
`18`	`18`	`$ltree = new Ltree(['a', 'b', 'c']);`
`19`		`- self::assertSame('a.b.c', (string) $ltree);`
	`19`	`+ $this->assertSame('a.b.c', (string) $ltree);`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/**`
`@@ -67,8 +67,8 @@ public static function provideInvalidStringRepresentation(): iterable`
`67`	`67`	`public function can_create_from_string(string $value, array $expected): void`
`68`	`68`	`{`
`69`	`69`	`$ltree = Ltree::fromString($value);`
`70`		`- self::assertSame($expected, $ltree->getPathFromRoot());`
`71`		`- self::assertSame($value, (string) $ltree);`
	`70`	`+ $this->assertSame($expected, $ltree->getPathFromRoot());`
	`71`	`+ $this->assertSame($value, (string) $ltree);`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`/**`
`@@ -79,7 +79,7 @@ public function can_create_from_string(string $value, array $expected): void`
`79`	`79`	`public function can_convert_to_string(string $expected, array $value): void`
`80`	`80`	`{`
`81`	`81`	`$ltree = new Ltree($value);`
`82`		`- self::assertSame($expected, (string) $ltree);`
	`82`	`+ $this->assertSame($expected, (string) $ltree);`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`/**`
`@@ -90,10 +90,10 @@ public function can_convert_to_string(string $expected, array $value): void`
`90`	`90`	`public function can_serialize_to_json(string $value, array $expected): void`
`91`	`91`	`{`
`92`	`92`	`$ltreeFromString = Ltree::fromString($value);`
`93`		`- self::assertSame($expected, $ltreeFromString->jsonSerialize());`
	`93`	`+ $this->assertSame($expected, $ltreeFromString->jsonSerialize());`
`94`	`94`
`95`	`95`	`$ltree = new Ltree($expected);`
`96`		`- self::assertSame($expected, $ltree->jsonSerialize());`
	`96`	`+ $this->assertSame($expected, $ltree->jsonSerialize());`
`97`	`97`	`}`
`98`	`98`
`99`	`99`	`/**`
`@@ -113,15 +113,15 @@ public function can_encode_to_json_array(): void`
`113`	`113`	`{`
`114`	`114`	`$ltree = new Ltree(['a', 'b', 'c']);`
`115`	`115`	`$json = \json_encode($ltree, \JSON_THROW_ON_ERROR);`
`116`		`- self::assertSame('["a","b","c"]', $json);`
	`116`	`+ $this->assertSame('["a","b","c"]', $json);`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`#[DataProvider('provideParentRelationship')]`
`120`	`120`	`#[Test]`
`121`	`121`	`public function can_get_parent(Ltree $child, Ltree $parent): void`
`122`	`122`	`{`
`123`	`123`	`$ltree = $child->getParent();`
`124`		`- self::assertSame((string) $parent, (string) $ltree);`
	`124`	`+ $this->assertSame((string) $parent, (string) $ltree);`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`#[DataProvider('provideParentRelationship')]`
`@@ -130,8 +130,8 @@ public function respect_immutability_when_getting_parent(Ltree $child, Ltree $pa`
`130`	`130`	`{`
`131`	`131`	`$childAsString = (string) $child;`
`132`	`132`	`$ltree = $child->getParent();`
`133`		`- self::assertNotSame($child, $ltree, 'getParent() should return a new instance');`
`134`		`- self::assertSame($childAsString, (string) $child, 'getParent() should not mutate the original instance');`
	`133`	`+ $this->assertNotSame($child, $ltree, 'getParent() should return a new instance');`
	`134`	`+ $this->assertSame($childAsString, (string) $child, 'getParent() should not mutate the original instance');`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`/**`
`@@ -161,10 +161,10 @@ public function throws_exception_when_getting_empty_ltree_parent(): void`
`161`	`161`	`public function can_verify_empty_status(): void`
`162`	`162`	`{`
`163`	`163`	`$ltree = new Ltree([]);`
`164`		`- self::assertTrue($ltree->isEmpty());`
	`164`	`+ $this->assertTrue($ltree->isEmpty());`
`165`	`165`
`166`	`166`	`$ltreeWithNodes = new Ltree(['a', 'b']);`
`167`		`- self::assertFalse($ltreeWithNodes->isEmpty());`
	`167`	`+ $this->assertFalse($ltreeWithNodes->isEmpty());`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`#[Test]`
`@@ -173,9 +173,9 @@ public function can_verify_root_status(): void`
`173`	`173`	`$emptyRoot = new Ltree([]);`
`174`	`174`	`$root = new Ltree(['a']);`
`175`	`175`	`$notRoot = new Ltree(['a', 'b']);`
`176`		`- self::assertFalse($emptyRoot->isRoot());`
`177`		`- self::assertTrue($root->isRoot());`
`178`		`- self::assertFalse($notRoot->isRoot());`
	`176`	`+ $this->assertFalse($emptyRoot->isRoot());`
	`177`	`+ $this->assertTrue($root->isRoot());`
	`178`	`+ $this->assertFalse($notRoot->isRoot());`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`/**`
`@@ -195,7 +195,7 @@ public function can_verify_relationship(`
`195`	`195`	`array $expected,`
`196`	`196`	`): void {`
`197`	`197`	`foreach ($expected as $method => $value) {`
`198`		`- self::assertSame(`
	`198`	`+ $this->assertSame(`
`199`	`199`	`$value,`
`200`	`200`	`$left->{$method}($right),`
`201`	`201`	`\sprintf('Failed %s check', $method),`
`@@ -476,7 +476,7 @@ public static function provideFamilyRelationshipWithExpectedResults(): iterable`
`476`	`476`	`public function can_create_leaf(Ltree $parent, string $leaf, Ltree $expected): void`
`477`	`477`	`{`
`478`	`478`	`$ltree = $parent->withLeaf($leaf);`
`479`		`- self::assertSame((string) $expected, (string) $ltree);`
	`479`	`+ $this->assertSame((string) $expected, (string) $ltree);`
`480`	`480`	`}`
`481`	`481`
`482`	`482`	`/**`
`@@ -488,8 +488,8 @@ public function respects_immutability_when_creating_leaf(Ltree $parent, string $`
`488`	`488`	`{`
`489`	`489`	`$parentAsString = (string) $parent;`
`490`	`490`	`$ltree = $parent->withLeaf($leaf);`
`491`		`- self::assertNotSame($parent, $ltree, 'withLeaf() should return a new instance');`
`492`		`- self::assertSame($parentAsString, (string) $parent, 'withLeaf() should not mutate the original instance');`
	`491`	`+ $this->assertNotSame($parent, $ltree, 'withLeaf() should return a new instance');`
	`492`	`+ $this->assertSame($parentAsString, (string) $parent, 'withLeaf() should not mutate the original instance');`
`493`	`493`	`}`
`494`	`494`
`495`	`495`	`/**`