Test Doubles, Dependency Injection, and Object Interactions - PHPUnit Part 5

Test Doubles in PHPUnit

Test doubles are objects that mimic real objects in your application to remove dependencies on external resources like databases, APIs, or file systems. PHPUnit provides several test doubles, including mocks, stubs, and fakes.

Creating a Mock Object in PHPUnit

Mocks allow you to simulate object behavior and verify interactions.

Example:

<?php
use PHPUnit\Framework\TestCase;

class UserServiceTest extends TestCase
{
    public function testUserIsSaved()
    {
        $userRepository = $this->createMock(UserRepository::class);
        $userRepository->expects($this->once())
                       ->method('save')
                       ->with($this->isInstanceOf(User::class));
        
        $userService = new UserService($userRepository);
        $userService->registerUser("John Doe");
    }
}

Why Use Test Doubles?

• Prevent reliance on external systems.
• Speed up test execution.
• Isolate code behavior for more focused testing.

Dependency Injection in PHPUnit

Dependency injection (DI) allows objects to receive their dependencies from external sources rather than creating them internally. This improves code flexibility and testability.

Example:

<?php
class UserService
{
    private $repository;
    
    public function __construct(UserRepository $repository)
    {
        $this->repository = $repository;
    }
}

When writing tests, you can inject mock dependencies:

$userRepositoryMock = $this->createMock(UserRepository::class);
$userService = new UserService($userRepositoryMock);

Benefits of Dependency Injection:

• Makes unit testing easier by allowing dependency substitution.
• Reduces tight coupling between components.
• Promotes better design and flexibility.

Testing Object Interactions in PHPUnit

Object interaction testing ensures that dependencies are used correctly within a class. PHPUnit allows verification of method calls, parameters, and execution count.

Example:

<?php
use PHPUnit\Framework\TestCase;

class PaymentServiceTest extends TestCase
{
    public function testProcessPaymentCallsGateway()
    {
        $gateway = $this->createMock(PaymentGateway::class);
        $gateway->expects($this->once())
                ->method('charge')
                ->with(100);

        $paymentService = new PaymentService($gateway);
        $paymentService->processPayment(100);
    }
}

Why Test Object Interactions?

• Ensures dependencies are used as expected.
• Catches integration issues early.
• Helps maintain proper application behavior.

Follow the link to learn more about test doubles and mock objects: https://docs.phpunit.de/en/10.5/test-doubles.html#creating-mock-objects

Conclusion

This part covered test doubles, dependency injection, and verifying object interactions in PHPUnit. These techniques help create isolated, efficient, and maintainable tests. In the next part, we'll dive into handling exceptions and edge cases in PHPUnit tests.