JUnitలో ఉపయోగకరమైన ఉల్లేఖనాలు

4.1 @డిసేబుల్

ఇప్పుడు JUnit ఫ్రేమ్‌వర్క్ యొక్క చాలా ఉపయోగకరమైన మరియు ప్రసిద్ధ ఉల్లేఖనాలను చూద్దాం. మొదటి ఉల్లేఖన నిర్దిష్ట పరీక్షను ఆఫ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది, తద్వారా JUnit దానిని కాల్ చేయదు. పరీక్ష సరిగ్గా పనిచేయడం లేదని మీరు గమనించినప్పుడు లేదా మీరు కోడ్‌ను మార్చినప్పుడు మరియు పరీక్ష అనుకోకుండా విచ్ఛిన్నమైతే ఇది అవసరం.

నేను ఇంతకు ముందు వ్రాసినట్లుగా, 99% పరీక్షలకు ఎవరూ మద్దతు ఇవ్వరు, కాబట్టి అవన్నీ త్వరగా లేదా తరువాత నిలిపివేయబడతాయి. కాబట్టి, ఈ ఉల్లేఖన ఉపయోగకరమైన వాటి జాబితాలో మొదటిది.

ఆమె ఉదాహరణను పరిగణించండి:

public class AppTest {

    @Disabled("Test is temporarily disabled. True, true")
    @Test
    void testOnDev(){
        System.setProperty("ENV", "DEV");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }

    @Test
    void testOnProd(){
     System.setProperty("ENV", "PROD");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }
}

పై ఉదాహరణలో, పద్ధతి testOnDev()పిలవబడదు. మార్గం ద్వారా, @Disabledక్లాస్ డిక్లరేషన్‌కు ముందు ఉల్లేఖనాన్ని వెంటనే వ్రాయవచ్చు, అప్పుడు దాని అన్ని పద్ధతులు విస్మరించబడతాయి.

@Disabled("Temporarily turned off the test, we will fix it by May 2001")
public class AppTest {
    @Test
    void testOnDev(){
        System.setProperty("ENV", "DEV");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }

    @Test
    void testOnProd(){
     System.setProperty("ENV", "PROD");
        Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
    }
}

4.2 @నెస్టెడ్

JUnit సమూహ తరగతులపై పరీక్ష పద్ధతులను కాల్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. నా ఉద్దేశ్యం నెస్టెడ్ టెస్ట్ తరగతులు. మీరు తరచుగా వాటిని ఎదుర్కొంటారనేది వాస్తవం కాదు, కానీ అలాంటి అవకాశం ఉంది, కాబట్టి మీరు అది ఏమిటో అర్థం చేసుకోవాలి.

దాని ప్రకటనకు ముందు సమూహ తరగతి యొక్క పద్ధతులను కాల్ చేయడానికి, మీరు ఒక ఉల్లేఖనాన్ని వ్రాయాలి @Nested. ఉదాహరణ:

public class AppTest {
    @Nested
    public class DevStagingEnvironment {
    @Test
        void testOnDev(){
            System.setProperty("ENV", "DEV");
            Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
        }
   }

    @Nested
    public class ProductionEnvironment {
        @Test
        void testOnProd(){
           System.setProperty("ENV", "PROD");
           Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV")));
        }
   }
}

మరిన్ని వివరాలను అధికారిక డాక్యుమెంటేషన్‌లో చూడవచ్చు .

4.3 @ExtendWith

మరొక ఉపయోగకరమైన ఉల్లేఖనం @ExtendWith. చాలా మటుకు మీరు ఆమెను చాలా తరచుగా కలుస్తారు, కాబట్టి ఆమెను మరింత వివరంగా చూద్దాం.

JUnit అనేది మీ పని యొక్క సౌకర్యవంతమైన అనుకూలీకరణ కోసం వివిధ ప్లగిన్‌లను (పొడిగింపులు) వ్రాయడానికి మిమ్మల్ని అనుమతించే శక్తివంతమైన ఫ్రేమ్‌వర్క్. కొన్ని పొడిగింపులు పరీక్షల గురించి గణాంకాలను సేకరించగలవు, మరికొన్ని ఇన్-మెమరీ ఫైల్ సిస్టమ్‌ను అనుకరించగలవు, మరికొన్ని వెబ్ సర్వర్‌లో పని చేయడాన్ని అనుకరించగలవు మరియు మొదలైనవి.

మీ కోడ్ ఫ్రేమ్‌వర్క్ లోపల అమలవుతున్నట్లయితే (ఉదాహరణకు, స్ప్రింగ్), అప్పుడు దాదాపు ఎల్లప్పుడూ ఈ ఫ్రేమ్‌వర్క్ మీ కోడ్‌లోని వస్తువుల సృష్టి మరియు కాన్ఫిగరేషన్‌ను నిర్వహిస్తుంది . అందువల్ల, ప్రత్యేక పరీక్ష ప్లగ్ఇన్ ఎంతో అవసరం. ఉదాహరణలు:

ఉదాహరణ 1. పొడిగింపు సరిగ్గా పని చేయడానికి WebServerExtensionపిలిచే పరీక్ష పద్ధతికి వెళుతుంది .URL

@Test
@ExtendWith(WebServerExtension.class)
void getProductList(@WebServerUrl String serverUrl) {
    WebClient webClient = new WebClient();
    // Use WebClient to connect to web server using serverUrl and verify response
    assertEquals(200, webClient.get(serverUrl + "/products").getResponseStatus());
}

స్ప్రింగ్ ఫ్రేమ్‌వర్క్‌తో పనిచేసే కోడ్‌ని పరీక్షించడానికి పరీక్షలు సాధారణంగా ఈ విధంగా ప్రారంభమవుతాయి:

@ExtendWith(SpringExtension.class)
@ExtendWith(MockitoExtension.class)
class TestServiceTest {

    @MockBean
    TestService service;

    @Test
    void test() {
        assertNotNull(service); // Test succeeds
    }
}

SpringExtensionస్ప్రింగ్ ఫ్రేమ్‌వర్క్ యొక్క పరీక్ష సంస్కరణను సృష్టిస్తుంది, కానీ MockitoExtentionనకిలీ వస్తువులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. నకిలీ వస్తువులు చాలా ఆసక్తికరమైన అంశం, మేము దానిని ఖచ్చితంగా తాకుతాము, కానీ కొంచెం తరువాత.

4.4 @సమయం ముగిసింది

చిన్న మరియు ఆసక్తికరమైన ఉల్లేఖనతో ఈ ఉపన్యాసాన్ని పూర్తి చేద్దాం @Timeout. ఇది పరీక్షను అమలు చేయడానికి సమయాన్ని సెట్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉల్లేఖనలో పేర్కొన్న దానికంటే పరీక్షకు ఎక్కువ సమయం పట్టినట్లయితే, అది విఫలమైనట్లు పరిగణించబడుతుంది.

class TimeoutDemo {
    @Test
    @Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
    void failsIfExecutionTimeExceeds100Milliseconds() {
        // test will fail if it takes more than 100 milliseconds
    }
}

ఇది మా ఉపన్యాసం ముగిసింది.