Java Code Examples for io.vavr.control.Try#of()

@Test
public void shouldReturnAfterOneAttemptAndIgnoreException() {
    given(helloWorldService.returnHelloWorld()).willThrow(new HelloWorldException());
    RetryConfig config = RetryConfig.custom()
        .retryOnException(throwable -> API.Match(throwable).of(
            API.Case($(Predicates.instanceOf(HelloWorldException.class)), false),
            API.Case($(), true)))
        .build();
    Retry retry = Retry.of("id", config);
    CheckedFunction0<String> retryableSupplier = Retry
        .decorateCheckedSupplier(retry, helloWorldService::returnHelloWorld);

    Try<String> result = Try.of(retryableSupplier);

    // Because the exception should be rethrown immediately.
    then(helloWorldService).should().returnHelloWorld();
    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(HelloWorldException.class);
    assertThat(sleptTime).isEqualTo(0);
}
 

@Test
public void decorateCheckedSupplier() throws Throwable {
    CheckedFunction0 supplier = mock(CheckedFunction0.class);
    CheckedFunction0 decorated = RateLimiter.decorateCheckedSupplier(limit, supplier);
    given(limit.acquirePermission(1)).willReturn(false);
    Try decoratedSupplierResult = Try.of(decorated);
    assertThat(decoratedSupplierResult.isFailure()).isTrue();
    assertThat(decoratedSupplierResult.getCause()).isInstanceOf(RequestNotPermitted.class);
    then(supplier).should(never()).apply();
    given(limit.acquirePermission(1)).willReturn(true);

    Try secondSupplierResult = Try.of(decorated);

    assertThat(secondSupplierResult.isSuccess()).isTrue();
    then(supplier).should().apply();
}
 

@Test
public void shouldDecorateCheckedFunctionAndReturnWithException() throws Throwable {
    CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
    CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("testName");
    CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
    assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(0);
    given(helloWorldService.returnHelloWorldWithNameWithException("Tom"))
        .willThrow(new RuntimeException("BAM!"));
    CheckedFunction1<String, String> function = CircuitBreaker
        .decorateCheckedFunction(circuitBreaker,
            helloWorldService::returnHelloWorldWithNameWithException);

    Try<String> result = Try.of(() -> function.apply("Tom"));

    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(RuntimeException.class);
    assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(1);
    assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(1);
    assertThat(metrics.getNumberOfSuccessfulCalls()).isEqualTo(0);
}
 

private void shouldCompleteFutureAfterAttemptsInCaseOfExceptionAtAsyncStage(int noOfAttempts) {
    CompletableFuture<String> failedFuture = new CompletableFuture<>();
    failedFuture.completeExceptionally(new HelloWorldException());
    given(helloWorldService.returnHelloWorld())
        .willReturn(failedFuture);
    Retry retryContext = Retry.of(
        "id",
        RetryConfig
            .custom()
            .maxAttempts(noOfAttempts)
            .build());
    Supplier<CompletionStage<String>> supplier = Retry.decorateCompletionStage(
        retryContext,
        scheduler,
        () -> helloWorldService.returnHelloWorld());

    Try<String> resultTry = Try.of(() -> awaitResult(supplier.get()));

    then(helloWorldService).should(times(noOfAttempts)).returnHelloWorld();
    assertThat(resultTry.isFailure()).isTrue();
    assertThat(resultTry.getCause().getCause()).isInstanceOf(HelloWorldException.class);
}
 

@Test
public void testDecoratorBuilderWithRateLimiter() {
    given(helloWorldService.returnHelloWorld()).willReturn("Hello world");
    RateLimiterConfig config = RateLimiterConfig.custom()
        .timeoutDuration(Duration.ofMillis(100))
        .limitRefreshPeriod(Duration.ofSeconds(1))
        .limitForPeriod(1)
        .build();
    RateLimiter rateLimiter = RateLimiter.of("backendName", config);
    CheckedFunction0<String> restrictedSupplier = Decorators
        .ofCheckedSupplier(() -> helloWorldService.returnHelloWorld())
        .withRateLimiter(rateLimiter)
        .decorate();
    alignTime(rateLimiter);

    Try<String> firstTry = Try.of(restrictedSupplier);
    Try<String> secondTry = Try.of(restrictedSupplier);

    assertThat(firstTry.isSuccess()).isTrue();
    assertThat(secondTry.isFailure()).isTrue();
    assertThat(secondTry.getCause()).isInstanceOf(RequestNotPermitted.class);
    then(helloWorldService).should(times(1)).returnHelloWorld();
}
 

