Merge branch 'feature/16' into develop

weierophinney · weierophinney · commit 9f6051c5fbaf · 2015-09-18T08:07:11.000-05:00
Close #16
diff --git a/src/Proxy/LazyServiceFactory.php b/src/Proxy/LazyServiceFactory.php
@@ -47,7 +47,7 @@ public function __construct(LazyLoadingValueHolderFactory $proxyFactory, array $
     /**
      * {@inheritDoc}
      *
-     * @return object|\ProxyManager\Proxy\LazyLoadingInterface|\ProxyManager\Proxy\ValueHolderInterface
+     * @return \ProxyManager\Proxy\VirtualProxyInterface
      */
     public function __invoke(ContainerInterface $container, $name, callable $callback, array $options = null)
     {
diff --git a/src/ServiceManager.php b/src/ServiceManager.php
@@ -241,23 +241,34 @@ public function has($name, $checkAbstractFactories = false)
      */
     protected function configure(array $config)
     {
-        $this->services        = (isset($config['services']) ? $config['services'] : []) + $this->services;
-        $this->factories       = (isset($config['factories']) ? $config['factories'] : []) + $this->factories;
-        $this->delegators      = array_merge_recursive($this->delegators, isset($config['delegators'])
-            ? $config['delegators']
-            : []);
-        $this->shared          = (isset($config['shared']) ? $config['shared'] : []) + $this->shared;
-        $this->aliases         = (isset($config['aliases']) ? $config['aliases'] : []) + $this->aliases;
-        $this->lazyServices    = array_merge_recursive($this->lazyServices, isset($config['lazy_services'])
-            ? $config['lazy_services']
-            : []);
-        $this->sharedByDefault = isset($config['shared_by_default'])
-            ? $config['shared_by_default']
-            : $this->sharedByDefault;
+        if (isset($config['services'])) {
+            $this->services = $config['services'] + $this->services;
+        }
+
+        if (isset($config['factories'])) {
+            $this->factories = $config['factories'] + $this->factories;
+        }
+
+        if (isset($config['delegators'])) {
+            $this->delegators = array_merge_recursive($this->delegators, $config['delegators']);
+        }
+
+        if (isset($config['shared'])) {
+            $this->shared = $config['shared'] + $this->shared;
+        }
+
+        if (isset($config['aliases'])) {
+            $this->aliases = $config['aliases'] + $this->aliases;
+        }
+
+        if (isset($config['shared_by_default'])) {
+            $this->sharedByDefault = $config['shared_by_default'];
+        }
 
         // If lazy service configuration was provided, reset the lazy services
         // delegator factory.
         if (isset($config['lazy_services']) && ! empty($config['lazy_services'])) {
+            $this->lazyServices          = array_merge_recursive($this->lazyServices, $config['lazy_services']);
             $this->lazyServicesDelegator = null;
         }
 
@@ -435,8 +446,7 @@ private function createDelegatorFromName($name, array $options = null)
                 }
 
                 throw new ServiceNotCreatedException(sprintf(
-                    'A non-callable delegator, "%s", was provided; expected a callable or '
-                    . 'instance of "%s"',
+                    'A non-callable delegator, "%s", was provided; expected a callable or instance of "%s"',
                     is_object($delegatorFactory) ? get_class($delegatorFactory) : gettype($delegatorFactory),
                     DelegatorFactoryInterface::class
                 ));
diff --git a/test/LazyServiceIntegrationTest.php b/test/LazyServiceIntegrationTest.php
@@ -10,10 +10,12 @@
 namespace ZendTest\ServiceManager;
 
 use PHPUnit_Framework_TestCase as TestCase;
+use ProxyManager\Autoloader\AutoloaderInterface;
 use RecursiveDirectoryIterator;
 use RecursiveIteratorIterator;
 use RecursiveRegexIterator;
 use RegexIterator;
+use stdClass;
 use Zend\ServiceManager\Exception\ServiceNotCreatedException;
 use Zend\ServiceManager\Exception\ServiceNotFoundException;
 use Zend\ServiceManager\Factory\InvokableFactory;
@@ -22,7 +24,7 @@
 use ZendTest\ServiceManager\TestAsset\InvokableObject;
 
 /**
- * @covers \Zend\ServiceManager\Proxy\LazyServiceFactory
+ * @covers \Zend\ServiceManager\ServiceManager
  */
 class LazyServiceIntegrationTest extends TestCase
 {
@@ -43,6 +45,9 @@ public function tearDown()
         }
 
         $this->removeDir($this->proxyDir);
+        foreach ($this->getRegisteredProxyAutoloadFunctions() as $autoloader) {
+            spl_autoload_unregister($autoloader);
+        }
     }
 
     public function removeDir($directory)
@@ -77,22 +82,15 @@ public function listProxyFiles()
     public function assertProxyDirEmpty($message = '')
     {
         $message = $message ?: 'Expected empty proxy directory; found files';
-        $count = 0;
-        foreach ($this->listProxyFiles() as $file) {
-            $this->assertFail($message);
-        }
-        $this->assertEquals(0, $count);
+        // AssertEquals instead AssertEmpty because the first one prints the list of files.
+        $this->assertEquals([], iterator_to_array($this->listProxyFiles()), $message);
     }
 
     public function assertProxyFileWritten($message = '')
     {
         $message = $message ?: 'Expected ProxyManager to write at least one class file; none found';
-        $count = 0;
-        foreach ($this->listProxyFiles() as $file) {
-            $count += 1;
-            break;
-        }
-        $this->assertNotEquals(0, $count, $message);
+        // AssertNotEquals instead AssertNotEmpty because the first one prints the list of files.
+        $this->assertNotEquals([], iterator_to_array($this->listProxyFiles()), $message);
     }
 
     /**
@@ -141,12 +139,12 @@ public function testCanUseLazyServiceFactoryFactoryToCreateLazyServiceFactoryToA
         $this->assertInternalType(
             'array',
             $options,
-            sprintf(
-                'Expected an array of options; %s received',
-                (is_object($options) ? get_class($options) : gettype($options))
-            )
+            'Expected an array of options'
         );
         $this->assertEquals(['foo' => 'bar'], $options, 'Options returned do not match configuration');
+
+        $proxyAutoloadFunctions = $this->getRegisteredProxyAutoloadFunctions();
+        $this->assertCount(1, $proxyAutoloadFunctions, 'Only 1 proxy autoloader should be registered');
     }
 
     /**
@@ -215,12 +213,49 @@ public function testWillNotGenerateProxyClassFilesByDefault()
         $this->assertInternalType(
             'array',
             $options,
-            sprintf(
-                'Expected an array of options; %s received',
-                (is_object($options) ? get_class($options) : gettype($options))
-            )
+            'Expected an array of options'
         );
         $this->assertEquals(['foo' => 'bar'], $options, 'Options returned do not match configuration');
+
+        $proxyAutoloadFunctions = $this->getRegisteredProxyAutoloadFunctions();
+        $this->assertCount(1, $proxyAutoloadFunctions, 'Only 1 proxy autoloader should be registered');
+    }
+
+    public function testOnlyOneProxyAutoloaderItsRegisteredOnSubsequentCalls()
+    {
+        $config = [
+            'lazy_services' => [
+                'class_map' => [
+                    InvokableObject::class => InvokableObject::class,
+                    stdClass::class => stdClass::class,
+                ],
+                'proxies_namespace'  => 'TestAssetProxy',
+            ],
+            'factories' => [
+                InvokableObject::class => InvokableFactory::class,
+            ],
+            'delegators' => [
+                InvokableObject::class => [LazyServiceFactory::class],
+                stdClass::class => [LazyServiceFactory::class],
+            ],
+        ];
+
+        $container = new ServiceManager($config);
+        $instance  = $container->build(InvokableObject::class, ['foo' => 'bar']);
+        $this->assertInstanceOf(
+            InvokableObject::class,
+            $instance,
+            'Service returned does not extend ' . InvokableObject::class
+        );
+        $instance  = $container->build(stdClass::class, ['foo' => 'bar']);
+        $this->assertInstanceOf(
+            stdClass::class,
+            $instance,
+            'Service returned does not extend ' . stdClass::class
+        );
+
+        $proxyAutoloadFunctions = $this->getRegisteredProxyAutoloadFunctions();
+        $this->assertCount(1, $proxyAutoloadFunctions, 'Only 1 proxy autoloader should be registered');
     }
 
     public function testRaisesServiceNotFoundExceptionIfRequestedLazyServiceIsNotInClassMap()
@@ -243,7 +278,20 @@ public function testRaisesServiceNotFoundExceptionIfRequestedLazyServiceIsNotInC
         $this->assertProxyDirEmpty();
 
         $container = new ServiceManager($config);
+
         $this->setExpectedException(ServiceNotFoundException::class, 'not found in the provided services map');
-        $instance  = $container->build(InvokableObject::class, ['foo' => 'bar']);
+        $container->build(InvokableObject::class, ['foo' => 'bar']);
+    }
+
+    /**
+     * @return AutoloaderInterface[]
+     */
+    protected function getRegisteredProxyAutoloadFunctions()
+    {
+        $filter = function ($autoload) {
+            return ($autoload instanceof AutoloaderInterface);
+        };
+
+        return array_filter(spl_autoload_functions(), $filter);
     }
 }
