PHPUnit இனால் PHP குறியீட்டை எப்படி சோதனை செய்வது?

Question

Accepted Answer

**PHPUnit** என்பது PHP க்கான நிலையான சோதனை கட்டமைப்பு — குறியீடு சரியாக செயல்படுகிறதா என்பதை சரிபார்க்க unit மற்றும் integration சோதனைகளை எழுத பயன்படுகிறது. Dependency injection (மocking க்கான) மற்றும் data providers போன்ற கருவிகளுடன் சேர்ந்து, இது முழுமையான, பராமரிப்பக் که சாத்தியமான சோதனையை செயல்படுத்துகிறது.

## அடிப்படை சோதனை

```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` சோதனை பிழை பாதைகளைச் சோதிக்கிறது.

## Dependencies ஐ mocking செய்தல் (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) ஐ கட்டுப்பாட்டுக்குட்பட்ட fake களால் மாற்ற அனுமதிக்கிறது — மற்றும் dependency injection அவற்றைச் செயல்படுத்துவதை எளிமையாக்குகிறது. Mocks சரியாக அழைக்கப்படுகின்றன என்பதை நீங்கள் சரிபார்க்கலாம். இது வேகமான, தனிமைப்படுத்தப்பட்ட unit சோதனைகளின் அடிப்படை.

## 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 வெட்டங்களுக்கு எதிராக ஒரே சோதனையை இயக்குகின்றன — நகல் இல்லாமல் பல வழக்குகளின் சுத்தமான கவரேஜ்.

## சிறந்த நடைமுறைகள்

```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` ஐ நீட்டிப்பது, asserta களைப் பயன்படுத்துதல், exception பாதைகளைச் சோதனை செய்வது) அடிப்படையாகும், ஆனால் மிகவும் மதிப்புள்ள insight என்பது **dependency injection எப்படி சுத்தமான சோதனையை செயல்படுத்துகிறது**: நன்கு வடிவமைக்கப்பட்ட PHP வर्ग அவற்றின் dependencies ஐ பெறுவதால், PHPUnit ன் mocking உங்களை actual dependencies (தரவுத்தளங்கள், mailers, வெளிப்புற APIs) ஐ கட்டுப்பாட்டுக்குட்பட்ட fake களால் மாற்ற அனுமதிக்கிறது — உண்மையான உள்கட்டமைப்பு இல்லாமல் வேகமான, தனிமைப்படுத்தப்பட்ட unit சோதனைகளை செயல்படுத்த உதவுகிறது, மற்றும் நீங்கள் interactions ஐ சரிபார்க்க விடுகிறது (mock சரியாக அழைக்கப்பட்டதை உறுதிசெய்யுங்கள்).

DI மற்றும் testability க்கு இடையே உள்ள இந்த সংযोग்கம் dependency injection pattern ஏன் மிகவும் முக்கியமாக இருக்கிறது என்பதே.

Mocking, **data providers** (பல input வழக்குகளை திறமையாக சோதனை செய்வது), மற்றும் சோதனை சிறந்த நடைமுறைகள் (செயல்பாட்டு சோதனை அல்ல செயல்படுத்தல், வெளிப்புற dependencies ஐ mocking செய்வது, edge cases மற்றும் பிழை பாதைகளை கவரேஜ் செய்வது, integration சோதனைகளுக்கு சோதனை தரவுத்தளங்களைப் பயன்படுத்துவது) ஆகியவை பயனுள்ள PHP சோதனையின் நடைமுறை scope ஐ மூடுகின்றன.

நன்கு சோதிக்கப்பட்ட PHP regressions ஐ பிடிக்கிறது, நம்பிக்கையுடன் refactoring ஐ செயல்படுத்த உதவுகிறது, மற்றும் expected செயல்பாட்டை ஆவணப்படுத்துகிறது, மற்றும் நவீன frameworks (Laravel, Symfony) PHPUnit இல் அவற்றின் சோதனையை கட்டமைப்புவதால், அதை தெரிந்துகொள்வது விரிவாக பொருந்தக்கூடியதாகும்.

PHPUnit ஐ தெரிந்துகொள்வது — குறிப்பாக தனிமைப்படுத்தப்பட்ட சோதனைகளுக்கு mocking மற்றும் DI ஐ பயன்படுத்துவது — முக்கியமான senior-level அறிவு ஆகும், அது மजबूত, பராமரிப்பக்கூடிய, நன்கு சோதிக்கப்பட்ட பயன்பாடுகளை கட்டமைக்கும் developers ஐ சோதிக்கப்படாத, fragile குறியீடு அனுப்பும் நிறுவனங்களிலிருந்து வேறுபடுத்துகிறது, இது அடிக்கடி பொருந்தக்கூடிய, வல்லுநர் முக்கிய தலைப்பாகும்.