आप PHPUnit के साथ PHP कोड का test कैसे करते हैं?

Question

Accepted Answer

**PHPUnit** PHP के लिए मानक testing framework है — जिसका उपयोग unit और integration tests लिखने के लिए किया जाता है जो सत्यापित करते हैं कि कोड सही ढंग से व्यवहार करता है। dependency injection (mocking के लिए) और data providers जैसे tools के साथ मिलकर, यह संपूर्ण, maintainable testing को सक्षम करता है।

## एक basic 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 classes `TestCase` को extend करती हैं, test methods `test` से शुरू होते हैं (या `#[Test]` attribute का उपयोग करते हैं), और expectations को सत्यापित करने के लिए `assert*` methods का उपयोग करते हैं (`assertEquals`, `assertTrue`, `assertCount`, आदि)। `expectException` error paths को test करता है।

## Dependencies को mock करना (DI के माध्यम से isolation)

```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 की mocking आपको dependencies (mailers, repositories, APIs) को नियंत्रित करने योग्य fakes से बदलने देती है — और dependency injection उन्हें inject करना तुच्छ बनाता है। आप यह assert कर सकते हैं कि mocks सही ढंग से call किए जाते हैं। यह तेज, isolated unit tests का आधार है।

## Data providers (कई cases test करना)

```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** एक ही test को कई input sets के विरुद्ध चलाते हैं — duplication के बिना कई cases का स्वच्छ coverage।

## सर्वोत्तम प्रथाएं

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

## यह क्यों महत्वपूर्ण है

Testing विश्वसनीय, maintainable PHP applications बनाने के लिए आवश्यक है, और **PHPUnit** मानक tool है — इसलिए PHP को test करना कैसे है यह समझना code quality और एक professional अपेक्षा, दोनों के लिए महत्वपूर्ण है।

Tests लिखना कैसे है यह जानना (`TestCase` को extend करना, assertions का उपयोग करना, exception paths को test करना) मौलिक है, लेकिन सबसे मूल्यवान अंतर्दृष्टि यह है कि **dependency injection स्वच्छ testing को कैसे सक्षम करता है**: चूंकि अच्छी तरह डिज़ाइन की गई PHP classes अपनी dependencies प्राप्त करती हैं, PHPUnit की mocking आपको वास्तविक dependencies (databases, mailers, external APIs) को नियंत्रित करने योग्य fakes से बदलने देती है — वास्तविक infrastructure के बिना तेज, isolated unit tests को सक्षम करते हुए, और आपको interactions सत्यापित करने देते हुए (यह assert करना कि एक mock सही ढंग से call किया गया था)।

DI और testability के बीच यह संबंध ठीक वही कारण है कि dependency injection pattern इतना मायने रखता है।

Mocking, **data providers** (कई input cases को कुशलता से test करना), और testing सर्वोत्तम प्रथाओं (implementation नहीं बल्कि behavior को test करना, external dependencies को mock करना, edge cases और error paths को cover करना, integration tests के लिए test databases का उपयोग करना) को समझना प्रभावी PHP testing के व्यावहारिक दायरे को कवर करता है।

अच्छी तरह से tested PHP regressions को पकड़ता है, आत्मविश्वासपूर्ण refactoring को सक्षम करता है, और अपेक्षित behavior को document करता है, और चूंकि आधुनिक frameworks (Laravel, Symfony) अपना testing PHPUnit पर बनाते हैं, इसे जानना व्यापक रूप से लागू होता है।

PHPUnit में महारत हासिल करना — विशेष रूप से isolated tests के लिए mocking और DI का लाभ उठाना — महत्वपूर्ण senior-level ज्ञान है जो उन डेवलपर्स को अलग करता है जो robust, maintainable, well-tested applications बनाते हैं उनसे जो untested, fragile कोड ship करते हैं, जो इसे एक बार-बार प्रासंगिक, professionally-महत्वपूर्ण विषय बनाता है।