Merge pull request #16 from sashirestela/15-feature-to-download-files

sashirestela · web-flow · commit 0eb33d96c040 · 2023-11-13T16:32:35.000-05:00
Enable file downloading
diff --git a/pom.xml b/pom.xml
@@ -6,7 +6,7 @@
 
   <groupId>io.github.sashirestela</groupId>
   <artifactId>cleverclient</artifactId>
-  <version>0.7.1</version>
+  <version>0.8.0</version>
   <packaging>jar</packaging>
 
   <name>cleverclient</name>
diff --git a/src/example/java/io/github/sashirestela/cleverclient/example/FileDownloadExample.java b/src/example/java/io/github/sashirestela/cleverclient/example/FileDownloadExample.java
@@ -0,0 +1,32 @@
+package io.github.sashirestela.cleverclient.example;
+
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import io.github.sashirestela.cleverclient.CleverClient;
+import io.github.sashirestela.cleverclient.annotation.GET;
+import io.github.sashirestela.cleverclient.annotation.Path;
+
+public class FileDownloadExample {
+
+    static interface ImageService {
+
+        @GET("/150/{id}")
+        InputStream getImage(@Path("id") String id);
+    }
+
+    public static void main(String[] args) throws IOException {
+        final var URL_BASE = "https://via.placeholder.com";
+
+        var cleverClient = CleverClient.builder()
+                .urlBase(URL_BASE)
+                .build();
+
+        var imageService = cleverClient.create(ImageService.class);
+        var binaryData = imageService.getImage("92c952");
+        var file = new FileOutputStream("src/test/resources/download.png");
+        file.write(binaryData.readAllBytes());
+        file.close();
+    }
+}
diff --git a/src/main/java/io/github/sashirestela/cleverclient/http/ReturnType.java b/src/main/java/io/github/sashirestela/cleverclient/http/ReturnType.java
@@ -6,6 +6,7 @@ public class ReturnType {
     private static final String ASYNC = "java.util.concurrent.CompletableFuture";
     private static final String STREAM = "java.util.stream.Stream";
     private static final String LIST = "java.util.List";
+    private static final String INPUTSTREAM = "java.io.InputStream";
     private static final String STRING = "java.lang.String";
 
     private static final String REGEX = "[<>]";
@@ -70,6 +71,8 @@ private Category asyncCategory() {
             return Category.ASYNC_GENERIC;
         } else if (isObject()) {
             return Category.ASYNC_OBJECT;
+        } else if (isBinary()) {
+            return Category.ASYNC_BINARY;
         } else if (isPlainText()) {
             return Category.ASYNC_PLAIN_TEXT;
         } else {
@@ -86,6 +89,8 @@ private Category syncCategory() {
             return Category.SYNC_GENERIC;
         } else if (isObject()) {
             return Category.SYNC_OBJECT;
+        } else if (isBinary()) {
+            return Category.SYNC_BINARY;
         } else if (isPlainText()) {
             return Category.SYNC_PLAIN_TEXT;
         } else {
@@ -111,13 +116,21 @@ public boolean isGeneric() {
     }
 
     public boolean isObject() {
-        return !isString() && (size == 1 || (size == 2 && isAsync()));
+        return !isInputStream() && !isString() && (size == 1 || (size == 2 && isAsync()));
+    }
+
+    public boolean isBinary() {
+        return isInputStream() && (size == 1 || (size == 2 && isAsync()));
     }
 
     public boolean isPlainText() {
         return isString() && (size == 1 || (size == 2 && isAsync()));
     }
 
+    private boolean isInputStream() {
+        return INPUTSTREAM.equals(returnTypeArray[lastIndex]);
+    }
+
     private boolean isString() {
         return STRING.equals(returnTypeArray[lastIndex]);
     }
@@ -127,11 +140,13 @@ public enum Category {
         ASYNC_LIST,
         ASYNC_GENERIC,
         ASYNC_OBJECT,
+        ASYNC_BINARY,
         ASYNC_PLAIN_TEXT,
         SYNC_STREAM,
         SYNC_LIST,
         SYNC_GENERIC,
         SYNC_OBJECT,
+        SYNC_BINARY,
         SYNC_PLAIN_TEXT;
     }
 }
diff --git a/src/main/java/io/github/sashirestela/cleverclient/sender/HttpAsyncBinarySender.java b/src/main/java/io/github/sashirestela/cleverclient/sender/HttpAsyncBinarySender.java
@@ -0,0 +1,26 @@
+package io.github.sashirestela.cleverclient.sender;
+
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse.BodyHandlers;
+
+public class HttpAsyncBinarySender extends HttpSender {
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <S, T> Object sendRequest(HttpClient httpClient, HttpRequest httpRequest, Class<T> responseClass,
+            Class<S> genericClass) {
+
+        var httpResponseFuture = httpClient.sendAsync(httpRequest, BodyHandlers.ofInputStream());
+
+        return httpResponseFuture.thenApply(response -> {
+
+            throwExceptionIfErrorIsPresent(response, false);
+
+            logger.debug("Response : {}", response.body());
+
+            return (T) response.body();
+        });
+    }
+
+}
diff --git a/src/main/java/io/github/sashirestela/cleverclient/sender/HttpSenderFactory.java b/src/main/java/io/github/sashirestela/cleverclient/sender/HttpSenderFactory.java
@@ -23,11 +23,13 @@ private HttpSenderFactory() {
         sendersMap.put(Category.ASYNC_LIST, HttpAsyncListSender::new);
         sendersMap.put(Category.ASYNC_GENERIC, HttpAsyncGenericSender::new);
         sendersMap.put(Category.ASYNC_OBJECT, HttpAsyncObjectSender::new);
+        sendersMap.put(Category.ASYNC_BINARY, HttpAsyncBinarySender::new);
         sendersMap.put(Category.ASYNC_PLAIN_TEXT, HttpAsyncPlainTextSender::new);
         sendersMap.put(Category.SYNC_STREAM, HttpSyncStreamSender::new);
         sendersMap.put(Category.SYNC_LIST, HttpSyncListSender::new);
         sendersMap.put(Category.SYNC_GENERIC, HttpSyncGenericSender::new);
         sendersMap.put(Category.SYNC_OBJECT, HttpSyncObjectSender::new);
+        sendersMap.put(Category.SYNC_BINARY, HttpSyncBinarySender::new);
         sendersMap.put(Category.SYNC_PLAIN_TEXT, HttpSyncPlainTextSender::new);
     }
 
diff --git a/src/main/java/io/github/sashirestela/cleverclient/sender/HttpSyncBinarySender.java b/src/main/java/io/github/sashirestela/cleverclient/sender/HttpSyncBinarySender.java
@@ -0,0 +1,33 @@
+package io.github.sashirestela.cleverclient.sender;
+
+import java.io.IOException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse.BodyHandlers;
+
+import io.github.sashirestela.cleverclient.support.CleverClientException;
+
+public class HttpSyncBinarySender extends HttpSender {
+
+    @Override
+    public <S, T> Object sendRequest(HttpClient httpClient, HttpRequest httpRequest, Class<T> responseClass,
+            Class<S> genericClass) {
+        try {
+
+            var httpResponse = httpClient.send(httpRequest, BodyHandlers.ofInputStream());
+
+            throwExceptionIfErrorIsPresent(httpResponse, false);
+
+            var rawData = httpResponse.body();
+
+            logger.debug("Response : {}", rawData);
+
+            return rawData;
+
+        } catch (IOException | InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new CleverClientException(e.getMessage(), null, e);
+        }
+    }
+
+}
diff --git a/src/test/java/io/github/sashirestela/cleverclient/http/HttpProcessorTest.java b/src/test/java/io/github/sashirestela/cleverclient/http/HttpProcessorTest.java
@@ -7,7 +7,11 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.HttpURLConnection;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
@@ -29,6 +33,7 @@ class HttpProcessorTest {
     HttpClient httpClient = mock(HttpClient.class);
     HttpResponse<String> httpResponse = mock(HttpResponse.class);
     HttpResponse<Stream<String>> httpResponseStream = mock(HttpResponse.class);
+    HttpResponse<InputStream> httpResponseBinary = mock(HttpResponse.class);
 
     @BeforeEach
     void init() {
@@ -83,6 +88,30 @@ void shouldThrownExceptionWhenMethodReturnTypeIsAString() throws IOException, In
         assertThrows(CleverClientException.class, () -> service.getDemoPlain(100));
     }
 
+    @Test
+    void shouldshouldReturnABinarySyncWhenMethodReturnTypeIsABinary() throws IOException, InterruptedException {
+        InputStream binaryData = new FileInputStream(new File("src/test/resources/image.png"));
+        when(httpClient.send(any(HttpRequest.class), any(HttpResponse.BodyHandlers.ofInputStream().getClass())))
+                .thenReturn(httpResponseBinary);
+        when(httpResponseBinary.statusCode()).thenReturn(HttpURLConnection.HTTP_OK);
+        when(httpResponseBinary.body()).thenReturn(binaryData);
+
+        var service = httpProcessor.createProxy(ITest.SyncService.class);
+        var actualDemo = service.getDemoBinary(100);
+        var expectedDemo = binaryData;
+
+        assertEquals(expectedDemo, actualDemo);
+    }
+
+    @Test
+    void shouldThrownExceptionWhenMethodReturnTypeIsABinary() throws IOException, InterruptedException {
+        when(httpClient.send(any(HttpRequest.class), any(HttpResponse.BodyHandlers.ofInputStream().getClass())))
+                .thenThrow(new InterruptedException("The operation was interrupted"));
+
+        var service = httpProcessor.createProxy(ITest.SyncService.class);
+        assertThrows(CleverClientException.class, () -> service.getDemoBinary(100));
+    }
+
     @Test
     void shouldReturnAnObjectSyncWhenMethodReturnTypeIsAnObject() throws IOException, InterruptedException {
         when(httpClient.send(any(HttpRequest.class), any(HttpResponse.BodyHandlers.ofString().getClass())))
@@ -193,6 +222,21 @@ void shouldReturnAStringAsyncWhenMethodReturnTypeIsAString() {
         assertEquals(expectedDemo, actualDemo);
     }
 
+    @Test
+    void shouldReturnABinaryAsyncWhenMethodReturnTypeIsABinary() throws FileNotFoundException {
+        InputStream binaryData = new FileInputStream(new File("src/test/resources/image.png"));
+        when(httpClient.sendAsync(any(HttpRequest.class), any(HttpResponse.BodyHandlers.ofInputStream().getClass())))
+                .thenReturn(CompletableFuture.completedFuture(httpResponseBinary));
+        when(httpResponseBinary.statusCode()).thenReturn(HttpURLConnection.HTTP_OK);
+        when(httpResponseBinary.body()).thenReturn(binaryData);
+
+        var service = httpProcessor.createProxy(ITest.AsyncService.class);
+        var actualDemo = service.getDemoBinary(100).join();
+        var expectedDemo = binaryData;
+
+        assertEquals(expectedDemo, actualDemo);
+    }
+
     @Test
     void shouldReturnAnObjectAsyncWhenMethodReturnTypeIsAnObject() {
         when(httpClient.sendAsync(any(HttpRequest.class), any(HttpResponse.BodyHandlers.ofString().getClass())))
diff --git a/src/test/java/io/github/sashirestela/cleverclient/http/ITest.java b/src/test/java/io/github/sashirestela/cleverclient/http/ITest.java
@@ -1,5 +1,6 @@
 package io.github.sashirestela.cleverclient.http;
 
+import java.io.InputStream;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CompletableFuture;
@@ -47,6 +48,9 @@ interface AsyncService {
         @GET("/{demoId}")
         CompletableFuture<String> getDemoPlain(@Path("demoId") Integer demoId);
 
+        @GET("/{demoId}")
+        CompletableFuture<InputStream> getDemoBinary(@Path("demoId") Integer demoId);
+
         @GET("/{demoId}")
         CompletableFuture<Demo> getDemo(@Path("demoId") Integer demoId);
 
@@ -74,6 +78,9 @@ interface SyncService {
         @GET("/{demoId}")
         String getDemoPlain(@Path("demoId") Integer demoId);
 
+        @GET("/{demoId}")
+        InputStream getDemoBinary(@Path("demoId") Integer demoId);
+
         @GET("/{demoId}")
         Demo getDemo(@Path("demoId") Integer demoId);
 
diff --git a/src/test/java/io/github/sashirestela/cleverclient/http/ReturnTypeTest.java b/src/test/java/io/github/sashirestela/cleverclient/http/ReturnTypeTest.java
@@ -3,6 +3,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
+import java.io.InputStream;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -24,17 +25,19 @@ void shouldReturnBaseClassForAMethod() throws NoSuchMethodException, SecurityExc
 
     @Test
     void shouldReturnCategoryAccordingToTheMethodType() throws NoSuchMethodException, SecurityException {
-        var testData = Map.of(
-                "asyncStreamMethod", ReturnType.Category.ASYNC_STREAM,
-                "asyncListMethod", ReturnType.Category.ASYNC_LIST,
-                "asyncGenericMethod", ReturnType.Category.ASYNC_GENERIC,
-                "asyncObjectMethod", ReturnType.Category.ASYNC_OBJECT,
-                "asyncStringMethod", ReturnType.Category.ASYNC_PLAIN_TEXT,
-                "syncStreamMethod", ReturnType.Category.SYNC_STREAM,
-                "syncListMethod", ReturnType.Category.SYNC_LIST,
-                "syncGenericMethod", ReturnType.Category.SYNC_GENERIC,
-                "syncObjectMethod", ReturnType.Category.SYNC_OBJECT,
-                "syncStringMethod", ReturnType.Category.SYNC_PLAIN_TEXT);
+        var testData = Map.ofEntries(
+                Map.entry("asyncStreamMethod", ReturnType.Category.ASYNC_STREAM),
+                Map.entry("asyncListMethod", ReturnType.Category.ASYNC_LIST),
+                Map.entry("asyncGenericMethod", ReturnType.Category.ASYNC_GENERIC),
+                Map.entry("asyncObjectMethod", ReturnType.Category.ASYNC_OBJECT),
+                Map.entry("asyncBinaryMethod", ReturnType.Category.ASYNC_BINARY),
+                Map.entry("asyncStringMethod", ReturnType.Category.ASYNC_PLAIN_TEXT),
+                Map.entry("syncStreamMethod", ReturnType.Category.SYNC_STREAM),
+                Map.entry("syncListMethod", ReturnType.Category.SYNC_LIST),
+                Map.entry("syncGenericMethod", ReturnType.Category.SYNC_GENERIC),
+                Map.entry("syncObjectMethod", ReturnType.Category.SYNC_OBJECT),
+                Map.entry("syncBinaryMethod", ReturnType.Category.SYNC_BINARY),
+                Map.entry("syncStringMethod", ReturnType.Category.SYNC_PLAIN_TEXT));
         for (String methodName : testData.keySet()) {
             var method = TestInterface.class.getMethod(methodName, new Class[] {});
             var returnType = new ReturnType(method);
@@ -64,6 +67,8 @@ static interface TestInterface {
 
         CompletableFuture<Object> asyncObjectMethod();
 
+        CompletableFuture<InputStream> asyncBinaryMethod();
+
         CompletableFuture<String> asyncStringMethod();
 
         CompletableFuture<Set<Object>> asyncSetMethod();
@@ -76,6 +81,8 @@ static interface TestInterface {
 
         Object syncObjectMethod();
 
+        InputStream syncBinaryMethod();
+
         String syncStringMethod();
 
         Set<Object> syncSetMethod();
diff --git a/src/test/resources/download.png b/src/test/resources/download.png
