जावा में परीक्षण: प्रमुख अवधारणाएँ [भाग 1: इकाई परीक्षण]

सॉफ़्टवेयर विकास में यूनिट परीक्षण एक मौलिक अभ्यास है जो आपके कोड की विश्वसनीयता और शुद्धता सुनिश्चित करता है। इस लेख में, हम जावा यूनिट परीक्षण की प्रमुख अवधारणाओं का पता लगाएंगे, जिसमें सरल कोड उदाहरण, पैरामीट्रिजेशन, अपवाद परीक्षण, @Before , @BeforeEach , @After , और @AfterEach जैसे एनोटेशन, साथ ही मॉक और स्टब्स का उपयोग शामिल है। .

हम मॉकिंग के लिए लोकप्रिय मॉकिटो लाइब्रेरी भी पेश करेंगे और मेवेन प्लगइन्स का उपयोग करके कोड कवरेज को मापने पर मार्गदर्शन प्रदान करेंगे।

इकाई परीक्षण का महत्व

यूनिट परीक्षण उनकी शुद्धता को सत्यापित करने के लिए व्यक्तिगत घटकों या कोड की इकाइयों को अलग-अलग परीक्षण करने का अभ्यास है। प्राथमिक लक्ष्य विकास प्रक्रिया की शुरुआत में ही बग का पता लगाना और उन्हें ठीक करना है, यह सुनिश्चित करते हुए कि कोड की प्रत्येक इकाई अपेक्षा के अनुरूप व्यवहार करती है।

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

 public class Calculator { public int add(int a, int b) { return a + b; } public int subtract(int a, int b) { return a - b; } public int multiply(int a, int b) { return a * b; } public int divide(int a, int b) { return a / b; } }

एक सरल इकाई परीक्षण लिखना

हमारे Calculator वर्ग के लिए एक यूनिट टेस्ट बनाने के लिए, आप JUnit फ्रेमवर्क का उपयोग कर सकते हैं, जो जावा के लिए एक लोकप्रिय परीक्षण फ्रेमवर्क है। आइए add विधि के लिए एक सरल इकाई परीक्षण लिखें:

 import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { @Test public void testAdd() { Calculator calculator = new Calculator(); int result = calculator.add(2, 3); assertEquals(5, result); } }

इस परीक्षण में, हम आवश्यक JUnit कक्षाओं को आयात करते हैं और @Test के साथ परीक्षण विधि को एनोटेट करते हैं। फिर हम Calculator वर्ग का एक उदाहरण बनाते हैं और दावा करते हैं कि add विधि का परिणाम अपेक्षित मूल्य (5) के बराबर है।

पैरामीटरयुक्त परीक्षण

पैरामीटरयुक्त परीक्षण आपको इनपुट डेटा के कई सेटों के साथ एक ही परीक्षण तर्क चलाने की अनुमति देते हैं। यह विभिन्न इनपुट मानों के साथ किसी विधि का परीक्षण करने के लिए उपयोगी है। JUnit में ऐसा करने के लिए, आप @ParameterizedTest एनोटेशन का उपयोग कर सकते हैं और पैरामीटर के रूप में इनपुट मान और अपेक्षित परिणाम प्रदान कर सकते हैं। यहाँ एक उदाहरण है:

 import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.CsvSource; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { @ParameterizedTest @CsvSource({"2, 3, 5", "4, 7, 11", "0, 0, 0"}) public void testAdd(int a, int b, int expected) { Calculator calculator = new Calculator(); int result = calculator.add(a, b); assertEquals(expected, result); } }

इस उदाहरण में, @ParameterizedTest एनोटेशन हमें CSV प्रारूप में इनपुट मानों और अपेक्षित परिणामों के कई सेट प्रदान करने की अनुमति देता है। add विधि की शुद्धता सुनिश्चित करते हुए, प्रत्येक संयोजन के लिए परीक्षण विधि निष्पादित की जाती है।

अपवाद परीक्षण

यह सुनिश्चित करने के लिए कि आपका कोड त्रुटियों को उचित रूप से संभालता है, अपवादों का परीक्षण करना महत्वपूर्ण है। अपवाद मामलों का परीक्षण करने के लिए, आप JUnit द्वारा प्रदान की गई assertThrows विधि के साथ @Test एनोटेशन का उपयोग कर सकते हैं।

