Support deserialization of lists containing JsonSerializable types (Azure#44208)

* Support deserialization of lists containing JsonSerializable types

* fix spotbugs issue

* remove unused import

Author: srnagar

sdk/clientcore/core/src/main/java/io/clientcore/core/implementation/utils/JsonSerializer.java

@@ -16,7 +16,9 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.util.List;
 
 /**
  * Class providing basic JSON serialization and deserialization methods.
@@ -52,13 +54,29 @@ public JsonSerializer() {
     @Override
     public <T> T deserializeFromBytes(byte[] bytes, Type type) throws IOException {
         try (JsonReader jsonReader = JsonReader.fromBytes(bytes)) {
-            if (type instanceof Class<?> && JsonSerializable.class.isAssignableFrom(TypeUtil.getRawClass(type))) {
+            if (type instanceof ParameterizedType && List.class.isAssignableFrom(TypeUtil.getRawClass(type))) {
+                ParameterizedType parameterizedType = (ParameterizedType) type;
+                Type listElementType = parameterizedType.getActualTypeArguments()[0];
+                if (listElementType instanceof Class<?>
+                    && JsonSerializable.class.isAssignableFrom(TypeUtil.getRawClass(listElementType))) {
+                    List<?> list = jsonReader.readArray(arrayReader -> {
+                        Type actualTypeArgument = parameterizedType.getActualTypeArguments()[0];
+                        Class<?> clazz = (Class<?>) actualTypeArgument;
+                        try {
+                            return clazz.getMethod("fromJson", JsonReader.class).invoke(null, arrayReader);
+                        } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
+                            throw LOGGER.logThrowableAsError(new RuntimeException(e));
+                        }
+                    });
+                    return (T) list;
+                }
+            } else if (type instanceof Class<?>
+                && JsonSerializable.class.isAssignableFrom(TypeUtil.getRawClass(type))) {
                 Class<T> clazz = (Class<T>) type;
 
                 return (T) clazz.getMethod("fromJson", JsonReader.class).invoke(null, jsonReader);
-            } else {
-                return (T) jsonReader.readUntyped();
             }
+            return (T) jsonReader.readUntyped();
         } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
             throw LOGGER.logThrowableAsError(new RuntimeException(e));
         }

sdk/clientcore/core/src/test/java/io/clientcore/core/utils/serializers/JsonSerializerTests.java

@@ -5,6 +5,7 @@
 
 import io.clientcore.core.http.models.HttpMethod;
 import io.clientcore.core.implementation.AccessibleByteArrayOutputStream;
+import io.clientcore.core.implementation.TypeUtil;
 import io.clientcore.core.implementation.utils.JsonSerializer;
 import io.clientcore.core.models.SimpleClass;
 import io.clientcore.core.serialization.json.JsonReader;
@@ -20,20 +21,25 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.ParameterizedType;
 import java.net.URI;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
 import java.time.OffsetDateTime;
 import java.time.ZoneOffset;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.stream.Stream;
 
 import static io.clientcore.core.utils.TestUtils.assertArraysEqual;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class JsonSerializerTests {
     private static final ObjectSerializer SERIALIZER = new JsonSerializer();
@@ -266,4 +272,91 @@ private static Stream<Arguments> unsupportedDeserializationSupplier() {
             Arguments.of(URI.class, IOException.class) // Thrown when the String cannot be parsed by core
         );
     }
+
+    @Test
+    public void deserializeListOfJsonSerializableTypes() throws IOException {
+        byte[] bytes = "[{\"property\":\"value1\"},{\"property\":\"value2\"}]".getBytes(StandardCharsets.UTF_8);
+
+        ParameterizedType type = TypeUtil.createParameterizedType(List.class, FooModel.class);
+
+        List<FooModel> models = SERIALIZER.deserializeFromBytes(bytes, type);
+        assertNotNull(models);
+        assertEquals(2, models.size());
+        assertEquals("value1", models.get(0).getProperty());
+        assertEquals("value2", models.get(1).getProperty());
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void deserializeListOfNonJsonSerializableTypes() throws IOException {
+        byte[] bytes = "[{\"property\":\"value1\"},{\"property\":\"value2\"}]".getBytes(StandardCharsets.UTF_8);
+
+        ParameterizedType type = TypeUtil.createParameterizedType(List.class, BarModel.class);
+
+        List<?> models = SERIALIZER.deserializeFromBytes(bytes, type);
+        assertNotNull(models);
+        assertEquals(2, models.size());
+        assertTrue(models.get(0) instanceof LinkedHashMap);
+
+        if (models.get(0) instanceof LinkedHashMap) {
+            LinkedHashMap<String, String> model = (LinkedHashMap<String, String>) models.get(0);
+            assertEquals("value1", model.get("property"));
+        }
+    }
+
+    /**
+     * A model that implements {@link JsonSerializable}.
+     */
+    public static final class FooModel implements JsonSerializable<FooModel> {
+        private final String property;
+
+        public FooModel(String property) {
+            this.property = property;
+        }
+
+        public String getProperty() {
+            return this.property;
+        }
+
+        @Override
+        public JsonWriter toJson(JsonWriter jsonWriter) throws IOException {
+            jsonWriter.writeStartObject();
+            jsonWriter.writeStringField("property", this.property);
+            return jsonWriter.writeEndObject();
+        }
+
+        public static FooModel fromJson(JsonReader jsonReader) throws IOException {
+            return jsonReader.readObject(reader -> {
+                String property = null;
+                while (reader.nextToken() != JsonToken.END_OBJECT) {
+                    String fieldName = reader.getFieldName();
+                    reader.nextToken();
+
+                    if ("property".equals(fieldName)) {
+                        property = reader.getString();
+                    } else {
+                        reader.skipChildren();
+                    }
+                }
+                FooModel deserializedModel = new FooModel(property);
+
+                return deserializedModel;
+            });
+        }
+    }
+
+    /**
+     * A model that does not implement {@link JsonSerializable}.
+     */
+    public static final class BarModel {
+        private final String property;
+
+        public BarModel(String property) {
+            this.property = property;
+        }
+
+        public String getProperty() {
+            return this.property;
+        }
+    }
 }