कैसे फिर से चलाने के लिए विफल JUnit परीक्षण तुरंत?

Question 1

क्या एक ऐसा तरीका है जो एक न्याय नियम या ऐसा ही कुछ है जो हर असफल परीक्षा को एक बार फिर मौका देता है, बस इसे एक बार फिर से चलाने की कोशिश करता है।

पृष्ठभूमि: मेरे पास जेनेट के साथ लिखे गए सेलेनियम 2-वेबड्राइवर परीक्षणों का एक बड़ा सेट है। बहुत आक्रामक समय के कारण (क्लिक के बाद केवल कम प्रतीक्षा अवधि) कुछ परीक्षण (100 में से 1, और हमेशा एक अलग एक) विफल हो सकते हैं क्योंकि सर्वर कभी-कभी थोड़ा धीमा प्रतिक्रिया करता है। लेकिन मैं प्रतीक्षा अवधि को इतना लंबा नहीं कर सकता कि यह निश्चित रूप से काफी लंबा हो, क्योंकि तब परीक्षण हमेशा के लिए होंगे।) - इसलिए मुझे लगता है कि यह इस उपयोग के मामले के लिए स्वीकार्य है कि एक परीक्षण हरा है भले ही उसे दूसरा चाहिए प्रयत्न।

बेशक 3 में से 2 का बहुमत होना बेहतर होगा (3 बार फेल होने वाले टेस्ट को दोहराएं, और उन्हें सही मानें, अगर दो में से दो टेस्ट सही हैं), लेकिन यह भविष्य में सुधार होगा।

Question 2

आप एक TestRule के साथ ऐसा कर सकते हैं । इससे आपको अपनी जरूरत का लचीलापन मिलेगा। एक TestRule आपको परीक्षण के चारों ओर तर्क सम्मिलित करने की अनुमति देता है, इसलिए आप रिट्री लूप को लागू करेंगे:

public class RetryTest {
    public class Retry implements TestRule {
        private int retryCount;

        public Retry(int retryCount) {
            this.retryCount = retryCount;
        }

        public Statement apply(Statement base, Description description) {
            return statement(base, description);
        }

        private Statement statement(final Statement base, final Description description) {
            return new Statement() {
                @Override
                public void evaluate() throws Throwable {
                    Throwable caughtThrowable = null;

                    // implement retry logic here
                    for (int i = 0; i < retryCount; i++) {
                        try {
                            base.evaluate();
                            return;
                        } catch (Throwable t) {
                            caughtThrowable = t;
                            System.err.println(description.getDisplayName() + ": run " + (i+1) + " failed");
                        }
                    }
                    System.err.println(description.getDisplayName() + ": giving up after " + retryCount + " failures");
                    throw caughtThrowable;
                }
            };
        }
    }

    @Rule
    public Retry retry = new Retry(3);

    @Test
    public void test1() {
    }

    @Test
    public void test2() {
        Object o = null;
        o.equals("foo");
    }
}

A का दिल एक TestRuleहै base.evaluate(), जो आपके परीक्षण विधि को कहता है। तो इस कॉल के आसपास आप एक रिट्री लूप डालते हैं। यदि आपकी परीक्षा पद्धति में एक अपवाद रखा गया है (वास्तव में एक विफलता विफलता है AssertionError), तो परीक्षण विफल हो गया है, और आप फिर से प्रयास करेंगे।

एक और चीज है जो उपयोग की हो सकती है। आप केवल परीक्षण के एक सेट पर इस रिट्री लॉजिक को लागू करना चाह सकते हैं, जिस स्थिति में आप विधि पर एक विशेष एनोटेशन के लिए टेस्ट से ऊपर रिट्री क्लास में जोड़ सकते हैं। Descriptionविधि के लिए एनोटेशन की एक सूची है। इसके बारे में अधिक जानकारी के लिए, मेरा उत्तर देखें कि कैसे प्रत्येक JUnit @Test पद्धति से पहले कुछ कोड चलाने के लिए, बिना @RunWith और AOP का उपयोग किए बिना? ।

एक कस्टम TestRunner का उपयोग करना

यह CKuck का सुझाव है, आप अपने स्वयं के रनर को परिभाषित कर सकते हैं। आपको BlockJUnit4ClassRunner का विस्तार करने और रनचाइल्ड () को ओवरराइड करने की आवश्यकता है । अधिक जानकारी के लिए मेरा उत्तर देखें कि सूट में ज्यूनिट विधि नियम को कैसे परिभाषित किया जाए? । यह उत्तर विवरण देता है कि एक सूट में हर विधि के लिए कोड को कैसे चलाया जाए, इसके लिए आपको अपने रनर को कैसे परिभाषित करना है।

