यूनिट परीक्षण लिखते समय, एक प्रमुख चुनौती यह सुनिश्चित करना है कि आपके परीक्षण बाहरी सिस्टम या निर्भरता के हस्तक्षेप के बिना परीक्षण के तहत कोड पर ध्यान केंद्रित करें। यह वह जगह है जहां नकली ऑब्जेक्ट PHPUnit में चलन में आते हैं। वे आपको नियंत्रित तरीके से वास्तविक वस्तुओं के व्यवहार का अनुकरण करने की अनुमति देते हैं, जिससे आपके परीक्षण अधिक विश्वसनीय और बनाए रखने में आसान हो जाते हैं। इस लेख में, हम पता लगाएंगे कि नकली वस्तुएं क्या हैं, वे उपयोगी क्यों हैं, और PHPUnit में उनका प्रभावी ढंग से उपयोग कैसे करें।

नकली वस्तुएँ क्या हैं?

मॉक ऑब्जेक्ट्स वास्तविक ऑब्जेक्ट्स के सिम्युलेटेड संस्करण हैं यूनिट परीक्षण में उपयोग किए जाते हैं। वे आपको इसकी अनुमति देते हैं:

• परीक्षण के तहत कोड को अलग करें: नकली वस्तुएं निर्भरता के व्यवहार का अनुकरण करती हैं, यह सुनिश्चित करती हैं कि परीक्षण के परिणाम उन निर्भरताओं के वास्तविक कार्यान्वयन से अप्रभावित हैं।
• निर्भरता व्यवहार को नियंत्रित करें: आप यह निर्दिष्ट कर सकते हैं कि कुछ विधियों को कॉल करने पर मॉक को कैसा व्यवहार करना चाहिए, जिससे आप विभिन्न परिदृश्यों का परीक्षण कर सकेंगे।
• इंटरैक्शन सत्यापित करें: विधि कॉल और उनके मापदंडों को ट्रैक करता है, यह सुनिश्चित करता है कि परीक्षण के तहत कोड अपनी निर्भरता के साथ सही ढंग से इंटरैक्ट करता है।

नकली वस्तुओं का उपयोग क्यों करें?

मॉक्स निम्नलिखित परिदृश्यों में विशेष रूप से उपयोगी होते हैं:

• जटिल निर्भरताएं: यदि आपका कोड डेटाबेस, एपीआई, या तृतीय-पक्ष सेवाओं जैसे बाहरी सिस्टम पर निर्भर करता है, तो मॉक ऑब्जेक्ट उन सिस्टम के साथ इंटरैक्ट करने की आवश्यकता को समाप्त करके परीक्षण को सरल बनाते हैं।
• इंटरेक्शन परीक्षण: मॉक आपको यह सत्यापित करने की अनुमति देता है कि विशिष्ट तरीकों को सही तर्कों के साथ बुलाया गया है, यह सुनिश्चित करते हुए कि आपका कोड अपेक्षित व्यवहार करता है।
• तेज परीक्षण निष्पादन: डेटाबेस क्वेरी या एपीआई अनुरोध जैसे वास्तविक दुनिया के संचालन परीक्षणों को धीमा कर सकते हैं। इन निर्भरताओं का मज़ाक उड़ाने से तेज़ परीक्षण निष्पादन सुनिश्चित होता है।

स्टबिंग बनाम मॉकिंग: क्या अंतर है?

नकली वस्तुओं के साथ काम करते समय, आपको दो शब्द मिलेंगे: स्टबिंग और मॉकिंग:

• स्टबिंग: एक मॉक ऑब्जेक्ट पर विधियों के व्यवहार को परिभाषित करने को संदर्भित करता है, उदाहरण के लिए, एक विशिष्ट मान वापस करने के लिए एक विधि को निर्देश देना।
• मॉकिंग: इसमें तरीकों को कैसे कॉल किया जाना चाहिए, इस पर अपेक्षाएं निर्धारित करना शामिल है, उदाहरण के लिए, विधि कॉल की संख्या और उनके मापदंडों को सत्यापित करना।

PHPUnit में मॉक ऑब्जेक्ट कैसे बनाएं और उपयोग करें

PHPUnit createMock() विधि के साथ नकली ऑब्जेक्ट बनाना और उपयोग करना आसान बनाता है। नीचे कुछ उदाहरण दिए गए हैं जो प्रदर्शित करते हैं कि नकली वस्तुओं के साथ प्रभावी ढंग से कैसे काम किया जाए।

उदाहरण 1: मूल नकली वस्तु उपयोग

