Debian Codegraph @

src/test/java/io/reactivex/rxjava3/internal/operators/observable/ObservableTimeoutTests.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 io.reactivex.rxjava3.internal.util.ExceptionHelper.timeoutMessage;
17 import static org.junit.Assert.*;
18 import static org.mockito.ArgumentMatchers.any;
19 import static org.mockito.Mockito.*;
20
21 import java.util.List;
22 import java.util.concurrent.*;
23
24 import org.junit.*;
25 import org.mockito.InOrder;
26
27 import io.reactivex.rxjava3.core.*;
28 import io.reactivex.rxjava3.disposables.*;
29 import io.reactivex.rxjava3.exceptions.TestException;
30 import io.reactivex.rxjava3.observers.TestObserver;
31 import io.reactivex.rxjava3.plugins.RxJavaPlugins;
32 import io.reactivex.rxjava3.schedulers.TestScheduler;
33 import io.reactivex.rxjava3.subjects.PublishSubject;
34 import io.reactivex.rxjava3.testsupport.*;
35
36 public class ObservableTimeoutTests extends RxJavaTest {
37 private PublishSubject<String> underlyingSubject;
38 private TestScheduler testScheduler;
39 private Observable<String> withTimeout;
40 private static final long TIMEOUT = 3;
41 private static final TimeUnit TIME_UNIT = TimeUnit.SECONDS;
42
43 @Before
44 public void setUp() {
45
46 underlyingSubject = PublishSubject.create();
47 testScheduler = new TestScheduler();
48 withTimeout = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, testScheduler);
49 }
50
51 @Test
52 public void shouldNotTimeoutIfOnNextWithinTimeout() {
53 Observer<String> observer = TestHelper.mockObserver();
54 TestObserver<String> to = new TestObserver<>(observer);
55
56 withTimeout.subscribe(to);
57
58 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
59 underlyingSubject.onNext("One");
60 verify(observer).onNext("One");
61 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
62 verify(observer, never()).onError(any(Throwable.class));
63 to.dispose();
64 }
65
66 @Test
67 public void shouldNotTimeoutIfSecondOnNextWithinTimeout() {
68 Observer<String> observer = TestHelper.mockObserver();
69 TestObserver<String> to = new TestObserver<>(observer);
70
71 withTimeout.subscribe(to);
72
73 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
74 underlyingSubject.onNext("One");
75 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
76 underlyingSubject.onNext("Two");
77 verify(observer).onNext("Two");
78 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
79 verify(observer, never()).onError(any(Throwable.class));
80 to.dispose();
81 }
82
83 @Test
84 public void shouldTimeoutIfOnNextNotWithinTimeout() {
85 TestObserverEx<String> observer = new TestObserverEx<>();
86
87 withTimeout.subscribe(observer);
88
89 testScheduler.advanceTimeBy(TIMEOUT + 1, TimeUnit.SECONDS);
90 observer.assertFailureAndMessage(TimeoutException.class, timeoutMessage(TIMEOUT, TIME_UNIT));
91 }
92
93 @Test
94 public void shouldTimeoutIfSecondOnNextNotWithinTimeout() {
95 TestObserverEx<String> observer = new TestObserverEx<>();
96 withTimeout.subscribe(observer);
97 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
98 underlyingSubject.onNext("One");
99 observer.assertValue("One");
100 testScheduler.advanceTimeBy(TIMEOUT + 1, TimeUnit.SECONDS);
101 observer.assertFailureAndMessage(TimeoutException.class, timeoutMessage(TIMEOUT, TIME_UNIT), "One");
102 }
103
104 @Test
105 public void shouldCompleteIfUnderlyingComletes() {
106 Observer<String> observer = TestHelper.mockObserver();
107 TestObserver<String> to = new TestObserver<>(observer);
108 withTimeout.subscribe(observer);
109 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
110 underlyingSubject.onComplete();
111 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
112 verify(observer).onComplete();
113 verify(observer, never()).onError(any(Throwable.class));
114 to.dispose();
115 }
116
117 @Test
118 public void shouldErrorIfUnderlyingErrors() {
119 Observer<String> observer = TestHelper.mockObserver();
120 TestObserver<String> to = new TestObserver<>(observer);
121 withTimeout.subscribe(observer);
122 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
123 underlyingSubject.onError(new UnsupportedOperationException());
124 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
125 verify(observer).onError(any(UnsupportedOperationException.class));
126 to.dispose();
127 }
128
129 @Test
130 public void shouldSwitchToOtherIfOnNextNotWithinTimeout() {
131 Observable<String> other = Observable.just("a", "b", "c");
132 Observable<String> source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, testScheduler, other);
133
134 Observer<String> observer = TestHelper.mockObserver();
135 TestObserver<String> to = new TestObserver<>(observer);
136 source.subscribe(to);
137
138 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
139 underlyingSubject.onNext("One");
140 testScheduler.advanceTimeBy(4, TimeUnit.SECONDS);
141 underlyingSubject.onNext("Two");
142 InOrder inOrder = inOrder(observer);
143 inOrder.verify(observer, times(1)).onNext("One");
144 inOrder.verify(observer, times(1)).onNext("a");
145 inOrder.verify(observer, times(1)).onNext("b");
146 inOrder.verify(observer, times(1)).onNext("c");
147 inOrder.verify(observer, times(1)).onComplete();
148 inOrder.verifyNoMoreInteractions();
149 to.dispose();
150 }
151
152 @Test
153 public void shouldSwitchToOtherIfOnErrorNotWithinTimeout() {
154 Observable<String> other = Observable.just("a", "b", "c");
155 Observable<String> source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, testScheduler, other);
156
157 Observer<String> observer = TestHelper.mockObserver();
158 TestObserver<String> to = new TestObserver<>(observer);
159 source.subscribe(to);
160
161 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
162 underlyingSubject.onNext("One");
163 testScheduler.advanceTimeBy(4, TimeUnit.SECONDS);
164 underlyingSubject.onError(new UnsupportedOperationException());
165 InOrder inOrder = inOrder(observer);
166 inOrder.verify(observer, times(1)).onNext("One");
167 inOrder.verify(observer, times(1)).onNext("a");
168 inOrder.verify(observer, times(1)).onNext("b");
169 inOrder.verify(observer, times(1)).onNext("c");
170 inOrder.verify(observer, times(1)).onComplete();
171 inOrder.verifyNoMoreInteractions();
172 to.dispose();
173 }
174
175 @Test
176 public void shouldSwitchToOtherIfOnCompletedNotWithinTimeout() {
177 Observable<String> other = Observable.just("a", "b", "c");
178 Observable<String> source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, testScheduler, other);
179
180 Observer<String> observer = TestHelper.mockObserver();
181 TestObserver<String> to = new TestObserver<>(observer);
182 source.subscribe(to);
183
184 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
185 underlyingSubject.onNext("One");
186 testScheduler.advanceTimeBy(4, TimeUnit.SECONDS);
187 underlyingSubject.onComplete();
188 InOrder inOrder = inOrder(observer);
189 inOrder.verify(observer, times(1)).onNext("One");
190 inOrder.verify(observer, times(1)).onNext("a");
191 inOrder.verify(observer, times(1)).onNext("b");
192 inOrder.verify(observer, times(1)).onNext("c");
193 inOrder.verify(observer, times(1)).onComplete();
194 inOrder.verifyNoMoreInteractions();
195 to.dispose();
196 }
197
198 @Test
199 public void shouldSwitchToOtherAndCanBeUnsubscribedIfOnNextNotWithinTimeout() {
200 PublishSubject<String> other = PublishSubject.create();
201 Observable<String> source = underlyingSubject.timeout(TIMEOUT, TIME_UNIT, testScheduler, other);
202
203 Observer<String> observer = TestHelper.mockObserver();
204 TestObserver<String> to = new TestObserver<>(observer);
205 source.subscribe(to);
206
207 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
208 underlyingSubject.onNext("One");
209 testScheduler.advanceTimeBy(4, TimeUnit.SECONDS);
210 underlyingSubject.onNext("Two");
211
212 other.onNext("a");
213 other.onNext("b");
214 to.dispose();
215
216 // The following messages should not be delivered.
217 other.onNext("c");
218 other.onNext("d");
219 other.onComplete();
220
221 InOrder inOrder = inOrder(observer);
222 inOrder.verify(observer, times(1)).onNext("One");
223 inOrder.verify(observer, times(1)).onNext("a");
224 inOrder.verify(observer, times(1)).onNext("b");
225 inOrder.verifyNoMoreInteractions();
226 }
227
228 @Test
229 public void shouldTimeoutIfSynchronizedObservableEmitFirstOnNextNotWithinTimeout()
230 throws InterruptedException {
231 final CountDownLatch exit = new CountDownLatch(1);
232 final CountDownLatch timeoutSetuped = new CountDownLatch(1);
233
234 final TestObserverEx<String> observer = new TestObserverEx<>();
235
236 new Thread(new Runnable() {
237
238 @Override
239 public void run() {
240 Observable.unsafeCreate(new ObservableSource<String>() {
241
242 @Override
243 public void subscribe(Observer<? super String> observer) {
244 observer.onSubscribe(Disposable.empty());
245 try {
246 timeoutSetuped.countDown();
247 exit.await();
248 } catch (InterruptedException e) {
249 e.printStackTrace();
250 }
251 observer.onNext("a");
252 observer.onComplete();
253 }
254
255 }).timeout(1, TimeUnit.SECONDS, testScheduler)
256 .subscribe(observer);
257 }
258 }).start();
259
260 timeoutSetuped.await();
261 testScheduler.advanceTimeBy(2, TimeUnit.SECONDS);
262
263 observer.assertFailureAndMessage(TimeoutException.class, timeoutMessage(1, TimeUnit.SECONDS));
264
265 exit.countDown(); // exit the thread
266 }
267
268 @Test
269 public void shouldUnsubscribeFromUnderlyingSubscriptionOnTimeout() throws InterruptedException {
270 // From https://github.com/ReactiveX/RxJava/pull/951
271 final Disposable upstream = mock(Disposable.class);
272
273 Observable<String> never = Observable.unsafeCreate(new ObservableSource<String>() {
274 @Override
275 public void subscribe(Observer<? super String> observer) {
276 observer.onSubscribe(upstream);
277 }
278 });
279
280 TestScheduler testScheduler = new TestScheduler();
281 Observable<String> observableWithTimeout = never.timeout(1000, TimeUnit.MILLISECONDS, testScheduler);
282
283 TestObserverEx<String> observer = new TestObserverEx<>();
284 observableWithTimeout.subscribe(observer);
285
286 testScheduler.advanceTimeBy(2000, TimeUnit.MILLISECONDS);
287
288 observer.assertFailureAndMessage(TimeoutException.class, timeoutMessage(1000, TimeUnit.MILLISECONDS));
289
290 verify(upstream, times(1)).dispose();
291 }
292
293 @Test
294 public void shouldUnsubscribeFromUnderlyingSubscriptionOnDispose() {
295 final PublishSubject<String> subject = PublishSubject.create();
296 final TestScheduler scheduler = new TestScheduler();
297
298 final TestObserver<String> observer = subject
299 .timeout(100, TimeUnit.MILLISECONDS, scheduler)
300 .test();
301
302 assertTrue(subject.hasObservers());
303
304 observer.dispose();
305
306 assertFalse(subject.hasObservers());
307 }
308
309 @Test
310 public void timedAndOther() {
311 Observable.never().timeout(100, TimeUnit.MILLISECONDS, Observable.just(1))
312 .test()
313 .awaitDone(5, TimeUnit.SECONDS)
314 .assertResult(1);
315 }
316
317 @Test
318 public void disposed() {
319 TestHelper.checkDisposed(PublishSubject.create().timeout(1, TimeUnit.DAYS));
320
321 TestHelper.checkDisposed(PublishSubject.create().timeout(1, TimeUnit.DAYS, Observable.just(1)));
322 }
323
324 @Test
325 public void timedErrorOther() {
326 Observable.error(new TestException())
327 .timeout(1, TimeUnit.DAYS, Observable.just(1))
328 .test()
329 .assertFailure(TestException.class);
330 }
331
332 @Test
333 public void timedError() {
334 Observable.error(new TestException())
335 .timeout(1, TimeUnit.DAYS)
336 .test()
337 .assertFailure(TestException.class);
338 }
339
340 @Test
341 public void timedEmptyOther() {
342 Observable.empty()
343 .timeout(1, TimeUnit.DAYS, Observable.just(1))
344 .test()
345 .assertResult();
346 }
347
348 @Test
349 public void timedEmpty() {
350 Observable.empty()
351 .timeout(1, TimeUnit.DAYS)
352 .test()
353 .assertResult();
354 }
355
356 @Test
357 public void badSource() {
358 List<Throwable> errors = TestHelper.trackPluginErrors();
359 try {
360 new Observable<Integer>() {
361 @Override
362 protected void subscribeActual(Observer<? super Integer> observer) {
363 observer.onSubscribe(Disposable.empty());
364
365 observer.onNext(1);
366 observer.onComplete();
367 observer.onNext(2);
368 observer.onError(new TestException());
369 observer.onComplete();
370 }
371 }
372 .timeout(1, TimeUnit.DAYS)
373 .test()
374 .assertResult(1);
375
376 TestHelper.assertUndeliverable(errors, 0, TestException.class);
377 } finally {
378 RxJavaPlugins.reset();
379 }
380 }
381
382 @Test
383 public void badSourceOther() {
384 List<Throwable> errors = TestHelper.trackPluginErrors();
385 try {
386 new Observable<Integer>() {
387 @Override
388 protected void subscribeActual(Observer<? super Integer> observer) {
389 observer.onSubscribe(Disposable.empty());
390
391 observer.onNext(1);
392 observer.onComplete();
393 observer.onNext(2);
394 observer.onError(new TestException());
395 observer.onComplete();
396 }
397 }
398 .timeout(1, TimeUnit.DAYS, Observable.just(3))
399 .test()
400 .assertResult(1);
401
402 TestHelper.assertUndeliverable(errors, 0, TestException.class);
403 } finally {
404 RxJavaPlugins.reset();
405 }
406 }
407
408 @Test
409 public void timedTake() {
410 PublishSubject<Integer> ps = PublishSubject.create();
411
412 TestObserver<Integer> to = ps.timeout(1, TimeUnit.DAYS)
413 .take(1)
414 .test();
415
416 assertTrue(ps.hasObservers());
417
418 ps.onNext(1);
419
420 assertFalse(ps.hasObservers());
421
422 to.assertResult(1);
423 }
424
425 @Test
426 public void timedFallbackTake() {
427 PublishSubject<Integer> ps = PublishSubject.create();
428
429 TestObserver<Integer> to = ps.timeout(1, TimeUnit.DAYS, Observable.just(2))
430 .take(1)
431 .test();
432
433 assertTrue(ps.hasObservers());
434
435 ps.onNext(1);
436
437 assertFalse(ps.hasObservers());
438
439 to.assertResult(1);
440 }
441
442 @Test
443 public void fallbackErrors() {
444 Observable.never()
445 .timeout(1, TimeUnit.MILLISECONDS, Observable.error(new TestException()))
446 .test()
447 .awaitDone(5, TimeUnit.SECONDS)
448 .assertFailure(TestException.class);
449 }
450
451 @Test
452 public void onNextOnTimeoutRace() {
453 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
454 final TestScheduler sch = new TestScheduler();
455
456 final PublishSubject<Integer> ps = PublishSubject.create();
457
458 TestObserverEx<Integer> to = ps.timeout(1, TimeUnit.SECONDS, sch).to(TestHelper.<Integer>testConsumer());
459
460 Runnable r1 = new Runnable() {
461 @Override
462 public void run() {
463 ps.onNext(1);
464 }
465 };
466
467 Runnable r2 = new Runnable() {
468 @Override
469 public void run() {
470 sch.advanceTimeBy(1, TimeUnit.SECONDS);
471 }
472 };
473
474 TestHelper.race(r1, r2);
475
476 if (to.values().size() != 0) {
477 if (to.errors().size() != 0) {
478 to.assertFailure(TimeoutException.class, 1);
479 to.assertErrorMessage(timeoutMessage(1, TimeUnit.SECONDS));
480 } else {
481 to.assertValuesOnly(1);
482 }
483 } else {
484 to.assertFailure(TimeoutException.class);
485 to.assertErrorMessage(timeoutMessage(1, TimeUnit.SECONDS));
486 }
487 }
488 }
489
490 @Test
491 public void onNextOnTimeoutRaceFallback() {
492 for (int i = 0; i < TestHelper.RACE_DEFAULT_LOOPS; i++) {
493 final TestScheduler sch = new TestScheduler();
494
495 final PublishSubject<Integer> ps = PublishSubject.create();
496
497 TestObserverEx<Integer> to = ps.timeout(1, TimeUnit.SECONDS, sch, Observable.just(2)).to(TestHelper.<Integer>testConsumer());
498
499 Runnable r1 = new Runnable() {
500 @Override
501 public void run() {
502 ps.onNext(1);
503 }
504 };
505
506 Runnable r2 = new Runnable() {
507 @Override
508 public void run() {
509 sch.advanceTimeBy(1, TimeUnit.SECONDS);
510 }
511 };
512
513 TestHelper.race(r1, r2);
514
515 if (to.isTerminated()) {
516 int c = to.values().size();
517 if (c == 1) {
518 int v = to.values().get(0);
519 assertTrue("" + v, v == 1 || v == 2);
520 } else {
521 to.assertResult(1, 2);
522 }
523 } else {
524 to.assertValuesOnly(1);
525 }
526 }
527 }
528 }