streamalism.org

1. Áttekintés

Ebben a cikkben megvizsgáljuk az RxJava használatával írt kód tesztelési módjait.

Az RxJava-val létrehozott tipikus áramlás egy Megfigyelhető és egy Megfigyelő. A megfigyelhető adatforrás, amely elemsorozat. Egy vagy több megfigyelő feliratkozik rá a kibocsátott események fogadására.

Jellemzően a megfigyelőt és a megfigyelhetőeket külön szálakban hajtják végre aszinkron módon - ez megnehezíti a kód hagyományos tesztelését.

Szerencsére, Az RxJava a TestSubscriber osztály, amely lehetővé teszi számunkra az aszinkron, eseményvezérelt áramlás tesztelését.

2. Az RxJava tesztelése - a hagyományos módszer

Kezdjük egy példával - van egy betűsorunk, amelyet össze akarunk pakolni 1-től kezdődő egész számok sorozatával.

Tesztünknek azt kell állítania, hogy egy előfizető, aki meghallgatja a cipzárral megfigyelhető, által kibocsátott eseményeket, egész számokkal cipzárolt betűket kap.

Egy ilyen teszt hagyományos módon történő megírása azt jelenti, hogy vezetnünk kell az eredmények listáját, és ezt a listát egy megfigyelőtől frissítenünk kell. Az elemek hozzáadása az egész számok listájához azt jelenti, hogy a megfigyelhető és a megfigyelőknek ugyanabban a szálban kell dolgozniuk - nem tudnak aszinkron módon működni.

Így hiányozna az RxJava egyik legnagyobb előnye - az események külön szálakban történő feldolgozása.

Így néz ki a teszt korlátozott verziója:

Lista betűk = Arrays.asList ("A", "B", "C", "D", "E"); Eredménylista = new ArrayList (); Megfigyelhető megfigyelhető = Megfigyelhető .from (betűk) .zipWith (Megfigyelhető.tartomány (1, Egész.MAX_VALUE), (karakterlánc, index) -> index + "-" + karakterlánc); megfigyelhető.feliratkozás (eredmények :: hozzáadás); assertThat (results, notNullValue ()); assertThat (eredmények, hasSize (5)); assertThat (eredmények, hasItems ("1-A", "2-B", "3-C", "4-D", "5-E");

Összegezzük egy megfigyelő eredményeit azáltal, hogy elemeket adunk a eredmények lista. A megfigyelő és a megfigyelhető munka ugyanabban a szálban, így állításunk megfelelően blokkol és várja a Iratkozz fel() módszer a befejezéshez.

3. Az RxJava tesztelése a TestSubscriber

RxJava jön a TestSubsriber osztály, amely lehetővé teszi számunkra az események aszinkron feldolgozásával működő tesztek írását. Ez egy normális megfigyelő, aki feliratkozik a megfigyelhetőre.

Egy teszt során megvizsgálhatjuk az a állapotát TestSubscriber és állításokat tegyen erről az állapotról:

Lista betűk = Arrays.asList ("A", "B", "C", "D", "E"); TestSubscriber előfizető = new TestSubscriber (); Megfigyelhető megfigyelhető = Megfigyelhető .from (betűkből) .zipWith (Megfigyelhető.tartomány (1, Egész.MAX_VALUE), ((karakterlánc, index) -> index + "-" + karakterlánc)); megfigyelhető.feliratkozás (előfizető); subscriber.assertCompleted (); subscriber.assertNoErrors (); subscriber.assertValueCount (5); assertThat (előfizető.getOnNextEvents (), hasItems ("1-A", "2-B", "3-C", "4-D", "5-E");

Elhaladunk a TestSubscriber példány a Iratkozz fel() módszer a megfigyelhető. Ezután megvizsgálhatjuk az előfizető állapotát.

TestSubscriber nagyon hasznos állítási módszerekkel rendelkezik hogy felhasználjuk az elvárásaink érvényesítésére. Az előfizetőnek 5 kibocsátott elemet kell kapnia egy megfigyelőtől, és mi ezt állítjuk a assertValueCount () módszer.

Megvizsgálhatunk minden olyan eseményt, amelyet az előfizető a getOnNextEvents () módszer.

Felhívás a assertCompleted () A módszer ellenőrzi, hogy befejeződött-e egy adatfolyam, amelyre a megfigyelő feliratkozott. A assertNoErrors () A módszer azt állítja, hogy nem voltak hibák a folyamra való feliratkozás során.

4. A várható kivételek tesztelése

Néha feldolgozásunk során hiba lép fel, amikor egy megfigyelhető eseményeket bocsát ki, vagy egy megfigyelő feldolgozza az eseményeket. A TestSubscriber rendelkezik egy speciális módszerrel a hibaállapot vizsgálatára - a assertError () metódus, amely a kivétel típusát veszi érvként:

Lista betűk = Arrays.asList ("A", "B", "C", "D", "E"); TestSubscriber előfizető = new TestSubscriber (); Megfigyelhető megfigyelhető = Figyelhető. "hiba a megfigyelhetőben"))); megfigyelhető.feliratkozás (előfizető); subscriber.assertError (RuntimeException.class); subscriber.assertNotCompleted ();

