Added more exception rules, more config checking, and more tests

Author: GeeH

src/AbstractFactory/ConfigAbstractFactory.php

@@ -9,6 +9,7 @@
 
 namespace Zend\ServiceManager\AbstractFactory;
 
+use Zend\ServiceManager\Exception\ServiceNotCreatedException;
 use Zend\ServiceManager\Factory\AbstractFactoryInterface;
 
 final class ConfigAbstractFactory implements AbstractFactoryInterface
@@ -27,18 +28,48 @@ public function canCreate(\Interop\Container\ContainerInterface $container, $req
         $config = $container->get('config');
         $dependencies = $config[self::class];
 
-        return is_array($dependencies) && array_key_exists($requestedName, $dependencies) && is_array(
-            $dependencies[$requestedName]
-        );
+        // config must be array, and have a key for the requested name that's value is also an array
+        if (!is_array($dependencies)
+            || !array_key_exists($requestedName, $dependencies)
+            || !is_array($dependencies[$requestedName])
+        ) {
+            return false;
+        }
+
+        // we can only create this service if the config is an array of strings
+        return $dependencies[$requestedName] === array_values(array_map('strval', $dependencies[$requestedName]));
+
     }
 
     /**
      * {@inheritDoc}
      */
     public function __invoke(\Interop\Container\ContainerInterface $container, $requestedName, array $options = null)
     {
+        if (!$container->has('config')) {
+            throw new ServiceNotCreatedException('Cannot find a config array in the container');
+        }
+
         $config = $container->get('config');
-        $dependencies = $config[self::class][$requestedName];
+
+        if (!is_array($config)) {
+            throw new ServiceNotCreatedException('Config must be an array');
+        }
+
+        if (!array_key_exists(self::class, $config)) {
+            throw new ServiceNotCreatedException('Cannot find a `' . self::class . '` key in the config array');
+        }
+
+        $dependencies = $config[self::class];
+
+        if (!is_array($dependencies)
+            || !array_key_exists($requestedName, $dependencies)
+            || !is_array($dependencies[$requestedName])
+            || $dependencies[$requestedName] !== array_values(array_map('strval', $dependencies[$requestedName]))
+        ) {
+            throw new ServiceNotCreatedException('Dependencies config must exist and be an array of strings');
+        }
+        $dependencies = $dependencies[$requestedName];  
         $arguments = array_map([$container, 'get'], $dependencies);
 
         return new $requestedName(...$arguments);

test/AbstractFactory/ConfigAbstractFactoryTest.php

@@ -11,6 +11,7 @@
 
 use ProxyManager\Factory\LazyLoadingValueHolderFactory;
 use Zend\ServiceManager\AbstractFactory\ConfigAbstractFactory;
+use Zend\ServiceManager\Exception\ServiceNotCreatedException;
 use Zend\ServiceManager\Proxy\LazyServiceFactory;
 use Zend\ServiceManager\ServiceManager;
 use ZendTest\ServiceManager\TestAsset\ComplexDependencyObject;
@@ -43,7 +44,22 @@ public function testCanCreateReturnsFalseIfDependencyNotArrays()
                 ]
             ]
         );
+        self::assertFalse($abstractFactory->canCreate($serviceManager, InvokableObject::class));
 
+        $serviceManager->setAllowOverride(true);
+        $serviceManager->setService(
+            'config',
+            [
+                ConfigAbstractFactory::class => [
+                    InvokableObject::class => [
+                        'Jabba',
+                        'Gandalf',
+                        'Blofeld',
+                        42
+                    ],
+                ]
+            ]
+        );
         self::assertFalse($abstractFactory->canCreate($serviceManager, InvokableObject::class));
 
     }
@@ -145,4 +161,109 @@ public function testInvokeWithComplexArguments()
             $abstractFactory($serviceManager, ComplexDependencyObject::class)
         );
     }
+
+    public function testExceptsWhenConfigNotSet()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Cannot find a config array in the container');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
+
+    public function testExceptsWhenConfigKeyNotSet()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        $serviceManager->setService('config', []);
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Cannot find a `' . ConfigAbstractFactory::class . '` key in the config array');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
+
+    public function testExceptsWhenConfigIsNotArray()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        $serviceManager->setService('config', 'Holistic');
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Config must be an array');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
+
+    public function testExceptsWhenServiceConfigIsNotArray()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        $serviceManager->setService(
+            'config',
+            [
+                ConfigAbstractFactory::class => 'Detective_Agency'
+            ]
+        );
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Dependencies config must exist and be an array of strings');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
+
+    public function testExceptsWhenServiceConfigDoesNotExist()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        $serviceManager->setService(
+            'config',
+            [
+                ConfigAbstractFactory::class => [],
+            ]
+        );
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Dependencies config must exist and be an array of strings');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
+
+    public function testExceptsWhenServiceConfigForRequestedNameIsNotArray()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        $serviceManager->setService(
+            'config',
+            [
+                ConfigAbstractFactory::class => [
+                    'DirkGently' => 'Holistic',
+                ],
+            ]
+        );
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Dependencies config must exist and be an array of strings');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
+
+    public function testExceptsWhenServiceConfigForRequestedNameIsNotArrayOfStrings()
+    {
+        $abstractFactory = new ConfigAbstractFactory();
+        $serviceManager = new ServiceManager();
+        $serviceManager->setService(
+            'config',
+            [
+                ConfigAbstractFactory::class => [
+                    'DirkGently' => [
+                        'Holistic',
+                        'Detective',
+                        'Agency',
+                        42
+                    ],
+                ],
+            ]
+        );
+        self::expectException(ServiceNotCreatedException::class);
+        self::expectExceptionMessage('Dependencies config must exist and be an array of strings');
+
+        $abstractFactory($serviceManager, 'Dirk_Gently');
+    }
 }