როგორ აწერთ PHP კოდის ტესტებს PHPUnit-ით?

Question

Accepted Answer

**PHPUnit** არის PHP-ის სტანდარტული ტესტირების ფреიმვორკი — გამოიყენება ერთეულის და ინტეგრაციის ტესტების დასაწერად, რომლებიც ადასტურებენ, რომ კოდი სწორად მუშაობს. დამოკიდებულებების ინჯექციასთან (მოკირებისთვის) და ისეთი ინსტრუმენტებთან, როგორებიცაა მონაცემთა მომწოდებელი, ის შესაძლებელს ხდის საფუძველიანი, მდგრადი ტესტირებას.

## ძირითადი ტესტი

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

ტესტის კლასები ვრცელდებიან `TestCase`-მდე, ტესტის მეთოდები იწყება `test`-ით (ან იყენებენ `#[Test]` ატრიბუტს), და იყენებენ `assert*` მეთოდებს მოლოდინის გადამოწმებისთვის (`assertEquals`, `assertTrue`, `assertCount` და ა.შ.). `expectException` ტესტავს შეცდომის ბილიკებს.

## მოკირების დამოკიდებულებები (იზოლაცია დაკი-ს მეშვეობით)

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

PHPUnit-ის მოკირება საშუალებას გაძლევთ შეცვალოთ დამოკიდებულებები (მეილერი, რეპოზიტორიუმი, API-ები) კონტროლირებადი ძალმოსილებით — და დამოკიდებულებების ინჯექცია ამას უბრალოს ხდის. შეგიძლიათ დაადასტუროთ, რომ მოკები სწორად არის გამოძახებული. ეს არის სწრაფი, იზოლირებული ერთეულის ტესტების საფუძველი.

## მონაცემთა მომწოდებელი (მრავალი შემთხვევის ტესტირება)

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

**მონაცემთა მომწოდებელი** აკვეთს იმავე ტესტს დამოკიდებულების მრავალი სიმრავლის დროს — სხვადსხვა შემთხვევის სუფთა დაფარვა დუბლირების გარეშე.

## საუკეთესო პრაქტიკა

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

## რატომ აქვს ეს მნიშვნელობა

ტესტირება აუცილებელია სანდო, მდგრადი PHP აპლიკაციების აგებისთვის, და **PHPUnit** არის სტანდარტული ინსტრუმენტი — ამიტომ იმის ცოდნა, თუ როგორ ტესტი PHP არის მნიშვნელოვანი კოდის ხარისხის და პროფესიონალური მოლოდინის თვალსაზრისით.

იმის ცოდნა, თუ როგორ დავწეროთ ტესტები (`TestCase`-ის გაფართოება, ადასტურებების გამოყენება, შეცდომის ბილიკების ტესტირება) ფუნდამენტურია, მაგრამ ყველაზე მূშელი შინაარსი იმაში არის, თუ როგორ **დამოკიდებულებების ინჯექცია ხსნის სუფთა ტესტირებას**: რადგან კარგად დაპროექტებული PHP კლასები იღებენ მათ დამოკიდებულებებს, PHPUnit-ის მოკირება საშუალებას გაძლევთ შეცვალოთ რეალური დამოკიდებულებები (მონაცემთა ბაზა, მეილერი, გარე API-ები) კონტროლირებადი ძალმოსილებით — რეალური ინფრასტრუქტურის გარეშე სწრაფი, იზოლირებული ერთეულის ტესტების ჩატარება, და ურთიერთქმედების გადამოწმება (იმის დადასტურება, რომ მოკი სწორად იყო გამოძახებული).

ეს კავშირი დაკი-სა და ტესტირებადობას შორის ზუსტად ის იმის, რატომ აქვს დამოკიდებულებების ინჯექციის ნიმუშს ისეთი დიდი მნიშვნელობა.

mocking-ის, **მონაცემთა მომწოდებლების** (მრავალი შემოწირვის შემთხვევის ეფექტური ტესტირება) და ტესტირების საუკეთესო პრაქტიკის (ქცევის, ვითარცემის მეუცნობისი არ იყოს ტესტი, გარე დამოკიდებულების მოკირება, კიდეების და შეცდომის ბილიკების დაფარვა, ინტეგრაციის ტესტებისთვის ტესტის მონაცემთა ბაზის გამოყენება) გაცნობა საკმარისია ეფექტური PHP ტესტირების პრაქტიკული ახლანდელი მდგომარეობის დასაფარავად.

კარგად-ტესტირებული PHP აჭერს რეგრესიებს, აპირებს თავისუფალ რეფაქტორებას, და დოკუმენტაციის მოლოდინის ქცევას, და რადგან თანამედროვე ფრეიმვორკები (Laravel, Symfony) აშენებენ მათ ტესტირებას PHPUnit-ის საფუძველზე, მისი ცოდნა ფართოდ გამოქვემდებარა.

PHPUnit-ის დაუფლება — განსაკუთრებით mocking-ისა და დაკი-ს გამოსაყენებლად იზოლირებული ტესტებისთვის — მნიშვნელოვანი უფროსი დონის ცოდნა, რომელიც განასხვავებს დეველოპერებს, რომლებიც აშენებენ მედგრად, მდგრადი, კარგად-ტესტირებული აპლიკაციებს მათ, რომლებიც აკითხავენ არატესტირებულ, კრთამელ კოდს, რაც მას ხშირად-აქტუალურ, პროფესიონალურად-მნიშვნელოვან თემაში აქცევს.