bug fixes for Structure and better tests

Author: rgrassian-split

src/main/java/io/split/openfeature/SplitProvider.java

@@ -14,7 +14,8 @@
 import io.split.client.SplitClient;
 import io.split.openfeature.utils.Serialization;
 
-import java.util.HashMap;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeParseException;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -127,11 +128,8 @@ public ProviderEvaluation<Structure> getObjectEvaluation(String key, Structure d
       if (noTreatment(evaluated)) {
         return constructProviderEvaluation(defaultTreatment, evaluated, Reason.DEFAULT, ErrorCode.FLAG_NOT_FOUND.name());
       }
-      Structure structure = new Structure();
       Map<String, Object> rawMap = Serialization.stringToMap(evaluated);
-      for (Map.Entry<String, Object> rawEntry : rawMap.entrySet()) {
-        structure.add(rawEntry.getKey(),(String) rawEntry.getValue());
-      }
+      Structure structure = mapToStructure(rawMap);
       return constructProviderEvaluation(structure, evaluated);
     } catch (OpenFeatureError e) {
       throw e;
@@ -173,17 +171,12 @@ private <T> ProviderEvaluation<T> constructProviderEvaluation(T value, String va
   }
 
   private Map<String, Object> getMapFromStructMap(Map<String, Value> structMap) {
-    Map<String, Object> toReturn = new HashMap<>();
-    for (Map.Entry<String, Value> entry : structMap.entrySet()) {
-      String key = entry.getKey();
-      Value value = entry.getValue();
-      toReturn.put(key, getInnerValue(value));
-    }
-    return toReturn;
+    return structMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> getInnerValue(e.getValue())));
   }
 
-  private Map<String, Object> getMapFromStructure(Structure structure) {
-    return getMapFromStructMap(structure.asMap());
+  private Structure mapToStructure(Map<String, Object> map) {
+    return new Structure(
+      map.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> objectToValue(e.getValue()))));
   }
 
   private Object getInnerValue(Value value) {
@@ -205,19 +198,49 @@ private Object getInnerValue(Value value) {
     }
     object = value.asZonedDateTime();
     if (object != null) {
-      return object.toString();
+      return object;
     }
     object = value.asStructure();
     if (object != null) {
       // must return a map
-      return getMapFromStructure((Structure) object);
+      return getMapFromStructMap(((Structure) object).asMap());
     }
     object = value.asList();
     if (object != null) {
       // must return a list of inner objects
       List<Value> values = (List<Value>) object;
       return values.stream().map(this::getInnerValue).collect(Collectors.toList());
     }
-    return null;
+    throw new ClassCastException("Could not get inner value from Value object.");
+  }
+
+  private Value objectToValue(Object object) {
+    if (object instanceof Value) {
+      return (Value) object;
+    } else if (object instanceof String) {
+      // try to parse to zoned date time, otherwise use as string
+      try {
+        return new Value(ZonedDateTime.parse((String) object));
+      } catch (DateTimeParseException e) {
+        return new Value((String) object);
+      }
+    } else if (object instanceof Boolean) {
+      return new Value((Boolean) object);
+    } else if (object instanceof Integer) {
+      return new Value((Integer) object);
+    } else if (object instanceof Double) {
+      return new Value((Double) object);
+    } else if (object instanceof Structure) {
+      return new Value((Structure) object);
+    } else if (object instanceof List) {
+      // need to translate each elem in list to a value
+      return new Value(((List<Object>) object).stream().map(this::objectToValue).collect(Collectors.toList()));
+    } else if (object instanceof ZonedDateTime) {
+      return new Value((ZonedDateTime) object);
+    } else if (object instanceof Map) {
+      return new Value(mapToStructure((Map<String, Object>) object));
+    } else {
+      throw new ClassCastException("Could not cast Object to Value");
+    }
   }
 }

src/test/java/io/split/openfeature/SplitProviderTest.java

@@ -13,6 +13,9 @@
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.List;
 import java.util.Map;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -400,6 +403,48 @@ public void evalStructureRegularTest() {
     assertEquals(treatment, response.getValue());
   }
 
+  @Test
+  public void evalStructureComplexTest() {
+    // an object treatment should eval to that object
+    SplitProvider splitProvider = new SplitProvider(mockSplitClient);
+
+    String flagName = "flagName";
+    ZonedDateTime zonedDateTime = ZonedDateTime.of(2020, 1, 10, 0, 0, 0, 0, ZoneId.of("UTC"));
+    Structure treatment = new Structure(Map.of(
+      "string", new Value("blah"),
+      "int", new Value(10),
+      "double", new Value(100D),
+      "bool", new Value(true),
+      "struct", new Value(
+        new Structure(Map.of(
+          "foo", new Value("bar"),
+          "baz", new Value(10),
+          "innerMap", new Value(
+            new Structure(Map.of(
+              "aa", new Value("bb"))))))),
+      "list", new Value(
+        List.of(
+          new Value(1),
+          new Value(true),
+          new Value(
+            new Structure(Map.of(
+              "cc", new Value("dd")
+            ))),
+          new Value(
+            new Structure(Map.of(
+              "ee", new Value(1)
+            ))))),
+      "dateTime", new Value(zonedDateTime)
+    ));
+    String treatmentAsString = "{\"string\":\"blah\",\"int\":10,\"double\":100.0,\"bool\":true, \"struct\":{\"foo\":\"bar\",\"baz\":10,\"innerMap\":{\"aa\":\"bb\"}},\"list\":[1,true,{\"cc\":\"dd\"},{\"ee\":1}],\"dateTime\":\"2020-01-10T00:00Z[UTC]\"}";
+
+    when(mockSplitClient.getTreatment(eq(key), eq(flagName), anyMap())).thenReturn(treatmentAsString);
+
+    ProviderEvaluation<Structure> response =
+      splitProvider.getObjectEvaluation(flagName, new Structure(Map.of("foo", new Value("bar"))), evaluationContext);
+    assertEquals(treatment, response.getValue());
+  }
+
   @Test
   public void evalStructureErrorTest() {
     // a treatment that can not be converted to the required object should throw an error