@Override public <T> T resultAt(int index) { return this.<T>future(index).result(); }
@Override public T result() { return fut.result(); }
/** * Map the failure of a future to a specific {@code value}.<p> * * When this future fails, this {@code value} will complete the future returned by this method call.<p> * * When this future succeeds, the result will be propagated to the returned future. * * @param value the value that eventually completes the mapped future * @return the mapped future */ default Future<T> otherwise(T value) { Future<T> ret = Future.future(); setHandler(ar -> { if (ar.succeeded()) { ret.complete(result()); } else { ret.complete(value); } }); return ret; }
setHandler(ar -> { if (ar.succeeded()) { ret.complete(result()); } else { T value;
/** * Handles a failure of this Future by returning the result of another Future. * If the mapper fails, then the returned future will be failed with this failure. * * @param mapper A function which takes the exception of a failure and returns a new future. * @return A recovered future */ default Future<T> recover(Function<Throwable, Future<T>> mapper) { if (mapper == null) { throw new NullPointerException(); } Future<T> ret = Future.future(); setHandler(ar -> { if (ar.succeeded()) { ret.complete(result()); } else { Future<T> mapped; try { mapped = mapper.apply(ar.cause()); } catch (Throwable e) { ret.fail(e); return; } mapped.setHandler(ret); } }); return ret; }
public void handle(Future<T> ar) { if (ar.succeeded()) { complete(ar.result()); } else { fail(ar.cause()); } }
void assertSucceeded(T expected) { assertTrue(future.isComplete()); assertTrue(future.succeeded()); assertFalse(future.failed()); assertNull(future.cause()); assertEquals(expected, future.result()); assertEquals(1, count.get()); AsyncResult<T> ar = result.get(); assertNotNull(ar); assertTrue(ar.succeeded()); assertFalse(ar.failed()); assertNull(ar.cause()); assertEquals(expected, future.result()); }
Throwable assertFailed() { assertTrue(future.isComplete()); assertFalse(future.succeeded()); assertTrue(future.failed()); assertEquals(null, future.result()); assertEquals(1, count.get()); AsyncResult<T> ar = result.get(); assertNotNull(ar); assertFalse(ar.succeeded()); assertTrue(ar.failed()); assertNull(ar.result()); return future.cause(); } }
void assertNotCompleted() { assertFalse(future.isComplete()); assertFalse(future.succeeded()); assertFalse(future.failed()); assertNull(future.cause()); assertNull(future.result()); assertEquals(0, count.get()); assertNull(result.get()); }
@Test public void testFailedFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> Future.succeededFuture(t.getMessage())); f.fail("recovered"); assertTrue(r.succeeded()); assertEquals(r.result(), "recovered"); }
@Test public void testSucceededFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> Future.succeededFuture(t.getMessage())); f.complete("yeah"); assertTrue(r.succeeded()); assertEquals(r.result(), "yeah"); }
@Test public void testResolveFutureToHandler() { Consumer<Handler<AsyncResult<String>>> consumer = handler -> { handler.handle(Future.succeededFuture("the-result")); }; Future<String> fut = Future.future(); consumer.accept(fut); assertTrue(fut.isComplete()); assertTrue(fut.succeeded()); assertEquals("the-result", fut.result()); }
@Test public void shouldExecuteFutureAndReturnWithSuccess() { // Given CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("testName"); CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics(); assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(0); // Given the HelloWorldService returns Hello world BDDMockito.given(helloWorldService.returnHelloWorld()).willReturn(Future.succeededFuture("Hello world")); //When Future<String> future = VertxCircuitBreaker.executeFuture(circuitBreaker, helloWorldService::returnHelloWorld); //Then assertThat(future.succeeded()).isTrue(); assertThat(future.result()).isEqualTo("Hello world"); assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(1); assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(0); assertThat(metrics.getNumberOfSuccessfulCalls()).isEqualTo(1); // Then the helloWorldService should be invoked 1 time BDDMockito.then(helloWorldService).should(Mockito.times(1)).returnHelloWorld(); }
@Test public void shouldDecorateFutureAndReturnWithSuccess(TestContext context) { // Given CircuitBreaker circuitBreaker = CircuitBreaker.ofDefaults("testName"); CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics(); assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(0); // Given the HelloWorldService returns Hello world BDDMockito.given(helloWorldService.returnHelloWorld()).willReturn(Future.succeededFuture("Hello world")); //When Supplier<Future<String>> supplier = VertxCircuitBreaker.decorateFuture(circuitBreaker, helloWorldService::returnHelloWorld); // Execute supplier Future<String> future = supplier.get(); //Then assertThat(future.succeeded()).isTrue(); assertThat(future.result()).isEqualTo("Hello world"); assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(1); assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(0); assertThat(metrics.getNumberOfSuccessfulCalls()).isEqualTo(1); // Then the helloWorldService should be invoked 1 time BDDMockito.then(helloWorldService).should(Mockito.times(1)).returnHelloWorld(); }
Future<HttpClientRequest> redirection = handler.apply(resp); if (expected != null) { assertEquals(location, redirection.result().absoluteURI()); } else { assertTrue(redirection == null || redirection.failed());
@Test public void testStateAfterCompletion() { Object foo = new Object(); Future<Object> future = Future.succeededFuture(foo); assertTrue(future.succeeded()); assertFalse(future.failed()); assertTrue(future.isComplete()); assertEquals(foo, future.result()); assertNull(future.cause()); Exception cause = new Exception(); future = Future.failedFuture(cause); assertFalse(future.succeeded()); assertTrue(future.failed()); assertTrue(future.isComplete()); assertNull(future.result()); assertEquals(cause, future.cause()); }
public void handle(Future<T> ar) { if (ar.succeeded()) { complete(ar.result()); } else { fail(ar.cause()); } }
@Test public void testSucceededFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> Future.succeededFuture(t.getMessage())); f.complete("yeah"); assertTrue(r.succeeded()); assertEquals(r.result(), "yeah"); }
@Test public void testFailedFutureRecover() { Future<String> f = Future.future(); Future<String> r = f.recover(t -> Future.succeededFuture(t.getMessage())); f.fail("recovered"); assertTrue(r.succeeded()); assertEquals(r.result(), "recovered"); }
@Test public void testResolveFutureToHandler() { Consumer<Handler<AsyncResult<String>>> consumer = handler -> { handler.handle(Future.succeededFuture("the-result")); }; Future<String> fut = Future.future(); consumer.accept(fut); assertTrue(fut.isComplete()); assertTrue(fut.succeeded()); assertEquals("the-result", fut.result()); }