org.eclipse.microprofile.fault.tolerance.tck.CircuitBreakerRetryTest Maven / Gradle / Ivy
Show all versions of microprofile-fault-tolerance-tck Show documentation
/*
*******************************************************************************
* Copyright (c) 2016-2018 Contributors to the Eclipse Foundation
*
* See the NOTICE file(s) distributed with this work for additional
* information regarding copyright ownership.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package org.eclipse.microprofile.fault.tolerance.tck;
import static org.hamcrest.Matchers.instanceOf;
import static org.hamcrest.Matchers.lessThan;
import static org.testng.Assert.fail;
import java.sql.Connection;
import java.time.Duration;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.eclipse.microprofile.fault.tolerance.tck.circuitbreaker.clientserver.CircuitBreakerClassLevelClientWithRetry;
import org.eclipse.microprofile.fault.tolerance.tck.circuitbreaker.clientserver.CircuitBreakerClientWithRetry;
import org.eclipse.microprofile.fault.tolerance.tck.circuitbreaker.clientserver.CircuitBreakerClientWithRetryAsync;
import org.eclipse.microprofile.fault.tolerance.tck.config.ConfigAnnotationAsset;
import org.eclipse.microprofile.fault.tolerance.tck.util.DurationMatcher;
import org.eclipse.microprofile.fault.tolerance.tck.util.Exceptions;
import org.eclipse.microprofile.fault.tolerance.tck.util.Packages;
import org.eclipse.microprofile.fault.tolerance.tck.util.TCKConfig;
import org.eclipse.microprofile.fault.tolerance.tck.util.TestException;
import org.eclipse.microprofile.faulttolerance.exceptions.CircuitBreakerOpenException;
import org.hamcrest.MatcherAssert;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.testng.Arquillian;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.testng.Assert;
import org.testng.annotations.Test;
import jakarta.inject.Inject;
/**
* Test CircuitBreaker Thresholds and delays with Retries.
*
* @author Neil Young
* @author Andrew Rouse
*/
public class CircuitBreakerRetryTest extends Arquillian {
private @Inject CircuitBreakerClientWithRetry clientForCBWithRetry;
private @Inject CircuitBreakerClassLevelClientWithRetry clientForClassLevelCBWithRetry;
private @Inject CircuitBreakerClientWithRetryAsync clientForCBWithRetryAsync;
@Deployment
public static WebArchive deploy() {
ConfigAnnotationAsset config = new ConfigAnnotationAsset()
.autoscaleMethod(CircuitBreakerClientWithRetry.class, "serviceC")
.autoscaleMethod(CircuitBreakerClientWithRetry.class, "serviceWithRetryOnCbOpen")
.autoscaleMethod(CircuitBreakerClientWithRetry.class, "serviceWithRetryOnTimeout")
.autoscaleMethod(CircuitBreakerClientWithRetry.class, "serviceWithRetryFailOnCbOpen")
.autoscaleMethod(CircuitBreakerClientWithRetryAsync.class, "serviceC")
.autoscaleMethod(CircuitBreakerClientWithRetryAsync.class, "serviceWithRetryOnCbOpen")
.autoscaleMethod(CircuitBreakerClientWithRetryAsync.class, "serviceWithRetryOnTimeout")
.autoscaleMethod(CircuitBreakerClientWithRetryAsync.class, "serviceWithRetryFailOnCbOpen");
JavaArchive testJar = ShrinkWrap.create(JavaArchive.class, "ftCircuitBreakerRetry.jar")
.addClasses(CircuitBreakerClientWithRetry.class,
CircuitBreakerClassLevelClientWithRetry.class,
CircuitBreakerClientWithRetryAsync.class)
.addPackage(Packages.UTILS)
.addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml")
.addAsManifestResource(config, "microprofile-config.properties")
.as(JavaArchive.class);
WebArchive war = ShrinkWrap.create(WebArchive.class, "ftCircuitBreakerRetry.war")
.addAsLibrary(testJar);
return war;
}
/**
* A test to exercise Circuit Breaker thresholds with sufficient retries to open the Circuit and result in a
* CircuitBreakerOpenException.
*/
@Test
public void testCircuitOpenWithMoreRetries() {
int invokeCounter = 0;
try {
clientForCBWithRetry.serviceA();
// serviceA should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceA();
Assert.fail("serviceA should retry in testCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
} catch (CircuitBreakerOpenException cboe) {
// Expected on iteration 4
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceA();
if (invokeCounter < 4) {
Assert.fail("serviceA should retry in testCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceA();
Assert.fail(
"serviceA should retry or throw a CircuitBreakerOpenException in testCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
}
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceA();
Assert.assertEquals(invokeCounter, 4, "The number of executions should be 4");
}
/**
* A test to exercise Circuit Breaker thresholds with insufficient retries to open the Circuit so that the Circuit
* remains closed and a RuntimeException is caught.
*/
@Test
public void testCircuitOpenWithFewRetries() {
int invokeCounter = 0;
try {
clientForCBWithRetry.serviceB();
// serviceB should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceB();
Assert.fail("serviceB should retry in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
} catch (CircuitBreakerOpenException cboe) {
// Not Expected
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceB();
Assert.fail(
"serviceB should retry or throw a RuntimeException (not a CBOE) in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
} catch (RuntimeException ex) {
// Expected on iteration 3
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceB();
if (invokeCounter < 3) {
Assert.fail("serviceB should retry in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceB();
Assert.fail(
"serviceB should retry or throw a RuntimeException in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
}
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceB();
Assert.assertEquals(invokeCounter, 3, "The number of executions should be 3");
}
/**
* Analogous to testCircuitOpenWithMoreRetries with Class level @CircuitBreaker and @Retry annotations that are
* inherited by serviceA
*/
@Test
public void testClassLevelCircuitOpenWithMoreRetries() {
int invokeCounter = 0;
try {
clientForClassLevelCBWithRetry.serviceA();
// serviceA should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceA();
Assert.fail("serviceA should retry in testClassLevelCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
} catch (CircuitBreakerOpenException cboe) {
// Expected on iteration 4
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceA();
if (invokeCounter < 4) {
Assert.fail("serviceA should retry in testClassLevelCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceA();
Assert.fail(
"serviceA should retry or throw a CircuitBreakerOpenException in testClassLevelCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
}
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceA();
Assert.assertEquals(invokeCounter, 4, "The number of executions should be 4");
}
/**
* Analogous to testCircuitOpenWithFewRetries with Class level @CircuitBreaker and @Retry annotations that are
* overridden by serviceB.
*/
@Test
public void testClassLevelCircuitOpenWithFewRetries() {
int invokeCounter = 0;
try {
clientForClassLevelCBWithRetry.serviceB();
// serviceB should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceB();
Assert.fail("serviceB should retry in testClassLevelCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
} catch (CircuitBreakerOpenException cboe) {
// Not Expected
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceB();
Assert.fail(
"serviceB should retry or throw a RuntimeException (not a CBOE) in testClassLevelCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
} catch (RuntimeException ex) {
// Expected on iteration 3
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceB();
if (invokeCounter < 3) {
Assert.fail("serviceB should retry in testClassLevelCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceB();
Assert.fail(
"serviceB should retry or throw a RuntimeException in testClassLevelCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
}
invokeCounter = clientForClassLevelCBWithRetry.getCounterForInvokingServiceB();
Assert.assertEquals(invokeCounter, 3, "The number of executions should be 3");
}
/**
* Analogous to testCircuitOpenWithMoreRetries but execution failures are caused by timeouts.
*/
@Test
public void testCircuitOpenWithMultiTimeouts() {
int invokeCounter = 0;
try {
clientForCBWithRetry.serviceC();
// serviceC should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceC();
Assert.fail("serviceC should retry in testCircuitOpenWithMultiTimeouts on iteration "
+ invokeCounter);
} catch (CircuitBreakerOpenException cboe) {
// Expected on iteration 4
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceC();
if (invokeCounter < 4) {
Assert.fail("serviceC should retry in testCircuitOpenWithMultiTimeouts on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceC();
Assert.fail(
"serviceC should retry or throw a CircuitBreakerOpenException in testCircuitOpenWithMultiTimeouts on iteration "
+ invokeCounter + ", caught exception: " + ex);
}
invokeCounter = clientForCBWithRetry.getCounterForInvokingServiceC();
Assert.assertEquals(invokeCounter, 4, "The number of executions should be 4");
}
/**
* Test that we retry around an open circuit breaker
*
* Test that when retries are configured with sufficient delay, a call to an open circuit can retry until the
* circuit half-closes, allowing the call to succeed.
*/
@Test
public void testRetriesSucceedWhenCircuitCloses() {
// Open the circuit by submitting four failures
for (int i = 0; i < 4; i++) {
try {
clientForCBWithRetry.serviceWithRetryOnCbOpen(true);
} catch (TestException e) {
// Expected
}
}
// Circuit is now open for 1 second
// Our next call should cause a CircuitBreakerOpenException which should then be retried
// The retry delay is 100ms, maxRetries is 20 so we expect a successful call after around 1 second when the
// circuit closes
long startTime = System.nanoTime();
clientForCBWithRetry.serviceWithRetryOnCbOpen(false);
long endTime = System.nanoTime();
// Check that the call took the expected time
// Allow a margin of 250ms since there's a retry delay of 100ms
MatcherAssert.assertThat("Call was successful but did not take the expected time",
Duration.ofNanos(endTime - startTime),
DurationMatcher.closeTo(TCKConfig.getConfig().getTimeoutInDuration(1000),
TCKConfig.getConfig().getTimeoutInDuration(250)));
}
/**
* Test that we don't retry around an open circuit breaker if CircuitBreakerOpenException is not included in the
* retryOn attribute of the Retry annotation
*
* This test calls a method which only retries on TimeoutException
*/
public void testNoRetriesIfNotRetryOn() {
// Open the circuit by submitting four failures
for (int i = 0; i < 4; i++) {
try {
clientForCBWithRetry.serviceWithRetryOnTimeout(true);
} catch (TestException e) {
// Expected
}
}
// Circuit is now open for 1 second
// Our next call should cause a CircuitBreakerOpenException which should not be retried
// We expect a response almost immediately
long startTime = System.nanoTime();
Exceptions.expectCbOpen(() -> clientForCBWithRetry.serviceWithRetryOnTimeout(false));
long endTime = System.nanoTime();
// Check that the call took less than 200ms (i.e. we didn't delay and retry)
MatcherAssert.assertThat("Call was successful but did not take the expected time",
Duration.ofNanos(endTime - startTime),
lessThan(TCKConfig.getConfig().getTimeoutInDuration(200)));
}
/**
* Test that we don't retry around an open circuit breaker if CircuitBreakerOpenException is included in the abortOn
* attribute of the Retry annotation
*/
public void testNoRetriesIfAbortOn() {
// Open the circuit by submitting four failures
for (int i = 0; i < 4; i++) {
try {
clientForCBWithRetry.serviceWithRetryFailOnCbOpen(true);
} catch (TestException e) {
// Expected
}
}
// Circuit is now open for 1 second
// Our next call should cause a CircuitBreakerOpenException which should not be retried
// We expect a response almost immediately
long startTime = System.nanoTime();
Exceptions.expectCbOpen(() -> clientForCBWithRetry.serviceWithRetryFailOnCbOpen(false));
long endTime = System.nanoTime();
// Check that the call took less than 200ms (i.e. we didn't delay and retry)
MatcherAssert.assertThat("Call was successful but did not take the expected time",
Duration.ofNanos(endTime - startTime),
lessThan(TCKConfig.getConfig().getTimeoutInDuration(200)));
}
/**
* A test to exercise Circuit Breaker thresholds with sufficient retries to open the Circuit and result in a
* CircuitBreakerOpenException using an Asynchronous call.
*/
@Test
public void testCircuitOpenWithMoreRetriesAsync() {
int invokeCounter = 0;
Future result = clientForCBWithRetryAsync.serviceA();
try {
result.get(TCKConfig.getConfig().getTimeoutInMillis(5000), TimeUnit.MILLISECONDS);
// serviceA should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceA();
Assert.fail("serviceA should retry in testCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
} catch (ExecutionException executionException) {
// Expected execution exception wrapping CircuitBreakerOpenException
MatcherAssert.assertThat("Thrown exception is the wrong type",
executionException.getCause(),
instanceOf(CircuitBreakerOpenException.class));
// Expected on iteration 4
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceA();
if (invokeCounter < 4) {
Assert.fail("serviceA should retry in testCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceA();
Assert.fail(
"serviceA should retry or throw a CircuitBreakerOpenException in testCircuitOpenWithMoreRetries on iteration "
+ invokeCounter);
}
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceA();
Assert.assertEquals(invokeCounter, 4, "The number of executions should be 4");
}
/**
* A test to exercise Circuit Breaker thresholds with insufficient retries to open the Circuit so that the Circuit
* remains closed and a RuntimeException is caught when using an Asynchronous call.
*/
@Test
public void testCircuitOpenWithFewRetriesAsync() {
int invokeCounter = 0;
Future result = clientForCBWithRetryAsync.serviceB();
try {
result.get(TCKConfig.getConfig().getTimeoutInMillis(5000), TimeUnit.MILLISECONDS);
// serviceB should retry until the Retry maxRetries is reached. At that point a TestException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceB();
Assert.fail("serviceB should retry in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
} catch (ExecutionException ex) {
// Expected execution exception wrapping TestException
MatcherAssert.assertThat("Thrown exception is the wrong type",
ex.getCause(),
instanceOf(TestException.class));
// Expected on iteration 3
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceB();
if (invokeCounter < 3) {
Assert.fail("serviceB should retry in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceB();
Assert.fail(
"serviceB should retry or throw a RuntimeException in testCircuitOpenWithFewRetries on iteration "
+ invokeCounter);
}
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceB();
Assert.assertEquals(invokeCounter, 3, "The number of executions should be 3");
}
/**
* Analogous to testCircuitOpenWithMoreRetriesAsync but execution failures are caused by timeouts.
*/
@Test
public void testCircuitOpenWithMultiTimeoutsAsync() {
int invokeCounter = 0;
Future result = clientForCBWithRetryAsync.serviceC();
try {
result.get(TCKConfig.getConfig().getTimeoutInMillis(10000), TimeUnit.MILLISECONDS); // Expected to finish
// after < 1 second
// serviceC should retry until the CB threshold is reached. At that point a CircuitBreakerOpenException
// should be thrown. Assert if this does not happen.
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceC();
Assert.fail("serviceC should retry in testCircuitOpenWithMultiTimeouts on iteration "
+ invokeCounter);
} catch (ExecutionException executionException) {
// Expected execution exception wrapping CircuitBreakerOpenException
MatcherAssert.assertThat("Thrown exception is the wrong type",
executionException.getCause(),
instanceOf(CircuitBreakerOpenException.class));
// Expected on iteration 4
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceC();
if (invokeCounter < 4) {
Assert.fail("serviceC should retry in testCircuitOpenWithMultiTimeouts on iteration "
+ invokeCounter);
}
} catch (Exception ex) {
// Not Expected
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceC();
Assert.fail(
"serviceC should retry or throw a CircuitBreakerOpenException in testCircuitOpenWithMultiTimeouts on iteration "
+ invokeCounter + ", caught exception: " + ex);
}
invokeCounter = clientForCBWithRetryAsync.getCounterForInvokingServiceC();
Assert.assertEquals(invokeCounter, 4, "The number of executions should be 4");
}
/**
* Test that we retry around an open circuit breaker
*
* Test that when retries are configured with sufficient delay, a call to an open circuit can retry until the
* circuit half-closes, allowing the call to succeed.
*/
@Test
public void testRetriesSucceedWhenCircuitClosesAsync() {
// Open the circuit by submitting four failures
for (int i = 0; i < 4; i++) {
Future result = clientForCBWithRetryAsync.serviceWithRetryOnCbOpen(true);
Exceptions.expect(TestException.class, result);
}
// Circuit is now open for 1 second
// Our next call should cause a CircuitBreakerOpenException which should then be retried
// The retry delay is 100ms, maxRetries is 20 so we expect a successful call after around 1 second when the
// circuit closes
long startTime = System.nanoTime();
Future result = clientForCBWithRetryAsync.serviceWithRetryOnCbOpen(false);
try {
result.get(TCKConfig.getConfig().getTimeoutInMillis(10000), TimeUnit.MILLISECONDS);
} catch (TimeoutException e) {
fail("Call to serviceWithRetryOnCbOpen did not succeed within 10 seconds");
} catch (ExecutionException e) {
fail("Call to serviceWithRetryOnCbOpen failed with exception", e);
} catch (InterruptedException e) {
fail("Call to serviceWithRetryOnCbOpen was interrupted", e);
}
long endTime = System.nanoTime();
// Check that the call took the expected time
// Allow a margin of 250ms since there's a retry delay of 100ms
MatcherAssert.assertThat("Call was successful but did not take the expected time",
Duration.ofNanos(endTime - startTime),
DurationMatcher.closeTo(TCKConfig.getConfig().getTimeoutInDuration(1000),
TCKConfig.getConfig().getTimeoutInDuration(250)));
}
/**
* Test that we don't retry around an open circuit breaker if CircuitBreakerOpenException is not included in the
* retryOn attribute of the Retry annotation
*
* This test calls a method which only retries on TimeoutException
*/
@Test
public void testNoRetriesIfNotRetryOnAsync() {
// Open the circuit by submitting four failures
for (int i = 0; i < 4; i++) {
Future result = clientForCBWithRetryAsync.serviceWithRetryOnTimeout(true);
Exceptions.expect(TestException.class, result);
}
// Circuit is now open for 1 second
// Our next call should cause a CircuitBreakerOpenException which should not be retried
long startTime = System.nanoTime();
Future result = clientForCBWithRetryAsync.serviceWithRetryOnTimeout(false);
Exceptions.expect(CircuitBreakerOpenException.class, result);
long endTime = System.nanoTime();
// Check that the call took less than 200ms (i.e. we didn't delay and retry)
MatcherAssert.assertThat("Call was successful but did not take the expected time",
Duration.ofNanos(endTime - startTime),
lessThan(TCKConfig.getConfig().getTimeoutInDuration(200)));
}
/**
* Test that we don't retry around an open circuit breaker if CircuitBreakerOpenException is included in the abortOn
* attribute of the Retry annotation
*/
@Test
public void testNoRetriesIfAbortOnAsync() {
// Open the circuit by submitting four failures
for (int i = 0; i < 4; i++) {
Future result = clientForCBWithRetryAsync.serviceWithRetryFailOnCbOpen(true);
Exceptions.expect(TestException.class, result);
}
// Circuit is now open for 1 second
// Our next call should cause a CircuitBreakerOpenException which should not be retried
long startTime = System.nanoTime();
Future result = clientForCBWithRetryAsync.serviceWithRetryFailOnCbOpen(false);
Exceptions.expect(CircuitBreakerOpenException.class, result);
long endTime = System.nanoTime();
// Check that the call took less than 200ms (i.e. we didn't delay and retry)
MatcherAssert.assertThat("Call was successful but did not take the expected time",
Duration.ofNanos(endTime - startTime),
lessThan(TCKConfig.getConfig().getTimeoutInDuration(200)));
}
}