Rx retry exclude error#317 (ReactiveX#372)

* Add response predicate to retry sync and async for enhancement ReactiveX#259

* ReactiveX#317 skipping Java Error type from onError Rx retry transformer

* ReactiveX#317 adding proper comment

Author: Romeh

resilience4j-rxjava2/src/main/java/io/github/resilience4j/retry/transformer/RetryTransformer.java

@@ -16,10 +16,24 @@
 
 package io.github.resilience4j.retry.transformer;
 
-import io.github.resilience4j.retry.Retry;
-import io.reactivex.*;
 import org.reactivestreams.Publisher;
 
+import io.github.resilience4j.retry.Retry;
+import io.reactivex.Completable;
+import io.reactivex.CompletableSource;
+import io.reactivex.CompletableTransformer;
+import io.reactivex.Flowable;
+import io.reactivex.FlowableTransformer;
+import io.reactivex.Maybe;
+import io.reactivex.MaybeSource;
+import io.reactivex.MaybeTransformer;
+import io.reactivex.Observable;
+import io.reactivex.ObservableSource;
+import io.reactivex.ObservableTransformer;
+import io.reactivex.Single;
+import io.reactivex.SingleSource;
+import io.reactivex.SingleTransformer;
+
 public class RetryTransformer<T> implements FlowableTransformer<T, T>, ObservableTransformer<T, T>,
         SingleTransformer<T, T>, CompletableTransformer, MaybeTransformer<T, T> {
     private final Retry retry;
@@ -102,10 +116,14 @@ void throwExceptionToForceRetryOnResult(T value) {
 
         void onError(Throwable throwable) throws Exception {
             if (throwable instanceof RetryDueToResultException) return;
+	        // Filter Error to not retry on it
+            if (throwable instanceof Error) {
+                throw (Error) throwable;
+            }
             try {
                 context.onError(castToException(throwable));
-            } catch (Throwable throwable1) {
-                throw castToException(throwable);
+            } catch (Throwable t) {
+                throw castToException(t);
             }
         }
 

resilience4j-rxjava2/src/test/java/io/github/resilience4j/retry/transformer/RetryTransformerTest.java

@@ -16,22 +16,28 @@
 
 package io.github.resilience4j.retry.transformer;
 
-import io.github.resilience4j.retry.Retry;
-import io.github.resilience4j.retry.RetryConfig;
-import io.github.resilience4j.test.HelloWorldService;
-import io.reactivex.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doThrow;
+
+import java.io.IOException;
+
+import javax.xml.ws.WebServiceException;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.BDDMockito;
 import org.mockito.Mockito;
 
-import javax.xml.ws.WebServiceException;
-import java.io.IOException;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doThrow;
+import io.github.resilience4j.retry.Retry;
+import io.github.resilience4j.retry.RetryConfig;
+import io.github.resilience4j.test.HelloWorldService;
+import io.reactivex.Completable;
+import io.reactivex.Flowable;
+import io.reactivex.Maybe;
+import io.reactivex.Observable;
+import io.reactivex.Single;
 
 public class RetryTransformerTest {
 
@@ -80,6 +86,57 @@ public void returnOnCompleteUsingSingle() {
         assertThat(metrics.getNumberOfFailedCallsWithoutRetryAttempt()).isEqualTo(0);
     }
 
+
+    @Test(expected = StackOverflowError.class)
+    public void shouldNotRetryUsingSingleStackOverFlow() {
+        //Given
+        RetryConfig config = RetryConfig.ofDefaults();
+        Retry retry = Retry.of("testName", config);
+        RetryTransformer<Object> retryTransformer = RetryTransformer.of(retry);
+
+        given(helloWorldService.returnHelloWorld())
+                .willThrow(new StackOverflowError("BAM!"));
+
+        //When
+        Single.fromCallable(helloWorldService::returnHelloWorld)
+                .compose(retryTransformer)
+                .test();
+
+
+        //Then
+        BDDMockito.then(helloWorldService).should(Mockito.times(1)).returnHelloWorld();
+        Retry.Metrics metrics = retry.getMetrics();
+
+        assertThat(metrics.getNumberOfFailedCallsWithoutRetryAttempt()).isEqualTo(0);
+        assertThat(metrics.getNumberOfFailedCallsWithRetryAttempt()).isEqualTo(0);
+    }
+
+    @Test
+    public void shouldNotRetryWhenItThrowErrorSingle() {
+        //Given
+        RetryConfig config = RetryConfig.ofDefaults();
+        Retry retry = Retry.of("testName", config);
+        RetryTransformer<Object> retryTransformer = RetryTransformer.of(retry);
+
+        given(helloWorldService.returnHelloWorld())
+                .willThrow(new Error("BAM!"));
+
+        //When
+        Single.fromCallable(helloWorldService::returnHelloWorld)
+                .compose(retryTransformer)
+                .test()
+                .assertError(Error.class)
+                .assertNotComplete()
+                .assertSubscribed();
+        //Then
+        BDDMockito.then(helloWorldService).should(Mockito.times(1)).returnHelloWorld();
+        Retry.Metrics metrics = retry.getMetrics();
+
+        assertThat(metrics.getNumberOfFailedCallsWithRetryAttempt()).isEqualTo(0);
+        assertThat(metrics.getNumberOfFailedCallsWithoutRetryAttempt()).isEqualTo(0);
+    }
+
+
     @Test
     public void returnOnErrorUsingSingle() {
         //Given