Si e testoni kodin PHP me PHPUnit?

Question

Accepted Answer

**PHPUnit** është framework-u standard për testim në PHP — përdoret për të shkruar teste unitare dhe teste integrimi që verifikojnë se kodi sillet siç duhet. Kombinuar me dependency injection (për mocking) dhe mjete si data providers, ai mundëson testim të plotë dhe të lehtë në mirëmbajtje.

## Një test bazë

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

Klasat e testit zgjerohen `TestCase`, metodat e testit fillojnë me `test` (ose përdorin atributin `#[Test]`), dhe përdorin metoda `assert*` për të verifikuar pritshmëritë (`assertEquals`, `assertTrue`, `assertCount`, etj.). `expectException` teston rrugët e gabimit.

## Mocking i varësive (izolim përmes 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 i PHPUnit-it ju lejon të zëvendësoni varësitë (dërguesit, depozitët, API-et) me falsifikime të kontrollueshme — dhe dependency injection e bën të parëndësishme injektimin e tyre. Mund të pohoni se mock-et thirren siç duhet. Kjo është themeli i testeve të shpejta dhe të izoluara.

## Data providers (testoni shumë raste)

```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** ekzekutojnë të njëjtin test kundër shumë grupeve të inputit — mbulim i pastër i shumë rasteve pa përsëritje.

## Praktika më të mira

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

## Pse ka rëndësi

Testimi është thelbësor për ndërtimin e aplikacioneve PHP të besueshme dhe të lehtë në mirëmbajtje, dhe **PHPUnit** është mjeti standard — prandaj të kuptosh se si të testosh PHP është i rëndësishëm si për cilësinë e kodit ashtu edhe si pritshmëri profesionale.

Të dish të shkruaj teste (zgjerimin e `TestCase`, përdorimin e assertion-eve, testimin e rrugëve të përjashtimit) është themelor, por njohja më e vlefshme është se si **dependency injection mundëson testim të pastër**: sepse klasat PHP të dizajnuara mirë marrin varësitë e tyre, mocking-u i PHPUnit-it ju lejon të zëvendësoni varësitë reale (bazat e të dhënave, dërguesit, API-et e jashtme) me falsifikime të kontrollueshme — mundësojnë teste të shpejta dhe të izoluara pa infrastrukturë reale, dhe ju lejojnë të verifikoni ndërveprimet (pohojnë se një mock-u është thirrur siç duhet).

Kjo lidhje midis DI dhe testability-t është saktësisht arsyeja pse modeli i dependency injection ka kaq shumë rëndësi.

Të kuptosh mocking-un, **data providers** (testimi efikas i shumë rasteve të inputit), dhe praktikën më të mirë të testimit (testimi i sjelljes jo i implementimit, mocking-u i varësive të jashtme, mbulimi i rasteve skare dhe rrugëve të gabimit, përdorimi i bazave të të dhënave të testimit për teste integrimi) mbulojnë gamën praktike të testimit efikas të PHP-it.

PHP i testuar mirë kap regresionet, mundëson refactorim me besim, dhe dokumenton sjelljen e pritur, dhe meqenëse framework-et moderne (Laravel, Symfony) ndërtojnë testimin e tyre mbi PHPUnit, ta dijsh atë është gjerësisht i aplikueshëm.

Mastering PHPUnit — veçanërisht përdorimi i mocking-ut dhe DI për teste të izoluara — është njohje e rëndësishme në nivel të lartë që dallon zhvilluesit që ndërtojnë aplikacione të fuqishme, të lehtë në mirëmbajtje dhe të mirë të testuara nga ata që dërgojnë kod të netestuar dhe të brishtë, duke e bërë atë një temë të shpeshtë dhe profesionalisht të rëndësishme.