Piye carane nyoba kode PHP karo PHPUnit?

Question

Accepted Answer

**PHPUnit** minangka framework pengujian standar kanggo PHP — digunakake kanggo nulis unit lan integration tests sing verifikasi yen kode ndamel dengan bener. Digabung karo dependency injection (kanggo mocking) lan tools kaya data providers, iku ngaktifake pengujian sing komprehensif lan mudah dijaga.

## Ujian dhasar

```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 nglanjutake `TestCase`, metode test miwiti karo `test` (utawa gunakake atribut `#[Test]`), lan gunakake metode `assert*` kanggo verifikasi ekspektasi (`assertEquals`, `assertTrue`, `assertCount`, mtu.). `expectException` nyoba jalur 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 PHPUnit nglilirake dependencies (mailers, repositories, APIs) karo fakes sing bisa dikontrol — lan dependency injection nggawe injecting metu trivial. Sampeyan bisa assert manawa mocks dipanggil kanthi bener. Iki yasan saka unit tests sing cepet lan terisolasi.

## Data providers (nyoba pirang-pirang kasus)

```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** nglampahi test sing padha marang pirang-pirang set input — jangkauan bersih sing mult­iple kasus tanpa duplikasi.

## Praktik terbaik

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

## Napa iku penting

Pengujian minangka perlu kanggo mbangun aplikasi PHP sing andal lan mudah dijaga, lan **PHPUnit** minangka alat standar — mula ngerti piye cara nyoba PHP penting kanggo kalité kode lan minangka ekspektasi profesional.

Ngerti piye cara nulis tests (nglanjutake `TestCase`, gunakake assertions, nyoba jalur exceptions) minangka dhasar, nanging wawasan sing paling berharga yaiku piye **dependency injection ngaktifake testing sing bersih**: amarga kelas PHP sing didisain kanthi bener nampa dependencies-ne, mocking PHPUnit nglilirake dependencies nyata (databases, mailers, external APIs) karo fakes sing bisa dikontrol — ngaktifake unit tests sing cepet lan terisolasi tanpa infrastruktur nyata, lan nglilirake sampeyan verifikasi interaksi (asserting mock dijalani kanthi bener).

Koneksi antara DI lan testability iku pancen napa pola dependency injection penting banget.

Ngerti mocking, **data providers** (nyoba banyak kasus input kanthi efisien), lan praktik testing terbaik (nyoba tingkah laku ora implementasi, mocking external dependencies, jangkauan edge cases lan jalur error, gunakake test databases kanggo integration tests) nutupi scope praktis saka PHP testing efektif.

PHP sing tested kanthi bener nyekel regressions, ngaktifake refactoring percaya diri, lan dokumentasi tingkah laku sing diharepake, lan amarga frameworks modern (Laravel, Symfony) mbangun testing-ne ing PHPUnit, ngerti iku kabeh ngangkat.

Menguasai PHPUnit — utama­ne nglewer mocking lan DI kanggo tests terisolasi — minangka pengetahuan senior-level penting sing ngbedakake developers sing mbangun aplikasi robust, mudah dijaga, tested kanthi bener saka sing ngirim kode untested, rapuh, dadi iku topik frequently-relevant, professionally-important.