下面列出了io.reactivex.observers.TestObserver#assertNotComplete ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Test
public void shouldNotResolveTokenRequest_invalidScope_withUser() {
final String scope = "read";
TokenRequest tokenRequest = new TokenRequest();
tokenRequest.setScopes(Collections.singleton(scope));
Client client = new Client();
client.setScopes(Collections.singletonList("write"));
User user = new User();
Role role = new Role();
role.setOauthScopes(Collections.singletonList("user"));
user.setRolesPermissions(Collections.singleton(role));
TestObserver<TokenRequest> testObserver = tokenRequestResolver.resolve(tokenRequest, client, user).test();
testObserver.assertNotComplete();
testObserver.assertError(InvalidScopeException.class);
}
@Test
public void shouldCreateUser_invalid_identity_provider() {
final String domainId = "domain";
User newUser = mock(User.class);
when(newUser.getSource()).thenReturn("unknown-idp");
when(newUser.getUserName()).thenReturn("username");
when(domain.getId()).thenReturn(domainId);
when(userRepository.findByDomainAndUsernameAndSource(anyString(), anyString(), anyString())).thenReturn(Maybe.empty());
when(identityProviderManager.getUserProvider(anyString())).thenReturn(Maybe.empty());
TestObserver<User> testObserver = userService.create(newUser, "/").test();
testObserver.assertNotComplete();
testObserver.assertError(InvalidValueException.class);
}
@Test
public void testDataChangesOfClazz_Query() {
TestObserver<DataValue<String>> sub = TestObserver.create();
RxFirebaseDatabase.dataChangesOf(mockQuery, String.class)
.subscribe(sub);
verifyQueryAddValueEventListener();
callValueEventOnDataChange("Foo");
sub.assertNotComplete();
sub.assertValue(new Predicate<DataValue<String>>() {
@Override
public boolean test(DataValue<String> value) throws Exception {
return value.isPresent() && "Foo".equals(value.get());
}
});
sub.dispose();
callValueEventOnDataChange("Foo");
// Ensure no more values are emitted after unsubscribe
sub.assertValueCount(1);
}
@Test
public void givenSubscriberAndError_whenRetryOnError_thenRetryConfirmed() {
TestObserver<String> testObserver = new TestObserver<>();
AtomicInteger atomicCounter = new AtomicInteger(0);
Observable
.<String>error(() -> {
atomicCounter.incrementAndGet();
return UNKNOWN_ERROR;
})
.retry(1)
.subscribe(testObserver);
testObserver.assertError(UNKNOWN_ERROR);
testObserver.assertNotComplete();
testObserver.assertNoValues();
assertTrue("should call twice", atomicCounter.get() == 2);
}
@Test
public void shouldCreate_uniquenessException() {
NewRole newRole = Mockito.mock(NewRole.class);
when(newRole.getName()).thenReturn("existing-role-name");
Role role = new Role();
role.setId("existing-role-id");
role.setName("existing-role-name");
role.setReferenceType(ReferenceType.DOMAIN);
role.setReferenceId("domain#1");
when(roleRepository.findAll(ReferenceType.DOMAIN, DOMAIN)).thenReturn(Flowable.just(role));
TestObserver testObserver = new TestObserver();
roleService.create(DOMAIN, newRole).subscribe(testObserver);
testObserver.assertError(RoleAlreadyExistsException.class);
testObserver.assertNotComplete();
verify(roleRepository, never()).create(any(Role.class));
}
@Test
public void givenSubscriberAndError_whenRetryConditionallyOnError_thenRetryConfirmed() {
TestObserver<String> testObserver = new TestObserver<>();
AtomicInteger atomicCounter = new AtomicInteger(0);
Observable
.<String>error(() -> {
atomicCounter.incrementAndGet();
return UNKNOWN_ERROR;
})
.retry((integer, throwable) -> integer < 4)
.subscribe(testObserver);
testObserver.assertError(UNKNOWN_ERROR);
testObserver.assertNotComplete();
testObserver.assertNoValues();
assertTrue("should call 4 times", atomicCounter.get() == 4);
}
@Test
public void shouldDelete_technicalException() {
when(identityProviderRepository.findById(eq(ReferenceType.DOMAIN), eq(DOMAIN), eq("my-identity-provider"))).thenReturn(Maybe.just(new IdentityProvider()));
TestObserver testObserver = identityProviderService.delete(DOMAIN, "my-identity-provider").test();
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void read_success_verifyOnlyOnce() {
readRssi.execute(peripheral);
int result = 100;
readOperationSingle.onSuccess(result);
readResultTestObserver.assertValue(result);
TestObserver<Integer> invalidObserver = readRssi.result().test();
invalidObserver.assertNotComplete();
verify(peripheral, times(1)).readRssi();
}
@Test
public void shouldDelete_notExistingIdentityProvider() {
when(identityProviderRepository.findById(eq(ReferenceType.DOMAIN), eq(DOMAIN), eq("my-identity-provider"))).thenReturn(Maybe.empty());
TestObserver testObserver = identityProviderService.delete(DOMAIN, "my-identity-provider").test();
testObserver.assertError(IdentityProviderNotFoundException.class);
testObserver.assertNotComplete();
verify(applicationService, never()).findByIdentityProvider(anyString());
verify(identityProviderRepository, never()).delete(anyString());
}
@Test
public void create_missingRedirectUri() {
TestObserver<Client> testObserver = dcrService.create(new DynamicClientRegistrationRequest(), BASE_PATH).test();
testObserver.assertError(InvalidRedirectUriException.class);
testObserver.assertErrorMessage("Missing or invalid redirect_uris.");//redirect_uri metadata can be null but is mandatory
testObserver.assertNotComplete();
}
@Test
public void create_errorSingleResource_missingScope() {
//Prepare request & resource
List<PermissionRequest> request = Arrays.asList(new PermissionRequest().setResourceId("one").setResourceScopes(Arrays.asList("a","b")));
List<Resource> found = Arrays.asList(new Resource().setId("one").setResourceScopes(Arrays.asList("not","same")));
when(resourceService.findByDomainAndClientAndResources(DOMAIN_ID, CLIENT_ID, Arrays.asList("one"))).thenReturn(Single.just(found));
TestObserver<PermissionTicket> testObserver = service.create(request, DOMAIN_ID, CLIENT_ID).test();
testObserver.assertNotComplete();
testObserver.assertError(err -> ((InvalidPermissionRequestException)err).getOAuth2ErrorCode().equals("invalid_scope"));
verify(repository, times(0)).create(any());
}
@Test
public void shouldUpdate_technicalException() {
UpdateDomain updateDomain = Mockito.mock(UpdateDomain.class);
when(domainRepository.findById("my-domain")).thenReturn(Maybe.error(TechnicalException::new));
TestObserver testObserver = domainService.update("my-domain", updateDomain).test();
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
verify(domainRepository, times(1)).findById(anyString());
verify(domainRepository, never()).update(any(Domain.class));
}
@Test
public void shouldLoadUserByUsernameAndDomain_technicalException() {
when(userRepository.findByUsernameAndDomain(DOMAIN, "my-user")).thenReturn(Maybe.error(TechnicalException::new));
TestObserver testObserver = new TestObserver();
userService.findByDomainAndUsername(DOMAIN, "my-user").subscribe(testObserver);
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void shouldNotCreate_technicalException() {
Event newEvent = Mockito.mock(Event.class);
when(eventRepository.create(any(Event.class))).thenReturn(Single.error(TechnicalException::new));
TestObserver testObserver = eventService.create(newEvent).test();
testObserver.awaitTerminalEvent();
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void shouldFindById_technicalException() {
when(scopeApprovalRepository.findById("my-consent")).thenReturn(Maybe.error(TechnicalException::new));
TestObserver testObserver = new TestObserver();
scopeApprovalService.findById("my-consent").subscribe(testObserver);
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void create_unknownResponseTypePayload() {
DynamicClientRegistrationRequest request = new DynamicClientRegistrationRequest();
request.setRedirectUris(Optional.empty());
request.setResponseTypes(Optional.of(Arrays.asList("unknownResponseType")));
TestObserver<Client> testObserver = dcrService.create(request, BASE_PATH).test();
testObserver.assertError(InvalidClientMetadataException.class);
testObserver.assertErrorMessage("Invalid response type.");
testObserver.assertNotComplete();
}
@Test
public void shouldFindAll_technicalException() {
when(domainRepository.findAll()).thenReturn(Single.error(TechnicalException::new));
TestObserver testObserver = new TestObserver<>();
domainService.findAll().subscribe(testObserver);
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void givenSubscriberAndError_whenRetryUntilOnError_thenRetryConfirmed() {
TestObserver<String> testObserver = new TestObserver<>();
AtomicInteger atomicCounter = new AtomicInteger(0);
Observable
.<String>error(UNKNOWN_ERROR)
.retryUntil(() -> atomicCounter.incrementAndGet() > 3)
.subscribe(testObserver);
testObserver.assertError(UNKNOWN_ERROR);
testObserver.assertNotComplete();
testObserver.assertNoValues();
assertTrue("should call 4 times", atomicCounter.get() == 4);
}
@Test
public void shouldFindTotalClients_technicalException() {
when(applicationRepository.count()).thenReturn(Single.error(TechnicalException::new));
TestObserver testObserver = new TestObserver<>();
applicationService.count().subscribe(testObserver);
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}
@Test
public void shouldFindByDomain_technicalException() {
when(roleRepository.findAll(ReferenceType.DOMAIN, DOMAIN)).thenReturn(Flowable.error(TechnicalManagementException::new));
TestObserver testObserver = roleService.findByDomain(DOMAIN).test();
testObserver.assertError(TechnicalManagementException.class);
testObserver.assertNotComplete();
}