Bagaimanakah anda menguji kod PHP dengan PHPUnit?

Question

Accepted Answer

**PHPUnit** ialah framework pengujian standard untuk PHP — digunakan untuk menulis ujian unit dan integrasi yang mengesahkan kod berkelakuan dengan betul. Digabungkan dengan dependency injection (untuk mocking) dan alat seperti data provider, ia membolehkan pengujian yang menyeluruh dan mudah diselenggara.

## Ujian asas

```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 ujian memanjangkan (extend) `TestCase`, method ujian bermula dengan `test` (atau menggunakan atribut `#[Test]`), dan menggunakan method `assert*` untuk mengesahkan jangkaan (`assertEquals`, `assertTrue`, `assertCount`, dll.). `expectException` menguji laluan ralat.

## Mocking dependency (pengasingan melalui 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 membolehkan anda menggantikan dependency (mailer, repository, API) dengan tiruan yang boleh dikawal — dan dependency injection menjadikan penyuntikannya remeh. Anda boleh mengesahkan bahawa mock dipanggil dengan betul. Ini ialah asas ujian unit yang pantas dan terasing.

## Data provider (menguji banyak kes)

```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 provider** menjalankan ujian yang sama terhadap banyak set input — liputan yang kemas untuk pelbagai kes tanpa pendua.

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

## Mengapa ia penting

Pengujian adalah penting untuk membina aplikasi PHP yang boleh dipercayai dan mudah diselenggara, dan **PHPUnit** ialah alat standard — jadi memahami cara menguji PHP penting untuk kualiti kod dan sebagai jangkaan profesional.

Mengetahui cara menulis ujian (memanjangkan `TestCase`, menggunakan assertion, menguji laluan exception) adalah asas, tetapi wawasan paling berharga ialah cara **dependency injection membolehkan pengujian yang bersih**: kerana kelas PHP yang direka dengan baik menerima dependency-nya, mocking PHPUnit membolehkan anda menggantikan dependency sebenar (pangkalan data, mailer, API luaran) dengan tiruan yang boleh dikawal — membolehkan ujian unit yang pantas dan terasing tanpa infrastruktur sebenar, dan membolehkan anda mengesahkan interaksi (memastikan sebuah mock dipanggil dengan betul).

Kaitan antara DI dan kebolehujian ini tepat sekali sebab mengapa corak dependency injection begitu penting.

Memahami mocking, **data provider** (menguji banyak kes input dengan cekap), dan amalan terbaik pengujian (menguji tingkah laku bukan implementasi, mocking dependency luaran, melindungi kes pinggir dan laluan ralat, menggunakan pangkalan data ujian untuk ujian integrasi) merangkumi skop praktikal pengujian PHP yang berkesan.

PHP yang diuji dengan baik menangkap regresi, membolehkan refactoring dengan yakin, dan mendokumentasikan tingkah laku yang dijangka, dan memandangkan framework moden (Laravel, Symfony) membina pengujian mereka di atas PHPUnit, mengetahuinya boleh digunakan secara meluas.

Menguasai PHPUnit — terutamanya memanfaatkan mocking dan DI untuk ujian terasing — ialah pengetahuan peringkat senior penting yang membezakan pembangun yang membina aplikasi yang teguh, mudah diselenggara, dan diuji dengan baik daripada mereka yang menghantar kod yang tidak diuji dan rapuh, menjadikannya topik yang kerap relevan dan penting secara profesional.