rx-java
इकाई का परीक्षण

टिप्पणियों

TestSubscriber

TestSubscribers आपको अपना स्वयं का सबस्क्राइबर बनाने के कार्य से बचने या कार्रवाई करने की अनुमति देता है <!> सत्यापित करने के लिए कि कुछ निश्चित मान जहाँ दिए गए हैं, वहाँ कितने हैं, यदि वेधशाला पूरी हो गई है, तो एक अपवाद उठाया गया था और एक पूरी बहुत कुछ।

शुरू करना

यह उदाहरण सिर्फ एक दावे को दर्शाता है कि मान 1,2,3 और 4 जहां वे ऑनरेबल के माध्यम से ऑब्जर्वेबल में पारित हुए हैं।

TestSubscriber<Integer> ts = TestSubscriber.create();
Observable.just(1,2,3,4).subscribe(ts);
ts.assertValues(1,2,3,4); // Success

assertValues दावा है कि गिनती सही है। यदि आप केवल कुछ मूल्यों को पारित करने के लिए थे, तो मुखर विफल हो जाएगा।

TestSubscriber<Integer> ts = TestSubscriber.create();
Observable.just(1,2,3,4).subscribe(ts);
ts.assertValues(1,2,3); // Fail

assertValues का उपयोग करता है equals विधि जब कर का दावा है। इससे आप आसानी से डेटा के रूप में व्यवहार किए जाने वाले वर्गों का परीक्षण कर सकते हैं।

TestSubscriber<Object> ts = TestSubscriber.create();
Observable.just(new Object(), new Object()).subscribe(ts);
ts.assertValues(new Object(), new Object()); // Fail

यह उदाहरण एक ऐसे वर्ग को दर्शाता है जिसमें ऑब्जर्वेबल से मानों को परिभाषित करने और उनका आकलन करने के बराबर है।

public class Room {

    public String floor;
    public String number;

    @Override
    public boolean equals(Object o) {
        if (o == this) {
            return true;
        }
        if (o instanceof Room) {
            Room that = (Room) o;
            return (this.floor.equals(that.floor))
                    && (this.number.equals(that.number));
        }
        return false;
    }
}

