java - JUnit4 में विशिष्ट क्रम में परीक्षण विधियों को कैसे चलाएं?




unit-testing (10)

मैं परीक्षण विधियों को निष्पादित करना चाहता @Test जिन्हें विशिष्ट क्रम में @Test द्वारा एनोटेट किया गया है।

उदाहरण के लिए:

public class MyTest {
    @Test public void test1(){}
    @Test public void test2(){}
}

मैं test2() test1() से पहले test2() को चलाने के लिए सुनिश्चित करना चाहता हूं, हर बार जब मैं @Test(order=xx) हूं, लेकिन मुझे @Test(order=xx) जैसे एनोटेशन नहीं मिल सका।

मुझे लगता है कि जुनीट के लिए यह काफी महत्वपूर्ण विशेषता है, अगर जुनीट के लेखक ऑर्डर फीचर नहीं चाहते हैं , तो क्यों?


मुझे लगता है कि जुनीट के लिए यह काफी महत्वपूर्ण विशेषता है, अगर जुनीट के लेखक ऑर्डर फीचर नहीं चाहते हैं, तो क्यों?

मुझे यकीन नहीं है कि जुनीट के साथ ऐसा करने का एक साफ तरीका है, मेरे ज्ञान के लिए जुनीट मानते हैं कि सभी परीक्षण मनमाना क्रम में किए जा सकते हैं। एफएक्यू से:

मैं एक परीक्षण स्थिरता का उपयोग कैसे करूं?

(...) टेस्ट-विधि इनवोकेशन का ऑर्डर करने की गारंटी नहीं है , इसलिए testOneItemCollection () testEmptyCollection () से पहले निष्पादित किया जा सकता है। (...)

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

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


(अभी तक अप्रकाशित) परिवर्तन https://github.com/junit-team/junit/pull/386 एक @SortMethodsWith परिचय करता है। https://github.com/junit-team/junit/pull/293 कम से कम आदेश के बिना अनुमानित किया गया है (जावा 7 में यह काफी यादृच्छिक हो सकता है)।


एक जुनीट रिपोर्ट देखें। जुनीट पहले ही पैकेज द्वारा व्यवस्थित है। प्रत्येक पैकेज में टेस्टसूइट कक्षाएं होती हैं (या हो सकती हैं), जिनमें से प्रत्येक बदले में कई टेस्टकेस चलाती है। प्रत्येक टेस्टकेस में public void test*() के रूप में कई परीक्षण विधियां हो सकती हैं, जिनमें से प्रत्येक वास्तव में टेस्टकेस कक्षा का उदाहरण बन जाएगी, जिसमें वे संबंधित हैं। प्रत्येक टेस्ट विधि (टेस्टकेस इंस्टेंस) का नाम और पास / असफल मानदंड होता है।

मेरे प्रबंधन की आवश्यकता क्या है व्यक्तिगत टेस्टस्टेप वस्तुओं की अवधारणा, जिनमें से प्रत्येक अपने पास / असफल मानदंडों की रिपोर्ट करता है। किसी भी परीक्षण चरण में विफलता को बाद के परीक्षण चरणों के निष्पादन को रोकना नहीं चाहिए।

अतीत में, मेरी स्थिति में टेस्ट डेवलपर्स ने टेस्टकेस कक्षाओं को टेस्ट के तहत उत्पाद के भाग (भाग) के अनुरूप पैकेज में व्यवस्थित किया, प्रत्येक परीक्षण के लिए टेस्टकेस क्लास बनाया, और प्रत्येक परीक्षण विधि को परीक्षण में एक अलग "चरण" बनाया, जुनीट आउटपुट में अपने पास / असफल मानदंडों के साथ पूरा करें। प्रत्येक टेस्टकेस एक स्टैंडअलोन "परीक्षण" है, लेकिन व्यक्तिगत तरीकों, या टेस्टकेस के भीतर "चरणों" का परीक्षण, एक विशिष्ट क्रम में होना चाहिए।

