ਤੁਸ PHPUnit ਨਾਲ PHP ਕੋਡ ਨੂੰ ਕਿਵੇਂ ਟੈਸਟ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

**PHPUnit** PHP ਲਈ ਸਟੈਂਡਰਡ ਟੈਸਟਿੰਗ ਫ੍ਰੇਮਵਰਕ ਹੈ — ਇਸ ਨੂੰ ਯੂਨਿਟ ਅਤੇ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਟੈਸਟ ਲਿਖਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਕੋਡ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰੇ। Dependency injection (mocking ਲਈ) ਅਤੇ data providers ਵਰਗੀਆਂ tools ਦੇ ਨਾਲ ਮਿਲ ਕੇ, ਇਹ ਪੂਰਨ, ਰਖਰਖਾਅ ਯੋਗ ਟੈਸਟਿੰਗ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ।

## ਇੱਕ ਬੁਨਿਆਦੀ ਟੈਸਟ

```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` ਨੂੰ extend ਕਰਦੀਆਂ ਹਨ, ਟੈਸਟ ਮੈਥਡ `test` ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀਆਂ ਹਨ (ਜਾਂ `#[Test]` ਐਟ੍ਰਿਬਿਊਟ ਵਰਤਦੀਆਂ ਹਨ), ਅਤੇ期待 ਨੂੰ verify ਕਰਨ ਲਈ `assert*` ਮੈਥਡ ਵਰਤਦੀਆਂ ਹਨ (`assertEquals`, `assertTrue`, `assertCount`, ਆਦਿ)। `expectException` ਗਲਤੀ ਦੇ ਰਸਤਿਆਂ ਨੂੰ ਟੈਸਟ ਕਰਦਾ ਹੈ।

## Dependencies ਨੂੰ Mock ਕਰਨਾ (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');
}
```

PHPUnit ਦੀ mocking ਤੁਹਾਨੂੰ dependencies (mailers, repositories, APIs) ਨੂੰ ਕਨਟਰੋਲ ਕਰਨ ਯੋਗ fakes ਨਾਲ ਬਦਲਣ ਦਿੰਦੀ ਹੈ — ਅਤੇ dependency injection ਉਨ੍ਹਾਂ ਨੂੰ inject ਕਰਨਾ ਅਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਤੁਸ assert ਕਰ ਸਕਦੇ ਹੋ ਕਿ mocks ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕਾਲ ਕੀਤੇ ਗਏ ਹਨ। ਇਹ ਤੇਜ਼, ਅਲਗਥਲਗ ਯੂਨਿਟ ਟੈਸਟ ਦੀ ਨਿਵੇੜ ਹੈ।

## Data providers (ਬਹੁਤ ਸਾਰੇ ਕੇਸ ਟੈਸਟ ਕਰੋ)

```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** ਉਹੀ ਟੈਸਟ ਨੂੰ ਬਹੁਤ ਸਾਰੇ input sets ਦੇ ਵਿਰੁੱਧ ਚਲਾਉਂਦੇ ਹਨ — duplication ਤੋਂ ਬਿਨਾਂ ਕਈ ਕੇਸ ਦਾ ਸਾਫ਼ 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 ਭਰੋਸੇਮੰਦ, ਰਖਰਖਾਅ ਯੋਗ PHP ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ **PHPUnit** ਸਟੈਂਡਰਡ tool ਹੈ — ਇਸ ਲਈ PHP ਨੂੰ ਟੈਸਟ ਕਰਨ ਦਾ ਤਰੀਕਾ ਜਾਨਣਾ ਕੋਡ ਦੀ ਗੁਣਵੱਤਾ ਅਤੇ ਪੇਸ਼ਾਵਰ ਉਮੀਦ ਦੋਵਾਂ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

