Hvordan tester du PHP-kode med PHPUnit?

Question

Accepted Answer

**PHPUnit** er standardtestframeworket for PHP — brukt til å skrive enhets- og integrasjonstester som verifiserer at kode oppfører seg korrekt. Kombinert med avhengighetsinjeksjon (for mocking) og verktøy som dataprovidera, gjør det muligheten for grundig, vedlikeholdbar testing.

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

Testklasser utvider `TestCase`, testmetoder starter med `test` (eller bruker `#[Test]`-attributten), og bruker `assert*`-metoder for å verifisere forventninger (`assertEquals`, `assertTrue`, `assertCount`, osv.). `expectException` tester feilveier.

## Mocking av avhengigheter (isolasjon 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 lar deg erstatte avhengigheter (mailere, repositorier, APIer) med kontrollerable falske objekter — og avhengighetsinjeksjon gjør det trivielt å injisere dem. Du kan hevde at mock-objekt kalles korrekt. Dette er grunnlaget for raske, isolerte enhetstester.

## Dataprovidera (test mange tilfeller)

```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));
}
```

**Dataprovidera** kjører samme test mot mange inputsett — ryddig dekning av flere tilfeller uten duplisering.

## Beste praksis

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

Testing er essensielt for å bygge pålitelige, vedlikeholdbare PHP-applikasjoner, og **PHPUnit** er standardverktøyet — så det er viktig å forstå hvordan man tester PHP både for kodekvalitet og som profesjonell forventning.

Å vite hvordan man skriver tester (utvide `TestCase`, bruke assertions, teste unntak) er grunnleggende, men den mest verdifulle innsikten er hvordan **avhengighetsinjeksjon muliggjør ren testing**: fordi velbygde PHP-klasser mottar sine avhengigheter, lar PHPUnits mocking deg erstatte virkelige avhengigheter (databaser, mailere, eksterne APIer) med kontrollerable falske objekter — noe som muliggjør raske, isolerte enhetstester uten virkelig infrastruktur, og lar deg verifisere interaksjoner (påstå at en mock ble kalt korrekt).

Denne forbindelsen mellom DI og testbarhet er nettopp hvorfor avhengighetsinjeksjonsmønsteret betyr så mye.

Å forstå mocking, **dataprovidera** (effektiv testing av mange inputtilfeller), og testingsbeste praksis (teste atferd ikke implementering, mocke eksterne avhengigheter, dekke grensentilfeller og feilveier, bruke testdatabaser for integrasjonstester) dekker det praktiske omfanget av effektiv PHP-testing.

Godtestet PHP avdekker regresjoner, muliggjør selvsikker refaktoring, og dokumenterer forventet atferd, og siden moderne rammeverk (Laravel, Symfony) bygger testing på PHPUnit, er det viktig å kjenne til det.

Å mestre PHPUnit — spesielt ved å utnytte mocking og DI for isolerte tester — er viktig kunnskap på seniornivå som skiller utviklere som bygger robuste, vedlikeholdbare, godt testede applikasjoner fra de som leverer utestet, skjør kode, noe som gjør det til et hyppig relevant, profesjonelt viktig emne.