#145: Fix bug with empty arguments

src/Traits/MockTrait.php

@@ -2,12 +2,13 @@
 
 namespace RonasIT\Support\Traits;
 
-use Exception;
-use Illuminate\Support\Arr;
 use Closure;
+use Illuminate\Support\Arr;
 use phpmock\phpunit\PHPMock;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\MockObject\Rule\InvokedCount;
+use ReflectionFunction;
+use ReflectionMethod;
 
 trait MockTrait
 {
@@ -129,30 +130,63 @@ protected function assertArguments(
         string $class,
         string $function,
         int $callIndex,
-        bool $isClass = true
+        bool $isClass = true,
     ): void {
+        $reflection = $isClass
+            ? new ReflectionMethod($class, $function)
+            : new ReflectionFunction($function);
+
         $expectedCount = count($expected);
         $actualCount = count($actual);
+        $parameters = $reflection->getParameters();
+        $requiredParametersCount = count(array_filter($parameters, fn ($param) => !$param->isOptional()));
+
+        $this->assertArgumentCount($expectedCount, $actualCount, $requiredParametersCount, $function);
+
+        $this->fillOptionalArguments($parameters, $actual, $expected, $isClass);
+
+        $message = $isClass
+            ? "Class '{$class}'\nMethod: '{$function}'\nMethod call index: {$callIndex}"
+            : "Namespace '{$class}'\nFunction: '{$function}'\nCall index: {$callIndex}";
+
+        $this->compareArguments($actual, $expected, $message);
+    }
 
+    protected function assertArgumentCount(int $expectedCount, int $actualCount, int $requiredParametersCount, string $function): void
+    {
         if ($expectedCount !== $actualCount) {
-            $requiredParametersCount = count(array_filter($actual, fn ($item) => $item !== self::OPTIONAL_ARGUMENT_NAME));
+            $this->assertFalse(
+                $expectedCount < $requiredParametersCount,
+                "Failed assert that function {$function} was called with {$expectedCount} require arguments, actually it calls with {$requiredParametersCount} require arguments."
+            );
 
-            if ($expectedCount > $actualCount || $expectedCount < $requiredParametersCount) {
-                throw new Exception("Failed assert that function {$function} was called with {$expectedCount} arguments, actually it calls with {$actualCount} arguments.");
-            }
+            $this->assertFalse(
+                $expectedCount > $actualCount,
+                "Failed assert that function {$function} was called with {$expectedCount} arguments, actually it calls with {$actualCount} arguments."
+            );
         }
+    }
 
-        $expected = array_pad($expected, $actualCount, self::OPTIONAL_ARGUMENT_NAME);
+    protected function fillOptionalArguments(array $parameters, array &$actual, array &$expected, bool $isClass): void
+    {
+        foreach ($parameters as $index => $parameter) {
+            if (!isset($expected[$index]) && $parameter->isOptional()) {
+                $expected[$index] = $parameter->getDefaultValue();
+            }
 
-        $message = ($isClass)
-            ? "Class '{$class}'\nMethod: '{$function}'\nMethod call index: {$callIndex}"
-            : "Namespace '{$class}'\nFunction: '{$function}'\nCall index: {$callIndex}";
+            if (!$isClass && $actual[$index] === 'optionalParameter') {
+                $actual[$index] = $expected[$index] ?? $parameter->getDefaultValue();
+            }
+        }
+    }
 
+    protected function compareArguments(array $actual, array $expected, string $message): void
+    {
         foreach ($actual as $index => $argument) {
             $this->assertEquals(
                 $expected[$index],
                 $argument,
-                "Failed asserting that arguments are equals to expected.\n{$message}\nArgument index: {$index}"
+                "Failed asserting that arguments are equal to expected.\n{$message}\nArgument index: {$index}"
             );
         }
     }

tests/MockTraitTest.php

@@ -2,8 +2,9 @@
 
 namespace RonasIT\Support\Tests;
 
+use PHPUnit\Framework\ExpectationFailedException;
+use RonasIT\Support\Tests\Support\Mock\TestMockClass;
 use RonasIT\Support\Traits\MockTrait;
-use Exception;
 
 class MockTraitTest extends HelpersTestCase
 {
@@ -46,26 +47,101 @@ public function testMockWithDifferentFunction()
             $this->functionCall('rand', [1, 5], 2),
             $this->functionCall('is_array', [123]),
             $this->functionCall('rand', [6, 10], 7),
-            $this->functionCall('uniqid', [], '0987654321'),
+            $this->functionCall('uniqid', ['prefix'], '0987654321'),
             $this->functionCall(name: 'uniqid', result: '0987654321'),
-            $this->functionCall('array_slice', [[1, 2, 3, 4, 5], 2, 2], [3, 4]),
             $this->functionCall('array_slice', [[1, 2, 3, 4, 5], 2], [3, 4, 5]),
+            $this->functionCall('array_slice', [[1, 2, 3, 4, 5], 2, 2, 'preserve_keys'], [3, 4]),
         ]);
 
         $this->assertEquals(2, rand(1, 5));
         $this->assertTrue(is_array(123));
         $this->assertEquals(7, rand(6, 10));
         $this->assertEquals('0987654321', uniqid());
         $this->assertEquals('0987654321', uniqid());
