Use OkHttp as an alternative Http client

src/main/java/io/github/sashirestela/cleverclient/client/HttpClientAdapter.java

@@ -128,7 +128,6 @@ protected Stream<Object> convertToStreamOfObjects(Stream<String> response, Retur
     protected Stream<Object> convertToStreamOfEvents(Stream<String> response, ReturnType returnType) {
         final var lineRecord = new CleverClientSSE.LineRecord();
         final var events = returnType.getClassByEvent().keySet();
-
         return response
                 .map(line -> {
                     logger.debug(RESPONSE_FORMAT, line);

src/main/java/io/github/sashirestela/cleverclient/client/JavaHttpClientAdapter.java

@@ -84,7 +84,7 @@ protected Object sendAsync(RequestData request) {
 
     @Override
     public void shutdown() {
-        this.httpClient.executor().ifPresent(executor -> {
+        httpClient.executor().ifPresent(executor -> {
             if (executor instanceof ExecutorService) {
                 ((ExecutorService) executor).shutdown();
             }

src/main/java/io/github/sashirestela/cleverclient/client/OkHttpClientAdapter.java

@@ -23,11 +23,14 @@
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.util.EnumMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Spliterator;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 
 public class OkHttpClientAdapter extends HttpClientAdapter {
 
@@ -57,12 +60,18 @@ protected Object send(RequestData request) {
         try {
             var response = okHttpClient.newCall(okHttpRequest).execute();
             logger.debug(RESPONSE_CODE_FORMAT, response.code());
-            var responseContent = getReponseContent(response.body(), returnType);
-            throwExceptionIfErrorIsPresent(convertToResponseData(response, responseContent));
-            if (!returnType.isStream()) {
-                logger.debug(RESPONSE_FORMAT, responseContent);
+            if (returnType.isStream()) {
+                var responseContent = getResponseContent(response.body(), returnType);
+                throwExceptionIfErrorIsPresent(convertToResponseData(response, responseContent));
+                return functions.responseConverter.apply(responseContent, returnType);
+            } else {
+                try (response) {
+                    var responseContent = getResponseContent(response.body(), returnType);
+                    throwExceptionIfErrorIsPresent(convertToResponseData(response, responseContent));
+                    logger.debug(RESPONSE_FORMAT, responseContent);
+                    return functions.responseConverter.apply(responseContent, returnType);
+                }
             }
-            return functions.responseConverter.apply(responseContent, returnType);
         } catch (IOException e) {
             throw new CleverClientException(e);
         }
@@ -84,15 +93,24 @@ public void onFailure(Call call, IOException e) {
             @Override
             public void onResponse(Call call, Response response) throws IOException {
                 logger.debug(RESPONSE_CODE_FORMAT, response.code());
-                var responseContent = getReponseContent(response.body(), returnType);
-                try {
-                    throwExceptionIfErrorIsPresent(convertToResponseData(response, responseContent));
-                    if (!returnType.isStream()) {
+                if (returnType.isStream()) {
+                    try {
+                        Object responseContent = getResponseContent(response.body(), returnType);
+                        throwExceptionIfErrorIsPresent(convertToResponseData(response, responseContent));
+                        responseFuture.complete(functions.responseConverter.apply(responseContent, returnType));
+                    } catch (CleverClientException e) {
+                        response.close();
+                        responseFuture.completeExceptionally(e);
+                    }
+                } else {
+                    try (response) {
+                        Object responseContent = getResponseContent(response.body(), returnType);
+                        throwExceptionIfErrorIsPresent(convertToResponseData(response, responseContent));
                         logger.debug(RESPONSE_FORMAT, responseContent);
+                        responseFuture.complete(functions.responseConverter.apply(responseContent, returnType));
+                    } catch (CleverClientException e) {
+                        responseFuture.completeExceptionally(e);
                     }
-                    responseFuture.complete(functions.responseConverter.apply(responseContent, returnType));
-                } catch (CleverClientException e) {
-                    responseFuture.completeExceptionally(e);
                 }
             }
 
@@ -168,11 +186,49 @@ private ResponseData convertToResponseData(Response response, Object responseCon
                 .build();
     }
 
-    private Object getReponseContent(ResponseBody responseBody, ReturnType returnType) {
+    private Object getResponseContent(ResponseBody responseBody, ReturnType returnType) {
         try {
             if (returnType.isStream()) {
-                var reader = new BufferedReader(new InputStreamReader(responseBody.byteStream()));
-                return reader.lines();
+                BufferedReader reader = new BufferedReader(new InputStreamReader(responseBody.byteStream()));
+                return StreamSupport.stream(new Spliterator<String>() {
+
+                    private final Iterator<String> iterator = reader.lines().iterator();
+                    private boolean closed = false;
+
+                    @Override
+                    public boolean tryAdvance(java.util.function.Consumer<? super String> action) {
+                        if (iterator.hasNext()) {
+                            action.accept(iterator.next());
+                            return true;
+                        }
+                        if (!closed) {
+                            try {
+                                reader.close();
+                                responseBody.close();
+                                closed = true;
+                            } catch (Exception e) {
+                                throw new CleverClientException(e);
+                            }
+                        }
+                        return false;
+                    }
+
+                    @Override
+                    public Spliterator<String> trySplit() {
+                        return null;
+                    }
+
+                    @Override
+                    public long estimateSize() {
+                        return Long.MAX_VALUE;
+                    }
+
+                    @Override
+                    public int characteristics() {
+                        return Spliterator.ORDERED;
+                    }
+
+                }, false);
             } else if (returnType.isInputStream()) {
                 return responseBody.byteStream();
             } else {

src/test/java/io/github/sashirestela/cleverclient/http/HttpProcessorTest.java

@@ -39,6 +39,8 @@ interface HttpProcessorTest {
 
     void setMocksForStreamWithError(Stream<String> result) throws IOException, URISyntaxException;
 
+    void testShutdown();
+
     @BeforeAll
     static void setup() {
         TestSupport.setupConfigurator();
@@ -343,4 +345,9 @@ default void shouldExecuteDefaultMethodWhenItIsCalled() {
         assertEquals(expectedValue, actualValue);
     }
 
+    @Test
+    default void shouldShutdownWithoutExceptions() {
+        testShutdown();
+    }
+
 }

src/test/java/io/github/sashirestela/cleverclient/http/JavaHttpProcessorTest.java

@@ -15,8 +15,10 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executors;
 import java.util.stream.Stream;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -146,4 +148,14 @@ public void setMocksForStreamWithError(Stream<String> result) throws IOException
         when(httpResponseStream.request()).thenReturn(httpRequest);
     }
 
+    @Override
+    public void testShutdown() {
+        var defaultAdapter = new JavaHttpClientAdapter();
+        assertDoesNotThrow(() -> defaultAdapter.shutdown());
+
+        var client = HttpClient.newBuilder().executor(Executors.newFixedThreadPool(2)).build();
+        var customAdapter = new JavaHttpClientAdapter(client);
+        assertDoesNotThrow(() -> customAdapter.shutdown());
+    }
+
 }

src/test/java/io/github/sashirestela/cleverclient/http/OkHttpProcessorTest.java

@@ -20,6 +20,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
@@ -179,4 +180,14 @@ public void setMocksForStreamWithError(Stream<String> result) throws IOException
         when(okHttpResponse.request()).thenReturn(okHttpRequest);
     }
 
+    @Override
+    public void testShutdown() {
+        var defaultAdapter = new OkHttpClientAdapter();
+        assertDoesNotThrow(() -> defaultAdapter.shutdown());
+
+        var client = new OkHttpClient();
+        var customAdapter = new OkHttpClientAdapter(client);
+        assertDoesNotThrow(() -> customAdapter.shutdown());
+    }
+
 }