Add Map<String, Object> support to JsonEncoder. (#1017)

Author: vkryachko

encoders/firebase-encoders/src/main/java/com/google/firebase/encoders/json/JsonValueObjectEncoderContext.java

@@ -192,6 +192,25 @@ JsonValueObjectEncoderContext add(@Nullable Object o) throws IOException, Encodi
       jsonWriter.endArray();
       return this;
     }
+    if (o instanceof Map) {
+      @SuppressWarnings("unchecked")
+      Map<Object, Object> map = (Map<Object, Object>) o;
+      jsonWriter.beginObject();
+      for (Map.Entry<Object, Object> entry : map.entrySet()) {
+        Object key = entry.getKey();
+        try {
+          add((String) key, entry.getValue());
+        } catch (ClassCastException ex) {
+          throw new EncodingException(
+              String.format(
+                  "Only String keys are currently supported in maps, got %s of type %s instead.",
+                  key, key.getClass()),
+              ex);
+        }
+      }
+      jsonWriter.endObject();
+      return this;
+    }
     @SuppressWarnings("unchecked") // safe because get the encoder by checking the object's type.
     ObjectEncoder<Object> objectEncoder = (ObjectEncoder<Object>) objectEncoders.get(o.getClass());
     if (objectEncoder != null) {

encoders/firebase-encoders/src/test/java/com/google/firebase/encoders/json/JsonValueObjectEncoderContextTest.java

@@ -15,6 +15,7 @@
 package com.google.firebase.encoders.json;
 
 import static com.google.common.truth.Truth.assertThat;
+import static org.junit.Assert.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
@@ -29,8 +30,8 @@
 import java.io.Writer;
 import java.nio.charset.Charset;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.TimeZone;
-import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
@@ -204,6 +205,38 @@ public void testEncodingCollection() throws IOException, EncodingException {
                 "[{\"Name\":\"innerClass\"},{\"Name\":\"innerClass\"}]"));
   }
 
+  @Test
+  public void testEncodingMap_withStringKey_shouldSucceed() throws EncodingException {
+    ObjectEncoder<DummyClass> objectEncoder =
+        (o, ctx) -> {
+          ctx.add("map", Collections.singletonMap("key", true));
+        };
+
+    String result =
+        new JsonDataEncoderBuilder()
+            .registerEncoder(DummyClass.class, objectEncoder)
+            .build()
+            .encode(DummyClass.INSTANCE);
+
+    assertThat(result).isEqualTo(String.format("{\"map\":%s}", "{\"key\":true}"));
+  }
+
+  @Test
+  public void testEncodingMap_withNonStringKey_shouldFail() {
+    ObjectEncoder<DummyClass> objectEncoder =
+        (o, ctx) -> {
+          ctx.add("map", Collections.singletonMap(1L, true));
+        };
+
+    DataEncoder encoder =
+        new JsonDataEncoderBuilder().registerEncoder(DummyClass.class, objectEncoder).build();
+
+    assertThrows(
+        "Only String keys are currently supported in maps",
+        EncodingException.class,
+        () -> encoder.encode(DummyClass.INSTANCE));
+  }
+
   @Test
   public void testEncodingBytes() throws IOException, EncodingException {
     ObjectEncoder<DummyClass> objectEncoder =
@@ -336,7 +369,7 @@ public void testEncodingComplexTypes_InnerExtendedEncoder()
   @Test
   public void testMissingEncoder() throws IOException, EncodingException {
     DataEncoder dataEncoder = new JsonDataEncoderBuilder().build();
-    Assert.assertThrows(EncodingException.class, () -> dataEncoder.encode(DummyClass.INSTANCE));
+    assertThrows(EncodingException.class, () -> dataEncoder.encode(DummyClass.INSTANCE));
   }
 
   @Test
@@ -345,7 +378,7 @@ public void testEncoderError() throws IOException, EncodingException {
     Writer mockWriter = mock(Writer.class);
     doThrow(IOException.class).when(mockWriter).write(any(String.class));
 
-    Assert.assertThrows(
+    assertThrows(
         IOException.class,
         () ->
             new JsonDataEncoderBuilder()