@SuppressWarnings("unchecked") @Test public void shouldNotInvokeFuncUntilSubscription() throws Exception { Callable<Object> func = mock(Callable.class); when(func.call()).thenReturn(new Object()); Single<Object> fromCallableSingle = Single.fromCallable(func); verifyZeroInteractions(func); fromCallableSingle.subscribe(); verify(func).call(); }
@Test public void settingSameDisposableTwiceDoesUnsubscribeIt() { Disposable underlying = mock(Disposable.class); serialDisposable.update(underlying); verifyZeroInteractions(underlying); serialDisposable.update(underlying); verify(underlying).dispose(); }
@Test public void shouldRemoveRegisteredListenersOnUnresgister() { SharedPreferences anotherSharedPreferences = context.getSharedPreferences("bazBang", Context.MODE_PRIVATE); SharedPreferences.OnSharedPreferenceChangeListener mockListener = mock(SharedPreferences.OnSharedPreferenceChangeListener.class); anotherSharedPreferences.registerOnSharedPreferenceChangeListener(mockListener); anotherSharedPreferences.unregisterOnSharedPreferenceChangeListener(mockListener); anotherSharedPreferences.edit().putString("key", "value"); verifyZeroInteractions(mockListener); }
@Test public void testException() { final IllegalStateException exception = new IllegalStateException("foo"); LottieTask<Integer> task = new LottieTask<>(new Callable<LottieResult<Integer>>() { @Override public LottieResult<Integer> call() { throw exception; } }, true) .addListener(successListener) .addFailureListener(failureListener); verifyZeroInteractions(successListener); verify(failureListener, times(1)).onResult(exception); }
@Test public void ignoreMessage() { // no destination this.handler.handleMessage(createWith(SimpMessageType.MESSAGE, "joe", "123", null)); Mockito.verifyZeroInteractions(this.brokerChannel); // not a user destination this.handler.handleMessage(createWith(SimpMessageType.MESSAGE, "joe", "123", "/queue/foo")); Mockito.verifyZeroInteractions(this.brokerChannel); // subscribe + not a user destination this.handler.handleMessage(createWith(SimpMessageType.SUBSCRIBE, "joe", "123", "/queue/foo")); Mockito.verifyZeroInteractions(this.brokerChannel); // no match on message type this.handler.handleMessage(createWith(SimpMessageType.CONNECT, "joe", "123", "user/joe/queue/foo")); Mockito.verifyZeroInteractions(this.brokerChannel); }
@Test void closeVerifiesUniquenessOfChangedValues() throws Exception { SchemaIndex index = mock( SchemaIndex.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( index ); updater.process( change( 1, descriptor, "foo1", "foo2" ) ); updater.process( change( 1, descriptor, "bar1", "bar2" ) ); updater.process( change( 1, descriptor, "baz1", "baz2" ) ); verifyZeroInteractions( index ); updater.close(); verifyVerifyUniqueness( index, descriptor, "foo2", "bar2", "baz2" ); }
@SuppressWarnings("unchecked") @Test public void shouldNotInvokeFuncUntilSubscription() throws Exception { Callable<Object> func = mock(Callable.class); when(func.call()).thenReturn(new Object()); Observable<Object> fromCallableObservable = Observable.fromCallable(func); verifyZeroInteractions(func); fromCallableObservable.subscribe(); verify(func).call(); }
@Test public void setOnTabSelectListener_WhenShouldFireInitiallySetToFalse_DoesNotFireWhenSet() { OnTabSelectListener listener = mock(OnTabSelectListener.class); bottomBar.setOnTabSelectListener(listener, false); verifyZeroInteractions(listener); }
@Test public void settingSameDisposableTwiceDoesUnsubscribeIt() { Disposable underlying = mock(Disposable.class); serialDisposable.set(underlying); verifyZeroInteractions(underlying); serialDisposable.set(underlying); verify(underlying).dispose(); }
@Test public void testListener() { LottieTask<Integer> task = new LottieTask<>(new Callable<LottieResult<Integer>>() { @Override public LottieResult<Integer> call() { return new LottieResult<>(5); } }, true) .addListener(successListener) .addFailureListener(failureListener); verify(successListener, times(1)).onResult(5); verifyZeroInteractions(failureListener); }
@Test public void performNetworkStateChangeWithNullInfoIgnores() { Dispatcher dispatcher = createDispatcher(serviceMock); dispatcher.performNetworkStateChange(null); verifyZeroInteractions(service); }
@Test void closeVerifiesUniquenessOfAddedValues() throws Exception { SchemaIndex index = mock( SchemaIndex.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( index ); updater.process( add( 1, descriptor, "foo" ) ); updater.process( add( 1, descriptor, "bar" ) ); updater.process( add( 1, descriptor, "baz" ) ); verifyZeroInteractions( index ); updater.close(); verifyVerifyUniqueness( index, descriptor, "foo", "bar", "baz" ); }
@SuppressWarnings("unchecked") @Test public void shouldNotInvokeFuncUntilSubscription() throws Exception { Callable<Object> func = mock(Callable.class); when(func.call()).thenReturn(new Object()); Flowable<Object> fromCallableFlowable = Flowable.fromCallable(func); verifyZeroInteractions(func); fromCallableFlowable.subscribe(); verify(func).call(); }
@Test public void onStart_has_no_effect() { CeTask ceTask = mock(CeTask.class); underTest.onStart(ceTask); verifyZeroInteractions(ceTask); }
@Test public void testGetUserListUseCaseObservableHappyCase() { getUserList.buildUseCaseObservable(null); verify(mockUserRepository).users(); verifyNoMoreInteractions(mockUserRepository); verifyZeroInteractions(mockThreadExecutor); verifyZeroInteractions(mockPostExecutionThread); } }
@Test public void testAddListenerAfter() { LottieTask<Integer> task = new LottieTask<>(new Callable<LottieResult<Integer>>() { @Override public LottieResult<Integer> call() { return new LottieResult<>(5); } }, true); task.addListener(successListener); task.addFailureListener(failureListener); verify(successListener, times(1)).onResult(5); verifyZeroInteractions(failureListener); } }
@Test public void performNetworkStateChangeWithConnectedInfoDifferentInstanceIgnores() { Dispatcher dispatcher = createDispatcher(serviceMock); NetworkInfo info = mockNetworkInfo(true); dispatcher.performNetworkStateChange(info); verifyZeroInteractions(service); }
@Test void closeVerifiesUniquenessOfAddedAndChangedValues() throws Exception { SchemaIndex index = mock( SchemaIndex.class ); UniqueLuceneIndexPopulatingUpdater updater = newUpdater( index ); updater.process( add( 1, descriptor, "added1" ) ); updater.process( add( 2, descriptor, "added2" ) ); updater.process( change( 3, descriptor, "before1", "after1" ) ); updater.process( change( 4, descriptor, "before2", "after2" ) ); updater.process( remove( 5, descriptor, "removed1" ) ); verifyZeroInteractions( index ); updater.close(); verifyVerifyUniqueness( index, descriptor, "added1", "added2", "after1", "after2" ); }
@Test public void return_400_on_get_request() throws Exception { when(request.getMethod()).thenReturn("GET"); underTest.doFilter(request, response, chain); verifyZeroInteractions(jwtHttpHandler, chain); verify(response).setStatus(400); }
@Test public void onStart_has_no_effect() { CeTask mockedCeTask = mock(CeTask.class); fullMockedUnderTest.onStart(mockedCeTask); verifyZeroInteractions(mockedCeTask, notificationService, dbClientMock, serializer, system2); }