@Test
public void shouldDecorateFunctionAndReturnWithException() throws Throwable {
    CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
    CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("testName");
    CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
    assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(0);
    given(helloWorldService.returnHelloWorldWithName("Tom"))
        .willThrow(new RuntimeException("BAM!"));
    Function<String, String> function = CircuitBreaker
        .decorateFunction(circuitBreaker, helloWorldService::returnHelloWorldWithName);

    Try<String> result = Try.of(() -> function.apply("Tom"));

    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(RuntimeException.class);
    assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(1);
    assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(1);
    assertThat(metrics.getNumberOfSuccessfulCalls()).isEqualTo(0);
}
 

@Test
public void shouldTakeIntoAccountBackoffFunction() {
    given(helloWorldService.returnHelloWorld()).willThrow(new HelloWorldException());
    RetryConfig config = RetryConfig.custom()
        .intervalFunction(IntervalFunction.ofExponentialBackoff(500, 2.0))
        .build();
    Retry retry = Retry.of("id", config);
    CheckedFunction0<String> retryableSupplier = Retry
        .decorateCheckedSupplier(retry, helloWorldService::returnHelloWorld);

    Try.of(retryableSupplier);

    then(helloWorldService).should(times(3)).returnHelloWorld();
    assertThat(sleptTime).isEqualTo(
        RetryConfig.DEFAULT_WAIT_DURATION +
            RetryConfig.DEFAULT_WAIT_DURATION * 2);
}
 

@Test
public void shouldDecorateCheckedSupplierAndReturnWithException() throws Throwable {
    CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.ofDefaults();
    CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("testName");
    CircuitBreaker.Metrics metrics = circuitBreaker.getMetrics();
    assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(0);
    given(helloWorldService.returnHelloWorldWithException())
        .willThrow(new RuntimeException("BAM!"));
    CheckedFunction0<String> checkedSupplier = circuitBreaker
        .decorateCheckedSupplier(helloWorldService::returnHelloWorldWithException);

    Try<String> result = Try.of(checkedSupplier);

    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(RuntimeException.class);
    assertThat(metrics.getNumberOfBufferedCalls()).isEqualTo(1);
    assertThat(metrics.getNumberOfFailedCalls()).isEqualTo(1);
    assertThat(metrics.getNumberOfSuccessfulCalls()).isEqualTo(0);
    then(helloWorldService).should().returnHelloWorldWithException();
}
 

@Test
public void shouldDecorateCheckedFunctionAndReturnWithException() throws Throwable {
    Bulkhead bulkhead = Bulkhead.of("test", config);
    given(helloWorldService.returnHelloWorldWithNameWithException("Tom"))
        .willThrow(new RuntimeException("BAM!"));
    CheckedFunction1<String, String> function = Bulkhead
        .decorateCheckedFunction(bulkhead,
            helloWorldService::returnHelloWorldWithNameWithException);

    Try<String> result = Try.of(() -> function.apply("Tom"));

    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(RuntimeException.class);
    assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(1);
}
 

public Try<BatchResult> expireHolds() {
    return Try.of(() ->
            find.queryForHoldsToExpireSheet()
            .toStreamOfEvents()
            .map(this::publish)
            .find(Try::isFailure)
            .map(handleEventError -> BatchResult.SomeFailed)
            .getOrElse(BatchResult.FullSuccess));
}
 

@Test
public void shouldReturnSuccessfullyAfterSecondAttempt() {
    given(helloWorldService.returnHelloWorld())
        .willThrow(new HelloWorldException())
        .willReturn("Hello world");
    Retry retry = Retry.ofDefaults("id");
    CheckedFunction0<String> retryableSupplier = Retry
        .decorateCheckedSupplier(retry, helloWorldService::returnHelloWorld);

    Try<String> result = Try.of(retryableSupplier);

    then(helloWorldService).should(times(2)).returnHelloWorld();
    assertThat(result.get()).isEqualTo("Hello world");
    assertThat(sleptTime).isEqualTo(RetryConfig.DEFAULT_WAIT_DURATION);
}
 