TestSubscriber<Room> ts = TestSubscriber.create();
Observable.just(new Room("1", "10")).subscribe(ts);
ts.assertValue(new Room("1", "10"); // Success

यह भी ध्यान रखें कि हम छोटे assertValue उपयोग करते हैं क्योंकि हमें केवल एक आइटम की जांच करनी है।

सभी आयोजन हो रहे हैं

जरूरत पड़ने पर आप एक सूची के रूप में सभी घटनाओं के लिए भी पूछ सकते हैं।

TestSubscriber<Integer> ts = TestSubscriber.create();
Observable.just(1,2,3,4).subscribe(ts);
List<Integer> onNextEvents = ts.getOnNextEvents();
List<Throwable> onErrorEvents = ts.getOnErrorEvents();
List<Notification<Integer>> onCompletedEvents = ts.getOnCompletedEvents();

घटनाओं पर जोर देना

यदि आप अपनी घटनाओं पर अधिक व्यापक परीक्षण करना चाहते हैं, तो आप अपने पसंदीदा दावे के साथ getOnNextEvents (या getOn*Events ) को जोड़ सकते हैं:

Observable<Integer> obs = Observable.just(1,2,3,4)
    .filter( x -> x % 2 == 0);

// note that we instanciate TestSubscriber via the constructor here 
TestSubscriber<Integer> ts = new TestSubscriber();
obs.subscribe(ts);

// Note that we are not using Observable#forEach here
// but java.lang.Iterable#forEach.
// You should never use Observable#forEach unless you know
// exactly what you're doing
ts.getOnNextEvents()
    .forEach( integer -> assertTrue(integer % 2 == 0));

परीक्षण Observable#error

आप यह सुनिश्चित कर सकते हैं कि सही अपवाद वर्ग उत्सर्जित होता है:

Observable<Integer> obs = Observable.error(new Exception("I am a Teapot"));

TestSubscriber<Integer> ts = new TestSubscriber<>();
obs.subscribe(ts);

ts.assertError(Exception.class);

आप यह भी सुनिश्चित कर सकते हैं कि सटीक अपवाद फेंक दिया गया था:

Exception e = new Exception("I am a Teapot");
Observable<Integer> obs = Observable.error(e);

TestSubscriber<Integer> ts = new TestSubscriber<>();
obs.subscribe(ts);

ts.assertError(e);

TestScheduler

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

TestSchedulers को अधिभार के माध्यम से प्रदान किया जा सकता है जो किसी भी RxJava संचालन के लिए एक समयबद्धक लेता है।

TestScheduler testScheduler = new TestScheduler();
TestSubscriber<Integer> subscriber = TestSubscriber.create();
Observable.just(1,2,3)
          .delay(10, TimeUnit.SECONDS, testScheduler)
          .subscribe(subscriber);

try {
    Thread.sleep(TimeUnit.SECONDS.toMillis(11));
} catch (InterruptedException ignored) { }
subscriber.assertValues(1,2,3); // fails

testScheduler.advanceTimeBy(10, TimeUnit.SECONDS);
subscriber.assertValues(1,2,3); // success

TestScheduler बहुत बुनियादी है। इसमें केवल तीन विधियाँ समाहित हैं।

testScheduler.advanceTimeBy(amount, timeUnit);
testScheduler.advanceTimeTo(when, timeUnit);
testScheduler.triggerActions();

यह आपको हेरफेर करने देता है जब TestScheduler को भविष्य में कुछ समय से संबंधित सभी क्रियाओं को फायर करना चाहिए।

अनुसूचक कार्यों को पारित करते समय, यह नहीं है कि टेस्टस्क्रूल्डर का आमतौर पर उपयोग कैसे किया जाता है क्योंकि यह कितना अप्रभावी है। कक्षाओं में शेड्यूलर पास करने से थोड़ा लाभ प्राप्त करने के लिए बहुत सारे अतिरिक्त कोड उपलब्ध होते हैं। इसके बजाय, आप RxJava के Schedulers.io () / कम्प्यूटेशन () / आदि में हुक कर सकते हैं। यह RxJava के हुक के साथ किया जाता है। यह आपको परिभाषित करता है कि किसी कॉल को शेड्यूलर विधियों में से क्या लौटाता है।

public final class TestSchedulers {

    public static TestScheduler test() {
        final TestScheduler testScheduler = new TestScheduler();
        RxJavaHooks.reset();
        RxJavaHooks.setOnComputationScheduler((scheduler) -> {
            return testScheduler;
        });
        RxJavaHooks.setOnIOScheduler((scheduler) -> {
            return testScheduler;
        });
        RxJavaHooks.setOnNewThreadScheduler((scheduler) -> {
            return testScheduler;
        });
        return testScheduler;
    }
}

यह वर्ग उपयोगकर्ता को परीक्षण अनुसूचक प्राप्त करने की अनुमति देता है जो शेड्यूलर्स को सभी कॉल के लिए झुका दिया जाएगा। एक इकाई परीक्षण को बस इस अनुसूचक को इसके सेटअप में लाना होगा। यह अत्यधिक सेटअप में इसे किराए पर लेने की सलाह देता है और किसी भी सादे पुराने क्षेत्र के रूप में नहीं क्योंकि आपका टेस्टस्क्रिलर किसी अन्य इकाई परीक्षण से ट्रिगर करने का प्रयास कर सकता है जब आप समय अग्रिम करते हैं। अब ऊपर हमारा उदाहरण बन जाता है

TestScheduler testScheduler = new TestScheduler();
TestSubscriber<Integer> subscriber = TestSubscriber.create();
Observable.just(1,2,3)
          .delay(10, TimeUnit.SECONDS, testScheduler)
          .subscribe(subscriber);
testScheduler.advanceTimeBy(9, TimeUnit.SECONDS);
subscriber.assertValues(); // success (delay hasn't finished)
testScheduler.advanceTimeBy(10, TimeUnit.SECONDS);
subscriber.assertValues(1,2,3); // success (delay has finished)

इस प्रकार आप अपने यूनिट टेस्ट से सिस्टम क्लॉक को प्रभावी रूप से हटा सकते हैं (कम से कम जहाँ तक RxJava का संबंध है)