ஜூனிட்டில் பயனுள்ள சிறுகுறிப்புகள்

4.1 @Disabled

இப்போது ஜூனிட் கட்டமைப்பின் மிகவும் பயனுள்ள மற்றும் பிரபலமான சில குறிப்புகளைப் பார்ப்போம். முதல் சிறுகுறிப்பு ஒரு குறிப்பிட்ட சோதனையை முடக்க உங்களை அனுமதிக்கிறது, இதனால் ஜூனிட் அதை அழைக்காது. சோதனை சரியாக வேலை செய்யவில்லை என்பதை நீங்கள் கவனிக்கும் சந்தர்ப்பங்களில் அல்லது குறியீட்டை மாற்றினால், சோதனை தற்செயலாக உடைந்தால் இது தேவைப்படுகிறது.

நான் முன்பு எழுதியது போல், 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 @Nested

உள்ளமைக்கப்பட்ட வகுப்புகளில் சோதனை முறைகளை அழைக்க 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. பெரும்பாலும் நீங்கள் அவளை அடிக்கடி சந்திப்பீர்கள், எனவே அவளை இன்னும் விரிவாகப் பார்ப்போம்.

ஜூனிட் என்பது ஒரு சக்திவாய்ந்த கட்டமைப்பாகும், இது உங்கள் வேலையின் நெகிழ்வான தனிப்பயனாக்கத்திற்காக பல்வேறு செருகுநிரல்களை (நீட்டிப்புகள்) எழுத அனுமதிக்கிறது. சில நீட்டிப்புகள் சோதனைகளைப் பற்றிய புள்ளிவிவரங்களைச் சேகரிக்கலாம், மற்றவை இன்-மெமரி கோப்பு முறைமையைப் பின்பற்றலாம், மற்றவை இணையச் சேவையகத்திற்குள் வேலை செய்வதைப் பின்பற்றலாம் மற்றும் பல.

உங்கள் குறியீடு ஒரு கட்டமைப்பிற்குள் இயங்கினால் (உதாரணமாக, ஸ்பிரிங்), இந்த கட்டமைப்பானது எப்போதும் உங்கள் குறியீட்டில் உள்ள பொருட்களின் உருவாக்கம் மற்றும் உள்ளமைவை நிர்வகிக்கிறது . எனவே, ஒரு சிறப்பு சோதனை செருகுநிரல் இன்றியமையாதது. எடுத்துக்காட்டுகள்:

எடுத்துக்காட்டு 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

இந்த விரிவுரையை ஒரு சிறிய மற்றும் சுவாரஸ்யமான சிறுகுறிப்புடன் முடிப்போம் @Timeout. சோதனையை இயக்க நேரத்தை அமைக்க இது உங்களை அனுமதிக்கிறது. சிறுகுறிப்பில் குறிப்பிடப்பட்டதை விட சோதனை அதிக நேரம் எடுத்தால், அது தோல்வியடைந்ததாகக் கருதப்படுகிறது.

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

இது எங்கள் விரிவுரையை முடிக்கிறது.