Chapters

10 Chapters | 1:02:48 |

01

Hello Integration Tests!

7:41
02

KernelTestCase: Fetching Services

4:46
03

Test Environment Database Setup

9:30
04

Resetting the Database

4:47
05

Factory Data Seeding

5:56
06

Testing a Service

7:31
07

Partial Mocking

5:24
08

The Repository Test Helper

5:13
09

Testing Emails

4:42
10

Testing Messenger

7:18

> Testing > PHPUnit: Integration Testing with Live Services

Buy Access to Course

07.

Partial Mocking

Autoplay

Keep on Learning!

If you liked what you've learned so far, dive in! Subscribe to get
access to this tutorial plus video, code and script downloads.

Start your All-Access Pass

Buy just this tutorial for $10.00

Previous Chapter

Next Chapter

With a Subscription, click any sentence in the script to jump to that part of the video!

Let's make LockDownHelper more interesting. Let's say that, when a lockdown ends, we need to send an API request to GitHub. In our first tutorial, we wrote code that made API requests to get info about this SymfonyCasts/dino-park repository. Now, we're going to pretend that, when we end a lockdown, we need to send an API request to find all the issues with a "lockdown" label and close them. We're not... actually going to do this, but we'll go through the motions to trigger a fascinating situation.

This Setup: Making API Calls from our Service

In that first tutorial, we made a GitHub service that wraps the API calls. Its one method grabs a health report for the dinosaurs. Add a new public function called clearLockDownAlerts(). Inside, pretend we're making an API call - we don't really need to - then, at least, log a message.

            
Copy Code

Show All Lines

                        79 lines
            |
            src/Service/GithubService.php
        
Show Lines

                                                    // ... lines 1 - 9
                            
            class GithubService
        
            {
        
Show Lines

                                                    // ... lines 12 - 46
                            
                public function clearLockDownAlerts(): void
        
                {
        
                    $this->logger->info('Cleaning lock down alerts on GitHub...');
        
                    // pretend like this makes an API call to GitHub
        
                }
        
Show Lines

                                                    // ... lines 52 - 77
                            
            }

Cool! Also pretend that we've tested this method in some way - via a unit or integration test. The point is: we're confident that this method works.

Over in LockDownHelper, to make our fake API call, autowire GithubService $githubService... and down here, after flush(), say $this->githubService->clearLockDownAlerts().

            
Copy Code

Show All Lines

                        32 lines
            |
            src/Service/LockDownHelper.php
        
Show Lines

                                                    // ... lines 1 - 8
                            
            class LockDownHelper
        
            {
        
                public function __construct(
        
Show Lines

                                                    // ... lines 12 - 13
                            
                    private GithubService $githubService
        
                )
        
                {
        
                }
        
Show Lines

                                                    // ... line 18
                            
                public function endCurrentLockDown(): void
        
                {
        
Show Lines

                                                    // ... lines 21 - 28
                            
                    $this->githubService->clearLockDownAlerts();
        
                }
        
            }

Okay! Try the test!

symfony php vendor/bin/phpunit tests/Integration/Service/LockDownHelperTest.php

We haven't changed anything and... it still passes. That makes sense. In our test, we ask Symfony for the LockDownHelper and it handles passing the new GithubService argument when it creates that service. And because GitHubService isn't actually making a real API call, everything is fine.

But what if GithubService did contain real logic to make an HTTP request to GitHub? That could cause a few problems. First, it would definitely slow down our test. Second, it might fail because, when it checks the repository, we may not have any issues with the LockDown label. And third, if it does find issues with that label, it might close them on our real production repository... even though this is just a test.

Furthermore - I know, I'm on a roll - if we wanted to test that the clearLockDownAlerts() method was actually called, in an integration test, the only way to do that is by making an API call from our test to seed the repository with some issues (creating an issue with a LockDown label), calling the method, then making another API request from our test to verify that the issue was closed. Yikes. That's too much work to check something so simple!

