Using mocks for dependency injection in testsfor Drupal 8 , 9 , 10 , and 11

Introduction

Unit testing in Drupal often requires isolation from external dependencies to ensure test reliability and accuracy. Mocking is a vital practice in this endeavor, allowing us to simulate the behavior of dependencies and test units of code in controlled environments. This lesson will guide you through using mocks for dependency injection in your Drupal module tests, enhancing the precision and reliability of your test results.

Understanding Mocks and Dependency Injection

Mocks are objects that simulate the behavior of real objects. By utilizing mocks in unit tests, you can focus on the component under test without worrying about the dependencies’ behavior. Dependency injection in Drupal involves passing these dependencies to your class, enabling easy swapping with mock objects during testing.

Benefits of Using Mocks

• Isolate Tests: Ensures your tests focus on the code in question rather than external behaviors.
• Speed: Tests run faster because they don't rely on actual service calls or I/O operations.
• Controlled Scenarios: Simulate edge cases and test failure modes without manipulating real objects.

Implementing Mocks in Your Tests

We will demonstrate using mocks in a PHPUnit test for a service in the mymodule module, which interacts with external services.

Step 1: Define a Service with Dependencies

Consider a service that utilizes another service, such as a simple greeting service:

namespace Drupal\mymodule\Service;

/**
 * Provides a simple greeting service.
 */
class GreetingService {

  /**
   * Provides a greeting based on the current time.
   *
   * @param \Drupal\mymodule\Service\TimeService $timeService
   *   The time service.
   *
   * @return string
   *   A greeting message.
   */
  public function getGreeting(TimeService $timeService) {
    $currentHour = $timeService--->getCurrentHour();
    if ($currentHour < 12) {
      return 'Good morning!';
    }
    elseif ($currentHour < 18) {
      return 'Good afternoon!';
    }
    else {
      return 'Good evening!';
    }
  }
}

Step 2: Create a Test with Mocks

We will write a test that mocks the TimeService to control the environment for testing the GreetingService. Place this in tests/src/Unit/GreetingServiceTest.php:

namespace Drupal\Tests\mymodule\Unit;

use Drupal\mymodule\Service\GreetingService;
use Drupal\mymodule\Service\TimeService;
use Drupal\Tests\UnitTestCase;
use PHPUnit\Framework\MockObject\MockObject;

/**
 * Tests the GreetingService.
 *
 * @group mymodule
 */
class GreetingServiceTest extends UnitTestCase {

  /**
   * The greeting service.
   *
   * @var \Drupal\mymodule\Service\GreetingService
   */
  protected $greetingService;

  /**
   * A mock time service.
   *
   * @var \PHPUnit\Framework\MockObject\MockObject
   */
  protected $mockTimeService;

  /**
   * {@inheritdoc}
   */
  protected function setUp(): void {
    parent::setUp();
    $this--->greetingService = new GreetingService();
    $this->mockTimeService = $this->createMock(TimeService::class);
  }

  /**
   * Tests the getGreeting method for morning.
   */
  public function testMorningGreeting() {
    $this->mockTimeService->expects($this->once())
      ->method('getCurrentHour')
      ->willReturn(9);

    $this->assertSame('Good morning!', $this->greetingService->getGreeting($this->mockTimeService));
  }

  /**
   * Tests the getGreeting method for afternoon.
   */
  public function testAfternoonGreeting() {
    $this->mockTimeService->expects($this->once())
      ->method('getCurrentHour')
      ->willReturn(15);

    $this->assertSame('Good afternoon!', $this->greetingService->getGreeting($this->mockTimeService));
  }

  /**
   * Tests the getGreeting method for evening.
   */
  public function testEveningGreeting() {
    $this->mockTimeService->expects($this->once())
      ->method('getCurrentHour')
      ->willReturn(21);

    $this->assertSame('Good evening!', $this->greetingService->getGreeting($this->mockTimeService));
  }
}

Explanation:

In the above tests, we create a mock of the TimeService to return controlled responses. This method allows us to test the GreetingService under various scenarios without relying on external factors like the actual time.

Conclusion

Using mocks for dependency injection in your Drupal tests improves both the accuracy and speed of your test suite. By isolating components, you gain precise control over test scenarios and ensure each unit behaves as expected in isolation.

In our upcoming lesson, we will delve into executing tests via Drush commands, streamlining your development workflow by leveraging Drupal's powerful command-line interface. Stay with us as we continue to refine your module development and testing skills!