टेस्टकेस विधियां टेस्टकेस के चरण थे, और परीक्षण डिजाइनरों को प्रति परीक्षण चरण में एक अलग पास / असफल मानदंड मिला। अब परीक्षण कदम झुकाए गए हैं, और परीक्षण (निश्चित रूप से) असफल हो जाते हैं।

उदाहरण के लिए:

Class testStateChanges extends TestCase

public void testCreateObjectPlacesTheObjectInStateA()
public void testTransitionToStateBAndValidateStateB()
public void testTransitionToStateCAndValidateStateC()
public void testTryToDeleteObjectinStateCAndValidateObjectStillExists()
public void testTransitionToStateAAndValidateStateA()
public void testDeleteObjectInStateAAndObjectDoesNotExist()
public void cleanupIfAnythingWentWrong()

प्रत्येक परीक्षण विधि अपने स्वयं के अलग पास / असफल मानदंडों का दावा करती है और रिपोर्ट करती है। ऑर्डर करने के लिए इसे "एक बड़ी टेस्ट विधि" में संकुचित करने से जुनीट सारांश रिपोर्ट में प्रत्येक "चरण" के पास / असफल मानदंड ग्रैन्युलरिटी को खो देता है। ... और यह मेरे प्रबंधकों को परेशान करता है। वे वर्तमान में एक और विकल्प की मांग कर रहे हैं।

क्या कोई समझा सकता है कि स्कैनबल्ड टेस्ट विधि ऑर्डरिंग के साथ एक जुनीट प्रत्येक अनुक्रमिक परीक्षण चरण के अलग-अलग पास / असफल मानदंडों का समर्थन करेगा, जैसा कि उपरोक्त उदाहरण और मेरे प्रबंधन द्वारा आवश्यक है?

दस्तावेज के बावजूद, मैं इसे जुनीट ढांचे में एक गंभीर प्रतिगमन के रूप में देखता हूं जो कई परीक्षण डेवलपर्स के लिए जीवन कठिन बना रहा है।


कृपया इसे https://github.com/TransparentMarket/junit : https://github.com/TransparentMarket/junit । यह उनके द्वारा निर्दिष्ट क्रम में परीक्षण चलाता है (संकलित कक्षा फ़ाइल के भीतर परिभाषित)। इसके अलावा उप-पैकेज द्वारा परिभाषित परीक्षण चलाने के लिए ऑलटेस्ट सूट भी शामिल है। ऑलटेस्ट कार्यान्वयन का उपयोग करने से गुणों के लिए फ़िल्टरिंग में समाधान भी बढ़ाया जा सकता है (हम @Fast एनोटेशन का उपयोग करते थे लेकिन वे अभी तक प्रकाशित नहीं हुए थे)।


जब मैंने जूनिट पर काम किया था तब मैंने इसका मुख्य मुद्दा उठाया था और मैं निम्नलिखित समाधान के साथ आया जो मेरे लिए ठीक काम करता है:

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;

public class OrderedRunner extends BlockJUnit4ClassRunner {

    public OrderedRunner(Class<?> clazz) throws InitializationError {
        super(clazz);
    }

    @Override
    protected List<FrameworkMethod> computeTestMethods() {
        List<FrameworkMethod> list = super.computeTestMethods();
        List<FrameworkMethod> copy = new ArrayList<FrameworkMethod>(list);
        Collections.sort(copy, new Comparator<FrameworkMethod>() {

            @Override
            public int compare(FrameworkMethod f1, FrameworkMethod f2) {
                Order o1 = f1.getAnnotation(Order.class);
                Order o2 = f2.getAnnotation(Order.class);

                if (o1 == null || o2 == null) {
                    return -1;
                }

                return o1.order() - o2.order();
            }
        });
        return copy;
    }
}

नीचे एक इंटरफ़ेस भी बनाएं:

 @Retention(RetentionPolicy.RUNTIME)