Mocking only Some Services?

I hope you're yelling at your computer:

Ryan! This is the whole point of mocking - what we learned in the first tutorial!

Yea, totally! If we mocked GitHubHelper, we would avoid any API calls and have an easy way to assert that the method was called. So, darn, we basically want to mock one dependency... but use the real services for the other dependencies. Is that possible? It is! With something I call "partial mocking".

Injecting a Mock into the Container

When we ask the container for the LockDownHelper service, it instantiates the real services that it needs and passes them to each of the three arguments. What we really want to do is have it pass the real service for $lockDownRepository and $entityManager, but a mock for $githubService. And Symfony gives us a way to do that!

Check it out. Before we ask for LockDownHelperService, create a $githubService mock set to $this->createMock(GitHubService::class). Below that, say $githubService->expects() and, to make sure this fails at first, use $this->never() and ->method('clearLockDownAlerts').

            
Copy Code

Show All Lines

                        36 lines
            |
            tests/Integration/Service/LockDownHelperTest.php
        
Show Lines

                                                    // ... lines 1 - 12
                            
            class LockDownHelperTest extends KernelTestCase
        
            {
        
Show Lines

                                                    // ... lines 15 - 16
                            
                public function testEndCurrentLockdown()
        
                {
        
Show Lines

                                                    // ... lines 19 - 24
                            
                    $githubService = $this->createMock(GithubService::class);
        
                    $githubService->expects($this->never())
        
                        ->method('clearLockDownAlerts');
        
Show Lines

                                                    // ... lines 28 - 33
                            
                }
        
            }

If we stop now and run the test:

symfony php vendor/bin/phpunit tests/Integration/Service/LockDownHelperTest.php

It still passes. We created a mock... but no one is using it. We need to tell Symfony:

Hey! Replace the real GitHubService in the container with this mock.

Doing that is simple: self::getContainer()->set() passing the ID of the service, which is GithubService::class, then $githubService.

            
Copy Code

Show All Lines

                        36 lines
            |
            tests/Integration/Service/LockDownHelperTest.php
        
Show Lines

                                                    // ... lines 1 - 16
                            
                public function testEndCurrentLockdown()
        
                {
        
Show Lines

                                                    // ... lines 19 - 27
                            
                    self::getContainer()->set(GithubService::class, $githubService);
        
Show Lines

                                                    // ... lines 29 - 33
                            
                }
        
Show Lines

                                                    // ... lines 35 - 36

Suddenly, that becomes the service in the container, and that is what will be passed to LockDownHelper as the third argument.

Try the test!

symfony php vendor/bin/phpunit tests/Integration/Service/LockDownHelperTest.php

Because of the $this->never()... it fails! clearLockDownAlerts() was not expected to be called, but it was... since we're calling it down here. That proves the mock was used!

Change the test from $this->never() to $this->once() and try again...

            
Copy Code

Show All Lines

                        36 lines
            |
            tests/Integration/Service/LockDownHelperTest.php
        
Show Lines

                                                    // ... lines 1 - 16
                            
                public function testEndCurrentLockdown()
        
                {
        
Show Lines

                                                    // ... lines 19 - 25
                            
                    $githubService->expects($this->once())
        
Show Lines

                                                    // ... lines 27 - 33
                            
                }
        
Show Lines

                                                    // ... lines 35 - 36

symfony php vendor/bin/phpunit tests/Integration/Service/LockDownHelperTest.php

It passes! This is such a cool strategy.

Next: Let's look at how we can test if our code caused certain external things to happen, starting with testing emails.

5 Comments

Sort By

kbond 5 months ago

By aware there are some edge cases where setting a service on the built test container doesn't work as expected:

The container has already created the service when you try and set it (I think)
If in a functional test that uses the test client, the container is reset between requests so you'd lose the service you had set

This great library can help with this: https://github.com/Happyr/service-mocking

1 | Reply |

jdevine kbond 24 days ago edited