इस उदाहरण में, हम एक वर्ग निर्भरता के लिए एक नकली वस्तु बनाते हैं और उसके व्यवहार को निर्दिष्ट करते हैं।

use PHPUnit\Framework\TestCase;

class MyTest extends TestCase
{
    public function testMockExample()
    {
        // Create a mock for the SomeClass dependency
        $mock = $this->createMock(SomeClass::class);

        // Specify that when the someMethod method is called, it returns 'mocked value'
        $mock->method('someMethod')
             ->willReturn('mocked value');

        // Pass the mock object to the class under test
        $unitUnderTest = new ClassUnderTest($mock);

        // Perform the action and assert that the result matches the expected value
        $result = $unitUnderTest->performAction();
        $this->assertEquals('expected result', $result);
    }
}

स्पष्टीकरण:

• createMock(SomeClass::class) SomClass के लिए एक मॉक ऑब्जेक्ट बनाता है।
• विधि('someMethod')->willReturn('नकली मूल्य') नकली के व्यवहार को परिभाषित करता है।
• मॉक ऑब्जेक्ट को परीक्षण की जा रही कक्षा में भेज दिया जाता है, यह सुनिश्चित करते हुए कि वास्तविक SomClass कार्यान्वयन का उपयोग नहीं किया जाता है।

उदाहरण 2: सत्यापन विधि कॉल

कभी-कभी, आपको यह सत्यापित करने की आवश्यकता होती है कि एक विधि को सही मापदंडों के साथ बुलाया गया है। यहां बताया गया है कि आप ऐसा कैसे कर सकते हैं:

public function testMethodCallVerification()
{
    // Create a mock object
    $mock = $this->createMock(SomeClass::class);

    // Expect the someMethod to be called once with 'expected argument'
    $mock->expects($this->once())
         ->method('someMethod')
         ->with($this->equalTo('expected argument'))
         ->willReturn('mocked value');

    // Pass the mock to the class under test
    $unitUnderTest = new ClassUnderTest($mock);

    // Perform an action that calls the mock's method
    $unitUnderTest->performAction();
}

प्रमुख बिंदु:

• अपेक्षा($this->ones()) यह सुनिश्चित करता है कि someMethod को बिल्कुल एक बार कॉल किया जाए।
• with($this->equalTo('अपेक्षित तर्क')) सत्यापित करता है कि विधि को सही तर्क के साथ बुलाया गया है।

उदाहरण: पेमेंटप्रोसेसर के साथ परीक्षण

नकली वस्तुओं के वास्तविक दुनिया के अनुप्रयोग को प्रदर्शित करने के लिए, आइए एक पेमेंटप्रोसेसर वर्ग का उदाहरण लें जो बाहरी पेमेंटगेटवे इंटरफ़ेस पर निर्भर करता है। हम पेमेंटगेटवे के वास्तविक कार्यान्वयन पर भरोसा किए बिना पेमेंटप्रोसेसर की प्रोसेसपेमेंट विधि का परीक्षण करना चाहते हैं।

यहां पेमेंटप्रोसेसर वर्ग है:

class PaymentProcessor
{
    private $gateway;

    public function __construct(PaymentGateway $gateway)
    {
        $this->gateway = $gateway;
    }

    public function processPayment(float $amount): bool
    {
        return $this->gateway->charge($amount);
    }
}

अब, हम वास्तविक भुगतान गेटवे के साथ इंटरैक्ट किए बिना प्रक्रिया भुगतान पद्धति का परीक्षण करने के लिए पेमेंटगेटवे के लिए एक मॉक बना सकते हैं।

मॉक ऑब्जेक्ट के साथ पेमेंटप्रोसेसर का परीक्षण

use PHPUnit\Framework\TestCase;

class PaymentProcessorTest extends TestCase
{
    public function testProcessPayment()
    {
        // Create a mock object for the PaymentGateway interface
        $gatewayMock = $this->createMock(PaymentGateway::class);

        // Define the expected behavior of the mock
        $gatewayMock->method('charge')
                    ->with(100.0)
                    ->willReturn(true);

        // Inject the mock into the PaymentProcessor
        $paymentProcessor = new PaymentProcessor($gatewayMock);

        // Assert that processPayment returns true
        $this->assertTrue($paymentProcessor->processPayment(100.0));
    }
}

परीक्षण का विवरण:

