Merge pull request #1 from l0gicgate/2778-ProphesizeUnitTests

2778 Prophesize Unit Tests

Slim/Factory/AppFactory.php

@@ -98,12 +98,15 @@ public static function createFromContainer(ContainerInterface $container): App
         $responseFactory = $container->has(ResponseFactoryInterface::class)
             ? $container->get(ResponseFactoryInterface::class)
             : self::determineResponseFactory();
+
         $callableResolver = $container->has(CallableResolverInterface::class)
             ? $container->get(CallableResolverInterface::class)
             : null;
+
         $routeCollector = $container->has(RouteCollectorInterface::class)
             ? $container->get(RouteCollectorInterface::class)
             : null;
+
         $routeResolver = $container->has(RouteResolverInterface::class)
             ? $container->get(RouteResolverInterface::class)
             : null;

tests/Factory/AppFactoryTest.php

@@ -31,7 +31,6 @@
 use Slim\Interfaces\RouteResolverInterface;
 use Slim\Psr7\Factory\ResponseFactory as SlimResponseFactory;
 use Slim\Routing\RouteCollector;
-use Slim\Tests\Mocks\MockContainer;
 use Slim\Tests\Mocks\MockPsr17FactoryWithoutStreamFactory;
 use Slim\Tests\TestCase;
 use Zend\Diactoros\ResponseFactory as ZendDiactorosResponseFactory;
@@ -230,40 +229,68 @@ public function testResponseAndStreamFactoryIsBeingInjectedInDecoratedResponseFa
         $this->assertSame($streamFactoryProphecy->reveal(), $streamFactoryProperty->getValue($response));
     }
 
-    public function testCreateAppWithEmptyContainer()
+    public function testCreateAppWithContainerUsesContainerDependenciesWhenPresent()
     {
-        $container = new MockContainer([]);
+        $responseFactoryProphecy = $this->prophesize(ResponseFactoryInterface::class);
+        $callableResolverProphecy = $this->prophesize(CallableResolverInterface::class);
+        $routeResolverProphecy = $this->prophesize(RouteResolverInterface::class);
+        $routeParserProphecy = $this->prophesize(RouteParserInterface::class);
 
-        $app = AppFactory::createFromContainer($container);
+        $routeCollectorProphecy = $this->prophesize(RouteCollectorInterface::class);
+        $routeCollectorProphecy
+            ->getRouteParser()
+            ->willReturn($routeParserProphecy->reveal())
+            ->shouldBeCalledOnce();
 
-        $this->assertSame($container, $app->getContainer());
-    }
+        $containerProphecy = $this->prophesize(ContainerInterface::class);
 
-    public function testCreateAppWithContainerThatProvidesAllImplementations()
-    {
-        $responseFactory = $this->prophesize(ResponseFactoryInterface::class)->reveal();
-        $callableResolver = $this->prophesize(CallableResolverInterface::class)->reveal();
-        $routeParser = $this->prophesize(RouteParserInterface::class)->reveal();
-        $routeCollectorProphecy = $this->prophesize(RouteCollectorInterface::class);
-        $routeCollectorProphecy->getRouteParser()
-            ->willReturn($routeParser);
-        $routeCollector = $routeCollectorProphecy->reveal();
-        $routeResolver = $this->prophesize(RouteResolverInterface::class)->reveal();
-
-        $container = new MockContainer([
-            ResponseFactoryInterface::class => $responseFactory,
-            CallableResolverInterface::class => $callableResolver,
-            RouteCollectorInterface::class => $routeCollector,
-            RouteParserInterface::class => $routeParser,
-            RouteResolverInterface::class => $routeResolver,
-        ]);
-
-        $app = AppFactory::createFromContainer($container);
-
-        $this->assertSame($responseFactory, $app->getResponseFactory());
-        $this->assertSame($container, $app->getContainer());
-        $this->assertSame($callableResolver, $app->getCallableResolver());
-        $this->assertSame($routeCollector, $app->getRouteCollector());
-        $this->assertSame($routeResolver, $app->getRouteResolver());
+        $containerProphecy
+            ->has(ResponseFactoryInterface::class)
+            ->willReturn(true)
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->get(ResponseFactoryInterface::class)
+            ->willReturn($responseFactoryProphecy->reveal())
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->has(CallableResolverInterface::class)
+            ->willReturn(true)
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->get(CallableResolverInterface::class)
+            ->willReturn($callableResolverProphecy->reveal())
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->has(RouteCollectorInterface::class)
+            ->willReturn(true)
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->get(RouteCollectorInterface::class)
+            ->willReturn($routeCollectorProphecy->reveal())
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->has(RouteResolverInterface::class)
+            ->willReturn(true)
+            ->shouldBeCalledOnce();
+
+        $containerProphecy
+            ->get(RouteResolverInterface::class)
+            ->willReturn($routeResolverProphecy->reveal())
+            ->shouldBeCalledOnce();
+
+        AppFactory::setSlimHttpDecoratorsAutomaticDetection(false);
+        $app = AppFactory::createFromContainer($containerProphecy->reveal());
+
+        $this->assertSame($app->getResponseFactory(), $responseFactoryProphecy->reveal());
+        $this->assertSame($app->getContainer(), $containerProphecy->reveal());
+        $this->assertSame($app->getCallableResolver(), $callableResolverProphecy->reveal());
+        $this->assertSame($app->getRouteCollector(), $routeCollectorProphecy->reveal());
+        $this->assertSame($app->getRouteResolver(), $routeResolverProphecy->reveal());
     }
 }