I was about to say the same thing. I ran into issues when trying to manually set a service in the container during testing. I believe it might happen more often in cases when only one (or any subset) of your tests in a class need to override the service.

I was using the happyr/service-mocking package for a while, but ran into issues regarding services that use the same class, but have different configurations. In my case the affected services were different Flysystem storages.

One possible solution might be to create a proxy (partial mock that falls back to real implementation) service, set it in the container during test setup, and then override the method behavior on it as needed. You can create a proxy with by calling $this->createTestProxy($className, $constructorArguments) in PHPUnit, where $className is the class you want to proxy, and $constructorArguments is an array of arguments to pass in the construction of the specified class. I haven't seen this proxy method used often in documentation, blog posts, or SA questions I've looked at in my search for an alternative solution to the problem happyr/service-mocking addresses. I'm not sure why that is the case, because using proxy objects has helped me a lot in writing tests at work.

Here is a possible example:
EDIT 2: Regarding Edit 1... According to the documentation overriding private services should work for Symfony 6.x or 7.x. I'm using 5.4, which does not seem to support this.

EDIT 1: After testing, I've found this specific example doesn't work because you can't overwrite a private service and the upload.storage service would be private with the default Flysystem config. It seems like this should be something that is allowed in the KernelTestCase class since you are allowed to retrieve private services even though that is normally prohibited in non-test code. So, this example would work, but only if the service you are replacing is public :/ My real-world work around currently is just making the proxy object and then manually constructing the depending service (UploadManager in this example), passing in the proxy object and retrieving services from the container as needed.

use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use League\Flysystem\Filesystem;
use League\Flysystem\InMemory\InMemoryFilesystemAdapter;
use League\Flysystem\UnableToWriteFile;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use App\Service\Uploader;
use App\Exception\UploadException;
// ...other imports...

class UploaderTest extends KernelTestCase 
{
    private Uploader $uploader;
    
    protected function setUp(): void
    {
        // create a proxy for the service we want partially modify behavior for
        $uploadStorageProxy = $this->createTestProxy(Filesystem::class, [new InMemoryFilesystemAdapter]);
    
        self::bootKernel();
        
        // call this before getting services from the container that depend on 'upload.storage'
        // THIS ONLY WORKS IF THE SERVICE IS PUBLIC
        self::getContainer()->set('upload.storage', $uploadStorageProxy);
    
        // make the service we are testing in this easily accessible for all tests
        // this service depends on the 'upload.storage' service
        $this->uploader = self::getContainer()->get(Uploader::class);
    }
    
    // ...several tests that don't need to modify 'upload.storage' service behavior
    
    public function testUploadExceptionThrownWhenStoringFileFails(): void
    {
        // get proxied service
        $uploadStorage = self::getContainer()->get('upload.storage');
        
        // modify desired method of proxied service and make sure it is called
        $uploadStorage
            ->expect($this->once())
            ->method('writeStream')
            ->willThrowException(new UnableToWriteFile());
            
        // making sure some custom exception is thrown
        $this->expectException(UploadException::class);
        
        $this->uploader->upload($this->createTestFile);
    }
    
    private function createTestFile(): UploadedFile
    {
        // create and return a basic UploadedFile object for testing
    }
}

| Reply |

jdevine jdevine 18 days ago

