சோதனை வகுப்புகளுக்கு வெளியே @LocalServerPort ஐப் பயன்படுத்தி ஸ்பிரிங் பூட்டில் ஆட்டோவயரிங் சிக்கல்களை எவ்வாறு சரிசெய்வது

ஸ்பிரிங் பூட் சோதனையில் சார்பு ஊசி சவால்களைப் புரிந்துகொள்வது

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

API சோதனையை ஒழுங்குபடுத்த உங்கள் கட்டுப்படுத்திகளுக்கு தனிப்பயன் ரேப்பரை உருவாக்குவதை கற்பனை செய்து பாருங்கள். இந்த சுருக்கமானது மீண்டும் மீண்டும் வரும் அழைப்புகளை எளிதாக்கும், ஆனால் அதை ஸ்பிரிங் பூட் சோதனை சுற்றுச்சூழல் அமைப்புடன் ஒருங்கிணைப்பது பெரும்பாலும் சார்பு ஊசி பிழைகளுக்கு வழிவகுக்கிறது. ஸ்பிரிங்கின் சோதனைச் சூழல் எப்போதும் போன்ற ப்ளாஸ்ஹோல்டர்களை தீர்க்காது என்பதால் இதுபோன்ற சிக்கல்கள் ஏற்படுகின்றன ${local.server.port} சோதனை அல்லாத பீன்ஸில்.

டெவலப்பர்கள் அடிக்கடி பிழையை எதிர்கொள்கின்றனர்: "தானியங்கி சார்புகளின் உட்செலுத்துதல் தோல்வியடைந்தது; 'local.server.port' என்ற ஒதுக்கிடத்தைத் தீர்க்க முடியவில்லை." சிக்கலான சோதனை அமைப்புகளுடன் நீங்கள் பணிபுரியும் போது அல்லது உங்கள் சோதனைக் குறியீட்டை சுத்தமாகவும் மட்டுமின்றி வைத்திருக்கும் நோக்கத்தில் இது குறிப்பாக வெறுப்பாக இருக்கும். இது ஏன் நடக்கிறது என்பதைப் புரிந்துகொள்வது ஒரு தீர்வைச் செயல்படுத்துவதற்கு முக்கியமாகும்.

இந்த கட்டுரையில், இந்த சிக்கலின் மூல காரணத்தை நாங்கள் ஆராய்வோம் மற்றும் அதை சமாளிக்க படிப்படியான தீர்வை வழங்குவோம். உதவிக்குறிப்புகள் மற்றும் சிறந்த நடைமுறைகள் உட்பட தொடர்புடைய சூழ்நிலைகளைப் பயன்படுத்தி, உங்கள் சோதனைப் பயணம் திறமையாகவும் பிழையற்றதாகவும் இருப்பதை உறுதி செய்வோம். 🚀

லோக்கல் சர்வர் போர்ட்களுடன் சோதனை செய்வதற்கான சார்பு ஊசியைப் புரிந்துகொள்வது

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

மற்றொரு ஸ்கிரிப்ட் பயன்படுத்துகிறது பயன்பாட்டு சூழல் விழிப்புணர்வு இடைமுகம், இது வசந்த பயன்பாட்டு சூழலுக்கு நேரடி அணுகலை அனுமதிக்கிறது. சர்வர் போர்ட் போன்ற சூழல் மாறிகளை நீங்கள் மாறும் வகையில் மீட்டெடுக்க விரும்பும் போது இது மிகவும் பயனுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, APIகளை சோதனை செய்வதற்கான கன்ட்ரோலர் அழைப்புகளை மடக்கும்போது, ​​ரேப்பர் கிளாஸ் இயக்க நேரத்தில் சரியான போர்ட்டைப் பெற்றுப் பயன்படுத்தலாம். இந்த முறை ஹார்ட்கோடிங்கை நீக்குகிறது மற்றும் சோதனை நெகிழ்வுத்தன்மையை மேம்படுத்துகிறது. சீரற்ற போர்ட்டைச் சார்ந்திருக்கும் API ஐச் சோதிப்பதை கற்பனை செய்து பாருங்கள் - நீங்கள் இனி அதை கைமுறையாக அமைக்க வேண்டியதில்லை. 😊

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

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