• createMock(PaymentGateway::class) PaymentGateway इंटरफ़ेस का अनुकरण करते हुए एक नकली ऑब्जेक्ट बनाता है।
• mode('charge')->with(100.0)->willReturn(true) निर्दिष्ट करता है कि जब चार्ज विधि को तर्क के रूप में 100.0 के साथ बुलाया जाता है, तो इसे true लौटना चाहिए।
• मॉक ऑब्जेक्ट को पेमेंटप्रोसेसर क्लास में भेज दिया जाता है, जिससे आप वास्तविक भुगतान गेटवे पर भरोसा किए बिना प्रोसेसपेमेंट का परीक्षण कर सकते हैं।

इंटरैक्शन सत्यापित करना

आप यह भी सत्यापित कर सकते हैं कि भुगतान संसाधित करते समय चार्ज विधि को ठीक एक बार कॉल किया गया है:

public function testProcessPaymentCallsCharge()
{
    $gatewayMock = $this->createMock(PaymentGateway::class);

    // Expect the charge method to be called once with the argument 100.0
    $gatewayMock->expects($this->once())
                ->method('charge')
                ->with(100.0)
                ->willReturn(true);

    $paymentProcessor = new PaymentProcessor($gatewayMock);
    $paymentProcessor->processPayment(100.0);
}

इस उदाहरण में, एक्सपेक्ट्स($this->ones()) यह सुनिश्चित करता है कि चार्ज विधि को ठीक एक बार कॉल किया जाए। यदि विधि को कॉल नहीं किया जाता है, या एक से अधिक बार कॉल किया जाता है, तो परीक्षण विफल हो जाएगा।

उदाहरण: रिपॉजिटरी के साथ परीक्षण

मान लें कि आपके पास एक UserService वर्ग है जो उपयोगकर्ता डेटा लाने के लिए UserRepository पर निर्भर करता है। UserService को अलग से परखने के लिए, आप UserRepository का नकल कर सकते हैं।

class UserService
{
    private $repository;

    public function __construct(UserRepository $repository)
    {
        $this->repository = $repository;
    }

    public function getUserName($id)
    {
        $user = $this->repository->find($id);
        return $user->name;
    }
}

इस वर्ग का परीक्षण करने के लिए, हम भंडार का नकल कर सकते हैं:

use PHPUnit\Framework\TestCase;

class UserServiceTest extends TestCase
{
    public function testGetUserName()
    {
        // Create a mock for the UserRepository
        $mockRepo = $this->createMock(UserRepository::class);

        // Define that the find method should return a user object with a predefined name
        $mockRepo->method('find')
                 ->willReturn((object) ['name' => 'John Doe']);

        // Instantiate the UserService with the mock repository
        $service = new UserService($mockRepo);

        // Assert that the getUserName method returns 'John Doe'
        $this->assertEquals('John Doe', $service->getUserName(1));
    }
}

मोक्स का उपयोग करने के लिए सर्वोत्तम अभ्यास

1. मॉक्स का उपयोग केवल तभी करें जब आवश्यक हो: मॉक कोड को अलग करने के लिए उपयोगी होते हैं, लेकिन अत्यधिक उपयोग से परीक्षणों को समझना मुश्किल हो सकता है। केवल नकली निर्भरताएँ जो परीक्षण के लिए आवश्यक हैं।
2. व्यवहार पर ध्यान दें, कार्यान्वयन पर नहीं: मॉक को आपके कोड के व्यवहार का परीक्षण करने में मदद करनी चाहिए, न कि निर्भरता के विशिष्ट कार्यान्वयन विवरण पर।
3. बहुत अधिक निर्भरताओं का मजाक उड़ाने से बचें: यदि किसी वर्ग को कई नकली निर्भरताओं की आवश्यकता होती है, तो यह एक संकेत हो सकता है कि वर्ग के पास बहुत अधिक जिम्मेदारियां हैं। यदि आवश्यक हो तो रिफैक्टर।
4. इंटरैक्शन को संयम से सत्यापित करें: जब तक परीक्षण के लिए आवश्यक न हो, विधि कॉल को अधिक सत्यापित करने से बचें।

निष्कर्ष

PHPUnit में यूनिट परीक्षण लिखने के लिए मॉक ऑब्जेक्ट अमूल्य उपकरण हैं। वे आपको अपने कोड को बाहरी निर्भरता से अलग करने की अनुमति देते हैं, जिससे यह सुनिश्चित होता है कि आपके परीक्षण तेज़, अधिक विश्वसनीय और बनाए रखने में आसान हैं। मॉक ऑब्जेक्ट परीक्षण के तहत कोड और उसकी निर्भरता के बीच इंटरैक्शन को सत्यापित करने में भी मदद करते हैं, यह सुनिश्चित करते हुए कि आपका कोड विभिन्न परिदृश्यों में सही ढंग से व्यवहार करता है