Add CaseInsensitiveEnumTypeAdapterFactory

Author: mythz

src/AndroidClient/client/src/main/java/net/servicestack/client/JsonSerializers.java

@@ -3,16 +3,27 @@
 
 package net.servicestack.client;
 
+import com.google.gson.Gson;
 import com.google.gson.JsonDeserializationContext;
 import com.google.gson.JsonDeserializer;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonParseException;
 import com.google.gson.JsonPrimitive;
 import com.google.gson.JsonSerializationContext;
 import com.google.gson.JsonSerializer;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
 
+import java.io.IOException;
 import java.lang.reflect.Type;
 import java.util.Date;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
 import java.util.UUID;
 
 public class JsonSerializers {
@@ -69,4 +80,45 @@ public UUID deserialize(JsonElement json, Type typeOfT, JsonDeserializationConte
             }
         };
     }
+
+    public static class CaseInsensitiveEnumTypeAdapterFactory implements TypeAdapterFactory {
+        public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
+            Class<T> rawType = (Class<T>) type.getRawType();
+            if (!rawType.isEnum()) {
+                return null;
+            }
+
+            final Map<String, T> lowercaseToConstant = new HashMap<String, T>();
+            for (T constant : rawType.getEnumConstants()) {
+                lowercaseToConstant.put(toLowercase(constant), constant);
+            }
+
+            return new TypeAdapter<T>() {
+                public void write(JsonWriter out, T value) throws IOException {
+                    if (value == null) {
+                        out.nullValue();
+                    } else {
+                        out.value(value.toString());
+                    }
+                }
+
+                public T read(JsonReader reader) throws IOException {
+                    if (reader.peek() == JsonToken.NULL) {
+                        reader.nextNull();
+                        return null;
+                    } else {
+                        return lowercaseToConstant.get(toLowercase(reader.nextString()));
+                    }
+                }
+            };
+        }
+
+        private String toLowercase(Object o) {
+            return o.toString().toLowerCase(Locale.US);
+        }
+    }
+
+    public static TypeAdapterFactory getCaseInsensitiveEnumTypeAdapterFactory() {
+        return new CaseInsensitiveEnumTypeAdapterFactory();
+    }
 }

src/AndroidClient/client/src/main/java/net/servicestack/client/JsonServiceClient.java

@@ -66,6 +66,7 @@ public void setTimeout(int timeoutMs) {
 
     public GsonBuilder getGsonBuilder() {
         return new GsonBuilder()
+            .registerTypeAdapterFactory(JsonSerializers.getCaseInsensitiveEnumTypeAdapterFactory())
             .registerTypeAdapter(Date.class, JsonSerializers.getDateSerializer())
             .registerTypeAdapter(Date.class, JsonSerializers.getDateDeserializer())
             .registerTypeAdapter(TimeSpan.class, JsonSerializers.getTimeSpanSerializer())

src/AndroidClient/client/src/test/java/utils/CaseInsensitiveTypeAdapterFactoryTest.java

@@ -0,0 +1,84 @@
+package utils;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import junitparams.JUnitParamsRunner;
+import junitparams.Parameters;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import junit.framework.TestCase;
+
+import net.servicestack.client.JsonSerializers;
+
+import static org.junit.Assert.assertEquals;
+
+enum SodaEnum
+{
+    Coke,
+    Pepsi,
+}
+
+@RunWith(JUnitParamsRunner.class)
+public class CaseInsensitiveTypeAdapterFactoryTest {
+
+    private Gson gson;
+
+    @Before
+    public void forEachTest() {
+        gson = new GsonBuilder()
+                .registerTypeAdapterFactory(new JsonSerializers.CaseInsensitiveEnumTypeAdapterFactory())
+                .create();
+    }
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    private Object[] validDeserializationTests() {
+        return new Object[]{
+                new Object[]{"Pascal case", "Coke", SodaEnum.Coke},
+                new Object[]{"Weird mixed case", "cOKe", SodaEnum.Coke},
+                new Object[]{"lowercase", "pepsi", SodaEnum.Pepsi},
+                new Object[]{"UPPERCASE", "PEPSI", SodaEnum.Pepsi},
+        };
+    }
+
+    @Test
+    @Parameters(method = "validDeserializationTests")
+    public void fromJson_withValidText_ConvertsAsExpected(String reason, String jsonText, SodaEnum expected) {
+        SodaEnum actual = gson.fromJson(jsonText, SodaEnum.class);
+
+        assertEquals(reason, expected, actual);
+    }
+
+    private Object[] invalidDeserializationTests() {
+        return new Object[]{
+                new Object[]{"Null should not deserialize", null},
+                new Object[]{"Unknown type", "SevenUp"},
+        };
+    }
+
+    @Test
+    @Parameters(method = "invalidDeserializationTests")
+    public void fromJson_withInvalidText_ReturnsNull(String reason, String jsonText){
+        SodaEnum actual = gson.fromJson(jsonText, SodaEnum.class);
+        assertEquals(reason, null, actual);
+    }
+
+    private Object[] validSerializationTests() {
+        return new Object[]{
+                new Object[]{SodaEnum.Coke, "\"Coke\""},
+                new Object[]{SodaEnum.Pepsi, "\"Pepsi\""},
+        };
+    }
+
+    @Test
+    @Parameters(method = "validSerializationTests")
+    public void toJson_ConvertsAsExpected(SodaEnum value, String expected) {
+        String actual = gson.toJson(value);
+
+        assertEquals("Serialized to json", expected, actual);
+    }
+}