How do you test PHP code with PHPUnit?

Question

Accepted Answer

**PHPUnit** is the standard testing framework for PHP — used to write unit and integration tests that verify code behaves correctly. Combined with dependency injection (for mocking) and tools like data providers, it enables thorough, maintainable testing.

## A basic test

```php
<?php
use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
    public function testAdd(): void {
        $calc = new Calculator();
        $result = $calc->add(2, 3);
        $this->assertEquals(5, $result);          // assertion
        $this->assertIsInt($result);
    }

public function testDivideByZeroThrows(): void {
        $this->expectException(DivisionByZeroError::class);   // assert it throws
        (new Calculator())->divide(1, 0);
    }
}
// run with: ./vendor/bin/phpunit
```

Test classes extend `TestCase`, test methods start with `test` (or use the `#[Test]` attribute), and use `assert*` methods to verify expectations (`assertEquals`, `assertTrue`, `assertCount`, etc.). `expectException` tests error paths.

## Mocking dependencies (isolation via DI)

```php
public function testSendsWelcomeEmail(): void {
    // create a MOCK of a dependency — no real mailer needed
    $mailer = $this->createMock(MailerInterface::class);
    $mailer->expects($this->once())          // assert it's called exactly once
           ->method('send')
           ->with('ann@x.com', $this->stringContains('Welcome'));

$service = new UserService($mailer);     // INJECT the mock (DI makes this easy)
    $service->register('ann@x.com');
}
```

PHPUnit's mocking lets you replace dependencies (mailers, repositories, APIs) with controllable fakes — and dependency injection makes injecting them trivial. You can assert that mocks are called correctly. This is the foundation of fast, isolated unit tests.

## Data providers (test many cases)

```php
public static function additionCases(): array {
    return [[1, 1, 2], [0, 5, 5], [-1, 1, 0]];   // [a, b, expected]
}

#[DataProvider('additionCases')]
public function testAdd(int $a, int $b, int $expected): void {
    $this->assertEquals($expected, (new Calculator())->add($a, $b));
}
```

**Data providers** run the same test against many input sets — clean coverage of multiple cases without duplication.

## Best practices

```text
✓ Test behavior/public API, not implementation details (so refactors don't break tests)
✓ Mock external dependencies (DB, APIs, mailers) for fast, isolated unit tests
✓ Use a test database for integration tests; setUp/tearDown for fixtures
✓ Measure coverage; test edge cases and error paths, not just the happy path
✓ Frameworks (Laravel, Symfony) build on PHPUnit with extra testing helpers
```

## Why it matters

Testing is essential for building reliable, maintainable PHP applications, and **PHPUnit** is the standard tool — so understanding how to test PHP is important both for code quality and as a professional expectation.

Knowing how to write tests (extending `TestCase`, using assertions, testing exception paths) is fundamental, but the most valuable insight is how **dependency injection enables clean testing**: because well-designed PHP classes receive their dependencies, PHPUnit's mocking lets you replace real dependencies (databases, mailers, external APIs) with controllable fakes — enabling fast, isolated unit tests without real infrastructure, and letting you verify interactions (asserting a mock was called correctly).

This connection between DI and testability is exactly why the dependency injection pattern matters so much.

Understanding mocking, **data providers** (efficiently testing many input cases), and testing best practices (testing behavior not implementation, mocking external dependencies, covering edge cases and error paths, using test databases for integration tests) covers the practical scope of effective PHP testing.

Well-tested PHP catches regressions, enables confident refactoring, and documents expected behavior, and since modern frameworks (Laravel, Symfony) build their testing on PHPUnit, knowing it is broadly applicable.

Mastering PHPUnit — especially leveraging mocking and DI for isolated tests — is important senior-level knowledge that distinguishes developers who build robust, maintainable, well-tested applications from those who ship untested, fragile code, making it a frequently-relevant, professionally-important topic.