ടെസ്റ്റ് ക്ലാസുകൾക്ക് പുറത്തുള്ള @LocalServerPort ഉപയോഗിച്ച് സ്പ്രിംഗ് ബൂട്ടിലെ ഓട്ടോവയറിംഗ് പ്രശ്നങ്ങൾ എങ്ങനെ പരിഹരിക്കാം

സ്പ്രിംഗ് ബൂട്ട് ടെസ്റ്റിംഗിലെ ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ വെല്ലുവിളികൾ മനസ്സിലാക്കുക

ഒറ്റപ്പെട്ട ടെസ്റ്റുകൾക്കായി ഒരു റാൻഡം പോർട്ടിൽ ഒരു സെർവർ സ്പിൻ അപ്പ് ചെയ്യാനുള്ള കഴിവ് ഉൾപ്പെടെ, വെബ് ആപ്ലിക്കേഷനുകൾ പരിശോധിക്കുന്നതിനുള്ള ശക്തമായ ടൂളുകൾ സ്പ്രിംഗ് ബൂട്ട് വാഗ്ദാനം ചെയ്യുന്നു. എന്നിരുന്നാലും, പോലുള്ള സവിശേഷതകൾ സംയോജിപ്പിക്കുന്നു @LocalServerPort കൺട്രോളർ പരിശോധനയ്ക്ക് അപ്രതീക്ഷിത തടസ്സങ്ങൾ ഉണ്ടാകാം. ടെസ്റ്റ് ക്ലാസുകൾക്ക് പുറത്ത് ലോക്കൽ സെർവർ പോർട്ട് ഓട്ടോവയർ ചെയ്യാൻ ശ്രമിക്കുമ്പോൾ ഒരു സാധാരണ പ്രശ്നം ഉയർന്നുവരുന്നു.

API പരിശോധന കാര്യക്ഷമമാക്കുന്നതിന് നിങ്ങളുടെ കൺട്രോളറുകൾക്കായി ഒരു ഇഷ്‌ടാനുസൃത റാപ്പർ സൃഷ്‌ടിക്കുന്നത് സങ്കൽപ്പിക്കുക. ഈ അമൂർത്തീകരണത്തിന് ആവർത്തിച്ചുള്ള കോളുകൾ ലളിതമാക്കാൻ കഴിയും, എന്നാൽ സ്പ്രിംഗ് ബൂട്ട് ടെസ്റ്റിംഗ് ഇക്കോസിസ്റ്റവുമായി ഇത് സംയോജിപ്പിക്കുന്നത് പലപ്പോഴും ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ പിശകുകളിലേക്ക് നയിക്കുന്നു. സ്പ്രിംഗിൻ്റെ ടെസ്റ്റ് എൻവയോൺമെൻ്റ് എല്ലായ്‌പ്പോഴും പോലുള്ള പ്ലെയ്‌സ്‌ഹോൾഡറുകൾ പരിഹരിക്കാത്തതിനാലാണ് ഇത്തരം പ്രശ്‌നങ്ങൾ ഉണ്ടാകുന്നത് ${local.server.port} നോൺ-ടെസ്റ്റ് ബീൻസിൽ.

ഡെവലപ്പർമാർ പതിവായി പിശക് നേരിടുന്നു: "ഓട്ടോവയർഡ് ഡിപൻഡൻസികളുടെ ഇൻജക്ഷൻ പരാജയപ്പെട്ടു; 'local.server.port' എന്ന പ്ലെയ്‌സ്‌ഹോൾഡർ പരിഹരിക്കാൻ കഴിഞ്ഞില്ല." നിങ്ങൾ സങ്കീർണ്ണമായ ടെസ്റ്റ് സജ്ജീകരണങ്ങൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോഴോ നിങ്ങളുടെ ടെസ്റ്റ് കോഡ് വൃത്തിയുള്ളതും മോഡുലാർ ആയി നിലനിർത്താൻ ശ്രമിക്കുമ്പോഴോ ഇത് പ്രത്യേകിച്ച് നിരാശാജനകമാണ്. എന്തുകൊണ്ടാണ് ഇത് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കുന്നത് ഒരു പരിഹാരം നടപ്പിലാക്കുന്നതിനുള്ള പ്രധാന കാര്യമാണ്.