@Component
public class BaseControllerWrapper {
    protected int port;
}

@Component
public class SpecificControllerWrapper extends BaseControllerWrapper {
    public void callEndpoint() {
        System.out.println("Calling endpoint on port: " + port);
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PermissionsTest {
    @Autowired
    private SpecificControllerWrapper specificControllerWrapper;

    @DynamicPropertySource
    static void dynamicProperties(DynamicPropertyRegistry registry) {
        registry.add("server.port", () -> 8080);
    }

    @Test
    public void testSomething() {
        specificControllerWrapper.port = 8080; // Dynamically set
        specificControllerWrapper.callEndpoint();
    }
}

@Component
public class BaseControllerWrapper {
    protected int port;
}

@Component
public class SpecificControllerWrapper extends BaseControllerWrapper {
    public void callEndpoint() {
        System.out.println("Calling endpoint on port: " + port);
    }
}

@Component
public class PortInjector implements ApplicationContextAware {
    @Autowired
    private SpecificControllerWrapper wrapper;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Environment env = applicationContext.getEnvironment();
        wrapper.port = Integer.parseInt(env.getProperty("local.server.port", "8080"));
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PermissionsTest {
    @Autowired
    private SpecificControllerWrapper specificControllerWrapper;

    @Test
    public void testSomething() {
        specificControllerWrapper.callEndpoint();
    }
}

@Configuration
public class PortConfig {
    @Bean
    public BaseControllerWrapper baseControllerWrapper(@Value("${local.server.port}") int port) {
        BaseControllerWrapper wrapper = new BaseControllerWrapper();
        wrapper.port = port;
        return wrapper;
    }
}

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class PermissionsTest {
    @Autowired
    private SpecificControllerWrapper specificControllerWrapper;

    @Test
    public void testSomething() {
        specificControllerWrapper.callEndpoint();
    }
}

ஸ்பிரிங் பூட் சோதனைகளில் சார்பு ஊசி சவால்களை சமாளித்தல்

ஸ்பிரிங் பூட் சோதனைகளில் சார்பு ஊசி பயன்படுத்தும்போது தந்திரமானதாக இருக்கும் @LocalServerPort. சோதனைகளின் போது சீரற்ற சர்வர் போர்ட்களை உட்செலுத்துவதற்கு இந்த சிறுகுறிப்பு சக்தி வாய்ந்தது ஆனால் ஒரு முக்கிய வரம்பு உள்ளது: இது சோதனை வகுப்புகளுக்குள் மட்டுமே வேலை செய்கிறது. பகிரப்பட்ட கூறுகள் அல்லது ரேப்பர்கள் போன்ற வெளியில் பயன்படுத்தும் போது, ​​ஸ்பிரிங் பிளேஸ்ஹோல்டரைத் தீர்க்கத் தவறி, பிழைகளுக்கு வழிவகுக்கும். இதைக் கையாள, டைனமிக் சொத்து உள்ளமைவு அல்லது சுற்றுச்சூழல் விழிப்புணர்வு தீர்வுகளைப் பயன்படுத்தலாம்.

ஒரு பயனுள்ள அணுகுமுறையை மேம்படுத்துகிறது @DynamicPropertySource சிறுகுறிப்பு, இது உள்ளூர் சர்வர் போர்ட்டை ஒரு சொத்தாக பதிவு செய்கிறது. சோதனை வகுப்புகளுக்கு வெளியேயும், வசந்த சூழல் முழுவதும் மதிப்பு கிடைப்பதை இது உறுதி செய்கிறது. உதாரணமாக, நீங்கள் REST API அழைப்புகளை மறுபயன்பாட்டிற்காக ஒரு கன்ட்ரோலர் ரேப்பரில் மடித்தால், போர்ட்டை டைனமிக் முறையில் அமைப்பது உங்கள் சோதனைகளை மாடுலராகவும் சுத்தமாகவும் வைத்திருக்கும். 🚀

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