@Test
public void shouldDecorateCheckedSupplierAndReturnWithException() throws Throwable {
    Bulkhead bulkhead = Bulkhead.of("test", config);
    given(helloWorldService.returnHelloWorldWithException())
        .willThrow(new RuntimeException("BAM!"));
    CheckedFunction0<String> checkedSupplier = Bulkhead
        .decorateCheckedSupplier(bulkhead, helloWorldService::returnHelloWorldWithException);

    Try<String> result = Try.of(checkedSupplier);

    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(RuntimeException.class);
    assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(1);
    then(helloWorldService).should(times(1)).returnHelloWorldWithException();
}
 

@Test
public void shouldDecorateSupplierAndReturnWithException() {
    Bulkhead bulkhead = Bulkhead.of("test", config);
    given(helloWorldService.returnHelloWorld()).willThrow(new RuntimeException("BAM!"));
    Supplier<String> supplier = Bulkhead
        .decorateSupplier(bulkhead, helloWorldService::returnHelloWorld);

    Try<String> result = Try.of(supplier::get);

    assertThat(result.isFailure()).isTrue();
    assertThat(result.failed().get()).isInstanceOf(RuntimeException.class);
    assertThat(bulkhead.getMetrics().getAvailableConcurrentCalls()).isEqualTo(1);
    then(helloWorldService).should(times(1)).returnHelloWorld();
}
 

@SuppressWarnings("unchecked")
@Test
public void testDecorateCheckedSupplierWithCache() {
    javax.cache.Cache<String, String> cache = mock(javax.cache.Cache.class);
    given(cache.containsKey("testKey")).willReturn(true);
    given(cache.get("testKey")).willReturn("Hello from cache");
    CheckedFunction1<String, String> cachedFunction = Decorators
        .ofCheckedSupplier(() -> "Hello world")
        .withCache(Cache.of(cache))
        .decorate();

    Try<String> value = Try.of(() -> cachedFunction.apply("testKey"));

    assertThat(value).contains("Hello from cache");
}
 

private Try<TestExecution> runShapes() {

            return Try.of(() -> {

                val shapesSource = SchemaSourceFactory.createSchemaSourceSimple(
                        getId(), getShapesGraphUri(),
                        new RdfModelReader(getShapesGraph())
                );

                Set<GenericTestCase> tests = ImmutableSet.copyOf(new ShaclTestGenerator().generate(shapesSource));
                val testSuite = new TestSuite(tests);

                return RDFUnitStaticValidator.validate(shaclTestCaseResult, getDataGraph(), testSuite);
            });
        }
 

public Try<Result> cancelHold(@NonNull CancelHoldCommand command) {
    return Try.of(() -> {
        BookOnHold bookOnHold = find(command.getBookId(), command.getPatronId());
        Patron patron = find(command.getPatronId());
        Either<BookHoldCancelingFailed, BookHoldCanceled> result = patron.cancelHold(bookOnHold);
        return Match(result).of(
                Case($Left($()), this::publishEvents),
                Case($Right($()), this::publishEvents)
        );
    });
}
 

private Try<String> getTypeListPattern(Config config, String path) {
    return Try.of(() -> List.ofAll(config.getStringList(path)).mkString("|"));
}
 

public static Try<URL> getKanelaJar() {
    return Try.of(() -> {
        val location = Kanela.class.getProtectionDomain().getCodeSource().getLocation();
        return Paths.get(location.toURI()).toUri().toURL();
    });
}
 

@Test
public void givenBadCode_whenTryHandles_thenCorrect() {
    Try<Integer> result = Try.of(() -> 1 / 0);
    assertTrue(result.isFailure());
}
 

/**
 * Removes the item at the specified index.
 *
 * @param index The index to remove the item at.
 * @return Returns a new DataColumn with the specified item removed.
 */
public Try<DataColumn<T>> removeItem(Integer index) {
    return Try.of(() -> createColumn(this.data.removeAt(index)));
}