Bagaimana Anda menguji kode PHP dengan PHPUnit?

Question

Accepted Answer

**PHPUnit** adalah framework testing standar untuk PHP — digunakan untuk menulis unit dan integration tests yang memverifikasi kode berperilaku dengan benar. Dikombinasikan dengan dependency injection (untuk mocking) dan tools seperti data providers, ini memungkinkan testing yang menyeluruh dan mudah dirawat.

## Test dasar

```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
```

Kelas test memperluas `TestCase`, method test dimulai dengan `test` (atau gunakan attribute `#[Test]`), dan gunakan method `assert*` untuk memverifikasi ekspektasi (`assertEquals`, `assertTrue`, `assertCount`, dll.). `expectException` menguji path error.

## Mocking dependencies (isolasi 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');
}
```

Mocking di PHPUnit memungkinkan Anda mengganti dependencies (mailers, repositories, APIs) dengan fakes yang dapat dikontrol — dan dependency injection membuat menginjeksinya menjadi trivial. Anda dapat assert bahwa mocks dipanggil dengan benar. Ini adalah fondasi dari unit tests yang cepat dan terisolasi.

## Data providers (test banyak 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** menjalankan test yang sama terhadap banyak set input — coverage yang bersih dari multiple cases tanpa duplikasi.

## 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
```

## Mengapa ini penting

Testing adalah essential untuk membangun aplikasi PHP yang reliable dan maintainable, dan **PHPUnit** adalah tool standar — jadi memahami cara menguji PHP penting baik untuk code quality maupun sebagai professional expectation.

Mengetahui cara menulis tests (memperluas `TestCase`, menggunakan assertions, menguji exception paths) adalah fundamental, tetapi insight paling berharga adalah bagaimana **dependency injection memungkinkan clean testing**: karena well-designed PHP classes menerima dependencies mereka, PHPUnit's mocking memungkinkan Anda mengganti real dependencies (databases, mailers, external APIs) dengan controllable fakes — enabling fast, isolated unit tests tanpa real infrastructure, dan memungkinkan Anda memverifikasi interactions (assert bahwa mock dipanggil dengan benar).

Koneksi antara DI dan testability ini adalah exactly mengapa dependency injection pattern sangat penting.

Memahami mocking, **data providers** (efficiently menguji banyak input cases), dan testing best practices (menguji behavior bukan implementation, mocking external dependencies, covering edge cases dan error paths, menggunakan test databases untuk integration tests) mencakup scope praktis dari effective PHP testing.

PHP yang well-tested menangkap regressions, memungkinkan confident refactoring, dan mendokumentasikan expected behavior, dan karena modern frameworks (Laravel, Symfony) membangun testing mereka di PHPUnit, mengetahuinya adalah broadly applicable.

Menguasai PHPUnit — especially leveraging mocking dan DI untuk isolated tests — adalah important senior-level knowledge yang membedakan developers yang membangun robust, maintainable, well-tested applications dari mereka yang mengirim untested, fragile code, menjadikannya frequently-relevant, professionally-important topic.