Partial mocks of abstract functions with return types now work as intended. Closes #212.

Author: ezzatron

CHANGELOG.md

@@ -2,8 +2,12 @@
 
 ## Next release
 
+- **[FIXED]** Partial mocks of abstract functions with return types now work as
+  intended ([#212]).
 - **[FIXED]** Fixed regression of [#203] and [#204].
 
+[#212]: https://github.com/eloquent/phony/issues/212
+
 ## 0.14.5 (2016-12-07)
 
 - **[FIXED]** Mock handle substitution fixed for `threw()` and

src/Facade/FacadeDriver.php

@@ -136,7 +136,9 @@ protected function __construct(AssertionRecorder $assertionRecorder)
         $matcherFactory
             ->addMatcherDriver(new ProphecyMatcherDriver($wildcardMatcher));
         $matcherFactory->addMatcherDriver(new MockeryMatcherDriver());
-        $emptyValueFactory = new EmptyValueFactory();
+        $emptyValueFactory = new EmptyValueFactory(
+            $featureDetector
+        );
         $generatorAnswerBuilderFactory = new GeneratorAnswerBuilderFactory(
             $invocableInspector,
             $invoker,
@@ -229,6 +231,7 @@ protected function __construct(AssertionRecorder $assertionRecorder)
         $handleFactory = new HandleFactory(
             $stubFactory,
             $stubVerifierFactory,
+            $emptyValueFactory,
             $assertionRenderer,
             $assertionRecorder,
             $invoker

src/Mock/Handle/AbstractHandle.php

@@ -24,6 +24,7 @@
 use Eloquent\Phony\Mock\Method\WrappedUncallableMethod;
 use Eloquent\Phony\Mock\Mock;
 use Eloquent\Phony\Spy\Spy;
+use Eloquent\Phony\Stub\EmptyValueFactory;
 use Eloquent\Phony\Stub\StubFactory;
 use Eloquent\Phony\Stub\StubVerifier;
 use Eloquent\Phony\Stub\StubVerifierFactory;
@@ -47,6 +48,7 @@ abstract class AbstractHandle implements Handle
      * @param Mock|null             $mock                The mock, or null if this is a static handle.
      * @param StubFactory           $stubFactory         The stub factory to use.
      * @param StubVerifierFactory   $stubVerifierFactory The stub verifier factory to use.
+     * @param EmptyValueFactory     $emptyValueFactory   The empty value factory to use.
      * @param AssertionRenderer     $assertionRenderer   The assertion renderer to use.
      * @param AssertionRecorder     $assertionRecorder   The assertion recorder to use.
      * @param Invoker               $invoker             The invoker to use.
@@ -60,6 +62,7 @@ public function __construct(
         Mock $mock = null,
         StubFactory $stubFactory,
         StubVerifierFactory $stubVerifierFactory,
+        EmptyValueFactory $emptyValueFactory,
         AssertionRenderer $assertionRenderer,
         AssertionRecorder $assertionRecorder,
         Invoker $invoker
@@ -72,6 +75,7 @@ public function __construct(
         $this->callMagicMethod = $callMagicMethod;
         $this->stubFactory = $stubFactory;
         $this->stubVerifierFactory = $stubVerifierFactory;
+        $this->emptyValueFactory = $emptyValueFactory;
         $this->assertionRenderer = $assertionRenderer;
         $this->assertionRecorder = $assertionRecorder;
         $this->invoker = $invoker;
@@ -332,21 +336,34 @@ protected function createStub($name)
                 $magicKey = '__callstatic';
             }
 
+            if (isset($this->uncallableMethods[$magicKey])) {
+                $isUncallable = true;
+                $returnValue = $this->emptyValueFactory->fromFunction(
+                    $this->class->getMethod($magicKey)
+                );
+            } else {
+                $isUncallable = false;
+                $returnValue = null;
+            }
+
             $stub = $this->stubFactory->create(
                 new WrappedMagicMethod(
                     $name,
                     $this->callMagicMethod,
-                    isset($this->uncallableMethods[$magicKey]),
-                    $this
+                    $isUncallable,
+                    $this,
+                    $returnValue
                 ),
                 $mock,
                 $this->state->defaultAnswerCallback
             );
         } elseif (isset($this->uncallableMethods[$key])) {
+            $method = $this->class->getMethod($name);
             $stub = $this->stubFactory->create(
                 new WrappedUncallableMethod(
-                    $this->class->getMethod($name),
-                    $this
+                    $method,
+                    $this,
+                    $this->emptyValueFactory->fromFunction($method)
                 ),
                 $mock,
                 $this->state->defaultAnswerCallback
@@ -409,6 +426,7 @@ protected function createStub($name)
     private $callMagicMethod;
     private $stubFactory;
     private $stubVerifierFactory;
+    private $emptyValueFactory;
     private $assertionRenderer;
     private $assertionRecorder;
     private $invoker;

src/Mock/Handle/HandleFactory.php

@@ -20,6 +20,7 @@
 use Eloquent\Phony\Mock\Exception\MockException;
 use Eloquent\Phony\Mock\Exception\NonMockClassException;
 use Eloquent\Phony\Mock\Mock;
+use Eloquent\Phony\Stub\EmptyValueFactory;
 use Eloquent\Phony\Stub\StubFactory;
 use Eloquent\Phony\Stub\StubVerifierFactory;
 use ReflectionClass;
@@ -41,6 +42,7 @@ public static function instance()
             self::$instance = new self(
                 StubFactory::instance(),
                 StubVerifierFactory::instance(),
+                EmptyValueFactory::instance(),
                 AssertionRenderer::instance(),
                 ExceptionAssertionRecorder::instance(),
                 Invoker::instance()
@@ -55,19 +57,22 @@ public static function instance()
      *
      * @param StubFactory         $stubFactory         The stub factory to use.
      * @param StubVerifierFactory $stubVerifierFactory The stub verifier factory to use.
+     * @param EmptyValueFactory   $emptyValueFactory   The empty value factory to use.
      * @param AssertionRenderer   $assertionRenderer   The assertion renderer to use.
      * @param AssertionRecorder   $assertionRecorder   The assertion recorder to use.
      * @param Invoker             $invoker             The invoker to use.
      */
     public function __construct(
         StubFactory $stubFactory,
         StubVerifierFactory $stubVerifierFactory,
+        EmptyValueFactory $emptyValueFactory,
         AssertionRenderer $assertionRenderer,
         AssertionRecorder $assertionRecorder,
         Invoker $invoker
     ) {
         $this->stubFactory = $stubFactory;
         $this->stubVerifierFactory = $stubVerifierFactory;
+        $this->emptyValueFactory = $emptyValueFactory;
         $this->assertionRenderer = $assertionRenderer;
         $this->assertionRecorder = $assertionRecorder;
         $this->invoker = $invoker;
@@ -114,6 +119,7 @@ public function instanceHandle($mock, $label = null)
             ),
             $this->stubFactory,
             $this->stubVerifierFactory,
+            $this->emptyValueFactory,
             $this->assertionRenderer,
             $this->assertionRecorder,
             $this->invoker
@@ -173,6 +179,7 @@ public function staticHandle($class)
             ),
             $this->stubFactory,
             $this->stubVerifierFactory,
+            $this->emptyValueFactory,
             $this->assertionRenderer,
             $this->assertionRecorder,
             $this->invoker
@@ -186,6 +193,7 @@ public function staticHandle($class)
     private static $instance;
     private $stubFactory;
     private $stubVerifierFactory;
+    private $emptyValueFactory;
     private $assertionRenderer;
     private $assertionRecorder;
     private $invoker;

src/Mock/Handle/InstanceHandle.php

@@ -16,6 +16,7 @@
 use Eloquent\Phony\Call\Arguments;
 use Eloquent\Phony\Invocation\Invoker;
 use Eloquent\Phony\Mock\Mock;
+use Eloquent\Phony\Stub\EmptyValueFactory;
 use Eloquent\Phony\Stub\StubFactory;
 use Eloquent\Phony\Stub\StubVerifierFactory;
 use ReflectionClass;
@@ -34,6 +35,7 @@ class InstanceHandle extends AbstractHandle
      * @param stdClass            $state               The state.
      * @param StubFactory         $stubFactory         The stub factory to use.
      * @param StubVerifierFactory $stubVerifierFactory The stub verifier factory to use.
+     * @param EmptyValueFactory   $emptyValueFactory   The empty value factory to use.
      * @param AssertionRenderer   $assertionRenderer   The assertion renderer to use.
      * @param AssertionRecorder   $assertionRecorder   The assertion recorder to use.
      * @param Invoker             $invoker             The invoker to use.
@@ -43,6 +45,7 @@ public function __construct(
         stdClass $state,
         StubFactory $stubFactory,
         StubVerifierFactory $stubVerifierFactory,
+        EmptyValueFactory $emptyValueFactory,
         AssertionRenderer $assertionRenderer,
         AssertionRecorder $assertionRecorder,
         Invoker $invoker
@@ -89,6 +92,7 @@ public function __construct(
             $mock,
             $stubFactory,
             $stubVerifierFactory,
+            $emptyValueFactory,
             $assertionRenderer,
             $assertionRecorder,
             $invoker

src/Mock/Handle/StaticHandle.php

@@ -14,6 +14,7 @@
 use Eloquent\Phony\Assertion\AssertionRecorder;
 use Eloquent\Phony\Assertion\AssertionRenderer;
 use Eloquent\Phony\Invocation\Invoker;
+use Eloquent\Phony\Stub\EmptyValueFactory;
 use Eloquent\Phony\Stub\StubFactory;
 use Eloquent\Phony\Stub\StubVerifierFactory;
 use ReflectionClass;
@@ -32,6 +33,7 @@ class StaticHandle extends AbstractHandle
      * @param stdClass            $state               The state.
      * @param StubFactory         $stubFactory         The stub factory to use.
      * @param StubVerifierFactory $stubVerifierFactory The stub verifier factory to use.
+     * @param EmptyValueFactory   $emptyValueFactory   The empty value factory to use.
      * @param AssertionRenderer   $assertionRenderer   The assertion renderer to use.
      * @param AssertionRecorder   $assertionRecorder   The assertion recorder to use.
      * @param Invoker             $invoker             The invoker to use.
@@ -41,6 +43,7 @@ public function __construct(
         stdClass $state,
         StubFactory $stubFactory,
         StubVerifierFactory $stubVerifierFactory,
+        EmptyValueFactory $emptyValueFactory,
         AssertionRenderer $assertionRenderer,
         AssertionRecorder $assertionRecorder,
         Invoker $invoker
@@ -75,6 +78,7 @@ public function __construct(
             null,
             $stubFactory,
             $stubVerifierFactory,
+            $emptyValueFactory,
             $assertionRenderer,
             $assertionRecorder,
             $invoker

src/Mock/Method/WrappedMagicMethod.php

@@ -31,17 +31,20 @@ class WrappedMagicMethod extends AbstractWrappedInvocable implements
      * @param ReflectionMethod $callMagicMethod The _callMagic() method.
      * @param bool             $isUncallable    True if the underlying magic method is uncallable.
      * @param Handle           $handle          The handle.
+     * @param mixed            $returnValue     The return value.
      */
     public function __construct(
         $name,
         ReflectionMethod $callMagicMethod,
         $isUncallable,
-        Handle $handle
+        Handle $handle,
+        $returnValue
     ) {
         $this->name = $name;
         $this->callMagicMethod = $callMagicMethod;
         $this->isUncallable = $isUncallable;
         $this->handle = $handle;
+        $this->returnValue = $returnValue;
 
         if ($callMagicMethod->isStatic()) {
             $this->mock = null;
@@ -120,7 +123,7 @@ public function mock()
     public function invokeWith($arguments = array())
     {
         if ($this->isUncallable) {
-            return;
+            return $this->returnValue;
         }
 
         if (!$arguments instanceof Arguments) {
@@ -131,9 +134,10 @@ public function invokeWith($arguments = array())
             ->invoke($this->mock, $this->name, $arguments);
     }
 
-    protected $name;
-    protected $callMagicMethod;
-    protected $isUncallable;
-    protected $handle;
-    protected $mock;
+    private $name;
+    private $callMagicMethod;
+    private $isUncallable;
+    private $handle;
+    private $mock;
+    private $returnValue;
 }

src/Mock/Method/WrappedUncallableMethod.php

@@ -11,14 +11,33 @@
 
 namespace Eloquent\Phony\Mock\Method;
 
+use Eloquent\Phony\Mock\Handle\Handle;
 use Error;
 use Exception;
+use ReflectionMethod;
 
 /**
  * A wrapper for uncallable methods.
  */
 class WrappedUncallableMethod extends AbstractWrappedMethod
 {
+    /**
+     * Construct a new wrapped uncallable method.
+     *
+     * @param ReflectionMethod $method      The method.
+     * @param Handle           $handle      The handle.
+     * @param mixed            $returnValue The return value.
+     */
+    public function __construct(
+        ReflectionMethod $method,
+        Handle $handle,
+        $returnValue
+    ) {
+        $this->returnValue = $returnValue;
+
+        parent::__construct($method, $handle);
+    }
+
     /**
      * Invoke this object.
      *
@@ -31,6 +50,8 @@ class WrappedUncallableMethod extends AbstractWrappedMethod
      */
     public function invokeWith($arguments = array())
     {
-        return null; // do nothing
+        return $this->returnValue;
     }
+
+    private $returnValue;
 }

src/Stub/EmptyValueFactory.php

@@ -12,6 +12,8 @@
 namespace Eloquent\Phony\Stub;
 
 use Eloquent\Phony\Mock\Builder\MockBuilderFactory;
+use Eloquent\Phony\Reflection\FeatureDetector;
+use ReflectionFunctionAbstract;
 use ReflectionType;
 
 /**
@@ -27,12 +29,23 @@ class EmptyValueFactory
     public static function instance()
     {
         if (!self::$instance) {
-            self::$instance = new self();
+            self::$instance = new self(FeatureDetector::instance());
         }
 
         return self::$instance;
     }
 
+    /**
+     * Construct a new empty value factory.
+     *
+     * @param FeatureDetector $featureDetector The feature detector to use.
+     */
+    public function __construct(FeatureDetector $featureDetector)
+    {
+        $this->isReturnTypeSupported =
+            $featureDetector->isSupported('return.type');
+    }
+
     /**
      * Set the stub verifier factory.
      *
@@ -116,7 +129,28 @@ public function fromType(ReflectionType $type)
         return $this->mockBuilderFactory->create($typeName)->full();
     }
 
+    /**
+     * Create a return value for the supplied function.
+     *
+     * @param ReflectionFunctionAbstract $function The function.
+     *
+     * @return mixed A value that can be returned by the function.
+     */
+    public function fromFunction(ReflectionFunctionAbstract $function)
+    {
+        if (!$this->isReturnTypeSupported) {
+            return null; // @codeCoverageIgnore
+        }
+
+        if ($type = $function->getReturnType()) {
+            return $this->fromType($type);
+        }
+
+        return null;
+    }
+
     private static $instance;
     private $stubVerifierFactory;
     private $mockBuilderFactory;
+    private $isReturnTypeSupported;
 }