परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण · पाठ

परीक्षण जीवनचक्र और क्रम

परीक्षणों के निष्पादन क्रम को नियंत्रित करें और उन्नत जीवनचक्र एनोटेशन का उपयोग करके परीक्षण की तैयारी और समापन प्रबंधित करें।

पाठ 1, कुल 4 में से11 चरण

परीक्षण जीवनचक्र और क्रम, CoddyKit पर परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

JUnit परीक्षण जीवनचक्र का परिचय

स्वागत है! इस पाठ में हम आपके परीक्षणों के चलने के तरीके को नियंत्रित करने वाली JUnit 5 की उन्नत सुविधाओं का अध्ययन करेंगे। संसाधनों को प्रबंधित करने और उचित परीक्षण सेटअप व क्लीनअप सुनिश्चित करने के लिए परीक्षण जीवनचक्र को समझना महत्वपूर्ण है।

जीवनचक्र उन क्रियाओं का क्रम परिभाषित करता है जिन्हें JUnit आपके परीक्षण मेथड और क्लास से पहले और बाद में करता है।

क्लास-स्तरीय सेटअप: @BeforeAll

कभी-कभी आपको किसी विशेष परीक्षण क्लास के सभी परीक्षणों के लिए सेटअप क्रियाएँ केवल एक बार करनी होती हैं। @BeforeAll एनोटेशन ऐसे मेथड को चिह्नित करता है जो उस क्लास के किसी भी परीक्षण मेथड से पहले चलता है।

डिफ़ॉल्ट रूप से, @BeforeAll मेथड का static होना आवश्यक है। इसे बदलने का तरीका हम जल्द देखेंगे!

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class BeforeAllDemo {
    private static StringBuilder log = new StringBuilder();

    @BeforeAll
    static void setupOnce() {
        log.append("-> @BeforeAll: Setup done once.\n");
        System.out.println("Setup for all tests.");
    }

    @Test
    void testA() {
        log.append("  -> @Test: Running testA.\n");
        System.out.println("  Running testA.");
        assertTrue(true);
    }

    @Test
    void testB() {
        log.append("  -> @Test: Running testB.\n");
        System.out.println("  Running testB.");
        assertTrue(true);
    }
    // The log output would typically be verified in @AfterAll or debugger.
}

क्लास-स्तरीय टियरडाउन: @AfterAll

इसी तरह, किसी क्लास के सभी परीक्षण पूरे होने के बाद आपको संसाधनों को केवल एक बार साफ़ करना पड़ सकता है। @AfterAll एनोटेशन ऐसे मेथड को चिह्नित करता है जो क्लास के सभी परीक्षण मेथड के बाद चलता है।

@BeforeAll की तरह, डिफ़ॉल्ट रूप से इसका static होना आवश्यक है।

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

public class AfterAllDemo {
    private static StringBuilder log = new StringBuilder();

    @BeforeAll
    static void setup() {
        log.append("-> @BeforeAll: Setup for AfterAllDemo.\n");
    }

    @Test
    void testOne() {
        log.append("  -> @Test: Running testOne.\n");
        assertTrue(true);
    }

    @Test
    void testTwo() {
        log.append("  -> @Test: Running testTwo.\n");
        assertTrue(true);
    }

    @AfterAll
    static void teardown() {
        log.append("-> @AfterAll: Teardown for AfterAllDemo.\n");
        System.out.println("--- Execution Log ---");
        System.out.println(log.toString()); // See the full order
        System.out.println("--- End Log ---");
    }
}

@TestInstance: PER_CLASS जीवनचक्र

डिफ़ॉल्ट रूप से, JUnit आपके परीक्षण क्लास का प्रत्येक परीक्षण मेथड के लिए एक नया इंस्टेंस बनाता है (Lifecycle.PER_METHOD)। इससे परीक्षण अलग-थलग रहते हैं।

यदि आपको @BeforeAll और @AfterAll मेथड को static न रखना हो, या आप किसी क्लास के सभी परीक्षणों में स्थिति साझा करना चाहते हों, तो परीक्षण इंस्टेंस जीवनचक्र को Lifecycle.PER_CLASS में बदल सकते हैं।

import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import static org.junit.jupiter.api.Assertions.assertEquals;

@TestInstance(Lifecycle.PER_CLASS) // Allows non-static @BeforeAll/@AfterAll
public class PerClassLifecycleDemo {
    private int counter = 0; // Instance variable, shared across tests

