ऐसी स्थिति की कल्पना करें जहां आपकी परियोजना को विभिन्न वातावरणों में संकलित करने की आवश्यकता है।

अब कल्पना करें कि इन वातावरणों में सभी परीक्षण पास नहीं होने चाहिए - प्रत्येक के पास परीक्षणों का अपना सेट है।

और यह पसंद करने के लिए बेहतर है कि कौन सा परीक्षण किया जाना चाहिए ... application.properties फ़ाइल - प्रत्येक परीक्षण का अपना / बंद स्विच है।

बहुत अच्छा लगता है, है ना?

फिर बिल्ली का स्वागत करते हैं, जहां हम स्प्रिंगबूट 2 और जुनाइट 5 का उपयोग करके यह सब लागू करते हैं।

प्रीसेट

सबसे पहले, JUnit 4 को बंद करें, जो कि स्प्रिंगबूट 2 में डिफ़ॉल्ट रूप से आता है, और JUnit 5 को चालू करें।

ऐसा करने के लिए, pom.xml परिवर्तन करें:

 <dependencies> <!--...--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>junit</groupId> <artifactId>junit</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.junit.jupiter</groupId> <artifactId>junit-jupiter-engine</artifactId> <version>5.3.2</version> <scope>test</scope> </dependency> <!--...--> </dependencies> 

प्रस्तावित समाधान

हम प्रत्येक परीक्षण को एक सरल एनोटेशन के साथ एक संपत्ति के साथ एनोटेट करना चाहते हैं जो यह दर्शाता है कि परीक्षण सक्षम है या नहीं। याद रखें कि हम इस प्रॉपर्टी के मूल्यों को application.properties फ़ाइल में स्टोर करने जा रहे हैं।

अमूर्त

एक टिप्पणी बनाएं:

 @Retention(RetentionPolicy.RUNTIME) @ExtendWith(TestEnabledCondition.class) public @interface TestEnabled { String property(); } 

एनोटेशन प्रोसेसिंग

एक एनोटेशन हैंडलर अपरिहार्य है।

 public class TestEnabledCondition implements ExecutionCondition { @Override public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { Optional<TestEnabled> annotation = context.getElement().map(e -> e.getAnnotation(TestEnabled.class)); return context.getElement() .map(e -> e.getAnnotation(TestEnabled.class)) .map(annotation -> { String property = annotation.property(); return Optional.ofNullable(environment.getProperty(property, Boolean.class)) .map(value -> { if (Boolean.TRUE.equals(value)) { return ConditionEvaluationResult.enabled("Enabled by property: "+property); } else { return ConditionEvaluationResult.disabled("Disabled by property: "+property); } }).orElse( ConditionEvaluationResult.disabled("Disabled - property <"+property+"> not set!") ); }).orElse( ConditionEvaluationResult.enabled("Enabled by default") ); } } 

आपको एक वर्ग बनाना होगा (बिना स्प्रिंग का एनोटेशन @Component ) जो ExecutionCondition इंटरफ़ेस लागू करता है।

इस वर्ग में, आपको इस इंटरफ़ेस की एक विधि लागू करने की आवश्यकता है - ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) ।

यह विधि JUnit द्वारा चलाए जा रहे परीक्षण का संदर्भ लेती है और यह शर्त लौटाती है कि परीक्षण चलाया जाना चाहिए या नहीं।

आधिकारिक दस्तावेज में JUnit5 परीक्षणों के सशर्त निष्पादन पर अधिक पढ़ें।

लेकिन हम इस मामले में application.properties में दर्ज की गई संपत्ति के मूल्य की जांच कैसे करते हैं?

JUnit प्रसंग से वसंत संदर्भ तक पहुँच प्राप्त करना

इस तरह हम स्प्रिंग पर्यावरण प्राप्त कर सकते हैं जिसके साथ हमारा जेनेट परीक्षण विस्ताराकोटेक्स्ट से चलाया गया था।

 Environment environment = SpringExtension.getApplicationContext(context).getEnvironment(); 

आप TestEnabledCondition वर्ग के पूर्ण कोड पर एक नज़र डाल सकते हैं।

टेस्ट बनाएं

आइए कुछ परीक्षण बनाएं और उनके लॉन्च को नियंत्रित करने का प्रयास करें:

 @SpringBootTest public class SkiptestApplicationTests { @TestEnabled(property = "app.skip.test.first") @Test public void testFirst() { assertTrue(true); } @TestEnabled(property = "app.skip.test.second") @Test public void testSecond() { assertTrue(false); } } 