Question 3

अब एक बेहतर विकल्प है। यदि आप मावेन प्लगइन्स का उपयोग कर रहे हैं जैसे: सर्फ या फेलसेफ में पैरामीटर rerunFailingTestsCount सरफेयर आपी को जोड़ने का विकल्प है । यह सामान निम्नलिखित टिकट में लागू किया गया था: जीरा टिकट । इस मामले में आपको अपने कस्टम कोड और प्लगइन को लिखने की आवश्यकता नहीं होती है जो स्वचालित रूप से परीक्षा परिणाम रिपोर्ट में संशोधन करते हैं।
मुझे इस दृष्टिकोण का केवल एक दोष दिखाई देता है: यदि कुछ परीक्षण पहले चरण में विफल रहा है / बाद में वर्ग चरण का परीक्षण फिर से नहीं होगा।

Question 4

मेरे लिए कस्टम रनर को और अधिक लचीला समाधान लिखना। ऊपर (कोड उदाहरण के साथ) पोस्ट किए गए समाधान के दो नुकसान हैं:

यदि यह @BeforeClass चरण में विफल रहता है तो यह परीक्षण का पुन: प्रयास नहीं करेगा;
यह गणना परीक्षणों को थोड़ा अलग तरीके से चलाता है (जब आपके पास 3 रिट्रीट होते हैं, तो आपको टेस्ट रन मिलेंगे: 4, सफलता 1 जो भ्रामक हो सकती है);

इसलिए मैं कस्टम रनर लिखने के साथ अधिक दृष्टिकोण पसंद करता हूं। और कस्टम धावक का कोड निम्नलिखित हो सकता है:

import org.junit.Ignore;
import org.junit.internal.AssumptionViolatedException;
import org.junit.internal.runners.model.EachTestNotifier;
import org.junit.runner.Description;
import org.junit.runner.notification.RunNotifier;
import org.junit.runner.notification.StoppedByUserException;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;


public class RetryRunner extends BlockJUnit4ClassRunner {

    private final int retryCount = 100;
    private int failedAttempts = 0;

    public RetryRunner(Class<?> klass) throws InitializationError {
        super(klass);
    }    


    @Override
    public void run(final RunNotifier notifier) {
        EachTestNotifier testNotifier = new EachTestNotifier(notifier,
                getDescription());
        Statement statement = classBlock(notifier);
        try {

            statement.evaluate();
        } catch (AssumptionViolatedException e) {
            testNotifier.fireTestIgnored();
        } catch (StoppedByUserException e) {
            throw e;
        } catch (Throwable e) {
            retry(testNotifier, statement, e);
        }
    }

    @Override
    protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
        Description description = describeChild(method);
        if (method.getAnnotation(Ignore.class) != null) {
            notifier.fireTestIgnored(description);
        } else {
            runTestUnit(methodBlock(method), description, notifier);
        }
    }

    /**
     * Runs a {@link Statement} that represents a leaf (aka atomic) test.
     */
    protected final void runTestUnit(Statement statement, Description description,
            RunNotifier notifier) {
        EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
        eachNotifier.fireTestStarted();
        try {
            statement.evaluate();
        } catch (AssumptionViolatedException e) {
            eachNotifier.addFailedAssumption(e);
        } catch (Throwable e) {
            retry(eachNotifier, statement, e);
        } finally {
            eachNotifier.fireTestFinished();
        }
    }

    public void retry(EachTestNotifier notifier, Statement statement, Throwable currentThrowable) {
        Throwable caughtThrowable = currentThrowable;
        while (retryCount > failedAttempts) {
            try {
                statement.evaluate();
                return;
            } catch (Throwable t) {
                failedAttempts++;
                caughtThrowable = t;
            }
        }
        notifier.addFailure(caughtThrowable);
    }
}

Question 5

आपको अपना स्वयं का लिखना होगा org.junit.runner.Runnerऔर अपने परीक्षणों को एनोटेट करना होगा @RunWith(YourRunner.class)।

Question 6

प्रस्तावित टिप्पणी इस लेख के आधार पर कुछ अतिरिक्त के साथ लिखी गई थी ।