    @BeforeAll // No longer needs to be static!
    void setupPerClass() {
        counter = 10; 
        System.out.println("-> @BeforeAll (PER_CLASS). Counter: " + counter);
    }

    @Test
    void testIncrementOne() {
        counter++;
        System.out.println("  -> @Test 1. Counter: " + counter);
        assertEquals(11, counter); // Shared state is modified
    }

    @Test
    void testIncrementTwo() {
        counter++;
        System.out.println("  -> @Test 2. Counter: " + counter);
        assertEquals(12, counter); // Counter continues from previous test
    }

    @AfterAll // No longer needs to be static!
    void teardownPerClass() {
        System.out.println("-> @AfterAll (PER_CLASS). Final Counter: " + counter);
    }
}

परीक्षण क्रम: कब उपयोग करें

आदर्श रूप से, JUnit परीक्षण स्वतंत्र होने चाहिए और किसी भी क्रम में सही ढंग से चलने चाहिए। किसी विशेष क्रम पर निर्भर रहने से आपके परीक्षण नाज़ुक और बनाए रखना कठिन हो सकते हैं।

हालाँकि, कुछ विशेष परिस्थितियों में स्पष्ट क्रम उपयोगी हो सकता है:

  • स्पष्ट, क्रमिक चरणों वाले जटिल कार्यप्रवाह का परीक्षण करना।
  • तेज़ परीक्षणों या साझा महँगे सेटअप वाले परीक्षणों को समूहित करके प्रदर्शन बेहतर करना।
  • ऐसी पुरानी प्रणालियों के साथ काम करना जिनमें किसी निश्चित इंटरैक्शन क्रम की आवश्यकता होती है।

@TestMethodOrder एनोटेशन

किसी क्लास के भीतर परीक्षण मेथड के निष्पादन का क्रम तय करने के लिए क्लास स्तर पर @TestMethodOrder एनोटेशन का उपयोग करें। इसमें तर्क के रूप में MethodOrderer का कार्यान्वयन दिया जाता है।

JUnit 5 में कई अंतर्निहित रणनीतियाँ उपलब्ध हैं:

  • Alphanumeric.class: मेथड नामों को वर्णानुक्रम में व्यवस्थित करता है।
  • OrderAnnotation.class: @Order एनोटेशन का उपयोग करता है।
  • Random.class: क्रम को यादृच्छिक बनाता है।
  • DisplayName.class: मेथड के प्रदर्शन नामों के आधार पर क्रम तय करता है।

अल्फ़ान्यूमेरिक मेथड क्रम

आइए MethodOrderer.Alphanumeric.class को व्यवहार में देखें। JUnit परीक्षण मेथड को उनके नामों के आधार पर केवल वर्णानुक्रम में व्यवस्थित करेगा।

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

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.MethodOrderer.Alphanumeric;
import static org.junit.jupiter.api.Assertions.assertTrue;

@TestMethodOrder(Alphanumeric.class) // Tests run A, B, C
public class AlphanumericOrderDemo {

    @Test
    void testA_First() {
        System.out.println("-> Running testA_First");
        assertTrue(true);
    }

    @Test
    void testC_Third() {
        System.out.println("-> Running testC_Third");
        assertTrue(true);
    }

    @Test
    void testB_Second() {
        System.out.println("-> Running testB_Second");
        assertTrue(true);
    }
}

@Order से कस्टम क्रम

सूक्ष्म नियंत्रण के लिए, @TestMethodOrder(MethodOrderer.OrderAnnotation.class) को अलग-अलग परीक्षण मेथड पर @Order(value) एनोटेशन के साथ प्रयोग करें। छोटे value अंक पहले निष्पादन का संकेत देते हैं।

इससे आप अपने परीक्षणों के लिए सटीक, कस्टम क्रम निर्धारित कर सकते हैं।

import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import static org.junit.jupiter.api.Assertions.assertTrue;

@TestMethodOrder(OrderAnnotation.class) // Activate @Order annotation
public class CustomOrderDemo {

    @Test
    @Order(2) // This test runs second
    void processStepTwo() {
        System.out.println("-> Running processStepTwo");
        assertTrue(true);
    }

    @Test
    @Order(1) // This test runs first
    void initializeSystem() {
        System.out.println("-> Running initializeSystem");
        assertTrue(true);
    }