हमारी application.properties फ़ाइल इस तरह दिखाई देती है:

 app.skip.test.first=true app.skip.test.second=false 

इसलिए ...

स्टार्टअप परिणाम:

अगला कदम हमारी संपत्तियों के उपसर्गों को वर्ग एनोटेशन में अलग करना है

प्रत्येक परीक्षण से पहले application.properties से पूरी संपत्ति के नाम लिखना एक कठिन काम है। इसलिए, उनके उपसर्ग को परीक्षण वर्ग के स्तर पर - एक अलग एनोटेशन में रखना उचित है।

उपसर्गों को संग्रहीत करने के लिए एनोटेशन बनाएं - TestEnabledPrefix :

 @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) public @interface TestEnabledPrefix { String prefix(); } 

TestEnabledPrefix एनोटेशन प्रसंस्करण और उपयोग करना

हम नए एनोटेशन के प्रसंस्करण के लिए आगे बढ़ते हैं।

आइए एनोटेशनडेसक्रिप्शन हेल्पर क्लास बनाएं

इस वर्ग के साथ, हम application.properties और उसके मूल्य से संपत्ति का नाम संग्रहीत कर सकते हैं।

 public class TestEnabledCondition implements ExecutionCondition { static class AnnotationDescription { String name; Boolean annotationEnabled; AnnotationDescription(String prefix, String property) { this.name = prefix + property; } String getName() { return name; } AnnotationDescription setAnnotationEnabled(Boolean value) { this.annotationEnabled = value; return this; } Boolean isAnnotationEnabled() { return annotationEnabled; } } /* ... */ } 

यह वर्ग हमारे लिए उपयोगी है, क्योंकि हम लैम्बडा एक्सप्रेशन का उपयोग करने जा रहे हैं।

चलिए एक विधि बनाते हैं जो TestEnabledPrefix वर्ग के एनोटेशन से उपसर्ग संपत्ति का मान निकालेगी

 public class TestEnabledCondition implements ExecutionCondition { /* ... */ private AnnotationDescription makeDescription(ExtensionContext context, String property) { String prefix = context.getTestClass() .map(cl -> cl.getAnnotation(TestEnabledPrefix.class)) .map(TestEnabledPrefix::prefix) .map(pref -> !pref.isEmpty() && !pref.endsWith(".") ? pref + "." : "") .orElse(""); return new AnnotationDescription(prefix, property); } /* ... */ } 

और अब चलो परीक्षण एनोटेशन में निर्दिष्ट नाम से application.properties से संपत्ति के मूल्य की जांच करें

 public class TestEnabledCondition implements ExecutionCondition { /* ... */ @Override public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) { Environment environment = SpringExtension.getApplicationContext(context).getEnvironment(); return context.getElement() .map(e -> e.getAnnotation(TestEnabled.class)) .map(TestEnabled::property) .map(property -> makeDescription(context, property)) .map(description -> description.setAnnotationEnabled(environment.getProperty(description.getName(), Boolean.class))) .map(description -> { if (description.isAnnotationEnabled()) { return ConditionEvaluationResult.enabled("Enabled by property: "+description.getName()); } else { return ConditionEvaluationResult.disabled("Disabled by property: "+description.getName()); } }).orElse( ConditionEvaluationResult.enabled("Enabled by default") ); } } 

पूरा क्लास कोड यहाँ उपलब्ध है।

नए एनोटेशन का उपयोग करना

अब हमारे एनोटेशन को टेस्ट क्लास में लागू करें:

 @SpringBootTest @TestEnabledPrefix(property = "app.skip.test") public class SkiptestApplicationTests { @TestEnabled(property = "first") @Test public void testFirst() { assertTrue(true); } @TestEnabled(property = "second") @Test public void testSecond() { assertTrue(false); } } 

अब हमारा परीक्षण कोड क्लीनर और सरल है।

मैं Reddit के उपयोगकर्ताओं को उनकी सलाह के लिए धन्यवाद देना चाहता हूं:

1) सलाह के लिए dpash
2) सलाह के लिए BoyRobot777

पुनश्च

लेख एक अनुवाद है। अंग्रेजी संस्करण प्रोजेक्ट कोड के आगे README.md फ़ाइल में प्रकाशित हुआ है।