Merge pull request #646 from maximium/463-mock-services

Add helper method to set service mocks in the container.

Author: alexislefebvre

doc/basic.md

@@ -234,4 +234,57 @@ $this->isSuccessful($client->getResponse());
 > Consider hard-coding the URLs in the test: it will ensure that if a route is changed,
 > the test will fail, so you'll know that there is a Breaking Change.
 
+#### Mock services
+
+##### setServiceMock()
+
+Mock a service:
+
+```php
+// mock a service
+$client = static::createClient();
+$mock = $this->getServiceMockBuilder(SomeService::class)->getMock();
+$mock->expects($this->once())->method('get')->willReturn('mocked service');
+$this->setServiceMock(static::$kernel->getContainer(), SomeService::class, $mock);
+
+// the service is mocked
+$client->request('GET', '/service');
+$this->assertSame('mocked service', $client->getResponse()->getContent());
+```
+
+There are some additional conditions to be aware of when mocking services:
+
+- The service you want to mock must be public.
+You can set all services to be public in the configuration of the test environment in the `services.yaml` file:
+```yaml
+when@test:
+  services:
+    _defaults:
+      public: true
+      autowire: true
+      autoconfigure: true
+```
+
+- The service must be mocked before any dependent services are used.
+Otherwise, you must restart the kernel to mock the service.
+```php
+...
+// run some tests with the original service
+$client->request('GET', '/service');
+$this->assertSame('non mocked output', $client->getResponse()->getContent());
+
+// kernel reboot is required to mock the service if the service is already loaded
+// because the service we want to mock is already injected into the dependent services
+static::ensureKernelShutdown();
+// boot the kernel again
+$client = static::createClient();
+
+// mock the service as shown above
+...
+```
+
+- When mocking a service for command testing,
+you must set the `$reuseKernel` argument to `true` in the `runCommand` method call.
+See example code [here](./command.md#service-mock).
+
 ← [Installation](./installation.md) • [Command test](./command.md) →

doc/command.md

@@ -46,4 +46,35 @@ class MyTestCase extends WebTestCase {
 }
 ```
 
+### Service mock
+
+It is important to set the `$reuseKernel` argument to `true` in the `runCommand` method call
+if you want to keep your services mocked in the command.
+
+```php
+use Liip\FunctionalTestBundle\Test\WebTestCase;
+use App\Service\YourService;
+
+class MyTestCase extends WebTestCase
+{
+    public function myTest()
+    {
+        // boot kernel
+        $kernel = static::bootKernel(['environment' => static::$env]);
+        $container = $kernel->getContainer();
+        // create a service mock
+        $mock = $this->getServiceMockBuilder(YourService::class)
+            ->onlyMethods(['getId'])
+            ->getMock();
+        $mock->expects($this->once())
+            ->method('getId')
+            ->willReturn(42);
+        // set the service mock in the container
+        $this->setServiceMock($container, YourService::class, $mock);
+        // now you have mocked service App\Service\YourService in your command
+        $this->runCommand('myCommand', [], true);
+    }
+}
+```
+
 ← [Basic usage](./basic.md) • [Logged client](./logged.md) →

src/Test/WebTestCase.php

@@ -84,6 +84,25 @@ protected function getServiceMockBuilder(string $id): MockBuilder
         return $this->getMockBuilder($class)->disableOriginalConstructor();
     }
 
+    /**
+     * Mock service in the container.
+     */
+    protected function setServiceMock(
+        ContainerInterface $container,
+        string $serviceId,
+        object $mock
+    ): void {
+        $containerRef = new \ReflectionObject($container);
+
+        if ($containerRef->hasProperty('services')) {
+            $servicesProperty = $containerRef->getProperty('services');
+            $servicesProperty->setAccessible(true);
+            $services = $servicesProperty->getValue($container);
+            $services[$serviceId] = $mock;
+            $servicesProperty->setValue($container, $services);
+        }
+    }
+
     /**
      * Builds up the environment to run the given command.
      */

tests/App/Controller/DefaultController.php

@@ -15,6 +15,7 @@
 
 use Doctrine\ORM\EntityManagerInterface;
 use Liip\Acme\Tests\App\Entity\User;
+use Liip\Acme\Tests\App\Service\Service;
 use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\Form\Extension\Core\Type\SubmitType;
 use Symfony\Component\Form\Extension\Core\Type\TextType;
@@ -112,4 +113,9 @@ public function exceptionAction(): Response
     {
         throw new \Exception('foo');
     }
+
+    public function serviceAction(Service $service): Response
+    {
+        return new Response($service->get());
+    }
 }

tests/App/Service/DependencyService.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the Liip/FunctionalTestBundle
+ *
+ * (c) Lukas Kahwe Smith <[email protected]>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Liip\Acme\Tests\App\Service;
+
+class DependencyService
+{
+    public function get(): string
+    {
+        return 'dependency service result';
+    }
+}

tests/App/Service/Service.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+/*
+ * This file is part of the Liip/FunctionalTestBundle
+ *
+ * (c) Lukas Kahwe Smith <[email protected]>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Liip\Acme\Tests\App\Service;
+
+class Service
+{
+    private $dependencyService;
+
+    public function __construct(DependencyService $dependencyService)
+    {
+        $this->dependencyService = $dependencyService;
+    }
+
+    public function get(): string
+    {
+        return $this->dependencyService->get();
+    }
+}

tests/App/config.yml

@@ -68,6 +68,11 @@ services:
     _defaults:
         autowire: true
         autoconfigure: true
+
+    Liip\Acme\Tests\App\Service\:
+        resource: './Service/'
+        public: true
+
     Liip\Acme\Tests\App\Command\TestCommand:
         tags: ['console.command']
     Liip\Acme\Tests\App\Command\TestInteractiveCommand:

tests/App/routing.yml

@@ -29,3 +29,8 @@ liipfunctionaltestbundle_json:
 liipfunctionaltestbundle_exception:
     path:  /exception
     defaults: { _controller: 'Liip\Acme\Tests\App\Controller\DefaultController::exceptionAction' }
+
+liipfunctionaltestbundle_service:
+    path:  /service
+    defaults: { _controller: 'Liip\Acme\Tests\App\Controller\DefaultController::serviceAction' }
+    

tests/Test/WebTestCaseTest.php

@@ -15,8 +15,12 @@
 
 use Doctrine\Common\Annotations\Annotation\IgnoreAnnotation;
 use Liip\Acme\Tests\App\AppKernel;
+use Liip\Acme\Tests\App\Service\DependencyService;
+use Liip\Acme\Tests\App\Service\Service;
 use Liip\FunctionalTestBundle\Test\WebTestCase;
 use PHPUnit\Framework\AssertionFailedError;
+use PHPUnit\Framework\MockObject\MockObject;
+use Symfony\Component\HttpFoundation\RequestStack;
 
 /**
  * @IgnoreAnnotation("depends")
@@ -398,4 +402,92 @@ public function testJsonIsSuccessful(): void
             'application/json'
         );
     }
+
+    public function testSetServiceMockCommand(): void
+    {
+        $mockedServiceClass = RequestStack::class;
+        $mockedServiceName = 'request_stack';
+
+        $kernel = static::bootKernel();
+        $container = $kernel->getContainer();
+        $mock = $this->getMockBuilder('\stdClass')->getMock();
+
+        $this->assertInstanceOf($mockedServiceClass, $container->get($mockedServiceName));
+        $this->setServiceMock($container, $mockedServiceName, $mock);
+        $this->assertInstanceOf(MockObject::class, $kernel->getContainer()->get($mockedServiceName));
+    }
+
+    public static function provideSetServiceMockClientData(): array
+    {
+        return [
+            'no mock' => [
+                'dependency service result',
+                null,
+            ],
+            'mock service dependency' => [
+                'mocked dependency service result',
+                DependencyService::class,
+            ],
+            'mock controller dependency' => [
+                'mocked service result',
+                Service::class,
+            ],
+        ];
+    }
+
+    /**
+     * @dataProvider provideSetServiceMockClientData
+     */
+    public function testSetServiceMockClient(string $expectedOutput, ?string $mockedServiceName): void
+    {
+        $client = static::createClient();
+
+        // mock the service
+        if ($mockedServiceName) {
+            $mock = $this->getServiceMockBuilder($mockedServiceName)->getMock();
+            $mock->expects($this->once())->method('get')->willReturn($expectedOutput);
+            $this->setServiceMock(static::$kernel->getContainer(), $mockedServiceName, $mock);
+        }
+
+        $client->request('GET', '/service');
+        $this->assertSame($expectedOutput, $client->getResponse()->getContent());
+    }
+
+    public static function provideSetServiceMockKernelRebootData(): array
+    {
+        return [
+            // do a kernel reboot, expects 'get' method call on mock, expected output
+            'no kernel reboot' => [false, false, 'dependency service result'],
+            'reboot kernel' => [true, true, 'mocked result'],
+        ];
+    }
+
+    /**
+     * @dataProvider provideSetServiceMockKernelRebootData
+     */
+    public function testSetServiceMockKernelReboot(
+        bool $rebootKernel,
+        bool $expectedMethodCall,
+        string $expectedOutput
+    ): void {
+        // use the real service
+        $client = static::createClient();
+        $client->request('GET', '/service');
+        $this->assertSame('dependency service result', $client->getResponse()->getContent());
+
+        if ($rebootKernel) {
+            static::ensureKernelShutdown();
+            $client = static::createClient();
+        }
+
+        // mock the service
+        $mock = $this->getServiceMockBuilder(Service::class)->getMock();
+        $mock->expects($expectedMethodCall ? $this->once() : $this->never())
+            ->method('get')
+            ->willReturn('mocked result');
+        $this->setServiceMock(static::$kernel->getContainer(), Service::class, $mock);
+
+        $client->request('GET', '/service');
+        $this->assertSame($expectedOutput, $client->getResponse()->getContent());
+    }
 }