-        $this->assertEquals([3, 4], array_slice([1, 2, 3, 4, 5], 2, 2));
         $this->assertEquals([3, 4, 5], array_slice([1, 2, 3, 4, 5], 2));
+        $this->assertEquals([3, 4], array_slice([1, 2, 3, 4, 5], 2, 2));
+    }
+
+    public function testMockNativeFunctionWhenLessRequiredParameters()
+    {
+        $this->expectException(ExpectationFailedException::class);
+        $this->expectExceptionMessage('Failed assert that function array_slice was called with 1 require arguments, actually it calls with 2 require arguments.');
+
+        $this->mockNativeFunction('RonasIT\Support\Tests', [
+            $this->functionCall('array_slice', [[1, 2, 3, 4, 5]], [3, 4]),
+        ]);
+
+        array_slice([1, 2, 3, 4, 5], 2, 2);
+    }
+
+    public function testMockNativeFunctionWhenMoreExpectedParameters()
+    {
+        $this->expectException(ExpectationFailedException::class);
+        $this->expectExceptionMessage('Failed assert that function array_slice was called with 5 arguments, actually it calls with 4 arguments.');
+
+        $this->mockNativeFunction('RonasIT\Support\Tests', [
+            $this->functionCall('array_slice', [[1, 2, 3, 4, 5], 2, 2, 'preserve_keys', 'extra_parameter'], [3, 4]),
+        ]);
+
+        array_slice([1, 2, 3, 4, 5], 2, 2, 'preserve_keys');
+    }
+
+    public function testMockNativeFunctionWhenDifferentResult()
+    {
+        $this->mockNativeFunction('RonasIT\Support\Tests', [
+            $this->functionCall('array_slice', [[1, 2, 3, 4, 5], 2, 2], [3, 4]),
+        ]);
+
+        $this->assertNotEquals([3, 4, 5], array_slice([1, 2, 3, 4, 5], 2, 2));
+    }
+
+    public function testMockFunctionInClass()
+    {
+        $mock = $this->mockClass(TestMockClass::class, [
+            $this->functionCall('mockFunction', ['firstRequired', 'secondRequired'], 'mockFunction'),
+            $this->functionCall('mockFunction', ['firstRequired', 'secondRequired', 'firstOptional'], 'mockFunction'),
+            $this->functionCall('mockFunction', ['firstRequired', 'secondRequired', 'firstOptional', 'secondOptional'], 'mockFunction'),
+        ]);
+
+        $this->assertEquals('mockFunction', ($mock->mockFunction('firstRequired', 'secondRequired')));
+        $this->assertEquals('mockFunction', ($mock->mockFunction('firstRequired', 'secondRequired', 'firstOptional')));
+        $this->assertEquals('mockFunction', ($mock->mockFunction('firstRequired', 'secondRequired', 'firstOptional', 'secondOptional')));
+    }
+
+    public function testMockFunctionInClassWhenDifferentResult()
+    {
+        $mock = $this->mockClass(TestMockClass::class, [
+            $this->functionCall('mockFunction', ['firstRequired', 'secondRequired'], 'mockFunction'),
+        ]);
+
+        $this->assertNotEquals('result', $mock->mockFunction('firstRequired', 'secondRequired'));
+    }
+
+    public function testMockFunctionInClassWhenLessRequiredParameters()
+    {
+        $this->expectException(ExpectationFailedException::class);
+        $this->expectExceptionMessage('Failed assert that function mockFunction was called with 1 require arguments, actually it calls with 2 require arguments.');
+
+        $this->assertArguments(
+            actual: ['firstRequired', 'secondRequired', 'string', null],
+            expected: ['firstRequired'],
+            class: TestMockClass::class,
+            function: 'mockFunction',
+            callIndex: 0,
+        );
     }
 
-    public function testAssertArgumentMismatchBetweenExpectedAndActualArguments()
+    public function testMockFunctionInClassWhenMoreExpectedParameters()
     {
-        $this->expectException(Exception::class);
-        $this->expectExceptionMessage('Failed assert that function testFunction was called with 2 arguments, actually it calls with 1 arguments.');
+        $this->expectException(ExpectationFailedException::class);
+        $this->expectExceptionMessage('Failed assert that function mockFunction was called with 5 arguments, actually it calls with 4 arguments.');
 
-        $this->assertArguments(['test'], ['test', ''], 'TestClass', 'testFunction', 0);
+        $this->assertArguments(
+            actual: ['firstRequired', 'secondRequired', 'string', null],
+            expected: ['firstRequired', 'secondRequired', 'firstOptional', 'secondOptional', 'thirdOptional'],
+            class: TestMockClass::class,
+            function: 'mockFunction',
+            callIndex: 0,
+        );
     }
 }

tests/support/Mock/TestMockClass.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace RonasIT\Support\Tests\Support\Mock;
+
+class TestMockClass
+{
+    public function mockFunction(
+        string $firsrRequeredParam,
+        string $secondRequiredParam,
+        string $firstOptionalParam = 'string',
+        ?string $secondOptionalParam = null,
+    ): string {
+        return 'mockFunction';
+    }
+}