    @Test
    @Order(3) // This test runs third
    void finalizeReport() {
        System.out.println("-> Running finalizeReport");
        assertTrue(true);
    }
}

क्रम निर्धारण की सर्वोत्तम प्रथाएँ

हालाँकि स्पष्ट परीक्षण क्रम शक्तिशाली होता है, फिर भी इसका उपयोग सावधानी से करना चाहिए:

  • स्वतंत्रता को प्राथमिकता दें: आदर्श रूप से प्रत्येक परीक्षण अपने आप चलने में सक्षम होना चाहिए।
  • पठनीयता: अत्यधिक क्रम निर्धारण से परीक्षणों को समझना और बनाए रखना कठिन हो सकता है।
  • रखरखाव का बोझ: प्रणाली में बदलाव के कारण क्रम मानों का दोबारा मूल्यांकन और अद्यतन करना पड़ सकता है।

क्रम निर्धारण का उपयोग केवल तभी करें जब इसका कोई ठोस और उचित कारण हो, और स्पष्ट उद्देश्य के लिए @Order को प्राथमिकता दें।

जीवनचक्र और क्रम की जाँच

निम्नलिखित JUnit 5 परीक्षण क्लास पर विचार करें:

import org.junit.jupiter.api.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
public class QuizTest {
    private int sharedValue = 0;

    @BeforeAll
    void setup() {
        sharedValue = 10;
        System.out.println("BeforeAll: sharedValue = " + sharedValue);
    }

    @Test
    @Order(2)
    void testB() {
        sharedValue += 2;
        System.out.println("  TestB: sharedValue = " + sharedValue);
        assertEquals(13, sharedValue);
    }

    @Test
    @Order(1)
    void testA() {
        sharedValue += 1;
        System.out.println("  TestA: sharedValue = " + sharedValue);
        assertEquals(11, sharedValue);
    }

    @AfterAll
    void teardown() {
        System.out.println("AfterAll: sharedValue = " + sharedValue);
    }
}

@AfterAll मेथड में प्रिंट होने वाला sharedValue का अंतिम मान क्या होगा?

पुनरावलोकन: जीवनचक्र और क्रम निर्धारण

इस पाठ में आपने परीक्षण निष्पादन को नियंत्रित करने वाली JUnit 5 की उन्नत सुविधाओं में निपुणता प्राप्त की:

  • क्लास-स्तरीय जीवनचक्र: एक बार के सेटअप/टियरडाउन के लिए @BeforeAll और @AfterAll।
  • इंस्टेंस जीवनचक्र: साझा स्थिति और गैर-static क्लास-स्तरीय हुक सक्षम करने के लिए @TestInstance(Lifecycle.PER_CLASS)।
  • परीक्षण मेथड का क्रम: निष्पादन क्रम निर्धारित करने के लिए @TestMethodOrder (जिसमें Alphanumeric या OrderAnnotation जैसी रणनीतियाँ होती हैं)।
  • कस्टम क्रम: मेथड के क्रम पर सटीक नियंत्रण के लिए @Order।

याद रखें कि स्पष्ट क्रम निर्धारण का विवेकपूर्ण उपयोग करें और स्वतंत्र व मज़बूत परीक्षणों को प्राथमिकता दें!

शुरुआत निःशुल्क

एआई शिक्षक के साथ परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
12
पाठ
48

अक्सर पूछे जाने वाले प्रश्न

क्या “परीक्षण जीवनचक्र और क्रम” पाठ निःशुल्क है?

हाँ — परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “परीक्षण जीवनचक्र और क्रम” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“परीक्षण जीवनचक्र और क्रम” में मैं क्या सीखूँगा?

परीक्षणों के निष्पादन क्रम को नियंत्रित करें और उन्नत जीवनचक्र एनोटेशन का उपयोग करके परीक्षण की तैयारी और समापन प्रबंधित करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।

“परीक्षण जीवनचक्र और क्रम” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. परीक्षण जीवनचक्र और क्रम
  2. पैरामीटरयुक्त और गतिशील परीक्षण
  3. अपवाद परीक्षण और टाइमआउट
  4. सशर्त परीक्षण और पूर्वधारणाएँ
← परीक्षण में निपुणता: JUnit, Mockito और एकीकरण परीक्षण पर वापस जाएँ