🌑 🐮 🤸🏾 मावेन, जुनीत और स्प्रिंग के साथ एकीकरण टेस्ट 🛵 🤷 🕋

यूनिट परीक्षण एक अच्छी बात है, लेकिन, मेरी राय में, आप केवल उन पर भरोसा नहीं कर सकते। कभी-कभी यह जांचना बहुत महत्वपूर्ण होता है कि कितनी कक्षाएँ काम करती हैं, और कभी-कभी एक साथ अनुप्रयोग परतें।

हमारा एप्लिकेशन सक्रिय रूप से स्प्रिंग का उपयोग करता है, जिसका अर्थ है कि ऐसे एकीकरण परीक्षणों को वसंत संदर्भ के साथ काम करना चाहिए।

अक्सर, ऐसे परीक्षणों में बहुत समय लग सकता है, भले ही आप इन-मेमोरी डेटाबेस का उपयोग करें (वैसे, मैंने जाँच की कि क्यों - हमारे पास प्रत्येक और हाइबरनेट इनिशियलाइज़ेशन में कई गुणों के साथ बहुत सारे जेपीए इकाइयाँ हैं, यह दसियों सेकंड लेता है!)

इसलिए हमें यह सुनिश्चित करने की आवश्यकता है कि इन परीक्षणों को सामान्य इकाई परीक्षणों के विपरीत, निर्माण के दौरान निष्पादित नहीं किया जाता है।

तो योजना यह है:
1. हम एप्लिकेशन की दो परतों में विभाजित सेवाओं को लिखते हैं
2. उन्हें वसंत के साथ कनेक्ट करें
3. हम इन सेवाओं की बातचीत के लिए JUnit का उपयोग करके एक परीक्षण लिखेंगे (वास्तविक, बिना किसी नकली)
4. सुनिश्चित करें कि यह परीक्षण बिल्ड के दौरान डिफ़ॉल्ट रूप से नहीं चलता है
5. लाभ!

1. हम एप्लिकेशन की दो परतों में विभाजित सेवाओं को लिखते हैं

दो परतें क्यों? मैं व्यापार तर्क को परतों में तोड़ना पसंद करता हूं (उदाहरण के लिए, दृढ़ता परत) ताकि कोड स्पेगेटी में बदल न जाए। परतों में एक पदानुक्रम है - जो किसे कॉल कर सकते हैं और परतों को अलग-अलग मावेन परियोजनाओं में अलग कर सकते हैं, मैं जांचता हूं कि कोई निषिद्ध निर्भरता नहीं है।

तो, हम निर्भरता के साथ पूरे आवेदन के pom.xml बनाते हैं जो सभी को चाहिए:

<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.mycompany</groupId> <artifactId>myapp</artifactId> <version>1.0-SNAPSHOT</version> <packaging>pom</packaging> <name>myapp</name> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring-version>3.1.0.RELEASE</spring-version> </properties> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.8.2</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>${spring-version}</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>${spring-version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring-version}</version> </dependency> </dependencies> <modules> <module>backend</module> <module>frontend</module> <module>gui</module> </modules> </project>

इसके तीन मॉड्यूल हैं - गुई, फ्रंटेंड और बैकएंड (बिजनेस लॉजिक की दो परतें)।

यहाँ दृश्य के लिए pom.xml है:

 <?xml version="1.0"?> <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.mycompany</groupId> <artifactId>myapp</artifactId> <version>1.0-SNAPSHOT</version> </parent> <groupId>com.mycompany</groupId> <artifactId>frontend</artifactId> <version>1.0-SNAPSHOT</version> <name>frontend</name> <dependencies> <dependency> <groupId>com.mycompany</groupId> <artifactId>backend</artifactId> <version>1.0-SNAPSHOT</version> </dependency> </dependencies> </project>

जैसा कि आप देख सकते हैं, यह बैकएंड पर निर्भर करता है, और यह अपने पिता के पोम से सब कुछ प्राप्त करता है।

यहाँ बैकेंड के लिए pom.xml है:

 <?xml version="1.0"?> <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.mycompany</groupId> <artifactId>myapp</artifactId> <version>1.0-SNAPSHOT</version> </parent> <groupId>com.mycompany</groupId> <artifactId>backend</artifactId> <version>1.0-SNAPSHOT</version> <name>backend</name> </project>

निर्देशिका बैकएंड / src / main / java / com / mycompany / सेवा / बैकएंड में, बनाएँ:

IBackendService1.java:

 package com.mycompany.service.backend; public interface IBackendService1 { String computeSecretString(); }

IBackendService2.java:

 package com.mycompany.service.backend; public interface IBackendService2 { int computeSecretNumber(); }

BackendService1.java:

 package com.mycompany.service.backend; public class BackendService1 implements IBackendService1 { @Override public String computeSecretString() { return "James Bond"; } }

BackendService2.java:

 package com.mycompany.service.backend; public class BackendService2 implements IBackendService2 { @Override public int computeSecretNumber() { return 7; } }

