fix(codestyle): fix some codestyle issues in code and tests

phpstan.neon.dist

@@ -5,10 +5,3 @@ parameters:
     - ./test
   bootstrapFiles:
     - ./test/phpstan/runkit7.stub.php
-  ignoreErrors:
-    - message: '/Parameter #2 \$code of class ReflectionException constructor expects int, mixed given\./'
-      paths:
-        - ./src/ClassMethod/UndefinedClassMethod.php
-        - ./src/Constant/MockedClassConstant.php
-        - ./src/Constant/UndefinedClassConstant.php
-        - ./src/Functions/UndefinedFunction.php

src/Constant/MockedGlobalConstant.php

@@ -26,7 +26,7 @@ class MockedGlobalConstant extends BaseConstant
     public function __construct(string $constantName, $newValue)
     {
         if (!defined($constantName)) {
-            throw new ReflectionException("Constant {$constantName} is not defined");
+            throw new ReflectionException("Constant $constantName is not defined");
         }
 
         $this->name  = $constantName;

src/Phpunit/MockedFunction.php

@@ -27,8 +27,6 @@ class MockedFunction
      * @param InvocationOrder|null $invocationRule
      *
      * @throws ReflectionException
-     *
-     * @noinspection UnusedConstructorDependenciesInspection
      */
     public function __construct(
         TestCase $testCase,

test/phpunit/ClassMethod/MockedClassMethodTest.php

@@ -11,7 +11,6 @@
 use ReflectionException;
 use RuntimeException;
 
-use function PHPUnit\Framework\assertSame;
 use function uniqid;
 
 /**
@@ -188,7 +187,7 @@ public function testCallOriginalPrivate(): void
     {
         $object = new ClassWithMethods();
         $method = new MockedClassMethod(ClassWithMethods::class, 'privateMethod');
-        assertSame('privateMethod', $method->callOriginal($object));
+        self::assertSame('privateMethod', $method->callOriginal($object));
     }
 
     /**
@@ -199,6 +198,6 @@ public function testCallOriginalProtected(): void
     {
         $object = new ClassWithMethods();
         $method = new MockedClassMethod(ClassWithMethods::class, 'protectedMethod');
-        assertSame('protectedMethod', $method->callOriginal($object));
+        self::assertSame('protectedMethod', $method->callOriginal($object));
     }
 }

test/phpunit/ClassMethod/UndefinedClassMethodTest.php

@@ -12,8 +12,6 @@
 use ReflectionMethod;
 
 use function array_reduce;
-use function PHPUnit\Framework\assertContains;
-use function PHPUnit\Framework\assertNotContains;
 
 /**
  * @internal
@@ -40,13 +38,13 @@ public function testMissingMethod(): void
     public function testRemoveMethod(string $class, string $method): void
     {
         $classReflection = new ReflectionClass($class);
-        assertContains($method, self::helperGetReflectionMethodNames($classReflection));
+        self::assertContains($method, self::helperGetReflectionMethodNames($classReflection));
 
         $undefinedMethod = new UndefinedClassMethod($class, $method);
-        assertNotContains($method, self::helperGetReflectionMethodNames($classReflection));
+        self::assertNotContains($method, self::helperGetReflectionMethodNames($classReflection));
 
         unset($undefinedMethod);
-        assertContains($method, self::helperGetReflectionMethodNames($classReflection));
+        self::assertContains($method, self::helperGetReflectionMethodNames($classReflection));
     }
 
     /**

test/phpunit/Constant/MockedClassConstantTest.php

@@ -11,7 +11,6 @@
 use ReflectionClassConstant;
 use ReflectionException;
 
-use function PHPUnit\Framework\assertSame;
 use function uniqid;
 
 /**
@@ -36,16 +35,16 @@ public function testUsagePublic(): void
         $mockedConst = new MockedClassConstant(ClassWithConstants::class, 'CONST_PUBLIC', 222);
 
         // check #1: value override (main target)
-        assertSame(222, ClassWithConstants::CONST_PUBLIC);
+        self::assertSame(222, ClassWithConstants::CONST_PUBLIC);
 
         // check #1: stored value
-        assertSame($originalValue, $mockedConst->getValue());
+        self::assertSame($originalValue, $mockedConst->getValue());
 
         // task #2: remove object - changes should be reverted
         unset($mockedConst);
 
         // check #3: constant now having original value
-        assertSame($originalValue, ClassWithConstants::CONST_PUBLIC);
+        self::assertSame($originalValue, ClassWithConstants::CONST_PUBLIC);
     }
 
     /**
@@ -70,14 +69,14 @@ public function testUsageComplex(string $class, string $constantName): void
         $mockedConst = new MockedClassConstant($class, $constantName, $newValue);
 
         // check #1: value override (main target)
-        assertSame($newValue, $classReflection->getConstants()[$constantName]);
+        self::assertSame($newValue, $classReflection->getConstants()[$constantName]);
         // check #2: stored value
-        assertSame($originalValue, $mockedConst->getValue());
+        self::assertSame($originalValue, $mockedConst->getValue());
 
         // task #2: destroy object (and revert changes)
         unset($mockedConst);
 
         // check #3: changes are revered
-        assertSame($originalValue, $classReflection->getConstants()[$constantName]);
+        self::assertSame($originalValue, $classReflection->getConstants()[$constantName]);
     }
 }

test/phpunit/Constant/MockedGlobalConstantTest.php

@@ -10,9 +10,6 @@
 
 use function constant;
 use function define;
-use function PHPUnit\Framework\assertFalse;
-use function PHPUnit\Framework\assertNotEquals;
-use function PHPUnit\Framework\assertSame;
 use function uniqid;
 
 /**
@@ -27,18 +24,18 @@ public function testMinimal(): void
     {
         $constantName  = uniqid('CONST_', false);
         $originalValue = uniqid('VALUE_', true);
-        assertFalse(defined($constantName));
+        self::assertFalse(defined($constantName));
 
         define($constantName, $originalValue);
-        assertSame($originalValue, constant($constantName));
+        self::assertSame($originalValue, constant($constantName));
 
         $mockedValue = 'someValue';
-        assertNotEquals($mockedValue, $originalValue);
+        self::assertNotEquals($mockedValue, $originalValue);
         $mockedConstant = new MockedGlobalConstant($constantName, $mockedValue);
 
-        assertSame($mockedValue, constant($constantName));
+        self::assertSame($mockedValue, constant($constantName));
 
         unset($mockedConstant);
-        assertSame($originalValue, constant($constantName));
+        self::assertSame($originalValue, constant($constantName));
     }
 }

test/phpunit/Constant/UndefinedClassConstantTest.php

@@ -12,10 +12,6 @@
 use ReflectionClassConstant;
 use ReflectionException;
 
-use function PHPUnit\Framework\assertArrayHasKey;
-use function PHPUnit\Framework\assertArrayNotHasKey;
-use function PHPUnit\Framework\assertSame;
-
 /**
  * @internal
  */
@@ -104,22 +100,22 @@ public function testRemoveComplex(string $class, string $constantName): void
         unset($constantReflection);
 
         // check #0: validate test data
-        assertArrayHasKey($constantName, $classReflection->getConstants());
+        self::assertArrayHasKey($constantName, $classReflection->getConstants());
 
         // task #1: remove constant
         $mockedConst = new UndefinedClassConstant($class, $constantName);
 
         // check #1: constant is missing
-        assertArrayNotHasKey($constantName, $classReflection->getConstants());
+        self::assertArrayNotHasKey($constantName, $classReflection->getConstants());
 
         // check #2: stored value is safe
-        assertSame($originalValue, $mockedConst->getValue());
+        self::assertSame($originalValue, $mockedConst->getValue());
 
         // task #2: revert changes
         unset($mockedConst);
 
         $constantReflection = new ReflectionClassConstant($class, $constantName);
         $revertedValue      = $constantReflection->getValue();
-        assertSame($originalValue, $revertedValue);
+        self::assertSame($originalValue, $revertedValue);
     }
 }