diff --git a/test/Proxy/LazyServiceFactoryTest.php b/test/Proxy/LazyServiceFactoryTest.php
@@ -0,0 +1,116 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace ZendTest\ServiceManager\Proxy;
+
+use Interop\Container\ContainerInterface;
+use PHPUnit_Framework_MockObject_MockObject as MockObject;
+use PHPUnit_Framework_TestCase as TestCase;
+use ProxyManager\Factory\LazyLoadingValueHolderFactory;
+use ProxyManager\Proxy\LazyLoadingInterface;
+use ProxyManager\Proxy\VirtualProxyInterface;
+use Zend\ServiceManager\Exception\ServiceNotFoundException;
+use Zend\ServiceManager\Factory\DelegatorFactoryInterface;
+use Zend\ServiceManager\Proxy\LazyServiceFactory;
+
+/**
+ * @covers \Zend\ServiceManager\Proxy\LazyServiceFactory
+ */
+class LazyServiceFactoryTest extends TestCase
+{
+    /**
+     * @var LazyServiceFactory
+     */
+    private $factory;
+
+    /**
+     * @var LazyLoadingValueHolderFactory|MockObject
+     */
+    private $proxyFactory;
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function setUp()
+    {
+        $this->proxyFactory = $this->getMock(LazyLoadingValueHolderFactory::class);
+        $servicesMap = [
+            'fooService' => 'FooClass',
+        ];
+
+        $this->factory = new LazyServiceFactory($this->proxyFactory, $servicesMap);
+    }
+
+    public function testImplementsDelegatorFactoryInterface()
+    {
+        $this->assertInstanceOf(DelegatorFactoryInterface::class, $this->factory);
+    }
+
+    public function testThrowExceptionWhenServiceNotExists()
+    {
+        $callback = $this->getMock('stdClass', ['callback']);
+        $callback->expects($this->never())
+            ->method('callback')
+        ;
+        $container = $this->createContainerMock();
+
+        $this->proxyFactory->expects($this->never())
+            ->method('createProxy')
+        ;
+        $this->setExpectedException(
+            ServiceNotFoundException::class,
+            'The requested service "not_exists" was not found in the provided services map'
+        );
+
+        $this->factory->__invoke($container, 'not_exists', [$callback, 'callback']);
+    }
+
+    public function testCreates()
+    {
+        $callback = $this->getMock('stdClass', ['callback']);
+        $callback->expects($this->once())
+            ->method('callback')
+            ->willReturn('fooValue')
+        ;
+        $container = $this->createContainerMock();
+        $expectedService = $this->getMock(VirtualProxyInterface::class);
+
+        $this->proxyFactory->expects($this->once())
+            ->method('createProxy')
+            ->willReturnCallback(
+                function ($className, $initializer) use ($expectedService) {
+                    $this->assertEquals('FooClass', $className, 'class name not match');
+
+                    $wrappedInstance = null;
+                    $result = $initializer($wrappedInstance, $this->getMock(LazyLoadingInterface::class));
+
+                    $this->assertEquals('fooValue', $wrappedInstance, 'expected callback return value');
+                    $this->assertTrue($result, 'initializer should return true');
+
+                    return $expectedService;
+                }
+            )
+        ;
+
+        $result = $this->factory->__invoke($container, 'fooService', [$callback, 'callback']);
+
+        $this->assertSame($expectedService, $result, 'service created not match the expected');
+    }
+
+    /**
+     * @return ContainerInterface|MockObject
+     */
+    private function createContainerMock()
+    {
+        /** @var ContainerInterface|MockObject $container */
+        $container = $this->getMock(ContainerInterface::class);
+
+        return $container;
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ public function __construct(LazyLoadingValueHolderFactory $proxyFactory, array $`
`47`	`47`	`/**`
`48`	`48`	`* {@inheritDoc}`
`49`	`49`	`*`
`50`		`- * @return object\|\ProxyManager\Proxy\LazyLoadingInterface\|\ProxyManager\Proxy\ValueHolderInterface`
	`50`	`+ * @return \ProxyManager\Proxy\VirtualProxyInterface`
`51`	`51`	`*/`
`52`	`52`	`public function __invoke(ContainerInterface $container, $name, callable $callback, array $options = null)`
`53`	`53`	`{`