Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableDoOnEachTest.java

raw
1 /*
2 * Copyright (c) 2016-present, RxJava Contributors.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
5 * compliance with the License. You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is
10 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
11 * the License for the specific language governing permissions and limitations under the License.
12 */
13
14 package io.reactivex.rxjava3.internal.operators.observable;
15
16 import static org.junit.Assert.assertEquals;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.io.IOException;
21 import java.util.List;
22 import java.util.concurrent.atomic.AtomicInteger;
23
24 import io.reactivex.rxjava3.disposables.Disposable;
25 import org.junit.*;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.exceptions.*;
29 import io.reactivex.rxjava3.functions.*;
30 import io.reactivex.rxjava3.internal.functions.Functions;
31 import io.reactivex.rxjava3.observers.TestObserver;
32 import io.reactivex.rxjava3.operators.QueueFuseable;
33 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
34 import io.reactivex.rxjava3.subjects.UnicastSubject;
35 import io.reactivex.rxjava3.testsupport.*;
36
37 public class ObservableDoOnEachTest extends RxJavaTest {
38
39 Observer<String> subscribedObserver;
40 Observer<String> sideEffectObserver;
41
42 @Before
43 public void before() {
44 subscribedObserver = TestHelper.mockObserver();
45 sideEffectObserver = TestHelper.mockObserver();
46 }
47
48 @Test
49 public void doOnEach() {
50 Observable<String> base = Observable.just("a", "b", "c");
51 Observable<String> doOnEach = base.doOnEach(sideEffectObserver);
52
53 doOnEach.subscribe(subscribedObserver);
54
55 // ensure the leaf Observer is still getting called
56 verify(subscribedObserver, never()).onError(any(Throwable.class));
57 verify(subscribedObserver, times(1)).onNext("a");
58 verify(subscribedObserver, times(1)).onNext("b");
59 verify(subscribedObserver, times(1)).onNext("c");
60 verify(subscribedObserver, times(1)).onComplete();
61
62 // ensure our injected Observer is getting called
63 verify(sideEffectObserver, never()).onError(any(Throwable.class));
64 verify(sideEffectObserver, times(1)).onNext("a");
65 verify(sideEffectObserver, times(1)).onNext("b");
66 verify(sideEffectObserver, times(1)).onNext("c");
67 verify(sideEffectObserver, times(1)).onComplete();
68 }
69
70 @Test
71 public void doOnEachWithError() {
72 Observable<String> base = Observable.just("one", "fail", "two", "three", "fail");
73 Observable<String> errs = base.map(new Function<String, String>() {
74 @Override
75 public String apply(String s) {
76 if ("fail".equals(s)) {
77 throw new RuntimeException("Forced Failure");
78 }
79 return s;
80 }
81 });
82
83 Observable<String> doOnEach = errs.doOnEach(sideEffectObserver);
84
85 doOnEach.subscribe(subscribedObserver);
86 verify(subscribedObserver, times(1)).onNext("one");
87 verify(subscribedObserver, never()).onNext("two");
88 verify(subscribedObserver, never()).onNext("three");
89 verify(subscribedObserver, never()).onComplete();
90 verify(subscribedObserver, times(1)).onError(any(Throwable.class));
91
92 verify(sideEffectObserver, times(1)).onNext("one");
93 verify(sideEffectObserver, never()).onNext("two");
94 verify(sideEffectObserver, never()).onNext("three");
95 verify(sideEffectObserver, never()).onComplete();
96 verify(sideEffectObserver, times(1)).onError(any(Throwable.class));
97 }
98
99 @Test
100 public void doOnEachWithErrorInCallback() {
101 Observable<String> base = Observable.just("one", "two", "fail", "three");
102 Observable<String> doOnEach = base.doOnNext(new Consumer<String>() {
103 @Override
104 public void accept(String s) {
105 if ("fail".equals(s)) {
106 throw new RuntimeException("Forced Failure");
107 }
108 }
109 });
110
111 doOnEach.subscribe(subscribedObserver);
112 verify(subscribedObserver, times(1)).onNext("one");
113 verify(subscribedObserver, times(1)).onNext("two");
114 verify(subscribedObserver, never()).onNext("three");
115 verify(subscribedObserver, never()).onComplete();
116 verify(subscribedObserver, times(1)).onError(any(Throwable.class));
117
118 }
119
120 @Test
121 public void issue1451Case1() {
122 // https://github.com/Netflix/RxJava/issues/1451
123 final int expectedCount = 3;
124 final AtomicInteger count = new AtomicInteger();
125 for (int i = 0; i < expectedCount; i++) {
126 Observable
127 .just(Boolean.TRUE, Boolean.FALSE)
128 .takeWhile(new Predicate<Boolean>() {
129 @Override
130 public boolean test(Boolean value) {
131 return value;
132 }
133 })
134 .toList()
135 .doOnSuccess(new Consumer<List<Boolean>>() {
136 @Override
137 public void accept(List<Boolean> booleans) {
138 count.incrementAndGet();
139 }
140 })
141 .subscribe();
142 }
143 assertEquals(expectedCount, count.get());
144 }
145
146 @Test
147 public void issue1451Case2() {
148 // https://github.com/Netflix/RxJava/issues/1451
149 final int expectedCount = 3;
150 final AtomicInteger count = new AtomicInteger();
151 for (int i = 0; i < expectedCount; i++) {
152 Observable
153 .just(Boolean.TRUE, Boolean.FALSE, Boolean.FALSE)
154 .takeWhile(new Predicate<Boolean>() {
155 @Override
156 public boolean test(Boolean value) {
157 return value;
158 }
159 })
160 .toList()
161 .doOnSuccess(new Consumer<List<Boolean>>() {
162 @Override
163 public void accept(List<Boolean> booleans) {
164 count.incrementAndGet();
165 }
166 })
167 .subscribe();
168 }
169 assertEquals(expectedCount, count.get());
170 }
171
172 // FIXME crashing ObservableSource can't propagate to an Observer
173 // @Test
174 // public void testFatalError() {
175 // try {
176 // Observable.just(1, 2, 3)
177 // .flatMap(new Function<Integer, Observable<?>>() {
178 // @Override
179 // public Observable<?> apply(Integer integer) {
180 // return Observable.create(new ObservableSource<Object>() {
181 // @Override
182 // public void accept(Observer<Object> o) {
183 // throw new NullPointerException("Test NPE");
184 // }
185 // });
186 // }
187 // })
188 // .doOnNext(new Consumer<Object>() {
189 // @Override
190 // public void accept(Object o) {
191 // System.out.println("Won't come here");
192 // }
193 // })
194 // .subscribe();
195 // fail("should have thrown an exception");
196 // } catch (OnErrorNotImplementedException e) {
197 // assertTrue(e.getCause() instanceof NullPointerException);
198 // assertEquals(e.getCause().getMessage(), "Test NPE");
199 // System.out.println("Received exception: " + e);
200 // }
201 // }
202
203 @Test
204 public void onErrorThrows() {
205 TestObserverEx<Object> to = new TestObserverEx<>();
206
207 Observable.error(new TestException())
208 .doOnError(new Consumer<Throwable>() {
209 @Override
210 public void accept(Throwable e) {
211 throw new TestException();
212 }
213 }).subscribe(to);
214
215 to.assertNoValues();
216 to.assertNotComplete();
217 to.assertError(CompositeException.class);
218
219 CompositeException ex = (CompositeException)to.errors().get(0);
220
221 List<Throwable> exceptions = ex.getExceptions();
222 assertEquals(2, exceptions.size());
223 Assert.assertTrue(exceptions.get(0) instanceof TestException);
224 Assert.assertTrue(exceptions.get(1) instanceof TestException);
225 }
226
227 @Test
228 public void ignoreCancel() {
229 List<Throwable> errors = TestHelper.trackPluginErrors();
230
231 try {
232 Observable.wrap(new ObservableSource<Object>() {
233 @Override
234 public void subscribe(Observer<? super Object> observer) {
235 observer.onSubscribe(Disposable.empty());
236 observer.onNext(1);
237 observer.onNext(2);
238 observer.onError(new IOException());
239 observer.onComplete();
240 }
241 })
242 .doOnNext(new Consumer<Object>() {
243 @Override
244 public void accept(Object e) throws Exception {
245 throw new TestException();
246 }
247 })
248 .test()
249 .assertFailure(TestException.class);
250
251 TestHelper.assertUndeliverable(errors, 0, IOException.class);
252 } finally {
253 RxJavaPlugins.reset();
254 }
255 }
256
257 @Test
258 public void onErrorAfterCrash() {
259 List<Throwable> errors = TestHelper.trackPluginErrors();
260
261 try {
262 Observable.wrap(new ObservableSource<Object>() {
263 @Override
264 public void subscribe(Observer<? super Object> observer) {
265 observer.onSubscribe(Disposable.empty());
266 observer.onError(new TestException());
267 }
268 })
269 .doAfterTerminate(new Action() {
270 @Override
271 public void run() throws Exception {
272 throw new IOException();
273 }
274 })
275 .test()
276 .assertFailure(TestException.class);
277
278 TestHelper.assertUndeliverable(errors, 0, IOException.class);
279 } finally {
280 RxJavaPlugins.reset();
281 }
282 }
283
284 @Test
285 public void onCompleteAfterCrash() {
286 List<Throwable> errors = TestHelper.trackPluginErrors();
287
288 try {
289 Observable.wrap(new ObservableSource<Object>() {
290 @Override
291 public void subscribe(Observer<? super Object> observer) {
292 observer.onSubscribe(Disposable.empty());
293 observer.onComplete();
294 }
295 })
296 .doAfterTerminate(new Action() {
297 @Override
298 public void run() throws Exception {
299 throw new IOException();
300 }
301 })
302 .test()
303 .assertResult();
304
305 TestHelper.assertUndeliverable(errors, 0, IOException.class);
306 } finally {
307 RxJavaPlugins.reset();
308 }
309 }
310
311 @Test
312 public void onCompleteCrash() {
313 Observable.wrap(new ObservableSource<Object>() {
314 @Override
315 public void subscribe(Observer<? super Object> observer) {
316 observer.onSubscribe(Disposable.empty());
317 observer.onComplete();
318 }
319 })
320 .doOnComplete(new Action() {
321 @Override
322 public void run() throws Exception {
323 throw new IOException();
324 }
325 })
326 .test()
327 .assertFailure(IOException.class);
328 }
329
330 @Test
331 public void ignoreCancelConditional() {
332 List<Throwable> errors = TestHelper.trackPluginErrors();
333
334 try {
335 Observable.wrap(new ObservableSource<Object>() {
336 @Override
337 public void subscribe(Observer<? super Object> observer) {
338 observer.onSubscribe(Disposable.empty());
339 observer.onNext(1);
340 observer.onNext(2);
341 observer.onError(new IOException());
342 observer.onComplete();
343 }
344 })
345 .doOnNext(new Consumer<Object>() {
346 @Override
347 public void accept(Object e) throws Exception {
348 throw new TestException();
349 }
350 })
351 .filter(Functions.alwaysTrue())
352 .test()
353 .assertFailure(TestException.class);
354
355 TestHelper.assertUndeliverable(errors, 0, IOException.class);
356 } finally {
357 RxJavaPlugins.reset();
358 }
359 }
360
361 @Test
362 public void onErrorAfterCrashConditional() {
363 List<Throwable> errors = TestHelper.trackPluginErrors();
364
365 try {
366 Observable.wrap(new ObservableSource<Object>() {
367 @Override
368 public void subscribe(Observer<? super Object> observer) {
369 observer.onSubscribe(Disposable.empty());
370 observer.onError(new TestException());
371 }
372 })
373 .doAfterTerminate(new Action() {
374 @Override
375 public void run() throws Exception {
376 throw new IOException();
377 }
378 })
379 .filter(Functions.alwaysTrue())
380 .test()
381 .assertFailure(TestException.class);
382
383 TestHelper.assertUndeliverable(errors, 0, IOException.class);
384 } finally {
385 RxJavaPlugins.reset();
386 }
387 }
388
389 @Test
390 public void onCompleteAfter() {
391 final int[] call = { 0 };
392 Observable.just(1)
393 .doAfterTerminate(new Action() {
394 @Override
395 public void run() throws Exception {
396 call[0]++;
397 }
398 })
399 .test()
400 .assertResult(1);
401
402 assertEquals(1, call[0]);
403 }
404
405 @Test
406 public void onCompleteAfterCrashConditional() {
407 List<Throwable> errors = TestHelper.trackPluginErrors();
408
409 try {
410 Observable.wrap(new ObservableSource<Object>() {
411 @Override
412 public void subscribe(Observer<? super Object> observer) {
413 observer.onSubscribe(Disposable.empty());
414 observer.onComplete();
415 }
416 })
417 .doAfterTerminate(new Action() {
418 @Override
419 public void run() throws Exception {
420 throw new IOException();
421 }
422 })
423 .filter(Functions.alwaysTrue())
424 .test()
425 .assertResult();
426
427 TestHelper.assertUndeliverable(errors, 0, IOException.class);
428 } finally {
429 RxJavaPlugins.reset();
430 }
431 }
432
433 @Test
434 public void onCompleteCrashConditional() {
435 Observable.wrap(new ObservableSource<Object>() {
436 @Override
437 public void subscribe(Observer<? super Object> observer) {
438 observer.onSubscribe(Disposable.empty());
439 observer.onComplete();
440 }
441 })
442 .doOnComplete(new Action() {
443 @Override
444 public void run() throws Exception {
445 throw new IOException();
446 }
447 })
448 .filter(Functions.alwaysTrue())
449 .test()
450 .assertFailure(IOException.class);
451 }
452
453 @Test
454 public void onErrorOnErrorCrashConditional() {
455 TestObserverEx<Object> to = Observable.error(new TestException("Outer"))
456 .doOnError(new Consumer<Throwable>() {
457 @Override
458 public void accept(Throwable e) throws Exception {
459 throw new TestException("Inner");
460 }
461 })
462 .filter(Functions.alwaysTrue())
463 .to(TestHelper.testConsumer())
464 .assertFailure(CompositeException.class);
465
466 List<Throwable> errors = TestHelper.compositeList(to.errors().get(0));
467
468 TestHelper.assertError(errors, 0, TestException.class, "Outer");
469 TestHelper.assertError(errors, 1, TestException.class, "Inner");
470 }
471
472 @Test
473 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
474 public void fused() {
475 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
476
477 final int[] call = { 0, 0 };
478
479 Observable.range(1, 5)
480 .doOnNext(new Consumer<Integer>() {
481 @Override
482 public void accept(Integer v) throws Exception {
483 call[0]++;
484 }
485 })
486 .doOnComplete(new Action() {
487 @Override
488 public void run() throws Exception {
489 call[1]++;
490 }
491 })
492 .subscribe(to);
493
494 to.assertFuseable()
495 .assertFusionMode(QueueFuseable.SYNC)
496 .assertResult(1, 2, 3, 4, 5);
497
498 assertEquals(5, call[0]);
499 assertEquals(1, call[1]);
500 }
501
502 @Test
503 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
504 public void fusedOnErrorCrash() {
505 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
506
507 final int[] call = { 0 };
508
509 Observable.range(1, 5)
510 .doOnNext(new Consumer<Integer>() {
511 @Override
512 public void accept(Integer v) throws Exception {
513 throw new TestException();
514 }
515 })
516 .doOnComplete(new Action() {
517 @Override
518 public void run() throws Exception {
519 call[0]++;
520 }
521 })
522 .subscribe(to);
523
524 to.assertFuseable()
525 .assertFusionMode(QueueFuseable.SYNC)
526 .assertFailure(TestException.class);
527
528 assertEquals(0, call[0]);
529 }
530
531 @Test
532 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
533 public void fusedConditional() {
534 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
535
536 final int[] call = { 0, 0 };
537
538 Observable.range(1, 5)
539 .doOnNext(new Consumer<Integer>() {
540 @Override
541 public void accept(Integer v) throws Exception {
542 call[0]++;
543 }
544 })
545 .doOnComplete(new Action() {
546 @Override
547 public void run() throws Exception {
548 call[1]++;
549 }
550 })
551 .filter(Functions.alwaysTrue())
552 .subscribe(to);
553
554 to.assertFuseable()
555 .assertFusionMode(QueueFuseable.SYNC)
556 .assertResult(1, 2, 3, 4, 5);
557
558 assertEquals(5, call[0]);
559 assertEquals(1, call[1]);
560 }
561
562 @Test
563 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
564 public void fusedOnErrorCrashConditional() {
565 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
566
567 final int[] call = { 0 };
568
569 Observable.range(1, 5)
570 .doOnNext(new Consumer<Integer>() {
571 @Override
572 public void accept(Integer v) throws Exception {
573 throw new TestException();
574 }
575 })
576 .doOnComplete(new Action() {
577 @Override
578 public void run() throws Exception {
579 call[0]++;
580 }
581 })
582 .filter(Functions.alwaysTrue())
583 .subscribe(to);
584
585 to.assertFuseable()
586 .assertFusionMode(QueueFuseable.SYNC)
587 .assertFailure(TestException.class);
588
589 assertEquals(0, call[0]);
590 }
591
592 @Test
593 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
594 public void fusedAsync() {
595 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
596
597 final int[] call = { 0, 0 };
598
599 UnicastSubject<Integer> us = UnicastSubject.create();
600
601 us
602 .doOnNext(new Consumer<Integer>() {
603 @Override
604 public void accept(Integer v) throws Exception {
605 call[0]++;
606 }
607 })
608 .doOnComplete(new Action() {
609 @Override
610 public void run() throws Exception {
611 call[1]++;
612 }
613 })
614 .subscribe(to);
615
616 TestHelper.emit(us, 1, 2, 3, 4, 5);
617
618 to.assertFuseable()
619 .assertFusionMode(QueueFuseable.ASYNC)
620 .assertResult(1, 2, 3, 4, 5);
621
622 assertEquals(5, call[0]);
623 assertEquals(1, call[1]);
624 }
625
626 @Test
627 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
628 public void fusedAsyncConditional() {
629 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
630
631 final int[] call = { 0, 0 };
632
633 UnicastSubject<Integer> us = UnicastSubject.create();
634
635 us
636 .doOnNext(new Consumer<Integer>() {
637 @Override
638 public void accept(Integer v) throws Exception {
639 call[0]++;
640 }
641 })
642 .doOnComplete(new Action() {
643 @Override
644 public void run() throws Exception {
645 call[1]++;
646 }
647 })
648 .filter(Functions.alwaysTrue())
649 .subscribe(to);
650
651 TestHelper.emit(us, 1, 2, 3, 4, 5);
652
653 to.assertFuseable()
654 .assertFusionMode(QueueFuseable.ASYNC)
655 .assertResult(1, 2, 3, 4, 5);
656
657 assertEquals(5, call[0]);
658 assertEquals(1, call[1]);
659 }
660
661 @Test
662 @Ignore("Fusion not supported yet") // TODO decide/implement fusion
663 public void fusedAsyncConditional2() {
664 TestObserverEx<Integer> to = new TestObserverEx<>(QueueFuseable.ANY);
665
666 final int[] call = { 0, 0 };
667
668 UnicastSubject<Integer> us = UnicastSubject.create();
669
670 us.hide()
671 .doOnNext(new Consumer<Integer>() {
672 @Override
673 public void accept(Integer v) throws Exception {
674 call[0]++;
675 }
676 })
677 .doOnComplete(new Action() {
678 @Override
679 public void run() throws Exception {
680 call[1]++;
681 }
682 })
683 .filter(Functions.alwaysTrue())
684 .subscribe(to);
685
686 TestHelper.emit(us, 1, 2, 3, 4, 5);
687
688 to.assertFuseable()
689 .assertFusionMode(QueueFuseable.NONE)
690 .assertResult(1, 2, 3, 4, 5);
691
692 assertEquals(5, call[0]);
693 assertEquals(1, call[1]);
694 }
695
696 @Test
697 public void dispose() {
698 TestHelper.checkDisposed(Observable.just(1).doOnEach(new TestObserver<>()));
699 }
700
701 @Test
702 public void doubleOnSubscribe() {
703 TestHelper.checkDoubleOnSubscribeObservable(new Function<Observable<Object>, ObservableSource<Object>>() {
704 @Override
705 public ObservableSource<Object> apply(Observable<Object> o) throws Exception {
706 return o.doOnEach(new TestObserver<>());
707 }
708 });
709 }
710 }