निर्देशिका दृश्यपटल / src / main / java / com / mycompany / सेवा / दृश्यपटल में, बनाएँ:

IFrontendService.java:

 package com.mycompany.service.frontend; public interface IFrontendService { String getAgent(); }

FrontendService.java:

 package com.mycompany.service.frontend; import com.mycompany.service.backend.*; public class FrontendService implements IFrontendService { private IBackendService1 backendService1; private IBackendService2 backendService2; public FrontendService(IBackendService1 backendService1, IBackendService2 backendService2) { this.backendService1 = backendService1; this.backendService2 = backendService2; } @Override public String getAgent() { return backendService1.computeSecretString()+backendService2.computeSecretNumber(); } }

2. उन्हें वसंत के साथ कनेक्ट करें

बैकएंड / src / मुख्य / संसाधन / बैकएंड- beans.xml:

 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <bean id="names_provider" class="com.mycompany.service.backend.BackendService1"/> <bean id="secret_service" class="com.mycompany.service.backend.BackendService2"/> </beans>

फ्रंटेंड / src / मुख्य / संसाधन / फ्रंटेंड- beans.xml:

 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd "> <import resource="classpath:backend-beans.xml"/> <bean id="agent_service" class="com.mycompany.service.frontend.FrontendService"> <constructor-arg index="0" ref="names_provider"/> <constructor-arg index="1" ref="secret_service"/> </bean> </beans>

3. हम इन सेवाओं की बातचीत के लिए JUnit का उपयोग करके एक परीक्षण लिखेंगे (असली, बिना किसी नकली)

निर्देशिका में दृश्यपटल / src / परीक्षण / जावा / कॉम / mycompany / एकीकरण
FrontendServiceTest.java:

 package com.mycompany.integration; import com.mycompany.service.frontend.IFrontendService; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.test.annotation.DirtiesContext; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import static org.junit.Assert.assertTrue; @RunWith(SpringJUnit4ClassRunner.class) @DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD) @ContextConfiguration(locations = {"classpath:frontend-beans.xml"}) public class FrontendServiceTest { @Autowired IFrontendService frontendService; @Test public void testBond() { String agent = frontendService.getAgent(); assertTrue("It should be Bond", agent.contains("Bond")); } }

नोट नोट करें:
@RunWith(SpringJUnit4ClassRunner.class) - स्प्रिंग के "ट्रिगर" के साथ परीक्षण चलाता है
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_EACH_TEST_METHOD) - प्रत्येक परीक्षण विधि के लिए फिर से एक स्प्रिंग संदर्भ बनाएगा
@ContextConfiguration(locations = {"classpath:frontend-beans.xml"}) - जहां सेम प्राप्त करने के लिए

यदि आप प्रोफाइल का उपयोग करते हैं तो @ActiveProfiles(profiles = "local") ।

@Autowired आपकी बीन्स को टेस्ट क्लास में इंजेक्ट @Autowired । यदि आपके पास एक से अधिक सेम है जो एक विशिष्ट इंटरफ़ेस को लागू करता है, तो आप इसे @Resource(name = "session-operations") बदल सकते हैं @Resource(name = "session-operations")

4. सुनिश्चित करें कि यह परीक्षण बिल्ड के दौरान डिफ़ॉल्ट रूप से नहीं चलता है

पूरे आवेदन के pom.xml में जोड़ें:

  <properties> ... <systest.package>**/com/mycompany/integration/**</systest.package> </properties> <build> .... <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.5</version> <configuration> <excludes> <exclude>${systest.package}</exclude> <exclude>**/*$*</exclude> </excludes> </configuration> </plugin> </plugins> </build>

अब निर्माण के दौरान परीक्षण शुरू नहीं होगा। (हमने यह भी कहा कि आंतरिक कक्षाएं परीक्षण नहीं हैं)

और न केवल नाम से इसे चलाने में सक्षम होने के लिए, एक प्रोफ़ाइल जोड़ें जिसमें यह exclude नहीं है:

  <profiles> <profile> <id>systest</id> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.5</version> <configuration> <excludes> <exclude>**/*$*</exclude> </excludes> </configuration> </plugin> </plugins> </build> </profile> </profiles>

अब com.mycompany.integration में स्थित सभी परीक्षण बिल्ड के दौरान नहीं चलेंगे, लेकिन उन्हें चलाने के लिए आपको मावेन प्रोफाइल "सिस्टेस्ट" स्थापित करना होगा, उदाहरण के लिए:

mvn -P=systest test

मावेन, जुनीत और स्प्रिंग के साथ एकीकरण टेस्ट

1. हम एप्लिकेशन की दो परतों में विभाजित सेवाओं को लिखते हैं

2. उन्हें वसंत के साथ कनेक्ट करें

3. हम इन सेवाओं की बातचीत के लिए JUnit का उपयोग करके एक परीक्षण लिखेंगे (असली, बिना किसी नकली)

4. सुनिश्चित करें कि यह परीक्षण बिल्ड के दौरान डिफ़ॉल्ट रूप से नहीं चलता है

5. लाभ!

More articles: