Hur testar man PHP-kod med PHPUnit?

Question

Accepted Answer

**PHPUnit** är standardtestningsramverket för PHP — används för att skriva enhets- och integrationstester som verifierar att kod fungerar korrekt. Kombinerat med beroendeinjektion (för mocking) och verktyg som dataproviders möjliggör det grundlig, underhållbar testning.

## Ett grundläggande 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 ärver från `TestCase`, testmetoder börjar med `test` (eller använder attributet `#[Test]`), och använder `assert*`-metoder för att verifiera förväntningar (`assertEquals`, `assertTrue`, `assertCount`, osv.). `expectException` testar felhanteringsvägar.

## Mocking av beroenden (isolering 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 låter dig ersätta beroenden (mailare, repositories, API:er) med kontrollerbar falska instanser — och beroendeinjektion gör det enkelt att injicera dem. Du kan verifiera att mockar anropas korrekt. Detta är grunden för snabba, isolerade enhetstester.

## Dataproviders (testa många fall)

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

**Dataproviders** kör samma test mot många uppsättningar indata — ren täckning av flera fall utan duplicering.

## Bästa praxis

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

## Varför det är viktigt

Testning är avgörande för att bygga pålitliga, underhållbara PHP-applikationer, och **PHPUnit** är standardverktyget — så att förstå hur man testar PHP är viktigt både för kodkvalitet och som yrkesmässig förväntning.

Att kunna skriva tester (ärva från `TestCase`, använda assertions, testa exceptionvägar) är grundläggande, men den viktigaste insikten är hur **beroendeinjektion möjliggör ren testning**: eftersom väl designade PHP-klasser tar emot sina beroenden kan PHPUnits mocking ersätta riktiga beroenden (databaser, mailare, externa API:er) med kontrollerbar falska instanser — möjliggörande snabba, isolerade enhetstester utan verklig infrastruktur, och låta dig verifiera interaktioner (verifiera att en mock anropades korrekt).

Denna koppling mellan DI och testbarhet är exakt varför beroendeinjektionsmönstret är så viktigt.

Att förstå mocking, **dataproviders** (effektivt testa många inmatningsfall), och testning best practices (testa beteende inte implementering, mocka externa beroenden, täcka gränsfall och felvägar, använd testdatabaser för integrationstester) täcker det praktiska omfånget för effektiv PHP-testning.

Väl testad PHP fångar regressioner, möjliggör säker refaktorering, och dokumenterar förväntat beteende, och eftersom moderna ramverk (Laravel, Symfony) bygger sin testning på PHPUnit är kunskap om det brett tillämpbart.

Att bemästra PHPUnit — särskilt genom att utnyttja mocking och DI för isolerade tester — är viktig kunskap på seniornivå som skiljer utvecklare som bygger robusta, underhållbara, väl testade applikationer från de som levererar otestade, skör kod, vilket gör det till ett ofta relevant, yrkesmässigt viktigt ämne.