Java TestObserver.assertError方法代码示例

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testUpdateEmail_notSuccessful() {
  mockNotSuccessfulVoidResult(new IllegalStateException());
  when(mockFirebaseUser.updateEmail("[email protected]")).thenReturn(mockVoidTaskResult);

  TestObserver obs = TestObserver.create();

  RxFirebaseUser.updateEmail(mockFirebaseUser, "[email protected]").subscribe(obs);

  callOnComplete(mockVoidTaskResult);
  obs.dispose();

  // Ensure no more values are emitted after unsubscribe
  callOnComplete(mockVoidTaskResult);

  obs.assertError(IllegalStateException.class);
  obs.assertNotComplete();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test
public void test_error() {
	Observable<String> observable = Observable.error(new Exception("We got an Exception"));
	TestObserver<String> testObserver = new TestObserver<>();

	observable.subscribe(testObserver);

	testObserver.assertError(Exception.class);
	testObserver.assertNotComplete();
	testObserver.assertErrorMessage("We got an Exception");
	testObserver.assertFailure(exception -> {
		return exception instanceof Exception;
	});

	testObserver.assertFailureAndMessage(Exception.class, "We got an Exception");
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testDelete_notSuccessful() {
  mockNotSuccessfulVoidResult(new IllegalStateException());
  when(mockFirebaseUser.delete()).thenReturn(mockVoidTaskResult);

  TestObserver obs = TestObserver.create();

  RxFirebaseUser.delete(mockFirebaseUser).subscribe(obs);

  callOnComplete(mockVoidTaskResult);
  obs.dispose();

  // Ensure no more values are emitted after unsubscribe
  callOnComplete(mockVoidTaskResult);

  obs.assertError(IllegalStateException.class);
  obs.assertNotComplete();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testUnlink_notSuccessful() {
  mockNotSuccessfulAuthResult(new IllegalStateException());
  when(mockFirebaseUser.unlink("provider")).thenReturn(mockAuthTaskResult);

  TestObserver<AuthResult> obs = TestObserver.create();

  RxFirebaseUser.unlink(mockFirebaseUser, "provider").subscribe(obs);

  callOnComplete(mockAuthTaskResult);
  obs.dispose();

  // Ensure no more values are emitted after unsubscribe
  callOnComplete(mockAuthTaskResult);

  obs.assertError(IllegalStateException.class);
  obs.assertNoValues();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testGetStreamWithProcessor_notSuccessful() {
  mockNotSuccessfulResultForTask(mockStreamDownloadTask, new IllegalStateException());
  when(mockStorageReference.getStream(mockStreamProcessor)).thenReturn(mockStreamDownloadTask);

  TestObserver<StreamDownloadTask.TaskSnapshot> obs = TestObserver.create();

  RxFirebaseStorage.getStream(mockStorageReference, mockStreamProcessor).subscribe(obs);
  verifyAddOnCompleteListenerForTask(mockStreamDownloadTask);

  callOnComplete(mockStreamDownloadTask);
  obs.dispose();

  callOnComplete(mockStreamDownloadTask);

  obs.assertError(IllegalStateException.class);
  obs.assertNoValues();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testGetToken_notSuccessful() {
  mockNotSuccessfulTokenResult(new IllegalStateException());
  when(mockFirebaseUser.getToken(true)).thenReturn(mockGetTokenTaskResult);

  TestObserver<String> obs = TestObserver.create();

  RxFirebaseUser.getToken(mockFirebaseUser, true).subscribe(obs);

  callOnComplete(mockGetTokenTaskResult);
  obs.dispose();

  // Ensure no more values are emitted after unsubscribe
  callOnComplete(mockGetTokenTaskResult);

  obs.assertError(IllegalStateException.class);
  obs.assertNoValues();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test
public void testCheckWidgetCalledFromNonMainThread() throws InterruptedException, TimeoutException {
	TestObserver<?> testObserver = getEmptySubscribedTestObserver();

	AtomicBoolean atomic = new AtomicBoolean(false);

	Thread thread = new Thread(() -> {
		boolean checkWidget = Preconditions.checkWidget(testObserver, shell);

		assertThat(checkWidget, is(false));

		testObserver.assertError(IllegalStateException.class);
		testObserver.assertErrorMessage(
				"Expected to be called on the main thread but was " + Thread.currentThread().getName());
		atomic.set(true);
	});
	thread.start();

	await().untilTrue(atomic);
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testGetMetaData_notSuccessful() {
  mockNotSuccessfulResultForTask(mockStorageMetadataTask, new IllegalStateException());
  when(mockStorageReference.getMetadata()).thenReturn(mockStorageMetadataTask);

  TestObserver<StorageMetadata> obs = TestObserver.create();

  RxFirebaseStorage.getMetadata(mockStorageReference).subscribe(obs);
  verifyAddOnCompleteListenerForTask(mockStorageMetadataTask);

  callOnComplete(mockStorageMetadataTask);
  obs.dispose();

  callOnComplete(mockStorageMetadataTask);

  obs.assertError(IllegalStateException.class);
  obs.assertNoValues();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test
public void oneToOne() {
    RxGreeterGrpc.RxGreeterStub stub = RxGreeterGrpc.newRxStub(channel);
    Single<HelloResponse> resp = stub.sayHello(Single.just(HelloRequest.getDefaultInstance()));
    TestObserver<HelloResponse> test = resp.test();

    test.awaitTerminalEvent(3, TimeUnit.SECONDS);
    test.assertError(t -> t instanceof StatusRuntimeException);
    test.assertError(t -> ((StatusRuntimeException)t).getStatus() == Status.INTERNAL);
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test
public void manyToOne() {
    RxGreeterGrpc.RxGreeterStub stub = RxGreeterGrpc.newRxStub(channel);
    Single<HelloResponse> resp = stub.sayHelloReqStream(Flowable.just(HelloRequest.getDefaultInstance()));
    TestObserver<HelloResponse> test = resp.test();

    test.awaitTerminalEvent(3, TimeUnit.SECONDS);
    test.assertError(t -> t instanceof StatusRuntimeException);
    test.assertError(t -> ((StatusRuntimeException)t).getStatus() == Status.INTERNAL);
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test
public void serverCanCancelClientStreamExplicitly() {
    RxNumbersGrpc.RxNumbersStub stub = RxNumbersGrpc.newRxStub(channel);

    svc.setExplicitCancel(true);

    AtomicBoolean requestWasCanceled = new AtomicBoolean(false);
    AtomicBoolean requestDidProduce = new AtomicBoolean(false);

    Flowable<NumberProto.Number> request = Flowable
            .fromIterable(IntStream.range(0, NUMBER_OF_STREAM_ELEMENTS)::iterator)
            .delay(10, TimeUnit.MILLISECONDS)
            .map(CancellationPropagationIntegrationTest::protoNum)
            .doOnNext(n -> {
                requestDidProduce.set(true);
                System.out.println("P: " + n.getNumber(0));
            })
            .doOnCancel(() -> {
                requestWasCanceled.set(true);
                System.out.println("Client canceled");
            });

    TestObserver<NumberProto.Number> observer = stub
            .requestPressure(request)
            .doOnSuccess(number -> System.out.println(number.getNumber(0)))
            .doOnError(throwable -> System.out.println(throwable.getMessage()))
            .test();

    observer.awaitTerminalEvent();
    observer.assertError(StatusRuntimeException.class);
    observer.assertTerminated();
    assertThat(requestWasCanceled.get()).isTrue();
    assertThat(requestDidProduce.get()).isTrue();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testGetBytes_notSuccessful() {
  mockNotSuccessfulResultForTask(mockBytesTask, new IllegalStateException());
  when(mockStorageReference.getBytes(3)).thenReturn(mockBytesTask);

  TestObserver<byte[]> obs = TestObserver.create();

  RxFirebaseStorage.getBytes(mockStorageReference, 3).subscribe(obs);

  verifyAddOnCompleteListenerForTask(mockBytesTask);

  callOnComplete(mockBytesTask);
  obs.dispose();

  callOnComplete(mockBytesTask);

  obs.assertError(IllegalStateException.class);
  obs.assertNoValues();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testCheckActionCode_NotSuccessful() {
  mockNotSuccessfulResultForTask(mockActionCodeResultTask, new IllegalStateException());

  when(mockFirebaseAuth.checkActionCode("code")).thenReturn(mockActionCodeResultTask);

  TestObserver<ActionCodeResult> obs = TestObserver.create();

  RxFirebaseAuth.checkActionCode(mockFirebaseAuth, "code").subscribe(obs);

  callOnComplete(mockActionCodeResultTask);
  obs.dispose();

  // Ensure no more values are emitted after unsubscribe
  callOnComplete(mockActionCodeResultTask);

  obs.assertError(IllegalStateException.class);
  obs.assertNoValues();
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testDataChanges_onCancelled() {
  TestObserver<DataSnapshot> sub = TestObserver.create();

  RxFirebaseDatabase.dataChanges(mockDatabaseReference).subscribe(sub);

  verifyAddValueEventListener();
  callValueEventOnCancelled(new DatabaseException("foo"));

  sub.assertError(DatabaseException.class);
  sub.assertNoValues();

  sub.dispose();

  callValueEventOnCancelled(new DatabaseException("foo"));

  // Ensure no more values are emitted after unsubscribe
  assertThat(sub.errorCount()).isEqualTo(1);
}
 

import io.reactivex.observers.TestObserver; //导入方法依赖的package包/类
@Test public void testUpdateChildren_notSuccessful() {
  Map<String, Object> map = new HashMap<>();

  when(mockDatabaseReference.updateChildren(map)).thenReturn(mockTask);

  TestObserver sub = TestObserver.create();

  RxFirebaseDatabase.updateChildren(mockDatabaseReference, map).subscribe(sub);

  verifyAddOnCompleteListenerForTask();
  callTaskOnCompleteWithError(new IllegalStateException());

  sub.assertNotComplete();
  sub.assertError(IllegalStateException.class);

  sub.dispose();
}