Fix ResponseHandler for return of generic BinaryData types

Author: samvaity

sdk/clientcore/annotation-processor-test/src/main/java/io/clientcore/annotation/processor/test/SpecialReturnBodiesServiceImpl.java

@@ -10,11 +10,15 @@
 import io.clientcore.core.implementation.utils.UriEscapers;
 import io.clientcore.core.models.binarydata.BinaryData;
 import java.io.InputStream;
+import java.util.List;
 import io.clientcore.annotation.processor.test.implementation.SpecialReturnBodiesService;
 import io.clientcore.core.instrumentation.logging.ClientLogger;
 import io.clientcore.core.serialization.json.JsonSerializer;
 import io.clientcore.core.serialization.xml.XmlSerializer;
 import io.clientcore.core.http.models.HttpResponseException;
+import io.clientcore.core.utils.CoreUtils;
+import java.lang.reflect.ParameterizedType;
+import io.clientcore.core.serialization.SerializationFormat;
 
 /**
  * Initializes a new instance of the SpecialReturnBodiesServiceImpl type.
@@ -147,4 +151,31 @@ public Response<InputStream> getInputStreamWithResponse(String url) {
         }
         return new Response<>(networkResponse.getRequest(), responseCode, networkResponse.getHeaders(), networkResponse.getValue().toStream());
     }
+
+    @SuppressWarnings("cast")
+    @Override
+    public Response<List<BinaryData>> getListOfBinaryData(String endpoint) {
+        // Create the HttpRequest.
+        HttpRequest httpRequest = new HttpRequest().setMethod(HttpMethod.GET).setUri(endpoint + "/type/array/unknown");
+        // Send the request through the httpPipeline
+        Response<BinaryData> networkResponse = this.httpPipeline.send(httpRequest);
+        int responseCode = networkResponse.getStatusCode();
+        boolean expectedResponse = responseCode == 200;
+        if (!expectedResponse) {
+            String errorMessage = networkResponse.getValue().toString();
+            networkResponse.close();
+            throw new HttpResponseException(errorMessage, networkResponse, null);
+        }
+        List<BinaryData> deserializedResult;
+        ParameterizedType returnType = CoreUtils.createParameterizedType(List.class, BinaryData.class);
+        SerializationFormat serializationFormat = CoreUtils.serializationFormatFromContentType(httpRequest.getHeaders());
+        if (jsonSerializer.supportsFormat(serializationFormat)) {
+            deserializedResult = CoreUtils.decodeNetworkResponse(networkResponse.getValue(), jsonSerializer, returnType);
+        } else if (xmlSerializer.supportsFormat(serializationFormat)) {
+            deserializedResult = CoreUtils.decodeNetworkResponse(networkResponse.getValue(), xmlSerializer, returnType);
+        } else {
+            throw new UnsupportedOperationException("None of the provided serializers support the format: " + serializationFormat + ".");
+        }
+        return new Response<>(networkResponse.getRequest(), responseCode, networkResponse.getHeaders(), deserializedResult);
+    }
 }

sdk/clientcore/annotation-processor-test/src/main/java/io/clientcore/annotation/processor/test/implementation/SpecialReturnBodiesService.java

@@ -5,13 +5,14 @@
 import io.clientcore.core.annotations.ServiceInterface;
 import io.clientcore.core.http.annotations.HostParam;
 import io.clientcore.core.http.annotations.HttpRequestInformation;
+import io.clientcore.core.http.annotations.UnexpectedResponseExceptionDetail;
 import io.clientcore.core.http.models.HttpMethod;
 import io.clientcore.core.http.models.Response;
 import io.clientcore.core.http.pipeline.HttpPipeline;
 import io.clientcore.core.models.binarydata.BinaryData;
-
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
+import java.util.List;
 
 /**
  * Service that tests special return bodies for methods.
@@ -100,4 +101,14 @@ static SpecialReturnBodiesService getNewInstance(HttpPipeline pipeline) {
      */
     @HttpRequestInformation(method = HttpMethod.GET, path = "bytes", expectedStatusCodes = { 200 })
     Response<InputStream> getInputStreamWithResponse(@HostParam("url") String url);
