@Override public SingleSource<Integer> apply(Maybe<Integer> m) throws Exception { return m.flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return Single.just(2); } }); } });
@Test(expected = NullPointerException.class) public void flatMapSingleNull() { Maybe.just(1) .flatMapSingle(null); }
@Test public void flatMapSingleError() { RuntimeException exception = new RuntimeException("test"); Maybe.error(exception).flatMapSingle(new Function<Object, SingleSource<Object>>() { @Override public SingleSource<Object> apply(final Object integer) throws Exception { return Single.just(new Object()); } }) .test() .assertError(exception); }
private void insertAndFind() { // Documents to insert Flowable<JsonObject> documents = Flowable.just( new JsonObject().put("username", "temporalfox").put("firstname", "Julien").put("password", "bilto"), new JsonObject().put("username", "purplefox").put("firstname", "Tim").put("password", "wibble") ); mongo .rxCreateCollection("users") .andThen( // After collection is created we insert each document documents.flatMap(doc -> mongo.rxInsert("users", doc).toFlowable()) ) .doOnNext(id -> { System.out.println("Inserted document " + id); }) .lastElement() .flatMapSingle(id -> { // Everything has been inserted now we can query mongo System.out.println("Insertions done"); return mongo.rxFind("users", new JsonObject()); }) .subscribe(results -> { System.out.println("Results " + results); }, error -> { System.out.println("Err"); error.printStackTrace(); }); } }
@Test public void dispose() { TestHelper.checkDisposed(Maybe.just(1).flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return Single.just(2); } })); }
@Test public void singleErrors() { Maybe.just(1) .flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return Single.error(new TestException()); } }) .test() .assertFailure(TestException.class); } }
@Test public void flatMapSingleValue() { Maybe.just(1).flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { if (integer == 1) { return Single.just(2); } return Single.just(1); } }) .test() .assertResult(2); }
@Test public void flatMapSingleValueDifferentType() { Maybe.just(1).flatMapSingle(new Function<Integer, SingleSource<String>>() { @Override public SingleSource<String> apply(final Integer integer) throws Exception { if (integer == 1) { return Single.just("2"); } return Single.just("1"); } }) .test() .assertResult("2"); }
@Test public void flatMapSingleValueErrorThrown() { Maybe.just(1).flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { throw new RuntimeException("something went terribly wrong!"); } }) .test() .assertNoValues() .assertError(RuntimeException.class) .assertErrorMessage("something went terribly wrong!"); }
@Test public void flatMapSingleEmpty() { Maybe.<Integer>empty().flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return Single.just(2); } }) .test() .assertNoValues() .assertError(NoSuchElementException.class); }
@Test public void maybeSingle() throws Exception { List<Throwable> errors = TestHelper.trackPluginErrors(); try { TestObserver<Integer> to = Maybe.just(1) .subscribeOn(Schedulers.io()) .flatMapSingle(new Function<Integer, Single<Integer>>() { @Override public Single<Integer> apply(Integer v) throws Exception { sleep(); return Single.<Integer>error(new TestException()); } }) .test(); cb.await(); beforeCancelSleep(to); to.cancel(); Thread.sleep(SLEEP_AFTER_CANCEL); to.assertEmpty(); assertTrue(errors.toString(), errors.isEmpty()); } finally { RxJavaPlugins.reset(); } }
@Test public void flatMapSingleValueNull() { Maybe.just(1).flatMapSingle(new Function<Integer, SingleSource<Integer>>() { @Override public SingleSource<Integer> apply(final Integer integer) throws Exception { return null; } }) .test() .assertNoValues() .assertError(NullPointerException.class) .assertErrorMessage("The mapper returned a null SingleSource"); }
@Override public Single<Token> grant(TokenRequest tokenRequest, Client client) { return parseRequest(tokenRequest, client) .flatMapMaybe(tokenRequest1 -> resolveResourceOwner(tokenRequest1, client)) .map(user -> Optional.of(user)) .defaultIfEmpty(Optional.empty()) .flatMapSingle(user -> handleRequest(tokenRequest, client, user.isPresent() ? user.get() : null)); }
@Override public Single<Token> grant(TokenRequest tokenRequest, Client client) { return parseRequest(tokenRequest, client) .flatMapMaybe(tokenRequest1 -> resolveResourceOwner(tokenRequest1, client)) .map(user -> Optional.of(user)) .defaultIfEmpty(Optional.empty()) .flatMapSingle(user -> handleRequest(tokenRequest, client, user.isPresent() ? user.get() : null)); }
@Override public Single<String> encode(JWT jwt, Client client) { return certificateManager.get(client.getCertificate()) .defaultIfEmpty(certificateManager.defaultCertificateProvider()) .flatMapSingle(certificateProvider -> encode(jwt, certificateProvider)); }
@Override public Single<String> encode(JWT jwt, Client client) { return certificateManager.get(client.getCertificate()) .defaultIfEmpty(certificateManager.defaultCertificateProvider()) .flatMapSingle(certificateProvider -> encode(jwt, certificateProvider)); }
@Override public Single<Client> patch(String domain, String id, PatchClient patchClient) { LOGGER.debug("Patch a client {} for domain {}", id, domain); return clientRepository.findById(id) .switchIfEmpty(Maybe.error(new ClientNotFoundException(id))) .flatMapSingle(toPatch -> Single.just(patchClient.patch(toPatch))) .flatMap(client -> this.validateClientMetadata(domain, client)) .flatMap(client -> this.updateClientAndReloadDomain(domain, client)) .onErrorResumeNext(this::handleError); }
@Override public Single<JWT> decodeAndVerify(String jwt, Client client) { // use findByDomainAndId method because introspect token can be use across domains return certificateManager.findByDomainAndId(client.getDomain(), client.getCertificate()) .defaultIfEmpty(certificateManager.defaultCertificateProvider()) .flatMapSingle(certificateProvider -> decode(certificateProvider, jwt)) .map(claims -> new JWT(claims)); }
@Override public Single<JWT> decodeAndVerify(String jwt, Client client) { // use findByDomainAndId method because introspect token can be use across domains return certificateManager.findByDomainAndId(client.getDomain(), client.getCertificate()) .defaultIfEmpty(certificateManager.defaultCertificateProvider()) .flatMapSingle(certificateProvider -> decode(certificateProvider, jwt)) .map(claims -> new JWT(claims)); }
@Override public Completable resetPassword(User user) { // only idp manage password, find user idp and update its password return identityProviderManager.getUserProvider(user.getSource()) .flatMapSingle(userProvider -> userProvider.update(user.getExternalId(), convert(user))) .flatMap(idpUser -> { // update 'users' collection for management and audit purpose user.setPassword(null); user.setExternalId(idpUser.getId()); user.setUpdatedAt(new Date()); return userRepository.update(user); }) .toCompletable(); }