यहाँ एक उदाहरण है:

 javaCopy codeimport org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertThrows; public class CalculatorTest { @Test public void testDivideByZero() { Calculator calculator = new Calculator(); assertThrows(ArithmeticException.class, () -> calculator.divide(5, 0)); } }

इस परीक्षण में, हम सत्यापित करते हैं कि Calculator वर्ग में किसी संख्या को शून्य से विभाजित करने पर एक ArithmeticException उत्पन्न होता है।

एनोटेशन का उपयोग करना: @पहले, @पहलेप्रत्येक, @बाद में, और @प्रत्येक के बाद

@Before , @BeforeEach , @After , और @AfterEach जैसे एनोटेशन का उपयोग परीक्षण वातावरण को सेट करने और ख़त्म करने के लिए किया जाता है। ये एनोटेशन सामान्य परीक्षण आरंभीकरण और सफ़ाई कार्यों को प्रबंधित करने में मदद करते हैं।

• @Before और @After क्रमशः परीक्षण वर्ग में सभी परीक्षण विधियों से पहले और बाद में एक बार चलते हैं।
• @BeforeEach और @AfterEach प्रत्येक परीक्षण विधि से पहले और बाद में चलते हैं।

यहाँ एक उदाहरण है:

 import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; public class CalculatorTest { private Calculator calculator; @BeforeEach public void setUp() { calculator = new Calculator(); } @AfterEach public void tearDown() { calculator = null; } @Test public void testAdd() { int result = calculator.add(2, 3); assertEquals(5, result); } @Test public void testSubtract() { int result = calculator.subtract(5, 3); assertEquals(2, result); } }

इस उदाहरण में, setUp विधि को @BeforeEach के साथ एनोटेट किया गया है, और यह प्रत्येक परीक्षण से पहले Calculator ऑब्जेक्ट को प्रारंभ करता है। tearDown विधि, जिसे @AfterEach के साथ एनोटेट किया गया है, प्रत्येक परीक्षण के बाद संसाधनों को साफ करती है।

मोक्स और स्टब्स

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

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

• स्टब: एक स्टब विधि कॉल के लिए डिब्बाबंद प्रतिक्रियाएँ प्रदान करता है। यह पूर्वनिर्धारित डेटा लौटाता है और इसका उपयोग बाहरी सिस्टम के कुछ व्यवहारों को अनुकरण करने के लिए किया जाता है।

आइए एक ऐसी विधि को शामिल करने के लिए Calculator वर्ग का विस्तार करें जिसमें बाहरी निर्भरता शामिल है और फिर उस निर्भरता को अनुकरण करने के लिए एक स्टब बनाएं।

 public class Calculator { private ExternalService externalService; public Calculator(ExternalService externalService) { this.externalService = externalService; } public int performComplexCalculation(int a, int b) { int result = externalService.multiply(a, b); return result + externalService.getConstant(); } }

इस अद्यतन Calculator वर्ग में, performComplexCalculation गुणन और स्थिर मान प्राप्त करने के लिए एक ExternalService पर निर्भर करता है।

