Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableRetryWithPredicateTest.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.*;
22 import java.util.concurrent.*;
23 import java.util.concurrent.atomic.*;
24
25 import org.junit.Test;
26 import org.mockito.InOrder;
27
28 import io.reactivex.rxjava3.core.*;
29 import io.reactivex.rxjava3.core.Observable;
30 import io.reactivex.rxjava3.core.Observer;
31 import io.reactivex.rxjava3.disposables.*;
32 import io.reactivex.rxjava3.exceptions.*;
33 import io.reactivex.rxjava3.functions.*;
34 import io.reactivex.rxjava3.internal.functions.Functions;
35 import io.reactivex.rxjava3.observers.TestObserver;
36 import io.reactivex.rxjava3.subjects.PublishSubject;
37 import io.reactivex.rxjava3.testsupport.*;
38
39 public class ObservableRetryWithPredicateTest extends RxJavaTest {
40
41 BiPredicate<Integer, Throwable> retryTwice = new BiPredicate<Integer, Throwable>() {
42 @Override
43 public boolean test(Integer t1, Throwable t2) {
44 return t1 <= 2;
45 }
46 };
47 BiPredicate<Integer, Throwable> retry5 = new BiPredicate<Integer, Throwable>() {
48 @Override
49 public boolean test(Integer t1, Throwable t2) {
50 return t1 <= 5;
51 }
52 };
53 BiPredicate<Integer, Throwable> retryOnTestException = new BiPredicate<Integer, Throwable>() {
54 @Override
55 public boolean test(Integer t1, Throwable t2) {
56 return t2 instanceof IOException;
57 }
58 };
59 @Test
60 public void withNothingToRetry() {
61 Observable<Integer> source = Observable.range(0, 3);
62
63 Observer<Integer> o = TestHelper.mockObserver();
64 InOrder inOrder = inOrder(o);
65
66 source.retry(retryTwice).subscribe(o);
67
68 inOrder.verify(o).onNext(0);
69 inOrder.verify(o).onNext(1);
70 inOrder.verify(o).onNext(2);
71 inOrder.verify(o).onComplete();
72 verify(o, never()).onError(any(Throwable.class));
73 }
74
75 @Test
76 public void retryTwice() {
77 Observable<Integer> source = Observable.unsafeCreate(new ObservableSource<Integer>() {
78 int count;
79 @Override
80 public void subscribe(Observer<? super Integer> t1) {
81 t1.onSubscribe(Disposable.empty());
82 count++;
83 t1.onNext(0);
84 t1.onNext(1);
85 if (count == 1) {
86 t1.onError(new TestException());
87 return;
88 }
89 t1.onNext(2);
90 t1.onNext(3);
91 t1.onComplete();
92 }
93 });
94
95 Observer<Integer> o = TestHelper.mockObserver();
96 InOrder inOrder = inOrder(o);
97
98 source.retry(retryTwice).subscribe(o);
99
100 inOrder.verify(o).onNext(0);
101 inOrder.verify(o).onNext(1);
102 inOrder.verify(o).onNext(0);
103 inOrder.verify(o).onNext(1);
104 inOrder.verify(o).onNext(2);
105 inOrder.verify(o).onNext(3);
106 inOrder.verify(o).onComplete();
107 verify(o, never()).onError(any(Throwable.class));
108
109 }
110
111 @Test
112 public void retryTwiceAndGiveUp() {
113 Observable<Integer> source = Observable.unsafeCreate(new ObservableSource<Integer>() {
114 @Override
115 public void subscribe(Observer<? super Integer> t1) {
116 t1.onSubscribe(Disposable.empty());
117 t1.onNext(0);
118 t1.onNext(1);
119 t1.onError(new TestException());
120 }
121 });
122
123 Observer<Integer> o = TestHelper.mockObserver();
124 InOrder inOrder = inOrder(o);
125
126 source.retry(retryTwice).subscribe(o);
127
128 inOrder.verify(o).onNext(0);
129 inOrder.verify(o).onNext(1);
130 inOrder.verify(o).onNext(0);
131 inOrder.verify(o).onNext(1);
132 inOrder.verify(o).onNext(0);
133 inOrder.verify(o).onNext(1);
134 inOrder.verify(o).onError(any(TestException.class));
135 verify(o, never()).onComplete();
136
137 }
138
139 @Test
140 public void retryOnSpecificException() {
141 Observable<Integer> source = Observable.unsafeCreate(new ObservableSource<Integer>() {
142 int count;
143 @Override
144 public void subscribe(Observer<? super Integer> t1) {
145 t1.onSubscribe(Disposable.empty());
146 count++;
147 t1.onNext(0);
148 t1.onNext(1);
149 if (count == 1) {
150 t1.onError(new IOException());
151 return;
152 }
153 t1.onNext(2);
154 t1.onNext(3);
155 t1.onComplete();
156 }
157 });
158
159 Observer<Integer> o = TestHelper.mockObserver();
160 InOrder inOrder = inOrder(o);
161
162 source.retry(retryOnTestException).subscribe(o);
163
164 inOrder.verify(o).onNext(0);
165 inOrder.verify(o).onNext(1);
166 inOrder.verify(o).onNext(0);
167 inOrder.verify(o).onNext(1);
168 inOrder.verify(o).onNext(2);
169 inOrder.verify(o).onNext(3);
170 inOrder.verify(o).onComplete();
171 verify(o, never()).onError(any(Throwable.class));
172 }
173
174 @Test
175 public void retryOnSpecificExceptionAndNotOther() {
176 final IOException ioe = new IOException();
177 final TestException te = new TestException();
178 Observable<Integer> source = Observable.unsafeCreate(new ObservableSource<Integer>() {
179 int count;
180 @Override
181 public void subscribe(Observer<? super Integer> t1) {
182 t1.onSubscribe(Disposable.empty());
183 count++;
184 t1.onNext(0);
185 t1.onNext(1);
186 if (count == 1) {
187 t1.onError(ioe);
188 return;
189 }
190 t1.onNext(2);
191 t1.onNext(3);
192 t1.onError(te);
193 }
194 });
195
196 Observer<Integer> o = TestHelper.mockObserver();
197 InOrder inOrder = inOrder(o);
198
199 source.retry(retryOnTestException).subscribe(o);
200
201 inOrder.verify(o).onNext(0);
202 inOrder.verify(o).onNext(1);
203 inOrder.verify(o).onNext(0);
204 inOrder.verify(o).onNext(1);
205 inOrder.verify(o).onNext(2);
206 inOrder.verify(o).onNext(3);
207 inOrder.verify(o).onError(te);
208 verify(o, never()).onError(ioe);
209 verify(o, never()).onComplete();
210 }
211
212 @Test
213 public void unsubscribeFromRetry() {
214 PublishSubject<Integer> subject = PublishSubject.create();
215 final AtomicInteger count = new AtomicInteger(0);
216 Disposable sub = subject.retry(retryTwice).subscribe(new Consumer<Integer>() {
217 @Override
218 public void accept(Integer n) {
219 count.incrementAndGet();
220 }
221 });
222 subject.onNext(1);
223 sub.dispose();
224 subject.onNext(2);
225 assertEquals(1, count.get());
226 }
227
228 @Test
229 public void unsubscribeAfterError() {
230
231 Observer<Long> observer = TestHelper.mockObserver();
232
233 // Observable that always fails after 100ms
234 ObservableRetryTest.SlowObservable so = new ObservableRetryTest.SlowObservable(100, 0, "testUnsubscribeAfterError");
235 Observable<Long> o = Observable
236 .unsafeCreate(so)
237 .retry(retry5);
238
239 ObservableRetryTest.AsyncObserver<Long> async = new ObservableRetryTest.AsyncObserver<>(observer);
240
241 o.subscribe(async);
242
243 async.await();
244
245 InOrder inOrder = inOrder(observer);
246 // Should fail once
247 inOrder.verify(observer, times(1)).onError(any(Throwable.class));
248 inOrder.verify(observer, never()).onComplete();
249
250 assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
251 assertEquals("Only 1 active subscription", 1, so.maxActive.get());
252 }
253
254 @Test
255 public void timeoutWithRetry() {
256
257 Observer<Long> observer = TestHelper.mockObserver();
258
259 // Observable that sends every 100ms (timeout fails instead)
260 ObservableRetryTest.SlowObservable so = new ObservableRetryTest.SlowObservable(100, 10, "testTimeoutWithRetry");
261 Observable<Long> o = Observable
262 .unsafeCreate(so)
263 .timeout(80, TimeUnit.MILLISECONDS)
264 .retry(retry5);
265
266 ObservableRetryTest.AsyncObserver<Long> async = new ObservableRetryTest.AsyncObserver<>(observer);
267
268 o.subscribe(async);
269
270 async.await();
271
272 InOrder inOrder = inOrder(observer);
273 // Should fail once
274 inOrder.verify(observer, times(1)).onError(any(Throwable.class));
275 inOrder.verify(observer, never()).onComplete();
276
277 assertEquals("Start 6 threads, retry 5 then fail on 6", 6, so.efforts.get());
278 }
279
280 @Test
281 public void issue2826() {
282 TestObserverEx<Integer> to = new TestObserverEx<>();
283 final RuntimeException e = new RuntimeException("You shall not pass");
284 final AtomicInteger c = new AtomicInteger();
285 Observable.just(1).map(new Function<Integer, Integer>() {
286 @Override
287 public Integer apply(Integer t1) {
288 c.incrementAndGet();
289 throw e;
290 }
291 }).retry(retry5).subscribe(to);
292
293 to.assertTerminated();
294 assertEquals(6, c.get());
295 assertEquals(Collections.singletonList(e), to.errors());
296 }
297
298 @Test
299 public void justAndRetry() throws Exception {
300 final AtomicBoolean throwException = new AtomicBoolean(true);
301 int value = Observable.just(1).map(new Function<Integer, Integer>() {
302 @Override
303 public Integer apply(Integer t1) {
304 if (throwException.compareAndSet(true, false)) {
305 throw new TestException();
306 }
307 return t1;
308 }
309 }).retry(1).blockingSingle();
310
311 assertEquals(1, value);
312 }
313
314 @Test
315 public void issue3008RetryWithPredicate() {
316 final List<Long> list = new CopyOnWriteArrayList<>();
317 final AtomicBoolean isFirst = new AtomicBoolean(true);
318 Observable.<Long> just(1L, 2L, 3L).map(new Function<Long, Long>() {
319 @Override
320 public Long apply(Long x) {
321 System.out.println("map " + x);
322 if (x == 2 && isFirst.getAndSet(false)) {
323 throw new RuntimeException("retryable error");
324 }
325 return x;
326 }})
327 .retry(new BiPredicate<Integer, Throwable>() {
328 @Override
329 public boolean test(Integer t1, Throwable t2) {
330 return true;
331 }})
332 .forEach(new Consumer<Long>() {
333
334 @Override
335 public void accept(Long t) {
336 System.out.println(t);
337 list.add(t);
338 }});
339 assertEquals(Arrays.asList(1L, 1L, 2L, 3L), list);
340 }
341
342 @Test
343 public void issue3008RetryInfinite() {
344 final List<Long> list = new CopyOnWriteArrayList<>();
345 final AtomicBoolean isFirst = new AtomicBoolean(true);
346 Observable.<Long> just(1L, 2L, 3L).map(new Function<Long, Long>() {
347 @Override
348 public Long apply(Long x) {
349 System.out.println("map " + x);
350 if (x == 2 && isFirst.getAndSet(false)) {
351 throw new RuntimeException("retryable error");
352 }
353 return x;
354 }})
355 .retry()
356 .forEach(new Consumer<Long>() {
357
358 @Override
359 public void accept(Long t) {
360 System.out.println(t);
361 list.add(t);
362 }});
363 assertEquals(Arrays.asList(1L, 1L, 2L, 3L), list);
364 }
365
366 @Test
367 public void predicateThrows() {
368
369 TestObserverEx<Object> to = Observable.error(new TestException("Outer"))
370 .retry(new Predicate<Throwable>() {
371 @Override
372 public boolean test(Throwable e) throws Exception {
373 throw new TestException("Inner");
374 }
375 })
376 .to(TestHelper.testConsumer())
377 .assertFailure(CompositeException.class);
378
379 List<Throwable> errors = TestHelper.compositeList(to.errors().get(0));
380
381 TestHelper.assertError(errors, 0, TestException.class, "Outer");
382 TestHelper.assertError(errors, 1, TestException.class, "Inner");
383 }
384
385 @Test
386 public void dontRetry() {
387 Observable.error(new TestException("Outer"))
388 .retry(Functions.alwaysFalse())
389 .to(TestHelper.testConsumer())
390 .assertFailureAndMessage(TestException.class, "Outer");
391 }
392
393 @Test
394 @SuppressUndeliverable
395 public void retryDisposeRace() {
396 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
397 final PublishSubject<Integer> ps = PublishSubject.create();
398
399 final TestObserver<Integer> to = ps.retry(Functions.alwaysTrue()).test();
400
401 final TestException ex = new TestException();
402
403 Runnable r1 = new Runnable() {
404 @Override
405 public void run() {
406 ps.onError(ex);
407 }
408 };
409
410 Runnable r2 = new Runnable() {
411 @Override
412 public void run() {
413 to.dispose();
414 }
415 };
416
417 TestHelper.race(r1, r2);
418
419 to.assertEmpty();
420 }
421 }
422
423 @Test
424 public void bipredicateThrows() {
425
426 TestObserverEx<Object> to = Observable.error(new TestException("Outer"))
427 .retry(new BiPredicate<Integer, Throwable>() {
428 @Override
429 public boolean test(Integer n, Throwable e) throws Exception {
430 throw new TestException("Inner");
431 }
432 })
433 .to(TestHelper.testConsumer())
434 .assertFailure(CompositeException.class);
435
436 List<Throwable> errors = TestHelper.compositeList(to.errors().get(0));
437
438 TestHelper.assertError(errors, 0, TestException.class, "Outer");
439 TestHelper.assertError(errors, 1, TestException.class, "Inner");
440 }
441
442 @Test
443 @SuppressUndeliverable
444 public void retryBiPredicateDisposeRace() {
445 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
446 final PublishSubject<Integer> ps = PublishSubject.create();
447
448 final TestObserver<Integer> to = ps.retry(new BiPredicate<Object, Object>() {
449 @Override
450 public boolean test(Object t1, Object t2) throws Exception {
451 return true;
452 }
453 }).test();
454
455 final TestException ex = new TestException();
456
457 Runnable r1 = new Runnable() {
458 @Override
459 public void run() {
460 ps.onError(ex);
461 }
462 };
463
464 Runnable r2 = new Runnable() {
465 @Override
466 public void run() {
467 to.dispose();
468 }
469 };
470
471 TestHelper.race(r1, r2);
472
473 to.assertEmpty();
474 }
475 }
476 }