ഈ ലേഖനത്തിൽ, ഈ പ്രശ്നത്തിൻ്റെ മൂലകാരണം ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യുകയും അതിനെ മറികടക്കാൻ ഘട്ടം ഘട്ടമായുള്ള പരിഹാരം നൽകുകയും ചെയ്യും. നുറുങ്ങുകളും മികച്ച രീതികളും ഉൾപ്പെടെയുള്ള പ്രസക്തമായ സാഹചര്യങ്ങൾ ഉപയോഗിച്ച്, നിങ്ങളുടെ പരീക്ഷണ യാത്ര കാര്യക്ഷമവും പിശകുകളില്ലാത്തതുമാണെന്ന് ഞങ്ങൾ ഉറപ്പാക്കും. 🚀

ലോക്കൽ സെർവർ പോർട്ടുകൾ ഉപയോഗിച്ച് ടെസ്റ്റിംഗിനായി ഡിപൻഡൻസി ഇഞ്ചക്ഷൻ മനസ്സിലാക്കുന്നു

സ്പ്രിംഗ് ബൂട്ടിൻ്റെ ശക്തമായ ടെസ്റ്റിംഗ് ഇക്കോസിസ്റ്റം യഥാർത്ഥ ലോക സാഹചര്യങ്ങൾ അനുകരിക്കുന്നത് എളുപ്പമാക്കുന്നു, എന്നാൽ ചില കോൺഫിഗറേഷനുകൾ വെല്ലുവിളികളിലേക്ക് നയിച്ചേക്കാം. അത്തരത്തിലുള്ള ഒരു പ്രശ്നം ഓട്ടോവയറിംഗ് ആണ് @LocalServerPort ഒരു ടെസ്റ്റ് ക്ലാസിന് പുറത്ത്. നൽകിയിരിക്കുന്ന ഉദാഹരണങ്ങളിൽ, ഈ പരിമിതിയെ മറികടക്കാൻ വ്യത്യസ്ത വഴികൾ കാണിക്കുന്നതിനാണ് സ്ക്രിപ്റ്റുകൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. പോലുള്ള വ്യാഖ്യാനങ്ങൾ ഉപയോഗിച്ച് @DynamicPropertySource, സെർവർ പോർട്ട് പോലെയുള്ള പ്രോപ്പർട്ടികൾ നമുക്ക് ചലനാത്മകമായി സജ്ജീകരിക്കാൻ കഴിയും, ഇത് മറ്റ് ബീൻസുകൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും. ഈ സമീപനം ടെസ്റ്റുകൾ സമയത്ത് പോർട്ട് മൂല്യം ശരിയായി കുത്തിവയ്ക്കുന്നത് ഉറപ്പാക്കുകയും ഭയാനകമായ പ്ലെയ്‌സ്‌ഹോൾഡർ റെസല്യൂഷൻ പിശക് ഒഴിവാക്കുകയും ചെയ്യുന്നു.

മറ്റൊരു സ്ക്രിപ്റ്റ് ഇതിനെ സ്വാധീനിക്കുന്നു ApplicationContextAware സ്പ്രിംഗ് ആപ്ലിക്കേഷൻ സന്ദർഭത്തിലേക്ക് നേരിട്ട് പ്രവേശനം അനുവദിക്കുന്ന ഇൻ്റർഫേസ്. സെർവർ പോർട്ട് പോലെയുള്ള എൻവയോൺമെൻ്റ് വേരിയബിളുകൾ ഡൈനാമിക് ആയി വീണ്ടെടുക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഉദാഹരണത്തിന്, 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 സെർവർ പോർട്ട് ചലനാത്മകമായി ലഭ്യമാക്കാൻ. റൺടൈമിൽ പ്രോപ്പർട്ടി റെസലൂഷൻ സംഭവിക്കേണ്ട സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകളിൽ ഈ സമീപനം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. പോർട്ട് നേരിട്ട് റാപ്പറിലോ ബീനിലോ കോൺഫിഗർ ചെയ്യുന്നതിലൂടെ, ടെസ്റ്റ് സജ്ജീകരണം തകർക്കാതെ നിങ്ങൾ അനുയോജ്യത ഉറപ്പാക്കുന്നു.