यहां बताया गया है कि आप वास्तविक ExternalService पर निर्भर हुए बिना Calculator वर्ग का परीक्षण करने के लिए एक स्टब कैसे बना सकते हैं।

 import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.mockito.Mockito.*; public class CalculatorTest { @Test public void testPerformComplexCalculation() { // Create a stub for ExternalService ExternalService externalServiceStub = new ExternalService() { @Override public int multiply(int a, int b) { return a * b; } @Override public int getConstant() { return 5; // Stubbed constant value } }; // Create the Calculator with the stubbed ExternalService Calculator calculator = new Calculator(externalServiceStub); // Test the performComplexCalculation method int result = calculator.performComplexCalculation(2, 3); assertEquals(11, result); // 2*3 + 5 (constant) = 11 } }

इस परीक्षण में, ExternalService एक अज्ञात वर्ग बनाकर परीक्षण विधि के भीतर रखा गया है जो आवश्यक तरीकों को ओवरराइड करता है। इस तरह, Calculator परीक्षण विधि ExternalService के वास्तविक कार्यान्वयन पर निर्भर हुए बिना चलती है।

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

मॉकिंग के लिए मॉकिटो का परिचय

मॉकिटो मॉक ऑब्जेक्ट बनाने और प्रबंधित करने के लिए एक लोकप्रिय जावा लाइब्रेरी है। मान लीजिए कि हमारे पास एक PaymentService क्लास है जो बाहरी भुगतान गेटवे के साथ इंटरैक्ट करती है। हम भुगतान गेटवे के लिए एक मॉक बनाने के लिए मॉकिटो का उपयोग कर सकते हैं:

 import org.junit.jupiter.api.Test; import static org.mockito.Mockito.*; public class PaymentServiceTest { @Test public void testProcessPayment() { PaymentGateway paymentGateway = mock(PaymentGateway.class); PaymentService paymentService = new PaymentService(paymentGateway); when(paymentGateway.charge(100.0)).thenReturn(true); boolean result = paymentService.processPayment(100.0); assertTrue(result); verify(paymentGateway, times(1)).charge(100.0); } }

इस उदाहरण में, हम एक नकली PaymentGateway बनाते हैं और उसके व्यवहार को परिभाषित करने के लिए when विधि का उपयोग करते हैं। फिर हम PaymentService क्लास पर processPayment विधि को कॉल करते हैं और सत्यापित करते हैं कि charge विधि को अपेक्षित मापदंडों के साथ बुलाया गया था।

कोड कवरेज और मावेन प्लगइन

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

मेवेन जावा प्रोजेक्ट्स के लिए एक लोकप्रिय बिल्ड टूल है, और आप JaCoCo जैसे प्लगइन्स का उपयोग करके अपने मेवेन प्रोजेक्ट में कोड कवरेज विश्लेषण को एकीकृत कर सकते हैं। अपने प्रोजेक्ट में JaCoCo को जोड़ने का तरीका यहां बताया गया है:

1. अपने प्रोजेक्ट की pom.xml फ़ाइल खोलें.
2. JaCoCo Maven प्लगइन कॉन्फ़िगरेशन जोड़ें:

 <build> <plugins> <plugin> <groupId>org.jacoco</groupId> <artifactId>jacoco-maven-plugin</artifactId> <version>0.8.7</version> <executions> <execution> <goals> <goal>prepare-agent</goal> </goals> </execution> <execution> <id>report</id> <phase>test</phase> <goals> <goal>report</goal> </goals> </execution> </executions> </plugin> </plugins> </build>

निम्नलिखित कमांड के साथ अपना मावेन बिल्ड चलाएँ:

 mvn clean verify

बिल्ड चलाने के बाद, आप target/site/jacoco/index.html फ़ाइल में कोड कवरेज रिपोर्ट पा सकते हैं। यह रिपोर्ट आपके यूनिट परीक्षणों द्वारा आपके कोड के कवरेज के बारे में विस्तृत जानकारी प्रदान करती है।

निष्कर्ष

आपके कोड की विश्वसनीयता और शुद्धता सुनिश्चित करने के लिए जावा यूनिट परीक्षण एक आवश्यक अभ्यास है। JUnit और Mockito जैसे टूल के साथ, आप अपने घटकों के लिए प्रभावी यूनिट परीक्षण और मॉक लिख सकते हैं।

मावेन और जाकोको के साथ कोड कवरेज विश्लेषण को एकीकृत करके, आप यह सुनिश्चित कर सकते हैं कि आपके परीक्षण आपके कोडबेस के एक महत्वपूर्ण हिस्से को कवर करते हैं। यूनिट परीक्षणों का नियमित परीक्षण और रखरखाव आपको उच्च-गुणवत्ता और मजबूत जावा एप्लिकेशन बनाने में मदद करेगा।

इस श्रृंखला के अगले भाग में, हम एकीकरण परीक्षण का पता लगाएंगे, जो सॉफ्टवेयर परीक्षण का एक महत्वपूर्ण पहलू है जिसमें समग्र सिस्टम सही ढंग से काम करता है यह सुनिश्चित करने के लिए विभिन्न घटकों और सेवाओं के बीच बातचीत का परीक्षण करना शामिल है।

भाग दो के लिए बने रहें, जहां हम एकीकरण परीक्षण की रोमांचक दुनिया में उतरेंगे!