स्प्रिंग बूट और Testcontainers के साथ डेटाबेस एकीकरण टेस्ट

1. अवलोकन

स्प्रिंग डेटा जेपीए के साथ, आप आसानी से डेटाबेस क्वेरी बना सकते हैं और अंतर्निहित एच 2 डेटाबेस का उपयोग करके उनका परीक्षण कर सकते हैं।

लेकिन कभी-कभी एक वास्तविक डेटाबेस पर परीक्षण बहुत अधिक उपयोगी होता है , खासकर यदि हम उन प्रश्नों का उपयोग करते हैं जो एक विशिष्ट डेटाबेस कार्यान्वयन से जुड़े होते हैं।

इस गाइड में, हम स्प्रिंग डेटा JPA और PostgreSQL डेटाबेस के साथ एकीकरण परीक्षण के लिए Testcontainers का उपयोग करने का तरीका बताएंगे ।

पिछले लेख में, हमने मुख्य रूप से @Query एनोटेशन का उपयोग करते हुए कई डेटाबेस क्वैश्चंस बनाए , जिनका हम अभी परीक्षण कर रहे हैं।

2. विन्यास

हमारे परीक्षण में PostgreSQL डेटाबेस का उपयोग करने के लिए, हमें केवल हमारे परीक्षण के Testcontainers निर्भरता और हमारे pom.xml फ़ाइल में PostgreSQL चालक को जोड़ना होगा:

<dependency> <groupId>org.testcontainers</groupId> <artifactId>postgresql</artifactId> <version>1.10.6</version> <scope>test</scope> </dependency> <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <version>42.2.5</version> </dependency> 

हम परीक्षण संसाधन निर्देशिका में एक application.properties फ़ाइल भी बनाएंगे, जिसमें हम स्प्रिंग के लिए आवश्यक ड्राइवर वर्ग के उपयोग को सेट करेंगे, साथ ही डेटाबेस स्कीमा को बनाने और हटाने के लिए हर बार परीक्षण चलता है:

 spring.datasource.driver-class-name=org.postgresql.Driver spring.jpa.hibernate.ddl-auto=create-drop 

3. यूनिट परीक्षण

एक एकल परीक्षण वर्ग में एक PostgreSQL उदाहरण का उपयोग शुरू करने के लिए, आपको एक कंटेनर परिभाषा बनाने की आवश्यकता है, और फिर कनेक्शन स्थापित करने के लिए इसके मापदंडों का उपयोग करें:

 @RunWith(SpringRunner.class) @SpringBootTest @ContextConfiguration(initializers = {UserRepositoryTCIntegrationTest.Initializer.class}) public class UserRepositoryTCIntegrationTest extends UserRepositoryCommonIntegrationTests { @ClassRule public static PostgreSQLContainer postgreSQLContainer = new PostgreSQLContainer("postgres:11.1") .withDatabaseName("integration-tests-db") .withUsername("sa") .withPassword("sa"); static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> { public void initialize(ConfigurableApplicationContext configurableApplicationContext) { TestPropertyValues.of( "spring.datasource.url=" + postgreSQLContainer.getJdbcUrl(), "spring.datasource.username=" + postgreSQLContainer.getUsername(), "spring.datasource.password=" + postgreSQLContainer.getPassword() ).applyTo(configurableApplicationContext.getEnvironment()); } } } 

उपरोक्त उदाहरण में, हमने परीक्षण विधियों को निष्पादित करने से पहले डेटाबेस कंटेनर को कॉन्फ़िगर करने के लिए JUnit से @ClassRule उपयोग किया। हमने एक स्थिर आंतरिक वर्ग भी बनाया है जो ApplicationContextInitializer को लागू करता है। अंत में, हमने पैरामीटर के रूप में इनिशियलाइज़िंग क्लास के साथ हमारे टेस्ट क्लास में @ContextConfiguration एनोटेशन लागू किया।

इन तीन चरणों को पूरा करने के बाद, हम स्प्रिंग संदर्भ को प्रकाशित करने से पहले कनेक्शन पैरामीटर सेट कर सकते हैं।

अब हम पिछले लेख से दो अद्यतन प्रश्नों का उपयोग करते हैं:

 @Modifying @Query("update User u set u.status = :status where u.name = :name") int updateUserSetStatusForName(@Param("status") Integer status, @Param("name") String name); @Modifying @Query(value = "UPDATE Users u SET u.status = ? WHERE u.name = ?", nativeQuery = true) int updateUserSetStatusForNameNative(Integer status, String name); 

और एक परीक्षण क्रम वातावरण में परीक्षण:

 @Test @Transactional public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationJPQL_ThenModifyMatchingUsers(){ insertUsers(); int updatedUsersSize = userRepository.updateUserSetStatusForName(0, "SAMPLE"); assertThat(updatedUsersSize).isEqualTo(2); } @Test @Transactional public void givenUsersInDB_WhenUpdateStatusForNameModifyingQueryAnnotationNative_ThenModifyMatchingUsers(){ insertUsers(); int updatedUsersSize = userRepository.updateUserSetStatusForNameNative(0, "SAMPLE"); assertThat(updatedUsersSize).isEqualTo(2); } private void insertUsers() { userRepository.save(new User("SAMPLE", "email@example.com", 1)); userRepository.save(new User("SAMPLE1", "email2@example.com", 1)); userRepository.save(new User("SAMPLE", "email3@example.com", 1)); userRepository.save(new User("SAMPLE3", "email4@example.com", 1)); userRepository.flush(); } 

