Merge pull request #6 from tweakers/interface-proxy

Interface proxy

Author: arjenm

composer.json

@@ -13,11 +13,11 @@
         }
     },
     "require": {
-        "php": "^7.2|^8.0",
-        "ocramius/proxy-manager": "^2.11"
+        "php": "^8.0",
+        "friendsofphp/proxy-manager-lts": "^1.0.16"
     },
     "require-dev": {
-        "phpunit/phpunit": "^9.5"
+        "phpunit/phpunit": "^10.2"
     },
     "license": "MIT",
     "authors": [

src/MockableService/MockableServiceProxyFactory.php

@@ -29,6 +29,36 @@ public function createServiceProxy(object $original): MockableService
         return $proxy;
     }
 
+    /**
+     * Similar to createServiceProxy, but with the class/interface to proxy explicitly specified.
+     *
+     * This allows proxying of instances of final implementations of the given interface.
+     *
+     * @param object $original The service to use as original.
+     * @param string $className The class (interface) to proxy.
+     *
+     * @return MockableService
+     */
+    public function createInterfaceServiceProxy(object $original, string $className): MockableService
+    {
+        // Body copied from parent::createProxy
+
+        /** @var MockableService $proxy */
+        $proxyClassName = $this->generateProxy($className);
+
+        /**
+         * We ignore type checks here, since `staticProxyConstructor` is not interfaced (by design)
+         *
+         * @psalm-suppress MixedMethodCall
+         * @psalm-suppress MixedReturnStatement
+         */
+        $proxy = $proxyClassName::staticProxyConstructor($original, [], []);
+
+        $proxy->setOriginalService($original);
+
+        return $proxy;
+    }
+
     /** {@inheritdoc} */
     protected function getGenerator(): ProxyGeneratorInterface
     {

test/MockableService/MockableServiceProxyFactoryTest.php

@@ -16,48 +16,89 @@ class MockableServiceProxyFactoryTest extends TestCase
     /** @var FakeService */
     private $alternative;
 
-    /** @var MockableService|FakeService $proxy */
-    private $proxy;
-
     protected function setUp(): void
     {
         parent::setUp();
 
         $this->original    = new FakeService('orig');
         $this->alternative = new FakeService('mock');
-
-        $factory = new MockableServiceProxyFactory();
-
-        $this->proxy = $factory->createServiceProxy($this->original);
     }
 
     /** @test */
     public function it_should_generate_a_mockable_service_proxy(): void
     {
-        $this->assertInstanceOf(MockableService::class, $this->proxy);
-        $this->assertInstanceOf(FakeService::class, $this->proxy);
+        $factory = new MockableServiceProxyFactory();
+        /** @var FakeService&MockableService $proxy */
+        $proxy = $factory->createServiceProxy($this->original);
 
-        $this->assertEquals($this->original->getValue(), $this->proxy->getValue());
+        $this->assertInstanceOf(MockableService::class, $proxy);
+        $this->assertInstanceOf(FakeService::class, $proxy);
+
+        $this->assertEquals($this->original->getValue(), $proxy->getValue());
     }
 
     /** @test */
     public function it_should_generate_a_working_set_alternative(): void
     {
-        $this->proxy->setAlternativeService($this->alternative);
-        $this->assertEquals($this->alternative->getValue(), $this->proxy->getValue());
+        $factory = new MockableServiceProxyFactory();
+        /** @var FakeService&MockableService $proxy */
+        $proxy = $factory->createServiceProxy($this->original);
+
+        $proxy->setAlternativeService($this->alternative);
+        $this->assertEquals($this->alternative->getValue(), $proxy->getValue());
     }
 
     /** @test */
     public function it_should_generate_a_working_reset(): void
     {
-        $this->proxy->setAlternativeService($this->alternative);
-        $this->proxy->restoreOriginalService();
+        $factory = new MockableServiceProxyFactory();
+        /** @var FakeService&MockableService $proxy */
+        $proxy = $factory->createServiceProxy($this->original);
+
+        $proxy->setAlternativeService($this->alternative);
+        $proxy->restoreOriginalService();
+
+        $this->assertEquals($this->original->getValue(), $proxy->getValue());
+    }
+
+    /** @test */
+    public function it_should_generate_a_mockable_service_proxy_via_an_interface(): void
+    {
+        $original = new FinalFakeService('value');
+
+        $factory = new MockableServiceProxyFactory();
+        /** @var FinalFakeService&MockableService $proxy */
+        $proxy = $factory->createInterfaceServiceProxy($original, TestInterface::class);
+
+        $this->assertInstanceOf(MockableService::class, $proxy);
+        $this->assertInstanceOf(TestInterface::class, $proxy);
+
+        $this->assertEquals($original->getValue(), $proxy->getValue());
+    }
+}
+
+interface TestInterface
+{
+    public function getValue(): string;
+}
+
+class FakeService implements TestInterface
+{
+    /** @var string */
+    private $value;
+
+    public function __construct(string $value)
+    {
+        $this->value = $value;
+    }
 
-        $this->assertEquals($this->original->getValue(), $this->proxy->getValue());
+    public function getValue(): string
+    {
+        return $this->value;
     }
 }
 
-class FakeService
+final class FinalFakeService implements TestInterface
 {
     /** @var string */
     private $value;