Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableOnErrorResumeNextTest.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.*;
17 import static org.mockito.ArgumentMatchers.any;
18 import static org.mockito.Mockito.*;
19
20 import java.io.IOException;
21 import java.util.concurrent.TimeUnit;
22 import java.util.concurrent.atomic.AtomicReference;
23
24 import io.reactivex.rxjava3.disposables.Disposable;
25 import org.junit.Test;
26 import org.mockito.Mockito;
27 import org.reactivestreams.Subscription;
28
29 import io.reactivex.rxjava3.core.*;
30 import io.reactivex.rxjava3.functions.Function;
31 import io.reactivex.rxjava3.internal.functions.Functions;
32 import io.reactivex.rxjava3.observers.TestObserver;
33 import io.reactivex.rxjava3.schedulers.Schedulers;
34 import io.reactivex.rxjava3.testsupport.TestHelper;
35
36 public class ObservableOnErrorResumeNextTest extends RxJavaTest {
37
38 @Test
39 public void resumeNextWithSynchronousExecution() {
40 final AtomicReference<Throwable> receivedException = new AtomicReference<>();
41 Observable<String> w = Observable.unsafeCreate(new ObservableSource<String>() {
42
43 @Override
44 public void subscribe(Observer<? super String> observer) {
45 observer.onSubscribe(Disposable.empty());
46 observer.onNext("one");
47 observer.onError(new Throwable("injected failure"));
48 observer.onNext("two");
49 observer.onNext("three");
50 }
51 });
52
53 Function<Throwable, Observable<String>> resume = new Function<Throwable, Observable<String>>() {
54
55 @Override
56 public Observable<String> apply(Throwable t1) {
57 receivedException.set(t1);
58 return Observable.just("twoResume", "threeResume");
59 }
60
61 };
62 Observable<String> observable = w.onErrorResumeNext(resume);
63
64 Observer<String> observer = TestHelper.mockObserver();
65
66 observable.subscribe(observer);
67
68 verify(observer, Mockito.never()).onError(any(Throwable.class));
69 verify(observer, times(1)).onComplete();
70 verify(observer, times(1)).onNext("one");
71 verify(observer, Mockito.never()).onNext("two");
72 verify(observer, Mockito.never()).onNext("three");
73 verify(observer, times(1)).onNext("twoResume");
74 verify(observer, times(1)).onNext("threeResume");
75 assertNotNull(receivedException.get());
76 }
77
78 @Test
79 public void resumeNextWithAsyncExecution() {
80 final AtomicReference<Throwable> receivedException = new AtomicReference<>();
81 Subscription s = mock(Subscription.class);
82 TestObservable w = new TestObservable(s, "one");
83 Function<Throwable, Observable<String>> resume = new Function<Throwable, Observable<String>>() {
84
85 @Override
86 public Observable<String> apply(Throwable t1) {
87 receivedException.set(t1);
88 return Observable.just("twoResume", "threeResume");
89 }
90
91 };
92 Observable<String> o = Observable.unsafeCreate(w).onErrorResumeNext(resume);
93
94 Observer<String> observer = TestHelper.mockObserver();
95
96 o.subscribe(observer);
97
98 try {
99 w.t.join();
100 } catch (InterruptedException e) {
101 fail(e.getMessage());
102 }
103
104 verify(observer, Mockito.never()).onError(any(Throwable.class));
105 verify(observer, times(1)).onComplete();
106 verify(observer, times(1)).onNext("one");
107 verify(observer, Mockito.never()).onNext("two");
108 verify(observer, Mockito.never()).onNext("three");
109 verify(observer, times(1)).onNext("twoResume");
110 verify(observer, times(1)).onNext("threeResume");
111 assertNotNull(receivedException.get());
112 }
113
114 /**
115 * Test that when a function throws an exception this is propagated through onError.
116 */
117 @Test
118 public void functionThrowsError() {
119 Subscription s = mock(Subscription.class);
120 TestObservable w = new TestObservable(s, "one");
121 Function<Throwable, Observable<String>> resume = new Function<Throwable, Observable<String>>() {
122
123 @Override
124 public Observable<String> apply(Throwable t1) {
125 throw new RuntimeException("exception from function");
126 }
127
128 };
129 Observable<String> o = Observable.unsafeCreate(w).onErrorResumeNext(resume);
130
131 Observer<String> observer = TestHelper.mockObserver();
132 o.subscribe(observer);
133
134 try {
135 w.t.join();
136 } catch (InterruptedException e) {
137 fail(e.getMessage());
138 }
139
140 // we should get the "one" value before the error
141 verify(observer, times(1)).onNext("one");
142
143 // we should have received an onError call on the Observer since the resume function threw an exception
144 verify(observer, times(1)).onError(any(Throwable.class));
145 verify(observer, times(0)).onComplete();
146 }
147
148 @Test
149 public void mapResumeAsyncNext() {
150 // Trigger multiple failures
151 Observable<String> w = Observable.just("one", "fail", "two", "three", "fail");
152
153 // Introduce map function that fails intermittently (Map does not prevent this when the Observer is a
154 // rx.operator incl onErrorResumeNextViaObservable)
155 w = w.map(new Function<String, String>() {
156 @Override
157 public String apply(String s) {
158 if ("fail".equals(s)) {
159 throw new RuntimeException("Forced Failure");
160 }
161 System.out.println("BadMapper:" + s);
162 return s;
163 }
164 });
165
166 Observable<String> o = w.onErrorResumeNext(new Function<Throwable, Observable<String>>() {
167
168 @Override
169 public Observable<String> apply(Throwable t1) {
170 return Observable.just("twoResume", "threeResume").subscribeOn(Schedulers.computation());
171 }
172
173 });
174
175 Observer<String> observer = TestHelper.mockObserver();
176
177 TestObserver<String> to = new TestObserver<>(observer);
178 o.subscribe(to);
179 to.awaitDone(5, TimeUnit.SECONDS);
180
181 verify(observer, Mockito.never()).onError(any(Throwable.class));
182 verify(observer, times(1)).onComplete();
183 verify(observer, times(1)).onNext("one");
184 verify(observer, Mockito.never()).onNext("two");
185 verify(observer, Mockito.never()).onNext("three");
186 verify(observer, times(1)).onNext("twoResume");
187 verify(observer, times(1)).onNext("threeResume");
188 }
189
190 static class TestObservable implements ObservableSource<String> {
191
192 final String[] values;
193 Thread t;
194
195 TestObservable(Subscription s, String... values) {
196 this.values = values;
197 }
198
199 @Override
200 public void subscribe(final Observer<? super String> observer) {
201 System.out.println("TestObservable subscribed to ...");
202 observer.onSubscribe(Disposable.empty());
203 t = new Thread(new Runnable() {
204
205 @Override
206 public void run() {
207 try {
208 System.out.println("running TestObservable thread");
209 for (String s : values) {
210 System.out.println("TestObservable onNext: " + s);
211 observer.onNext(s);
212 }
213 throw new RuntimeException("Forced Failure");
214 } catch (Throwable e) {
215 observer.onError(e);
216 }
217 }
218
219 });
220 System.out.println("starting TestObservable thread");
221 t.start();
222 System.out.println("done starting TestObservable thread");
223 }
224
225 }
226
227 @Test
228 public void backpressure() {
229 TestObserver<Integer> to = new TestObserver<>();
230 Observable.range(0, 100000)
231 .onErrorResumeNext(new Function<Throwable, Observable<Integer>>() {
232
233 @Override
234 public Observable<Integer> apply(Throwable t1) {
235 return Observable.just(1);
236 }
237
238 })
239 .observeOn(Schedulers.computation())
240 .map(new Function<Integer, Integer>() {
241 int c;
242
243 @Override
244 public Integer apply(Integer t1) {
245 if (c++ <= 1) {
246 // slow
247 try {
248 Thread.sleep(500);
249 } catch (InterruptedException e) {
250 e.printStackTrace();
251 }
252 }
253 return t1;
254 }
255
256 })
257 .subscribe(to);
258 to.awaitDone(5, TimeUnit.SECONDS);
259 to.assertNoErrors();
260 }
261
262 @Test
263 public void badOtherSource() {
264 TestHelper.checkBadSourceObservable(new Function<Observable<Integer>, Object>() {
265 @Override
266 public Object apply(Observable<Integer> o) throws Exception {
267 return Observable.error(new IOException())
268 .onErrorResumeNext(Functions.justFunction(o));
269 }
270 }, false, 1, 1, 1);
271 }
272 }