+
+    /**
+     * Gets a binary payload from the specified URL.
+     *
+     * @param endpoint The URL.
+     * @return A response containing the list of binary data.
+     */
+    @HttpRequestInformation(method = HttpMethod.GET, path = "/type/array/unknown", expectedStatusCodes = { 200 })
+    @UnexpectedResponseExceptionDetail
+    Response<List<BinaryData>> getListOfBinaryData(@HostParam("url") String endpoint);
 }

sdk/clientcore/annotation-processor/src/main/java/io/clientcore/annotation/processor/utils/ResponseHandler.java

@@ -17,16 +17,15 @@
 import io.clientcore.core.models.binarydata.BinaryData;
 import io.clientcore.core.serialization.SerializationFormat;
 import io.clientcore.core.utils.CoreUtils;
-
+import java.io.InputStream;
+import java.lang.reflect.ParameterizedType;
+import java.util.List;
+import java.util.stream.Collectors;
 import javax.lang.model.element.TypeElement;
 import javax.lang.model.type.ArrayType;
 import javax.lang.model.type.DeclaredType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.type.TypeMirror;
-import java.io.InputStream;
-import java.lang.reflect.ParameterizedType;
-import java.util.List;
-import java.util.stream.Collectors;
 
 /**
  * Utility class to generate response body mode assignment and response handling based on the response body mode.
@@ -148,24 +147,40 @@ private static void handleRequestReturn(BlockStmt body, TypeMirror returnType, j
             addReturnStatement(body, returnIsResponse, "networkResponse.getValue().toStream()");
         } else if (TypeUtil.isTypeOrSubTypeOf(entityType, BinaryData.class)) {
             // Return type is a BinaryData. Return the network response body.
-            // DO NOT close the network response for this return as it will result in the BinaryData either being
-            // closed or invalid when it is returned.
+            // DO NOT close the network response for this return as it will result in the BinaryData either being closed or invalid when it is returned.
             if (returnIsResponse) {
+                if (returnType instanceof DeclaredType) {
+                    DeclaredType declaredType = (DeclaredType) returnType;
+                    if (!declaredType.getTypeArguments().isEmpty()
+                        && ((TypeElement) ((DeclaredType) declaredType.getTypeArguments().get(0)).asElement())
+                            .getQualifiedName()
+                            .contentEquals(List.class.getCanonicalName())) {
+                        // Response<List<BinaryData>> or other generics
+                        handleDeclaredTypes(body, returnType, serializationFormatSet, true);
+                        return;
+                    }
+                }
+                // Raw Response or not a DeclaredType
                 body.addStatement(StaticJavaParser.parseStatement("return networkResponse;"));
             } else {
                 body.addStatement(StaticJavaParser.parseStatement("return networkResponse.getValue();"));
             }
         } else {
             // Fallback to a generalized code path that handles declared types as the entity, which uses deserialization
             // to create the return.
-            String typeCast = determineTypeCast(returnType, body);
+            handleDeclaredTypes(body, returnType, serializationFormatSet, returnIsResponse);
+        }
+    }
 
-            // Initialize the variable that will be used in the return statement.
-            body.addStatement(StaticJavaParser.parseStatement(typeCast + " deserializedResult;"));
-            handleDeclaredTypeResponse(body, (DeclaredType) returnType, serializationFormatSet, typeCast);
+    private static void handleDeclaredTypes(BlockStmt body, TypeMirror returnType, boolean serializationFormatSet,
+        boolean returnIsResponse) {
+        String typeCast = determineTypeCast(returnType, body);
 
-            addReturnStatement(body, returnIsResponse, "deserializedResult");
-        }
+        // Initialize the variable that will be used in the return statement.
+        body.addStatement(StaticJavaParser.parseStatement(typeCast + " deserializedResult;"));
+        handleDeclaredTypeResponse(body, (DeclaredType) returnType, serializationFormatSet, typeCast);
+
+        addReturnStatement(body, returnIsResponse, "deserializedResult");
     }
 
     // Helper method that creates the return statement as either Response<T> or T.