@SuppressWarnings("unchecked") @Test public void shouldCallOnError() throws Exception { Callable<Object> func = mock(Callable.class); Throwable throwable = new IllegalStateException("Test exception"); when(func.call()).thenThrow(throwable); Observable<Object> fromCallableObservable = Observable.fromCallable(func); Observer<Object> observer = TestHelper.mockObserver(); fromCallableObservable.subscribe(observer); verify(observer, never()).onNext(any()); verify(observer, never()).onComplete(); verify(observer).onError(throwable); }
public void testAddDelayedShutdownHook_success() throws InterruptedException { TestApplication application = new TestApplication(); ExecutorService service = mock(ExecutorService.class); application.addDelayedShutdownHook(service, 2, TimeUnit.SECONDS); verify(service, Mockito.never()).shutdown(); application.shutdown(); InOrder shutdownFirst = Mockito.inOrder(service); shutdownFirst.verify(service).shutdown(); shutdownFirst.verify(service).awaitTermination(2, TimeUnit.SECONDS); }
@SuppressWarnings("unchecked") @Test public void shouldCallOnNextAndOnCompleted() throws Exception { Callable<String> func = mock(Callable.class); when(func.call()).thenReturn("test_value"); Observable<String> fromCallableObservable = Observable.fromCallable(func); Observer<Object> observer = TestHelper.mockObserver(); fromCallableObservable.subscribe(observer); verify(observer).onNext("test_value"); verify(observer).onComplete(); verify(observer, never()).onError(any(Throwable.class)); }
@Test public void testToMultimap() { Flowable<String> source = Flowable.just("a", "b", "cc", "dd"); Single<Map<Integer, Collection<String>>> mapped = source.toMultimap(lengthFunc); Map<Integer, Collection<String>> expected = new HashMap<Integer, Collection<String>>(); expected.put(1, Arrays.asList("a", "b")); expected.put(2, Arrays.asList("cc", "dd")); mapped.subscribe(singleObserver); verify(singleObserver, never()).onError(any(Throwable.class)); verify(singleObserver, times(1)).onSuccess(expected); }
@Test public void testDeferFunctionThrows() throws Exception { Callable<Observable<String>> factory = mock(Callable.class); when(factory.call()).thenThrow(new TestException()); Observable<String> result = Observable.defer(factory); Observer<String> o = TestHelper.mockObserver(); result.subscribe(o); verify(o).onError(any(TestException.class)); verify(o, never()).onNext(any(String.class)); verify(o, never()).onComplete(); } }
@Test public void testSkipTwoElements() { Observable<String> skip = Observable.just("one", "two", "three").skip(2); Observer<String> observer = TestHelper.mockObserver(); skip.subscribe(observer); verify(observer, never()).onNext("one"); verify(observer, never()).onNext("two"); verify(observer, times(1)).onNext("three"); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testSuccess() throws Exception { @SuppressWarnings("unchecked") Future<Object> future = mock(Future.class); Object value = new Object(); when(future.get()).thenReturn(value); Observer<Object> o = TestHelper.mockObserver(); TestObserver<Object> to = new TestObserver<Object>(o); Observable.fromFuture(future).subscribe(to); to.dispose(); verify(o, times(1)).onNext(value); verify(o, times(1)).onComplete(); verify(o, never()).onError(any(Throwable.class)); verify(future, never()).cancel(true); }
@Test public void testTake2() { Observable<String> w = Observable.fromIterable(Arrays.asList("one", "two", "three")); Observable<String> take = w.take(1); Observer<String> observer = TestHelper.mockObserver(); take.subscribe(observer); verify(observer, times(1)).onNext("one"); verify(observer, never()).onNext("two"); verify(observer, never()).onNext("three"); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@Test public void testFailure() throws Exception { @SuppressWarnings("unchecked") Future<Object> future = mock(Future.class); RuntimeException e = new RuntimeException(); when(future.get()).thenThrow(e); Observer<Object> o = TestHelper.mockObserver(); TestObserver<Object> to = new TestObserver<Object>(o); Observable.fromFuture(future).subscribe(to); to.dispose(); verify(o, never()).onNext(null); verify(o, never()).onComplete(); verify(o, times(1)).onError(e); verify(future, never()).cancel(true); }
@Test public void testTakeLastEmpty() { Observable<String> w = Observable.empty(); Observable<String> take = w.takeLast(2); Observer<String> observer = TestHelper.mockObserver(); take.subscribe(observer); verify(observer, never()).onNext(any(String.class)); verify(observer, never()).onError(any(Throwable.class)); verify(observer, times(1)).onComplete(); }
@SuppressWarnings("unchecked") @Test public void shouldCallOnError() throws Exception { Callable<Object> func = mock(Callable.class); Throwable throwable = new IllegalStateException("Test exception"); when(func.call()).thenThrow(throwable); Flowable<Object> fromCallableFlowable = Flowable.fromCallable(func); Subscriber<Object> subscriber = TestHelper.mockSubscriber(); fromCallableFlowable.subscribe(subscriber); verify(subscriber, never()).onNext(any()); verify(subscriber, never()).onComplete(); verify(subscriber).onError(throwable); }
@Test public void testFirstOrElseWithPredicateOfNoneMatchingThePredicate() { Observable<String> src = Observable.just("a", "b", "c"); src.filter(IS_D).first("default").subscribe(wo); verify(wo, times(1)).onSuccess(anyString()); verify(wo, times(1)).onSuccess("default"); verify(wo, never()).onError(any(Throwable.class)); }
@Test public void testDeferFunctionThrows() throws Exception { Callable<Flowable<String>> factory = mock(Callable.class); when(factory.call()).thenThrow(new TestException()); Flowable<String> result = Flowable.defer(factory); Subscriber<String> subscriber = TestHelper.mockSubscriber(); result.subscribe(subscriber); verify(subscriber).onError(any(TestException.class)); verify(subscriber, never()).onNext(any(String.class)); verify(subscriber, never()).onComplete(); } }
@Test public void testCountError() { Flowable<String> f = Flowable.error(new Callable<Throwable>() { @Override public Throwable call() { return new RuntimeException(); } }); f.count().subscribe(wo); verify(wo, never()).onSuccess(anyInt()); verify(wo, times(1)).onError(any(RuntimeException.class)); }
@SuppressWarnings("unchecked") @Test public void shouldCallOnNextAndOnCompleted() throws Exception { Callable<String> func = mock(Callable.class); when(func.call()).thenReturn("test_value"); Flowable<String> fromCallableFlowable = Flowable.fromCallable(func); Subscriber<String> subscriber = TestHelper.mockSubscriber(); fromCallableFlowable.subscribe(subscriber); verify(subscriber).onNext("test_value"); verify(subscriber).onComplete(); verify(subscriber, never()).onError(any(Throwable.class)); }