ਟੈਸਟ ਲਿਖਣਾ ਜਾਨਣਾ (`TestCase` ਨੂੰ extend ਕਰਦੇ ਹੋਏ, assertions ਵਰਤਦੇ ਹੋਏ, exception ਦੀਆਂ ਪਾਥ ਨੂੰ ਟੈਸਟ ਕਰਦੇ ਹੋਏ) ਬੁਨਿਆਦੀ ਹੈ, ਪਰ ਸਭ ਤੋਂ ਮੂਲਵਾਨ insight ਇਹ ਹੈ ਕਿ **dependency injection ਸਾਫ਼ testing ਨੂੰ ਕਿਵੇਂ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ**: ਕਿਉਂਕਿ ਚੰਗੀ ਤਰਾਂ ਤੋਂ ਡਿਜ਼ਾਈਨ ਕੀਤੀਆਂ PHP classes ਆਪਣੀਆਂ dependencies ਲੈਂਦੀਆਂ ਹਨ, PHPUnit ਦੀ mocking ਤੁਹਾਨੂੰ ਰਿਆਲ dependencies (databases, mailers, external APIs) ਨੂੰ ਕਨਟਰੋਲ ਕਰਨ ਯੋਗ fakes ਨਾਲ ਬਦਲਣ ਦਿੰਦੀ ਹੈ — ਅਸਲ infrastructure ਤੋਂ ਬਿਨਾਂ ਤੇਜ਼, ਅਲਗਥਲਗ ਯੂਨਿਟ ਟੈਸਟ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ interactions ਨੂੰ verify ਕਰਨ ਦਿੰਦਾ ਹੈ (assert ਕਰਦੇ ਹੋਏ ਇੱਕ mock ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕਾਲ ਕੀਤਾ ਗਿਆ)।

DI ਅਤੇ testability ਦਰਮਿਆਨ ਇਹ ਸਬੰਧ ਬਿਲਕੁਲ ਉਸੇ ਕਾਰਨ ਹੈ ਕਿ dependency injection pattern ਇੰਨਾ ਬਹੁਤ ਮਾਇਨਾ ਰੱਖਦਾ ਹੈ।

Mocking, **data providers** (ਕੁਸ਼ਲਤਾ ਨਾਲ ਬਹੁਤ ਸਾਰੇ input ਕੇਸ ਨੂੰ ਟੈਸਟ ਕਰਨਾ), ਅਤੇ testing ਦੀਆਂ ਸਰਵੋਤਮ practices (implementation ਤੇ ਨਹੀਂ behavior ਟੈਸਟ ਕਰਨਾ, external dependencies ਨੂੰ mock ਕਰਨਾ, edge cases ਅਤੇ error ਪਾਥ ਨੂੰ cover ਕਰਨਾ, integration ਟੈਸਟ ਲਈ test databases ਵਰਤਨਾ) ਨੂੰ ਸਮਝਣਾ ਕਾਰਜਸ਼ੀਲ ਖੇਤਰ ਦਾ ਸਬੰਧ ਰੱਖਦਾ ਹੈ।

ਚੰਗੀ ਤਰਾਂ ਨਾਲ ਟੈਸਟ ਕੀਤਾ PHP regressions ਨੂੰ ਪਕੜਦਾ ਹੈ, confident refactoring ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ, ਅਤੇ ਉਮੀਦ ਕੀ behavior ਨੂੰ document ਕਰਦਾ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ ਮਾਡਰਨ frameworks (Laravel, Symfony) PHPUnit ਉੱਤੇ ਆਪਣੀ testing ਨੂੰ ਬਣਾਉਂਦੇ ਹਨ, ਇਸ ਨੂੰ ਜਾਨਣਾ ਵਿਆਪਕ ਤੌਰ ਤੇ ਲਾਗੂ ਹੈ।

PHPUnit ਨੂੰ ਮਾਸਟਰ ਕਰਨਾ — ਖਾਸ ਕਰ ਕੇ isolated tests ਲਈ mocking ਅਤੇ DI ਨੂੰ ਲਾਭ ਉਠਾਉਂਦੇ ਹੋਏ — ਮਹੱਤਵਪੂਰਨ senior-level ਗਿਆਨ ਹੈ ਜੋ ਉਹਨਾਂ developers ਨੂੰ ਵੱਖਰਾ ਕਰਦਾ ਹੈ ਜੋ robust, maintainable, well-tested applications ਬਣਾਉਂਦੇ ਹਨ ਉਹਨਾਂ ਤੋਂ ਜੋ untested, fragile ਕੋਡ ਭੇਜਦੇ ਹਨ, ਇਸ ਨੂੰ ਬਾਰ-ਬਾਰ relevant, professionally-important ਵਿਸ਼ਾ ਬਣਾਉਂਦੇ ਹੋਏ।