Make @​Retryable and RetryTemplate timeout tests more robust

See gh-35963

Author: sbrannen

spring-context/src/test/java/org/springframework/resilience/ReactiveRetryInterceptorTests.java

@@ -351,7 +351,7 @@ void timeoutExceededAfterInitialFailure() {
 .satisfies(isReactiveException())
 .havingCause()
 .isInstanceOf(TimeoutException.class)
-.withMessageContaining("within 5ms");
+.withMessageContaining("within 20ms");
 // 1 initial attempt + 0 retries
 assertThat(target.counter).hasValue(1);
 }
@@ -363,7 +363,7 @@ void timeoutExceededAfterFirstDelayButBeforeFirstRetry() {
 .satisfies(isReactiveException())
 .havingCause()
 .isInstanceOf(TimeoutException.class)
-.withMessageContaining("within 5ms");
+.withMessageContaining("within 20ms");
 // 1 initial attempt + 0 retries
 assertThat(target.counter).hasValue(1);
 }
@@ -464,16 +464,16 @@ public Mono<Object> retryOperationWithTimeoutNotExceededAndRetriesExhausted() {
 });
 }
 
-@Retryable(timeout = 5, delay = 0)
+@Retryable(timeout = 20, delay = 0)
 public Mono<Object> retryOperationWithTimeoutExceededAfterInitialFailure() {
 return Mono.fromCallable(() -> {
 counter.incrementAndGet();
-Thread.sleep(20);
+Thread.sleep(100);
 throw new IOException(counter.toString());
 });
 }
 