@Target({ ElementType.METHOD})

public @interface Order {
public int order();
}

अब मान लें कि आपके पास कक्षा ए है जहां आपने नीचे कई परीक्षण मामले लिखे हैं:

(@runWith=OrderRunner.class)
Class A{
@Test
@Order(order = 1)

void method(){

//do something

}

}

तो "विधि ()" नामक विधि से निष्पादन शुरू होगा। धन्यवाद!


टेस्टएनजी में माइग्रेशन सबसे अच्छा तरीका प्रतीत होता है, लेकिन मुझे जुनीट के लिए यहां कोई स्पष्ट समाधान नहीं दिख रहा है। Junit के लिए मैंने पाया सबसे अधिक पढ़ने योग्य समाधान / स्वरूपण यहां दिया गया है:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SampleTest {
    @Test
    void stage1_prepareAndTest(){};

    @Test
    void stage2_checkSomething(){};

    @Test
    void stage2_checkSomethingElse(){};

    @Test
    void stage3_thisDependsOnStage2(){};

    @Test
    void callTimeDoesntMatter(){}
}

यह सुनिश्चित करता है कि चरण 1 विधियों को चरण 1 के बाद और चरण 3 के पहले कहा जाता है।


मैं यहां सोच रहा था कि मेरे परीक्षण क्रम में नहीं चल रहे थे, लेकिन सच्चाई यह है कि गड़बड़ मेरी एसिंक नौकरियों में थी। समेकन के साथ काम करते समय आपको अपने परीक्षणों के बीच समवर्ती जांच भी करने की आवश्यकता है। मेरे मामले में, नौकरियां और परीक्षण एक सेमफोर साझा करते हैं, इसलिए अगले परीक्षण तब तक लटकते हैं जब तक चलने वाली नौकरी लॉक जारी नहीं करती है।

मुझे पता है कि यह इस सवाल से पूरी तरह से संबंधित नहीं है, लेकिन शायद सही मुद्दे को लक्षित करने में मदद कर सकता है


मैंने कुछ जवाब पढ़े हैं और यह सर्वोत्तम अभ्यास नहीं मानते हैं, लेकिन आपके परीक्षणों को ऑर्डर करने का सबसे आसान तरीका - और जिस तरह से जुनीट डिफ़ॉल्ट रूप से परीक्षण चलाता है वह वर्णमाला नाम आरोही है।

तो बस अपने परीक्षणों को वर्णमाला क्रम में नाम दें जो आप चाहते हैं। यह भी ध्यान दें कि परीक्षण नाम शब्द परीक्षण के साथ शुरू होना चाहिए। बस संख्याओं के लिए बाहर देखो

test12 test2 से पहले चलाएगा

इसलिए:

testA_MyFirstTest testC_ThirdTest testB_ATestThatRunsSecond


यदि आप जूनिट के अपने मौजूदा उदाहरण से छुटकारा पा लेते हैं, और बिल्ड पथ में जुनीट 4.11 या इससे अधिक डाउनलोड करते हैं, तो निम्न कोड आरोही क्रम में क्रमबद्ध, उनके नामों के क्रम में परीक्षण विधियों को निष्पादित करेगा:

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SampleTest {

    @Test
    public void testAcreate() {
        System.out.println("first");
    }
    @Test
    public void testBupdate() {
        System.out.println("second");
    }
    @Test
    public void testCdelete() {
        System.out.println("third");
    }
}

यहां जुनीट का विस्तार है जो वांछित व्यवहार का उत्पादन कर सकता है: https://github.com/aafuks/aaf-junit

मुझे पता है कि यह जुनीट दर्शन के लेखकों के खिलाफ है, लेकिन जब पर्यावरण में जुनीट का उपयोग करते हैं जो सख्त इकाई परीक्षण (जावा में अभ्यास के रूप में नहीं) हैं तो यह बहुत उपयोगी हो सकता है।





junit4