Hvordan tester du PHP-kode med PHPUnit?

Question

Accepted Answer

**PHPUnit** er standard test-framework for PHP — bruges til at skrive unit- og integration-tests, der verificerer, at kode opfører sig korrekt. Kombineret med dependency injection (til mocking) og værktøjer som data providers muliggør det grundig, vedligeholdelig testing.

## Et grundlæggende 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-klasser udvider `TestCase`, test-metoder starter med `test` (eller bruger `#[Test]` attributten), og bruger `assert*` metoder til at verificere forventninger (`assertEquals`, `assertTrue`, `assertCount`, osv.). `expectException` tester fejlsti.

## Mocking af afhængigheder (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');
}
```

PHPUnits mocking lader dig erstatte afhængigheder (mailers, repositories, APIs) med kontrollerbare fakes — og dependency injection gør det trivielt at injicere dem. Du kan verificere, at mocks bliver kaldt korrekt. Dette er grundlaget for hurtige, isolerede unit tests.

## Data providers (test mange tilfælde)

```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** kører det samme test mod mange input-sæt — ren dækning af flere tilfælde uden duplikering.

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

## Hvorfor det betyder noget

Testing er væsentlig for at bygge pålidelige, vedligeholdelige PHP-applikationer, og **PHPUnit** er standard-værktøjet — så det at forstå, hvordan man tester PHP, er vigtigt både for kodekvalitet og som professionel forventning.

At vide, hvordan man skriver tests (udvidelse af `TestCase`, brug af assertions, test af exception-stier) er fundamentalt, men den mest værdifulde indsigt er, hvordan **dependency injection muliggør ren testing**: fordi veldesignede PHP-klasser modtager deres afhængigheder, lader PHPUnits mocking dig erstatte rigtige afhængigheder (databaser, mailers, eksterne APIs) med kontrollerbare fakes — hvilket muliggør hurtige, isolerede unit tests uden rigtig infrastruktur, og lader dig verificere interaktioner (assert at en mock blev kaldt korrekt).

Denne forbindelse mellem DI og testability er præcis hvorfor dependency injection-mønsteret betyder så meget.

At forstå mocking, **data providers** (effektivt testing af mange input-tilfælde) og test best practices (test adfærd ikke implementering, mock eksterne afhængigheder, dæk edge cases og fejlsti, brug test-databaser til integration tests) dækker det praktiske omfang af effektiv PHP-testing.

Veltest PHP fanger regressioner, muliggør sikker refactoring og dokumenterer forventet adfærd, og eftersom moderne frameworks (Laravel, Symfony) bygger deres testing på PHPUnit, er det bredt applicable at kende den.

At mestre PHPUnit — især ved at udnytte mocking og DI til isolerede tests — er vigtig senior-level viden, der skelner udvikler, der bygger robuste, vedligeholdelige, veltest applikationer fra dem, der leverer utest, skrøbelig kode, hvilket gør det til et hyppigt relevant, professionelt vigtigt emne.