test/phpunit/Constant/UndefinedGlobalConstantTest.php

@@ -11,9 +11,6 @@
 use function constant;
 use function define;
 use function defined;
-use function PHPUnit\Framework\assertFalse;
-use function PHPUnit\Framework\assertSame;
-use function PHPUnit\Framework\assertTrue;
 use function uniqid;
 
 /**
@@ -44,20 +41,20 @@ public function testUndefinedComplex(): void
         $originalValue = constant($constantName);
 
         // check #0: validate test data
-        assertTrue(defined($constantName));
+        self::assertTrue(defined($constantName));
 
         // task #1: remove constant
         $mockedConst = new UndefinedGlobalConstant($constantName);
 
         // check #1: constant is missing
-        assertFalse(defined($constantName));
+        self::assertFalse(defined($constantName));
 
         // check #2: stored value is safe
-        assertSame($originalValue, $mockedConst->getValue());
+        self::assertSame($originalValue, $mockedConst->getValue());
 
         // task #2: revert changes
         unset($mockedConst);
 
-        assertSame($originalValue, constant($constantName));
+        self::assertSame($originalValue, constant($constantName));
     }
 }

test/phpunit/Helpers/ClassWithMethods.php

@@ -49,11 +49,13 @@ public function publicMethod(): string
         return __FUNCTION__;
     }
 
+    /** @noinspection PhpUnused */
     protected function protectedMethod(): string
     {
         return __FUNCTION__;
     }
 