उपरोक्त परिदृश्य में, पहला परीक्षण सफल होता है, और दूसरा एक InvalidDataAccessResourceUsageException संदेश के साथ फेंकता है:

 Caused by: org.postgresql.util.PSQLException: ERROR: column "u" of relation "users" does not exist 

यदि हम अंतर्निहित H2 डेटाबेस का उपयोग करके समान परीक्षण चलाते हैं, तो दोनों सफल होंगे, लेकिन PostgreSQL SET कथन में उपनामों को स्वीकार नहीं करता है। हम समस्याग्रस्त उपनाम को हटाकर अनुरोध को जल्दी से ठीक कर सकते हैं:

 @Modifying @Query(value = "UPDATE Users u SET status = ? WHERE u.name = ?", nativeQuery = true) int updateUserSetStatusForNameNative(Integer status, String name); 

इस बार दोनों परीक्षण सफलतापूर्वक पास हुए। इस उदाहरण में, हमने एक देशी क्वेरी के साथ समस्या की पहचान करने के लिए Testcontainers का उपयोग किया है जो अन्यथा उत्पादन डेटाबेस में जाने के बाद ही पता लगाया जाएगा । यह भी ध्यान दिया जाना चाहिए कि JPQL प्रश्नों का उपयोग करना आम तौर पर सुरक्षित होता है, क्योंकि स्प्रिंग उन्हें इस्तेमाल किए गए डेटाबेस प्रदाता के आधार पर सही ढंग से अनुवाद करता है।

4. साझा डेटाबेस उदाहरण

पिछले भाग में, हमने एक परीक्षण में टेस्टकॉनटेनर्स का उपयोग करने का तरीका बताया। वास्तविक मामलों में, मैं अपेक्षाकृत लंबे लॉन्च समय के कारण कई परीक्षणों में एक ही डेटाबेस कंटेनर का उपयोग करना चाहूंगा।

चलिए PostgreSQLContainer को विरासत में लेते हुए और स्टार्ट () और स्टॉप () के तरीकों को इनहेरिट करके डेटाबेस कंटेनर बनाने के लिए एक सामान्य वर्ग बनाते हैं:

 public class BaeldungPostgresqlContainer extends PostgreSQLContainer<BaeldungPostgresqlContainer> { private static final String IMAGE_VERSION = "postgres:11.1"; private static BaeldungPostgresqlContainer container; private BaeldungPostgresqlContainer() { super(IMAGE_VERSION); } public static BaeldungPostgresqlContainer getInstance() { if (container == null) { container = new BaeldungPostgresqlContainer(); } return container; } @Override public void start() { super.start(); System.setProperty("DB_URL", container.getJdbcUrl()); System.setProperty("DB_USERNAME", container.getUsername()); System.setProperty("DB_PASSWORD", container.getPassword()); } @Override public void stop() { //do nothing, JVM handles shut down } } 

स्टॉप () विधि को खाली छोड़ते हुए, हम JVM को अपने दम पर कंटेनर के पूरा होने को संभालने में सक्षम बनाते हैं। हम एक साधारण सिंगलटन को भी लागू करते हैं, जिसमें केवल पहला परीक्षण कंटेनर शुरू करता है, और प्रत्येक बाद के परीक्षण एक मौजूदा उदाहरण का उपयोग करता है। प्रारंभ () विधि में, हम पर्यावरण चर के लिए कनेक्शन मापदंडों को बचाने के लिए सिस्टम # सेटप्रॉपर्टी का उपयोग करते हैं।

अब हम उन्हें application.properties फ़ाइल में लिख सकते हैं:

 spring.datasource.url=${DB_URL} spring.datasource.username=${DB_USERNAME} spring.datasource.password=${DB_PASSWORD} 

अब हम परीक्षण उपयोगिता में अपनी उपयोगिता वर्ग का उपयोग करते हैं:

 @RunWith(SpringRunner.class) @SpringBootTest public class UserRepositoryTCAutoIntegrationTest { @ClassRule public static PostgreSQLContainer postgreSQLContainer = BaeldungPostgresqlContainer.getInstance(); // tests } 

पिछले उदाहरणों की तरह, हमने कंटेनर परिभाषा के साथ फ़ील्ड में @ClassRule एनोटेशन लागू किया। इस प्रकार, डेटा स्रोत कनेक्शन पैरामीटर को स्प्रिंग संदर्भ बनाने से पहले सही मानों के साथ आबाद किया जाता है।

अब हम अपने उपयोगिता वर्ग BaeldungPostgresqlContainer का उपयोग करके बनाए गए @ClassRule एनोटेशन के साथ फ़ील्ड सेट करके उसी डेटाबेस उदाहरण का उपयोग करके कई परीक्षण लागू कर सकते हैं।

5. निष्कर्ष

इस लेख में, हमने एक उत्पादन डेटाबेस पर Testcontainers का उपयोग करके परीक्षण विधियों को दिखाया।

हमने स्प्रिंग से ApplicationContextInitializer तंत्र का उपयोग करके एकल परीक्षण का उपयोग करने के उदाहरणों की भी जांच की, साथ ही एक डेटाबेस उदाहरण का पुन: उपयोग करने के लिए एक वर्ग को लागू किया।

हमने यह भी दिखाया कि कैसे टेस्टकॉनटेनर कई डेटाबेस प्रदाताओं के बीच संगतता के मुद्दों की पहचान करने में मदद कर सकते हैं, विशेष रूप से देशी प्रश्नों के लिए।

हमेशा की तरह, इस लेख में प्रयुक्त पूर्ण कोड GitHub पर उपलब्ध है ।