Improved test coverage

Ran coverage reports and identified uncovered paths.

Also, modified `createLazyServiceDelegatorFactory()` to raise
ServiceNotCreatedException for missing class_map, as this method is called
during actual service creation.

Author: weierophinney

src/ServiceManager.php

@@ -498,6 +498,8 @@ private function doCreate($resolvedName, array $options = null)
      * configuration present.
      *
      * @return Proxy\LazyServiceFactory
+     * @throws ServiceNotCreatedException when the lazy service class_map
+     *     configuration is missing
      */
     private function createLazyServiceDelegatorFactory()
     {
@@ -506,7 +508,7 @@ private function createLazyServiceDelegatorFactory()
         }
 
         if (! isset($this->lazyServices['class_map'])) {
-            throw new Exception\InvalidArgumentException('Missing "class_map" config key in "lazy_services"');
+            throw new ServiceNotCreatedException('Missing "class_map" config key in "lazy_services"');
         }
 
         $factoryConfig = new ProxyConfiguration();

test/CommonServiceLocatorBehaviorsTrait.php

@@ -471,13 +471,22 @@ public function invalidFactories()
         ];
     }
 
+    public function invalidAbstractFactories()
+    {
+        $factories = $this->invalidFactories();
+        $factories['non-class-string'] = ['non-callable-string', 'valid class name'];
+        return $factories;
+    }
+
     /**
-     * @dataProvider invalidFactories
+     * @dataProvider invalidAbstractFactories
      * @covers \Zend\ServiceManager\ServiceManager::configure
      */
-    public function testPassingInvalidAbstractFactoryTypeViaConfigurationRaisesException($factory)
-    {
-        $this->setExpectedException(InvalidArgumentException::class, 'invalid abstract factory');
+    public function testPassingInvalidAbstractFactoryTypeViaConfigurationRaisesException(
+        $factory,
+        $contains = 'invalid abstract factory'
+    ) {
+        $this->setExpectedException(InvalidArgumentException::class, $contains);
         $serviceManager = $this->createContainer([
             'abstract_factories' => [
                 $factory,
@@ -502,13 +511,22 @@ public function testCanSpecifyInitializerUsingStringViaConfiguration()
         $this->assertEquals('bar', $instance->foo, '"foo" property was not properly injected');
     }
 
+    public function invalidInitializers()
+    {
+        $factories = $this->invalidFactories();
+        $factories['non-class-string'] = ['non-callable-string', 'valid function name or class name'];
+        return $factories;
+    }
+
     /**
-     * @dataProvider invalidFactories
+     * @dataProvider invalidInitializers
      * @covers \Zend\ServiceManager\ServiceManager::configure
      */
-    public function testPassingInvalidInitializerTypeViaConfigurationRaisesException($initializer)
-    {
-        $this->setExpectedException(InvalidArgumentException::class, 'invalid initializer');
+    public function testPassingInvalidInitializerTypeViaConfigurationRaisesException(
+        $initializer,
+        $contains = 'invalid initializer'
+    ) {
+        $this->setExpectedException(InvalidArgumentException::class, $contains);
         $serviceManager = $this->createContainer([
             'initializers' => [
                 $initializer,

test/LazyServiceIntegrationTest.php

@@ -14,6 +14,8 @@
 use RecursiveIteratorIterator;
 use RecursiveRegexIterator;
 use RegexIterator;
+use Zend\ServiceManager\Exception\ServiceNotCreatedException;
+use Zend\ServiceManager\Exception\ServiceNotFoundException;
 use Zend\ServiceManager\Factory\InvokableFactory;
 use Zend\ServiceManager\Proxy\LazyServiceFactory;
 use Zend\ServiceManager\ServiceManager;
@@ -146,4 +148,102 @@ public function testCanUseLazyServiceFactoryFactoryToCreateLazyServiceFactoryToA
         );
         $this->assertEquals(['foo' => 'bar'], $options, 'Options returned do not match configuration');
     }
+
+    /**
+     * @covers \Zend\ServiceManager\ServiceManager::createLazyServiceDelegatorFactory
+     */
+    public function testMissingClassMapRaisesExceptionOnAttemptToRetrieveLazyService()
+    {
+        $config = [
+            'lazy_services' => [
+            ],
+            'factories' => [
+                InvokableObject::class => InvokableFactory::class,
+            ],
+            'delegators' => [
+                InvokableObject::class => [LazyServiceFactory::class],
+            ],
+        ];
+
+        $container = new ServiceManager($config);
+        $this->setExpectedException(ServiceNotCreatedException::class, 'class_map');
+        $container->get(InvokableObject::class);
+    }
+
+    /**
+     * @covers \Zend\ServiceManager\ServiceManager::createLazyServiceDelegatorFactory
+     */
+    public function testWillNotGenerateProxyClassFilesByDefault()
+    {
+        $config = [
+            'lazy_services' => [
+                'class_map' => [
+                    InvokableObject::class => InvokableObject::class,
+                ],
+                'proxies_namespace'  => 'TestAssetProxy',
+            ],
+            'factories' => [
+                InvokableObject::class => InvokableFactory::class,
+            ],
+            'delegators' => [
+                InvokableObject::class => [LazyServiceFactory::class],
+            ],
+        ];
+
+        $this->assertProxyDirEmpty();
+
+        $container = new ServiceManager($config);
+        $instance  = $container->build(InvokableObject::class, ['foo' => 'bar']);
+
+        // This is the important test
+        $this->assertProxyDirEmpty('Expected proxy directory to remain empty when write_proxy_files disabled');
+
+        // Test we got a usable proxy
+        $this->assertInstanceOf(
+            InvokableObject::class,
+            $instance,
+            'Service returned does not extend ' . InvokableObject::class
+        );
+        $this->assertContains(
+            'TestAssetProxy',
+            get_class($instance),
+            'Service returned does not contain expected namespace'
+        );
+
+        // Test proxying works as expected
+        $options = $instance->getOptions();
+        $this->assertInternalType(
+            'array',
+            $options,
+            sprintf(
+                'Expected an array of options; %s received',
+                (is_object($options) ? get_class($options) : gettype($options))
+            )
+        );
+        $this->assertEquals(['foo' => 'bar'], $options, 'Options returned do not match configuration');
+    }
+
+    public function testRaisesServiceNotFoundExceptionIfRequestedLazyServiceIsNotInClassMap()
+    {
+        $config = [
+            'lazy_services' => [
+                'class_map' => [
+                    stdClass::class => stdClass::class,
+                ],
+                'proxies_namespace'  => 'TestAssetProxy',
+            ],
+            'factories' => [
+                InvokableObject::class => InvokableFactory::class,
+            ],
+            'delegators' => [
+                InvokableObject::class => [LazyServiceFactory::class],
+            ],
+        ];
+
+        $this->assertProxyDirEmpty();
+
+        $container = new ServiceManager($config);
+        $this->setExpectedException(ServiceNotFoundException::class, 'not found in the provided services map');
+        $instance  = $container->build(InvokableObject::class, ['foo' => 'bar']);
+    }
 }