यहां, यदि आपके junit प्रोजेक्ट से कुछ टेस्ट केस "विफलता" या "त्रुटि" परिणाम प्राप्त करते हैं, तो यह टेस्ट केस एक बार फिर से चलाया जाएगा। पूरी तरह से यहाँ हम सफलता के परिणाम प्राप्त करने के लिए 3 मौका निर्धारित किया है।

इसलिए, हमें नियम कक्षा बनाने और अपने टेस्ट कक्षा में "@ नियम " सूचनाएं जोड़ने की आवश्यकता है ।

यदि आप अपने प्रत्येक टेस्ट क्लास के लिए "@ नियम" सूचनाओं को राइट नहीं करना चाहते हैं, तो आप इसे अपने अमूर्त सेटप्रॉपर्टी क्लास (यदि आपके पास है) में जोड़ सकते हैं और इससे निकाल सकते हैं।

नियम वर्ग:

import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;

public class RetryRule implements TestRule {
    private int retryCount;

    public RetryRule (int retryCount) {
        this.retryCount = retryCount;
    }

    public Statement apply(Statement base, Description description) {
        return statement(base, description);
    }

    private Statement statement(final Statement base, final Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                Throwable caughtThrowable = null;

                // implement retry logic here
                for (int i = 0; i < retryCount; i++) {
                    try {
                        base.evaluate();
                        return;
                    } catch (Throwable t) {
                        caughtThrowable = t;
                        //  System.out.println(": run " + (i+1) + " failed");
                        System.err.println(description.getDisplayName() + ": run " + (i + 1) + " failed.");
                    }
                }
                System.err.println(description.getDisplayName() + ": giving up after " + retryCount + " failures.");
                throw caughtThrowable;
            }
        };
    }
}

टेस्ट क्लास:

import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.firefox.FirefoxDriver;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

/**
 * Created by ONUR BASKIRT on 27.03.2016.
 */
public class RetryRuleTest {

    static WebDriver driver;
    final private String URL = "http://www.swtestacademy.com";

    @BeforeClass
    public static void setupTest(){
        driver = new FirefoxDriver();
    }

    //Add this notification to your Test Class 
    @Rule
    public RetryRule retryRule = new RetryRule(3);

    @Test
    public void getURLExample() {
        //Go to www.swtestacademy.com
        driver.get(URL);

        //Check title is correct
        assertThat(driver.getTitle(), is("WRONG TITLE"));
    }
}

Question 7

इस उत्तर पर बनाया गया है इस सवाल का जवाब ।

यदि आपको ActivityScenarioप्रत्येक रन से पहले अपनी (और आपकी गतिविधि) की आवश्यकता है , तो आप इसे कोशिश-के-संसाधनों का उपयोग करके लॉन्च कर सकते हैं। ActivityScenarioउसके बाद प्रत्येक कोशिश के बाद स्वत: बंद हो जाएगा।

public final class RetryRule<A extends Activity> implements TestRule {
    private final int retryCount;
    private final Class<A> activityClazz;
    private ActivityScenario<A> scenario;

    /**
     * @param retryCount the number of retries. retryCount = 1 means 1 (normal) try and then
     * 1 retry, i.e. 2 tries overall
     */
    public RetryRule(int retryCount, @NonNull Class<A> clazz) {
        this.retryCount = retryCount;
        this.activityClazz = clazz;
    }

    public Statement apply(Statement base, Description description) {
        return statement(base, description);
    }

    private Statement statement(final Statement base, final Description description) {
        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                Throwable caughtThrowable = null;

                // implement retry logic here
                for (int i = 0; i <= retryCount; i++) {
                    try(ActivityScenario<A> scenario = ActivityScenario.launch(activityClazz)){
                        RetryRule.this.scenario = scenario;
                        base.evaluate();
                        return;
                    } catch (Throwable t) {
                        caughtThrowable = t;
                        Log.e(LOGTAG,
                                description.getDisplayName() + ": run " + (i + 1) + " failed: ", t);
                    }
                }
                Log.e(LOGTAG,
                        description.getDisplayName() + ": giving up after " + (retryCount + 1) +
                                " failures");
                throw Objects.requireNonNull(caughtThrowable);
            }
        };
    }

    public ActivityScenario<A> getScenario() {
        return scenario;
    }
}

आप getScenario()विधि का उपयोग करके अपने परिक्षणों में अपने परिदृश्य तक पहुँच सकते हैं ।