Létrehozzuk azt a megfigyelhetőt, amely összekapcsolódik egy másik megfigyelhetővel a concatWith () módszer. A második megfigyelhető dobás a RuntimeException miközben kibocsátja a következő eseményt. Megvizsgálhatjuk a kivétel egy típusát a TestSubsciber felhívásával a assertError () módszer.

A hibát kapó megfigyelő leállítja a feldolgozást és befejezetlen állapotba kerül. Ezt az állapotot a assertNotCompleted () módszer.

5. Időalapú tesztelés Megfigyelhető

Tegyük fel, hogy van egy Megfigyelhető amely másodpercenként egy eseményt bocsát ki, és ezt a viselkedést a TestSubsciber.

Meghatározhatunk időalapú Megfigyelhető használni a Observable.interval () módszer és adja át a TimeUnit érvként:

Lista betűk = Arrays.asList ("A", "B", "C", "D", "E"); TestScheduler ütemező = új TestScheduler (); TestSubscriber előfizető = new TestSubscriber (); Megfigyelhető pipa = Megfigyelhető.interval (1, TimeUnit.SECONDS, ütemező); Megfigyelhető megfigyelhető = Megfigyelhető.-tól (betűk) .zipWith (pipa, (karakterlánc, index) -> index + "-" + karakterlánc); megfigyelhető.subscribeOn (ütemező) .subscribe (előfizető);

A ketyegés a megfigyelhető másodpercenként új értéket bocsát ki.

A teszt elején a nulla időpontban vagyunk, tehát a mi TestSubscriber nem készül el:

előfizető.assertNoValues ​​(); subscriber.assertNotCompleted ();

A tesztünk során eltelt idő utánzásához használnunk kell a TestScheduler osztály. Szimulálhatjuk azt az egy másodperces áthaladást a avatarTimeBy () módszer a TestScheduler:

ütemező.advanceTimeBy (1, TimeUnit.SECONDS);

A avanceTimeBy () módszerrel megfigyelhető lesz egy esemény. Azt állíthatjuk, hogy egy eseményt egy assertValueCount () módszer:

subscriber.assertNoErrors (); subscriber.assertValueCount (1); subscriber.assertValues ​​("0-A");

A mi listánk leveleket 5 elem van benne, tehát amikor megfigyelhetõvé akarjuk tenni az összes esemény kibocsátását, 6 másodperc feldolgozásnak kell eltelnie. A 6 másodperc utánzásához a advanceTimeTo () módszer:

ütemező.advanceTimeTo (6, TimeUnit.SECONDS); subscriber.assertCompleted (); subscriber.assertNoErrors (); subscriber.assertValueCount (5); assertThat (előfizető.getOnNextEvents (), hasItems ("0-A", "1-B", "2-C", "3-D", "4-E");

Az eltelt idő utánzása után állításokat hajthatunk végre a TestSubscriber. Azt állíthatjuk, hogy az összes esemény a assertValueCount () módszer.

6. Következtetés

Ebben a cikkben megvizsgáltuk a megfigyelők és megfigyelhetőek tesztelési módszereit az RxJava-ban. Megvizsgáltuk a kibocsátott események, hibák és időalapú megfigyelhetőség tesztelésének módját.

Ezeknek a példáknak és kódrészleteknek a megvalósítása megtalálható a GitHub projektben - ez egy Maven projekt, ezért könnyen importálhatónak és futtathatónak kell lennie.