-@Retryable(timeout = 5, delay = 10)
+@Retryable(timeout = 20, delay = 100) // Delay > Timeout
 public Mono<Object> retryOperationWithTimeoutExceededAfterFirstDelayButBeforeFirstRetry() {
 return Mono.fromCallable(() -> {
 counter.incrementAndGet();
@@ -486,7 +486,7 @@ public Mono<Object> retryOperationWithTimeoutExceededAfterFirstRetry() {
 return Mono.fromCallable(() -> {
 counter.incrementAndGet();
 if (counter.get() == 2) {
-Thread.sleep(50);
+Thread.sleep(100);
 }
 throw new IOException(counter.toString());
 });
@@ -497,7 +497,7 @@ public Mono<Object> retryOperationWithTimeoutExceededAfterSecondRetry() {
 return Mono.fromCallable(() -> {
 counter.incrementAndGet();
 if (counter.get() == 3) {
-Thread.sleep(50);
+Thread.sleep(100);
 }
 throw new IOException(counter.toString());
 });

spring-context/src/test/java/org/springframework/resilience/RetryInterceptorTests.java

@@ -426,14 +426,14 @@ public void retryOperationWithTimeoutNotExceededAndRetriesExhausted() throws Exc
 throw new IOException(Integer.toString(counter));
 }
 
-@Retryable(timeout = 5, delay = 10)
+@Retryable(timeout = 20, delay = 0)
 public void retryOperationWithTimeoutExceededAfterInitialFailure() throws Exception {
 counter++;
-Thread.sleep(10);
+Thread.sleep(100);
 throw new IOException(Integer.toString(counter));
 }
 
-@Retryable(timeout = 5, delay = 10)
+@Retryable(timeout = 20, delay = 100) // Delay > Timeout
 public void retryOperationWithTimeoutExceededAfterFirstDelayButBeforeFirstRetry() throws IOException {
 counter++;
 throw new IOException(Integer.toString(counter));
@@ -443,7 +443,7 @@ public void retryOperationWithTimeoutExceededAfterFirstDelayButBeforeFirstRetry(
 public void retryOperationWithTimeoutExceededAfterFirstRetry() throws Exception {
 counter++;
 if (counter == 2) {
-Thread.sleep(50);
+Thread.sleep(100);
 }
 throw new IOException(Integer.toString(counter));
 }
@@ -452,7 +452,7 @@ public void retryOperationWithTimeoutExceededAfterFirstRetry() throws Exception
 public void retryOperationWithTimeoutExceededAfterSecondRetry() throws Exception {
 counter++;
 if (counter == 3) {
-Thread.sleep(50);
+Thread.sleep(100);
 }
 throw new IOException(Integer.toString(counter));
 }

spring-core/src/test/java/org/springframework/core/retry/RetryTemplateTests.java

@@ -413,14 +413,14 @@ class TimeoutTests {
 
 @Test
 void retryWithImmediateSuccessAndTimeoutExceeded() throws Exception {
-RetryPolicy retryPolicy = RetryPolicy.builder().timeout(Duration.ofMillis(5)).build();
+RetryPolicy retryPolicy = RetryPolicy.builder().timeout(Duration.ofMillis(10)).build();
 RetryTemplate retryTemplate = new RetryTemplate(retryPolicy);
 retryTemplate.setRetryListener(retryListener);
 
 AtomicInteger invocationCount = new AtomicInteger();
 Retryable<String> retryable = () -> {
 invocationCount.incrementAndGet();
-Thread.sleep(10);
+Thread.sleep(100);
 return "always succeeds";
 };
 
@@ -435,15 +435,15 @@ void retryWithImmediateSuccessAndTimeoutExceeded() throws Exception {
 @Test
 void retryWithInitialFailureAndZeroRetriesRetryPolicyAndTimeoutExceeded() {
 RetryPolicy retryPolicy = RetryPolicy.builder()
-.timeout(Duration.ofMillis(5))
+.timeout(Duration.ofMillis(10))
 .predicate(throwable -> false) // Zero retries
 .build();
 RetryTemplate retryTemplate = new RetryTemplate(retryPolicy);
 retryTemplate.setRetryListener(retryListener);
 
 Exception exception = new RuntimeException("Boom!");
 Retryable<String> retryable = () -> {
-Thread.sleep(10);
+Thread.sleep(100);
 throw exception;
 };
 
@@ -461,22 +461,22 @@ void retryWithInitialFailureAndZeroRetriesRetryPolicyAndTimeoutExceeded() {
 @Test
 void retryWithTimeoutExceededAfterInitialFailure() throws Exception {
 RetryPolicy retryPolicy = RetryPolicy.builder()
-.timeout(Duration.ofMillis(5))
+.timeout(Duration.ofMillis(10))
 .delay(Duration.ZERO)
 .build();
 RetryTemplate retryTemplate = new RetryTemplate(retryPolicy);
 retryTemplate.setRetryListener(retryListener);
 
 AtomicInteger invocationCount = new AtomicInteger();
 Retryable<String> retryable = () -> {
-Thread.sleep(10);
+Thread.sleep(100);
 throw new CustomException("Boom " + invocationCount.incrementAndGet());
 };
 
 assertThat(invocationCount).hasValue(0);
 assertThatExceptionOfType(RetryException.class)
 .isThrownBy(() -> retryTemplate.execute(retryable))
-.withMessageMatching("Retry policy for operation '.+?' exceeded timeout \\(5ms\\); aborting execution")
+.withMessageMatching("Retry policy for operation '.+?' exceeded timeout \\(10ms\\); aborting execution")
 .withCause(new CustomException("Boom 1"))
 .satisfies(throwable -> inOrder.verify(retryListener).onRetryPolicyTimeout(
 eq(retryPolicy), eq(retryable), eq(throwable)));
@@ -488,8 +488,8 @@ void retryWithTimeoutExceededAfterInitialFailure() throws Exception {
 @Test
 void retryWithTimeoutExceededAfterFirstDelayButBeforeFirstRetry() throws Exception {
 RetryPolicy retryPolicy = RetryPolicy.builder()
-.timeout(Duration.ofMillis(5))
-.delay(Duration.ofMillis(10)) // Delay > Timeout
+.timeout(Duration.ofMillis(20))
+.delay(Duration.ofMillis(100)) // Delay > Timeout
 .build();
 RetryTemplate retryTemplate = new RetryTemplate(retryPolicy);
 retryTemplate.setRetryListener(retryListener);
@@ -503,8 +503,8 @@ void retryWithTimeoutExceededAfterFirstDelayButBeforeFirstRetry() throws Excepti
 assertThatExceptionOfType(RetryException.class)
 .isThrownBy(() -> retryTemplate.execute(retryable))
 .withMessageMatching("""
-Retry policy for operation '.+?' would exceed timeout \\(5ms\\) \
-due to pending sleep time \\(10ms\\); preemptively aborting execution\
+Retry policy for operation '.+?' would exceed timeout \\(20ms\\) \
+due to pending sleep time \\(100ms\\); preemptively aborting execution\
 """)
 .withCause(new CustomException("Boom 1"))
 .satisfies(throwable -> inOrder.verify(retryListener).onRetryPolicyTimeout(
@@ -527,7 +527,7 @@ void retryWithTimeoutExceededAfterFirstRetry() throws Exception {
 Retryable<String> retryable = () -> {
 int currentInvocation = invocationCount.incrementAndGet();
 if (currentInvocation == 2) {
-Thread.sleep(50);
+Thread.sleep(100);
 }
 throw new CustomException("Boom " + currentInvocation);
 };
@@ -562,7 +562,7 @@ void retryWithTimeoutExceededAfterSecondRetry() throws Exception {
 Retryable<String> retryable = () -> {
 int currentInvocation = invocationCount.incrementAndGet();
 if (currentInvocation == 3) {
-Thread.sleep(50);
+Thread.sleep(100);
 }
 throw new CustomException("Boom " + currentInvocation);
 };