fix: comprehend deserializtion of primitive types (#1007)

Resolves: #997

Author: jamesonwilliams

aws-api-appsync/src/main/java/com/amplifyframework/core/model/types/GsonJavaTypeAdapters.java

@@ -101,13 +101,45 @@ public Class<?> read(JsonReader jsonReader) throws IOException {
                     jsonReader.nextNull();
                     return null;
                 }
-                final Class<?> clazz;
+                String classString = jsonReader.nextString();
                 try {
-                    clazz = Class.forName(jsonReader.nextString());
+                    return Class.forName(classString);
                 } catch (ClassNotFoundException exception) {
-                    throw new IOException(exception);
+                    // Class.forName() doesn't support primitives.
+                    // So, we'll try that next, before giving up.
+                }
+                try {
+                    return boxForPrimitiveLabel(classString);
+                } catch (IllegalArgumentException illegalArgumentException) {
+                    // At this point, we've tried to load the class,
+                    // and also tried to box up a primitive, but neither have worked.
+                    throw new IOException("Unable to deserialize class for " + classString);
+                }
+            }
+
+            private static Class<?> boxForPrimitiveLabel(String primitiveLabel) {
+                switch (primitiveLabel) {
+                    case "boolean":
+                        return Boolean.class;
+                    case "byte":
+                        return Byte.class;
+                    case "short":
+                        return Short.class;
+                    case "int":
+                        return Integer.class;
+                    case "long":
+                        return Long.class;
+                    case "float":
+                        return Float.class;
+                    case "double":
+                        return Double.class;
+                    case "char":
+                        return Character.class;
+                    case "void":
+                        return Void.class;
+                    default:
+                        throw new IllegalArgumentException("No primitive with name = " + primitiveLabel);
                 }
-                return clazz;
             }
         }
     }

aws-api-appsync/src/test/java/com/amplifyframework/core/model/types/GsonJavaTypeAdaptersTest.java

@@ -20,23 +20,36 @@
 
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import org.junit.Before;
 import org.junit.Test;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import static org.junit.Assert.assertEquals;
 
 /**
  * Tests the {@link GsonJavaTypeAdapters.ClassTypeAdapterFactory} in isolation.
  */
 public final class GsonJavaTypeAdaptersTest {
+    private Gson gson;
+
+    /**
+     * We'll test the adapter through a Gson instance. Set one up.
+     */
+    @Before
+    public void setup() {
+        this.gson = new GsonBuilder()
+            .registerTypeAdapterFactory(new GsonJavaTypeAdapters.ClassTypeAdapterFactory())
+            .create();
+    }
+
     /**
      * Start with a class, serialize it, deserialize it, and
      * expect the same class back.
      */
     @Test
     public void serializeAndDeserializeClass() {
-        Gson gson = new GsonBuilder()
-            .registerTypeAdapterFactory(new GsonJavaTypeAdapters.ClassTypeAdapterFactory())
-            .create();
         String serialized = gson.toJson(BlogOwner.class);
         assertEquals(
             Wrap.inDoubleQuotes("com.amplifyframework.testmodels.commentsblog.BlogOwner"),
@@ -45,4 +58,56 @@ public void serializeAndDeserializeClass() {
         Class<?> deserialized = gson.fromJson(serialized, Class.class);
         assertEquals(BlogOwner.class, deserialized);
     }
+
+    /**
+     * Validate that primitive type labels (e.g. "int") can be derialized to their
+     * corresponding boxed class types.
+     */
+    @Test
+    public void deserializePrimitiveLabel() {
+        Map<String, Class<?>> primitiveNameToBoxedType = new HashMap<>();
+        primitiveNameToBoxedType.put("int", Integer.class);
+        primitiveNameToBoxedType.put("short", Short.class);
+        primitiveNameToBoxedType.put("long", Long.class);
+        primitiveNameToBoxedType.put("boolean", Boolean.class);
+        primitiveNameToBoxedType.put("byte", Byte.class);
+        primitiveNameToBoxedType.put("char", Character.class);
+        primitiveNameToBoxedType.put("float", Float.class);
+        primitiveNameToBoxedType.put("double", Double.class);
+        primitiveNameToBoxedType.put("void", Void.class);
+
+        for (Map.Entry<String, Class<?>> entry : primitiveNameToBoxedType.entrySet()) {
+            assertEquals(
+                "Primitive comprehension failed for " + entry.getKey(),
+                entry.getValue(),
+                gson.fromJson(entry.getKey(), Class.class)
+            );
+        }
+    }
+
+    /**
+     * If a user inadvertently provided a primitive type, we just box it.
+     */
+    @Test
+    public void serializePrimitiveRetrieveClass() {
+        Map<Class<?>, Class<?>> primitiveTypeToBoxedType = new HashMap<>();
+        primitiveTypeToBoxedType.put(int.class, Integer.class);
+        primitiveTypeToBoxedType.put(short.class, Short.class);
+        primitiveTypeToBoxedType.put(long.class, Long.class);
+        primitiveTypeToBoxedType.put(boolean.class, Boolean.class);
+        primitiveTypeToBoxedType.put(byte.class, Byte.class);
+        primitiveTypeToBoxedType.put(char.class, Character.class);
+        primitiveTypeToBoxedType.put(float.class, Float.class);
+        primitiveTypeToBoxedType.put(double.class, Double.class);
+        primitiveTypeToBoxedType.put(void.class, Void.class);
+
+        for (Map.Entry<Class<?>, Class<?>> entry : primitiveTypeToBoxedType.entrySet()) {
+            String serialized = gson.toJson(entry.getKey());
+            assertEquals(
+                "Primitive comprehension failed for " + serialized,
+                entry.getValue(),
+                gson.fromJson(serialized, Class.class)
+            );
+        }
+    }
 }