@Test public void testMapFails() { RuntimeException cause = new RuntimeException(); Future<Integer> fut = Future.future(); Future<Object> mapped = fut.map(i -> { throw cause; }); Checker<Object> checker = new Checker<>(mapped); fut.fail(cause); checker.assertFailed(cause); }
@Test public void testMapFailure() { Throwable cause = new Throwable(); Future<Integer> fut = Future.future(); Future<String> mapped = fut.map(Object::toString); Checker<String> checker = new Checker<>(mapped); checker.assertNotCompleted(); fut.fail(cause); checker.assertFailed(cause); }
@Test public void testMapSuccess() { Future<Integer> fut = Future.future(); Future<String> mapped = fut.map(Object::toString); Checker<String> checker = new Checker<>(mapped); checker.assertNotCompleted(); fut.complete(3); checker.assertSucceeded("3"); }
@Test public void testMapWithNullFunction() { Future<Integer> fut = Future.future(); try { fut.map((Function<Integer, String>) null); fail(); } catch (NullPointerException ignore) { } try { asyncResult(fut).map((Function<Integer, String>) null); fail(); } catch (NullPointerException ignore) { } }
@Test public void testMapFails() { RuntimeException cause = new RuntimeException(); Future<Integer> fut = Future.future(); Future<Object> mapped = fut.map(i -> { throw cause; }); Checker<Object> checker = new Checker<>(mapped); fut.fail(cause); checker.assertFailed(cause); }
@Test public void testMapFailure() { Throwable cause = new Throwable(); Future<Integer> fut = Future.future(); Future<String> mapped = fut.map(Object::toString); Checker<String> checker = new Checker<>(mapped); checker.assertNotCompleted(); fut.fail(cause); checker.assertFailed(cause); }
@Test public void testMapSuccess() { Future<Integer> fut = Future.future(); Future<String> mapped = fut.map(Object::toString); Checker<String> checker = new Checker<>(mapped); checker.assertNotCompleted(); fut.complete(3); checker.assertSucceeded("3"); }
Future<ReconciliationState> withZkDiff(Future<ReconcileResult<StatefulSet>> r) { return r.map(rr -> { this.zkDiffs = rr; return this; }); }
Future<ReconciliationState> withKafkaDiff(Future<ReconcileResult<StatefulSet>> r) { return r.map(rr -> { this.kafkaDiffs = rr; return this; }); }
Future<ReconciliationState> withKafkaAncillaryCmChanged(boolean onlyMetricsSettingChanged, Future<ReconcileResult<ConfigMap>> r) { return r.map(rr -> { if (onlyMetricsSettingChanged) { log.debug("Only metrics setting changed - not triggering rolling update"); this.kafkaAncillaryCmChange = false; } else { this.kafkaAncillaryCmChange = rr instanceof ReconcileResult.Patched; } return this; }); }
Future<ReconciliationState> withZkAncillaryCmChanged(boolean onlyMetricsSettingChanged, Future<ReconcileResult<ConfigMap>> r) { return r.map(rr -> { if (onlyMetricsSettingChanged) { log.debug("Only metrics setting changed - not triggering rolling update"); this.zkAncillaryCmChange = false; } else { this.zkAncillaryCmChange = rr instanceof ReconcileResult.Patched; } return this; }); }
@Test public void testMapWithNullFunction() { Future<Integer> fut = Future.future(); try { fut.map((Function<Integer, String>) null); fail(); } catch (NullPointerException ignore) { } try { asyncResult(fut).map((Function<Integer, String>) null); fail(); } catch (NullPointerException ignore) { } }
@Override public ProductService retrieveProduct(String productId, Handler<AsyncResult<Product>> resultHandler) { this.retrieveOne(productId, FETCH_STATEMENT) .map(option -> option.map(Product::new).orElse(null)) .setHandler(resultHandler); return this; }
@Override public OrderService retrieveOrdersForAccount(String accountId, Handler<AsyncResult<List<Order>>> resultHandler) { retrieveMany(new JsonArray().add(accountId), RETRIEVE_BY_ACCOUNT_STATEMENT) .map(rawList -> rawList.stream() .map(Order::new) .collect(Collectors.toList()) ) .setHandler(resultHandler); return this; }
@Override public Future<Integer> decrease(String productId, int decrease) { Future<Long> future = Future.future(); client.decrby(PREFIX + productId, decrease, future.completer()); return future.map(Long::intValue); }
@Override protected Future<Void> delete(Reconciliation reconciliation) { return deleteKafka(reconciliation) .compose(i -> deleteZk(reconciliation)) .map((Void) null); }
private Future<Void> deployRestVerticle() { Future<String> future = Future.future(); vertx.deployVerticle(new RestShoppingAPIVerticle(shoppingCartService, checkoutService), new DeploymentOptions().setConfig(config()), future.completer()); return future.map(r -> null); }
private Future<Void> deployRestService(ProductService service) { Future<String> future = Future.future(); vertx.deployVerticle(new RestProductAPIVerticle(service), new DeploymentOptions().setConfig(config()), future.completer()); return future.map(r -> null); }
private Future<Void> prepareDispatcher() { Future<String> future = Future.future(); vertx.deployVerticle(new RawOrderDispatcher(orderService), new DeploymentOptions().setConfig(config()), future.completer()); return future.map(r -> null); }
private Future<Void> initProductDatabase(ProductService service) { Future<Void> initFuture = Future.future(); service.initializePersistence(initFuture.completer()); return initFuture.map(v -> { ExampleHelper.initData(vertx, config()); return null; }); }