Add tests for unresolvable argument dependencies

Author: e1himself

specs/Fixtures/MyUnresolvableScalarArgumentService.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Technically\DependencyResolver\Specs\Fixtures;
+
+final class MyUnresolvableScalarArgumentService
+{
+    public $name;
+
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+}

specs/dependency-resolver.spec.php

@@ -3,12 +3,14 @@
 use Psr\Container\ContainerInterface;
 use Technically\ArrayContainer\ArrayContainer;
 use Technically\DependencyResolver\DependencyResolver;
+use Technically\DependencyResolver\Exceptions\CannotAutowireDependencyArgument;
 use Technically\DependencyResolver\Exceptions\ClassCannotBeInstantiated;
 use Technically\DependencyResolver\Specs\Fixtures\MyAbstractClass;
 use Technically\DependencyResolver\Specs\Fixtures\MyConcreteContainerService;
 use Technically\DependencyResolver\Specs\Fixtures\MyAbstractContainerService;
 use Technically\DependencyResolver\Specs\Fixtures\MyNullableArgumentService;
 use Technically\DependencyResolver\Specs\Fixtures\MyOptionalArgumentService;
+use Technically\DependencyResolver\Specs\Fixtures\MyUnresolvableScalarArgumentService;
 
 describe('DependencyResolver', function() {
     it('should instantiate', function () {
@@ -85,4 +87,38 @@
         assert($exception instanceof ClassCannotBeInstantiated);
         assert($exception->getClassName() === MyAbstractClass::class);
     });
+
+    it('should throw exception if dependency class cannot be autowired', function () {
+        $container = new ArrayContainer();
+        $resolver = new DependencyResolver($container);
+
+        try {
+            $resolver->resolve(MyAbstractContainerService::class);
+        } catch (Exception $exception) {
+            // passthru
+        }
+
+        assert(isset($exception));
+        assert($exception instanceof CannotAutowireDependencyArgument);
+        assert($exception->getDependencyName() === MyAbstractContainerService::class);
+        assert($exception->getArgumentName() === 'container');
+        assert($exception->getMessage() === 'Could not autowire argument `container` for `Technically\DependencyResolver\Specs\Fixtures\MyAbstractContainerService`.');
+    });
+
+    it('should throw exception if scalar dependency cannot be autowired', function () {
+        $container = new ArrayContainer();
+        $resolver = new DependencyResolver($container);
+
+        try {
+            $resolver->resolve(MyUnresolvableScalarArgumentService::class);
+        } catch (Exception $exception) {
+            // passthru
+        }
+
+        assert(isset($exception));
+        assert($exception instanceof CannotAutowireDependencyArgument);
+        assert($exception->getDependencyName() === MyUnresolvableScalarArgumentService::class);
+        assert($exception->getArgumentName() === 'name');
+        assert($exception->getMessage() === 'Could not autowire argument `name` for `Technically\DependencyResolver\Specs\Fixtures\MyUnresolvableScalarArgumentService`.');
+    });
 });

src/DependencyResolver.php

@@ -2,7 +2,7 @@
 
 namespace Technically\DependencyResolver;
 
-use LogicException;
+use Psr\Container\ContainerExceptionInterface;
 use Psr\Container\ContainerInterface;
 use ReflectionClass;
 use ReflectionMethod;
@@ -11,7 +11,9 @@
 use ReflectionUnionType;
 use Technically\DependencyResolver\Arguments\Argument;
 use Technically\DependencyResolver\Arguments\Type;
+use Technically\DependencyResolver\Exceptions\CannotAutowireDependencyArgument;
 use Technically\DependencyResolver\Exceptions\ClassCannotBeInstantiated;
+use Technically\DependencyResolver\Exceptions\DependencyResolutionException;
 
 final class DependencyResolver
 {
@@ -48,7 +50,7 @@ public function resolve(string $className, array $bindings = [])
 
         if ($constructor = $reflection->getConstructor()) {
             $arguments = $this->parseArguments($constructor);
-            $values = $this->resolveArguments($arguments, $bindings);
+            $values = $this->resolveArguments($className, $arguments, $bindings);
         }
 
         return $reflection->newInstanceArgs($values);
@@ -77,28 +79,34 @@ private function parseArguments(ReflectionMethod $function): array
     }
 
     /**
+     * @param string $className
      * @param Argument[] $arguments
      * @param array $bindings
      * @return array
+     *
+     * @throws CannotAutowireDependencyArgument
      * @throws \Psr\Container\ContainerExceptionInterface
      * @throws \Psr\Container\NotFoundExceptionInterface
      */
-    private function resolveArguments(array $arguments, array $bindings = []): array
+    private function resolveArguments(string $className, array $arguments, array $bindings = []): array
     {
         $values = [];
         foreach ($arguments as $argument) {
-            $values[] = $this->resolveArgument($argument, $bindings);
+            $values[] = $this->resolveArgument($className, $argument, $bindings);
         }
 
         return $values;
     }
 
     /**
+     * @param string $className
      * @param Argument $argument
      * @param array $bindings
      * @return mixed|null
+     *
+     * @throws CannotAutowireDependencyArgument
      */
-    private function resolveArgument(Argument $argument, array $bindings)
+    private function resolveArgument(string $className, Argument $argument, array $bindings)
     {
         if (array_key_exists($argument->getName(), $bindings)) {
             return $bindings[$argument->getName()];
@@ -107,7 +115,11 @@ private function resolveArgument(Argument $argument, array $bindings)
         foreach ($argument->getTypes() as $type) {
             $class = $type->getClassName();
             if (! empty($class) && $this->container->has($class)) {
-                return $this->container->get($class);
+                try {
+                    return $this->container->get($class);
+                } catch (ContainerExceptionInterface $exception) {
+                    throw new CannotAutowireDependencyArgument($className, $argument->getName());
+                }
             }
         }
 
@@ -121,11 +133,15 @@ private function resolveArgument(Argument $argument, array $bindings)
 
         foreach ($argument->getTypes() as $type) {
             if ($class = $type->getClassName()) {
-                return $this->resolve($class);
+                try {
+                    return $this->resolve($class);
+                } catch (DependencyResolutionException $exception) {
+                    // try another one
+                }
             }
         }
 
-        throw new LogicException("Cannot resolve argument: `{$argument->getName()}`.");
+        throw new CannotAutowireDependencyArgument($className, $argument->getName());
     }
 
     private static function reflectClass(string $class): ReflectionClass

src/Exceptions/CannotAutowireDependencyArgument.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Technically\DependencyResolver\Exceptions;
+
+use Throwable;
+
+final class CannotAutowireDependencyArgument extends DependencyResolutionException
+{
+    /**
+     * @var string
+     */
+    private $dependencyName;
+
+    /**
+     * @var string
+     */
+    private $argumentName;
+
+    /**
+     * @param string $dependencyName
+     * @param string $argumentName
+     * @param Throwable|null $previous
+     */
+    public function __construct(string $dependencyName, string $argumentName, Throwable $previous = null)
+    {
+        $this->dependencyName = $dependencyName;
+        $this->argumentName = $argumentName;
+
+        parent::__construct("Could not autowire argument `{$argumentName}` for `${dependencyName}`.", 0, $previous);
+    }
+
+    /**
+     * @return string
+     */
+    public function getDependencyName(): string
+    {
+        return $this->dependencyName;
+    }
+
+    /**
+     * @return string
+     */
+    public function getArgumentName(): string
+    {
+        return $this->argumentName;
+    }
+}