+    /** @noinspection PhpUnusedPrivateMethodInspection */
     private function privateMethod(): string
     {
         return __FUNCTION__;

test/phpunit/Helpers/ExtendedClassWithMethods.php

@@ -1,5 +1,7 @@
 <?php
 
+/** @noinspection EmptyClassInspection */
+
 declare(strict_types=1);
 
 namespace QratorLabs\Smocky\Test\PhpUnit\Helpers;

test/phpunit/Smocky/MockedEntityTest.php

@@ -9,12 +9,10 @@
 use QratorLabs\Smocky\Test\PhpUnit\Helpers\ClassWithConstants;
 use QratorLabs\Smocky\Test\PhpUnit\Helpers\ClassWithMethods;
 use ReflectionClassConstant;
+use ReflectionException;
 use ReflectionMethod;
 
 use function constant;
-use function PHPUnit\Framework\assertEquals;
-use function PHPUnit\Framework\assertNotSame;
-use function PHPUnit\Framework\assertStringContainsString;
 use function strtoupper;
 
 /**
@@ -45,35 +43,38 @@ public function getStashedNamePublic(string $basename, string $prefix = ''): str
 
         // check #1: contains basename
         $basename = 'someName';
-        assertStringContainsString($basename, $helper->getStashedNamePublic($basename));
+        self::assertStringContainsString($basename, $helper->getStashedNamePublic($basename));
 
         // check #2: contains basename and prefix
         $prefix = 'somePrefix';
         $name   = $helper->getStashedNamePublic($basename, $prefix);
-        assertStringContainsString($basename, $name);
-        assertStringContainsString($prefix, $name);
+        self::assertStringContainsString($basename, $name);
+        self::assertStringContainsString($prefix, $name);
 
         // check #3: unique
         // yep, I know that we can't call `uniqid()` in true parallel,
         // but let's make it look like pretty close calls
-        assertNotSame($helper->getStashedNamePublic($basename), $helper->getStashedNamePublic($basename));
+        self::assertNotSame($helper->getStashedNamePublic($basename), $helper->getStashedNamePublic($basename));
     }
 
+    /**
+     * @throws ReflectionException
+     */
     public function testGetVisibility(): void
     {
         $mock   = $this->getMockForAbstractClass(MockedEntity::class, []);
         $method = new ReflectionMethod(MockedEntity::class, 'getVisibility');
         $method->setAccessible(true);
 
         foreach (ClassWithConstants::getDataForTests() as $key => $item) {
-            assertEquals(
+            self::assertEquals(
                 constant('RUNKIT7_ACC_' . strtoupper($key)),
                 $method->invoke($mock, new ReflectionClassConstant($item[0], $item[1]))
             );
         }
         foreach (ClassWithMethods::getDataForTests() as $key => $item) {
             [$vis] = explode(' ', $key);
-            assertEquals(
+            self::assertEquals(
                 constant('RUNKIT7_ACC_' . strtoupper($vis)),
                 $method->invoke($mock, new ReflectionMethod($item[0], $item[1]))
             );