ContainerDoubleTrait: Allow configuring mising services

Also it is possible to get the ObjectProphecy object instead of the revealed double

Author: TiSiE

src/TestCase/ContainerDoubleTrait.php

@@ -11,8 +11,11 @@
 
 namespace Cross\TestUtils\TestCase;
 
+use Cross\TestUtils\Exception\InvalidUsageException;
+use Prophecy\Prophecy\ObjectProphecy;
+
 /**
- * Creates a service manager double with configured services.
+ * Creates a service manager prophecy or double with configured services.
  *
  * @method \Prophecy\Prophecy\ObjectProphecy prophesize(string $classOrInterface)
  *
@@ -21,7 +24,7 @@
 trait ContainerDoubleTrait
 {
     /**
-     * Prohesizes a container interface double.
+     * Prohesizes a container interface.
      *
      * Pass in services as iterable:
      * <pre>
@@ -36,21 +39,30 @@ trait ContainerDoubleTrait
      * ]
      * </pre>
      *
+     * Passing the boolean value 'false' as service will cause the following:
+     * - Calling has(service) will return false.
+     * - Calling get(service) will throw an exception.
+     *
      * @param iterable $services
      *
-     * @return object
+     * @return ObjectProphecy
      */
-    public function createContainerDouble(iterable $services = []): object
+    public function createContainerProphecy(iterable $services = []): ObjectProphecy
     {
-        /** @noinspection PhpUndefinedClassInspection */
-        /** @noinspection PhpUndefinedNamespaceInspection */
+        if (!interface_exists(\Psr\Container\ContainerInterface::class)) {
+            throw InvalidUsageException::fromTrait(
+                __TRAIT__,
+                get_class($this),
+                'Cannot create container double. Interface %s does not exist.',
+                \Psr\Container\ContainerInterface::class
+            );
+        }
+
         $container = $this->prophesize(\Psr\Container\ContainerInterface::class);
 
         foreach ($services as $name => $spec) {
             if (!is_array($spec)) {
-                $container->get($name)->willReturn($spec);
-                $container->has($name)->willReturn(true);
-                continue;
+                $spec = ['service' => $spec];
             }
 
             $countGet = $spec['count_get'] ?? $spec[1] ?? 0;
@@ -59,20 +71,39 @@ public function createContainerDouble(iterable $services = []): object
 
             /** @var \Prophecy\Prophecy\MethodProphecy $method */
             $method = $container->get($name);
-            $method->willReturn($service);
+
+            if (false === $service) {
+                $ex = $this->prophesize(\Psr\Container\NotFoundExceptionInterface::class)->reveal();
+                $method->willThrow($ex);
+            } else {
+                $method->willReturn($service);
+            }
 
             if ($countGet) {
                 $method->shouldBeCalledTimes($countGet);
             }
 
             $method = $container->has($name);
-            $method->willReturn(true);
+            $method->willReturn(false !== $service);
 
             if ($countHas) {
                 $method->shouldBeCalledTimes($countHas);
             }
         }
 
-        return $container->reveal();
+        return $container;
+    }
+
+    /**
+     * Creates a container interface double.
+     *
+     * @param iterable $services The services the container should provide
+     *                           see {@link createContainerProphecy()}
+     *
+     * @return object The revealed container double
+     */
+    public function createContainerDouble(iterable $services = []): object
+    {
+        return $this->createContainerProphecy($services)->reveal();
     }
 }

test/TestUtilsTest/TestCase/ContainerDoubleTraitTest.php

@@ -11,8 +11,14 @@
 
 namespace Cross\TestUtilsTest\TestCase;
 
+use Cross\TestUtils\Exception\InvalidUsageException;
+
 use Cross\TestUtils\TestCase\ContainerDoubleTrait;
 
+use Prophecy\Argument;
+
+use phpmock\prophecy\PHPProphet;
+
 /**
  * Tests for \Cross\TestUtils\TestCase\ContainerDoubleTrait
  *
@@ -91,6 +97,18 @@ public function servicesProvider()
                     'reveal' => [[]]
                 ]
             ],
+            [
+                [
+                    'name' => false,
+                ],
+                [
+                    'get' => [['name']],
+                    'willThrow' => [['ExceptionMock']],
+                    'reveal' => [[]],
+                    'has' => [['name']],
+                    'willReturn' => [[false]],
+                ],
+            ],
         ];
     }
 
@@ -102,13 +120,15 @@ public function servicesProvider()
      */
     public function testCreatesContainerDouble(array $services, array $expect)
     {
+        $scope = $this;
         $target = new class
         {
             use ContainerDoubleTrait;
 
             public function prophesize($class)
             {
-                return new class($class)
+
+                return new class($class) extends \Prophecy\Prophecy\ObjectProphecy
                 {
                     public $name;
                     public $calls = [];
@@ -124,15 +144,41 @@ public function __call($method, $args)
 
                         return $this;
                     }
+
+                    public function reveal()
+                    {
+                        if (\Psr\Container\NotFoundExceptionInterface::class == $this->name) {
+                            return 'ExceptionMock';
+                        }
+
+                        $this->calls['reveal'][] = [];
+
+                        return $this;
+                    }
                 };
             }
         };
 
         $actual = $target->createContainerDouble($services);
 
-        /** @noinspection PhpUndefinedNamespaceInspection */
-        /** @noinspection PhpUndefinedClassInspection */
         static::assertEquals(\Psr\Container\ContainerInterface::class, $actual->name);
         static::assertEquals($expect, $actual->calls);
     }
+
+    public function testThrowsExceptionIfInterfaceIsNotDefined()
+    {
+
+        $func = (new PHPProphet)->prophesize('Cross\TestUtils\TestCase');
+        $func->interface_exists(Argument::any())->willReturn(false);
+        $func->reveal();
+
+        $this->expectException(InvalidUsageException::class);
+
+        $target = new class {
+            use ContainerDoubleTrait;
+        };
+
+        $target->createContainerProphecy();
+
+    }
 }