{"id":2271,"date":"2018-08-01T14:31:52","date_gmt":"2018-08-01T13:31:52","guid":{"rendered":"https:\/\/www.entropywins.wtf\/blog\/?p=2271"},"modified":"2019-02-23T06:18:48","modified_gmt":"2019-02-23T05:18:48","slug":"clean-architecture-usecase-tests","status":"publish","type":"post","link":"https:\/\/www.entropywins.wtf\/blog\/2018\/08\/01\/clean-architecture-usecase-tests\/","title":{"rendered":"Clean Architecture: UseCase tests"},"content":{"rendered":"

When creating an application that follows The Clean Architecture<\/a> you end up with a number of UseCases that hold your application logic. In this blog post I outline a testing pattern for effectively testing these UseCases and avoiding common pitfalls.<\/p>\n

Testing UseCases<\/h2>\n

A UseCase contains the application logic for a single “action” that your system supports. For instance “cancel a membership”. This application logic interacts with the domain and various services. These services and the domain should have their own unit and integration tests. Each UseCase gets used in one or more applications, where it gets invoked from inside the presentation layer. Typically you want to have a few integration or edge-to-edge tests that cover this invocation. In this post I look at how to test the application logic of the UseCase itself.<\/p>\n

UseCases tend to have “many” collaborators. I can’t recall any that had less than 3. For the typical UseCase the number is likely closer to 6 or 7, with more collaborators being possible even when the design is good. That means constructing a UseCase takes some work: you need to provide working instances of all the collaborators.<\/p>\n

Integration Testing<\/h2>\n

One way to deal with this is to write integration tests for your UseCases. Simply get an instance of the UseCase from your Top Level Factory or Dependency Injection Container.<\/p>\n

This approach often requires you to mutate the factory or DIC. Want to test that an exception from the persistence service gets handled properly? You’ll need to use some test double<\/a> instead of the real service, or perhaps mutate the real service in some way. Want to verify a mail got send? Definitely want to use a Spy<\/a> here instead of the real service. Mutability comes with a cost so is better avoided.<\/p>\n

A second issue with using real collaborators is that your tests get slow due to real persistence usage. Even using an in-memory SQLite database (that needs initialization) instead of a simple in-memory fake repository makes for a speed difference of easily two orders of magnitude.<\/p>\n

Unit Testing<\/h2>\n

While there might be some cases where integration tests make sense, normally it is better to write unit tests for UseCases. This means having test doubles for all collaborators. Which leads us to the question of how to best inject these test doubles into our UseCases.<\/p>\n

As example I will use the CancelMembershipApplicationUseCase of the Wikimedia Deutschland<\/a> fundrasing application<\/a>.<\/p>\n

function __construct(ApplicationAuthorizer $authorizer, ApplicationRepository $repository, TemplateMailerInterface $mailer) {\n    $this->authorizer = $authorizer;\n    $this->repository = $repository;\n    $this->mailer = $mailer;\n}<\/pre>\n
This UseCase uses 3 collaborators. An authorization service, a repository (persistence service) and a mailing service. First it checks if the operation is allowed with the authorizer, then it interacts with the persistence and finally, if all went well, it uses the mailing service to send a confirmation email. Our unit test should test all this behavior and needs to inject test doubles for the 3 collaborators.<\/p>\n
The most obvious approach is to construct the UseCase in each test method.<\/p>\n
public function testGivenIdOfUnknownDonation_cancellationIsNotSuccessful(): void {\n    $useCase = new CancelMembershipApplicationUseCase(\n        new SucceedingAuthorizer(),\n        $this->newRepositoryWithCancellableDonation(),\n        new MailerSpy()\n    );\n\n    $response = $useCase->cancelApplication(\n        new CancellationRequest( self::ID_OF_NON_EXISTING_APPLICATION )\n    );\n\n    $this->assertFalse( $response->cancellationWasSuccessful() );\n}\n\npublic function testGivenIdOfCancellableApplication_cancellationIsSuccessful(): void {\n    $useCase = new CancelMembershipApplicationUseCase(\n        new SucceedingAuthorizer(),\n        $this->newRepositoryWithCancellableDonation(),\n        new MailerSpy()\n    );\n    \n    $response = $useCase->cancelApplication(\n        new CancellationRequest( $this->cancelableApplication->getId() )\n    );\n\n    $this->assertTrue( $response->cancellationWasSuccessful() );\n}<\/pre>\n
Note how both these test methods use the same test doubles. This is not always the case, for instance when testing authorization failure, the test double for the authorizer service will differ, and when testing persistence failure, the test double for the persistence service will differ.<\/p>\n
public function testWhenAuthorizationFails_cancellationFails(): void {\n    $useCase = new CancelMembershipApplicationUseCase(\n        new FailingAuthorizer(),\n        $this->newRepositoryWithCancellableDonation(),\n        new MailerSpy()\n    );\n\n    $response = $useCase->cancelApplication(\n        new CancellationRequest( $this->cancelableApplication->getId() )\n    );\n\n    $this->assertFalse( $response->cancellationWasSuccessful() );\n}<\/pre>\n
Normally a test function will only change a single test double.<\/p>\n
UseCases tend to have, on average, two or more behaviors (and thus tests) per collaborator. That means for most UseCases you will be repeating the construction of the UseCase in a dozen or more test functions. That is a problem. Ask yourself why.<\/p>\n
If the answer you came up with was DRY then think again and read my blog post on DRY<\/a> \ud83d\ude09 The primary issue is that you couple each of those test methods to the list of collaborators. So when the constructor signature of your UseCase changes, you will need to do Shotgun Surgery<\/a> and update all test functions. Even if those tests have nothing to do with the changed collaborator. A second issue is that you pollute the test methods with irrelevant details, making them harder to read.<\/p>\n
Default Test Doubles Pattern<\/h2>\n
The pattern is demonstrated using PHP + PHPUnit and will need some adaptation when using a testing framework that does not work with a class based model like that of PHPUnit.<\/em><\/p>\n
The coupling to the constructor signature and resulting Shotgun Surgery can be avoided by having a default instance of the UseCase filled with the right test doubles. This can be done by having a newUseCase method that constructs the UseCase and returns it. A way to change specific collaborators is needed (ie a FailingAuthorizer<\/code> to test\u00a0handling of failing authorization).<\/p>\n
private function newUseCase() {\n    return new CancelMembershipApplicationUseCase(\n        new SucceedingAuthorizer(),\n        new InMemoryApplicationRepository(),\n        new MailerSpy()\n    );\n}<\/pre>\n
Making the UseCase itself mutable is a big no-no. Adding optional parameters to the newUseCase<\/code> method works in languages that have named parameters. Since PHP does not have named parameters<\/a>, another solution is needed.<\/p>\n
An alternative approach to getting modified collaborators into the newUseCase<\/code> method is using fields. This is less nice than named parameters, as it introduces mutable state on the level of the test class. Since in PHP this approach gives us named fields and is understandable by tools, it is better than either using a positional list of optional arguments or emulating named arguments with an associative array (key-value map).<\/p>\n
The fields can be set in the setUp<\/code> method, which gets called by PHPUnit before the test methods. For each test method PHPUnit instantiates the test class, then calls setUp<\/code>, and then calls the test method.<\/p>\n
public function setUp() {\n    $this->authorizer = new SucceedingAuthorizer();\n    $this->repository = new InMemoryApplicationRepository();\n    $this->mailer = new MailerSpy();\n\n    $this->cancelableApplication = ValidMembershipApplication::newDomainEntity();\n    $this->repository->storeApplication( $this->cancelableApplication );\n}<\/pre>\n
private function newUseCase(): CancelMembershipApplicationUseCase {\n    return new CancelMembershipApplicationUseCase(\n        $this->authorizer,\n        $this->repository,\n        $this->mailer\n    );\n}<\/pre>\n
With this field-based approach individual test methods can modify a specific collaborator by writing to the field before calling newUseCase<\/code>.<\/p>\n
public function testWhenAuthorizationFails_cancellationFails(): void {\n    $this->authorizer = new FailingAuthorizer();\n\n    $response = $this->newUseCase()->cancelApplication(\n        new CancellationRequest( $this->cancelableApplication->getId() )\n    );\n\n    $this->assertFalse( $response->cancellationWasSuccessful() );\n}\n\npublic function testWhenSaveFails_cancellationFails() {\n    $this->repository->throwOnWrite();\n\n    $response = $this->newUseCase()->cancelApplication(\n        new CancellationRequest( $this->cancelableApplication->getId() )\n    );\n\n    $this->assertFalse( $response->cancellationWasSuccessful() );\n}<\/pre>\n
The choice of default collaborators is important. To minimize binding in the test functions, the default collaborators should not cause any failures<\/strong>. This is the case both when using the field-based approach and when using optional named parameters.<\/p>\n
If the authorization service failed by default, most test methods would need to modify it, even if they have nothing to do with authorization. And it is not always self-evident they need to modify the unrelated collaborator. Imagine the default authorization service indeed fails and that the testWhenSaveFails_cancellationFails<\/code> test method forgets to modify it. This test method would end up passing even if the behavior it tests is broken, since the UseCase will return the expected failure result even before getting to the point where it saves something.<\/p>\n
This is why inside of the setUp<\/code> function the example creates a “cancellable application” and puts it inside an in-memory test double of the repository.<\/p>\n
I chose the CancelMembershipApplication UseCase as an example because it is short and easy to understand. For most UseCases it is even more important to avoid the constructor signature coupling as this issue becomes more severe with size. And no matter how big or small the UseCase is, you benefit from not polluting your tests with unrelated setup details.<\/p>\n
You can view the whole CancelMembershipApplicationUseCase<\/a> and CancelMembershipApplicationUseCaseTest<\/a>.<\/p>\n
See also<\/h2>\n