Ok, so it turns out the functionality to create a test proxy (and it's supporting methods) are being deprecated. So... I guess this isn't the way to go :( According to this issue it is being deprecated solely for the fact that the author hasn't seen it used much?

| Reply |

kbond jdevine 24 days ago

Thanks for the details Joe! My mission this year is to improve the Symfony testing process experience and this is one area that needs improvement.

| Reply |

MolloKhan SFCASTS kbond 5 months ago

Hey Kevin!

Excellent point - I was not aware of that library, it seems great. By the way, if your tests are not very complex, you can create a services_test.yaml file and override any service definition that you may need on your functional tests

Cheers!

| Reply |

This tutorial uses PHPUnit 9 but works just fine for PHPUnit 10.

PHPUnit 9 Symfony 6.3

What PHP libraries does this tutorial use?

// composer.json
{
    "require": {
        "php": ">=8.1.0",
        "ext-ctype": "*",
        "ext-iconv": "*",
        "doctrine/doctrine-bundle": "^2.8", // 2.10.2
        "doctrine/doctrine-migrations-bundle": "^3.2", // 3.2.4
        "doctrine/orm": "^2.14", // 2.16.2
        "symfony/asset": "6.3.*", // v6.3.0
        "symfony/console": "6.3.*", // v6.3.4
        "symfony/dotenv": "6.3.*", // v6.3.0
        "symfony/flex": "^2", // v2.3.3
        "symfony/framework-bundle": "6.3.*", // v6.3.5
        "symfony/http-client": "6.3.*", // v6.3.5
        "symfony/mailer": "6.3.*", // v6.3.5
        "symfony/messenger": "6.3.*", // v6.3.5
        "symfony/monolog-bundle": "^3.0", // v3.8.0
        "symfony/runtime": "6.3.*", // v6.3.2
        "symfony/security-csrf": "6.3.*", // v6.3.2
        "symfony/twig-bundle": "6.3.*", // v6.3.0
        "symfony/yaml": "6.3.*" // v6.3.3
    },
    "require-dev": {
        "doctrine/doctrine-fixtures-bundle": "^3.4", // 3.4.4
        "phpunit/phpunit": "^9.5", // 9.6.13
        "symfony/browser-kit": "6.3.*", // v6.3.2
        "symfony/css-selector": "6.3.*", // v6.3.2
        "symfony/debug-bundle": "6.3.*", // v6.3.2
        "symfony/maker-bundle": "^1.48", // v1.51.1
        "symfony/phpunit-bridge": "^6.2", // v6.3.2
        "symfony/stopwatch": "6.3.*", // v6.3.0
        "symfony/web-profiler-bundle": "6.3.*", // v6.3.2
        "zenstruck/foundry": "^1.35", // v1.35.0
        "zenstruck/mailer-test": "^1.3", // v1.3.0
        "zenstruck/messenger-test": "^1.7" // v1.7.3
    }
}

Previous Chapter

Next Chapter

Partial Mocking

Share this awesome video!

Keep on Learning!

This Setup: Making API Calls from our Service

Mocking only Some Services?

Injecting a Mock into the Container

5 Comments

Delete comment?

What PHP libraries does this tutorial use?

Show Lines	// ... lines 1 - 9
	class GithubService
	{
Show Lines	// ... lines 12 - 46
	public function clearLockDownAlerts(): void
	{
	$this->logger->info('Cleaning lock down alerts on GitHub...');
	// pretend like this makes an API call to GitHub
	}
Show Lines	// ... lines 52 - 77
	}

Show Lines	// ... lines 1 - 8
	class LockDownHelper
	{
	public function __construct(
Show Lines	// ... lines 12 - 13
	private GithubService $githubService
	)
	{
	}
Show Lines	// ... line 18
	public function endCurrentLockDown(): void
	{
Show Lines	// ... lines 21 - 28
	$this->githubService->clearLockDownAlerts();
	}
	}

Show Lines	// ... lines 1 - 12
	class LockDownHelperTest extends KernelTestCase
	{
Show Lines	// ... lines 15 - 16
	public function testEndCurrentLockdown()
	{
Show Lines	// ... lines 19 - 24
	$githubService = $this->createMock(GithubService::class);
	$githubService->expects($this->never())
	->method('clearLockDownAlerts');
Show Lines	// ... lines 28 - 33
	}
	}

Show Lines	// ... lines 1 - 16
	public function testEndCurrentLockdown()
	{
Show Lines	// ... lines 19 - 27
	self::getContainer()->set(GithubService::class, $githubService);
Show Lines	// ... lines 29 - 33
	}
Show Lines	// ... lines 35 - 36