Support complex types in interface operation inputs

[sdc.git] / catalog-model / src / test / java / org / openecomp / sdc / be / model / tosca / converters / ToscaValueBaseConverterTest.java

diff --git a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaValueBaseConverterTest.java b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaValueBaseConverterTest.java
index 0923f8e..179d3cf 100644 (file)
--- a/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaValueBaseConverterTest.java
+++ b/catalog-model/src/test/java/org/openecomp/sdc/be/model/tosca/converters/ToscaValueBaseConverterTest.java
@@ -20,41 +20,46 @@
 
 package org.openecomp.sdc.be.model.tosca.converters;
 
-import com.google.gson.JsonPrimitive;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import org.junit.jupiter.api.Test;
-
 
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
 import java.util.HashMap;
 import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
 
 
-public class ToscaValueBaseConverterTest {
+class ToscaValueBaseConverterTest {
 
-    private ToscaValueBaseConverter converter = new ToscaValueBaseConverter();
+    private final ToscaValueBaseConverter converter = new ToscaValueBaseConverter();
 
     @Test
-    public void testJson2JavaPrimitive() throws Exception {
+    void testJson2JavaPrimitive() {
         JsonPrimitive prim1 = new JsonPrimitive(Boolean.FALSE);
         Object res1 = converter.json2JavaPrimitive(prim1);
         assertFalse((Boolean)res1);
 
         JsonPrimitive prim2 = new JsonPrimitive("Test");
         Object res2 = converter.json2JavaPrimitive(prim2);
-        assertTrue(res2.equals("Test"));
+        assertEquals("Test", res2);
 
         JsonPrimitive prim3 = new JsonPrimitive(3);
         Object res3 = converter.json2JavaPrimitive(prim3);
-        assertTrue((Integer)res3 == 3);
+        assertEquals(3, (int) (Integer) res3);
 
         JsonPrimitive prim4 = new JsonPrimitive(3.6);
         Object res4 = converter.json2JavaPrimitive(prim4);
-        assertTrue((Double)res4 == 3.6);
+        assertEquals(3.6, (Double) res4);
     }
 
     @Test
-    public void testIsEmptyObjectValue() throws Exception {
+    void testIsEmptyObjectValue() {
         boolean res1 = ToscaValueBaseConverter.isEmptyObjectValue(null);
         assertTrue(res1);
 
@@ -70,4 +75,74 @@ public class ToscaValueBaseConverterTest {
         boolean res5 = ToscaValueBaseConverter.isEmptyObjectValue("test");
         assertFalse(res5);
     }
+
+    @Test
+    void testHandleComplexJsonValue() {
+        JsonObject innerObject = new JsonObject();
+        innerObject.addProperty("string", "stringValue");
+        innerObject.addProperty("int", 1);
+        innerObject.addProperty("float", 1.1);
+        innerObject.add("null", null);
+
+        JsonArray jsonArray1 = new JsonArray();
+        jsonArray1.add(innerObject);
+        jsonArray1.add(innerObject);
+        jsonArray1.add(innerObject);
+
+        JsonArray jsonArray2 = new JsonArray();
+        jsonArray2.add("value0");
+        jsonArray2.add("value1");
+        jsonArray2.add("value2");
+
+        JsonObject jsonObject = new JsonObject();
+        jsonObject.add("objectProperty", innerObject);
+        jsonObject.add("arrayProperty1", jsonArray1);
+        jsonObject.add("arrayProperty2", jsonArray2);
+        jsonObject.addProperty("stringProperty", "stringPropertyValue");
+
+        final Object resultingObject = converter.handleComplexJsonValue(jsonObject);
+        assertTrue(resultingObject instanceof Map);
+        final Map<String, Object> jsonObjectAsMap = (Map<String, Object>) resultingObject;
+        assertEquals(4, jsonObjectAsMap.keySet().size());
+        assertTrue(jsonObjectAsMap.containsKey("objectProperty"));
+        assertTrue(jsonObjectAsMap.containsKey("arrayProperty1"));
+        assertTrue(jsonObjectAsMap.containsKey("arrayProperty2"));
+        assertTrue(jsonObjectAsMap.containsKey("stringProperty"));
+
+        final String stringProperty = (String) jsonObjectAsMap.get("stringProperty");
+        assertEquals(jsonObject.get("stringProperty").getAsString(), stringProperty);
+
+        final Object arrayProperty1 = jsonObjectAsMap.get("arrayProperty1");
+        assertTrue(arrayProperty1 instanceof List);
+        final List<Object> arrayProperty1AsList = (List<Object>) arrayProperty1;
+        assertEquals(3, arrayProperty1AsList.size());
+        for (int i = 0; i < arrayProperty1AsList.size(); i++) {
+            final Object actualElement = arrayProperty1AsList.get(i);
+            assertTrue(actualElement instanceof Map);
+            final Map<String, Object> actualElementAsMap = (Map<String, Object>) actualElement;
+            final JsonObject expectedJsonObject = jsonArray1.get(i).getAsJsonObject();
+            assertEquals(expectedJsonObject.get("string").getAsString(), actualElementAsMap.get("string"));
+            assertEquals(expectedJsonObject.get("int").getAsInt(), actualElementAsMap.get("int"));
+            assertEquals(expectedJsonObject.get("float").getAsDouble(), actualElementAsMap.get("float"));
+            assertNull(actualElementAsMap.get("null"));
+        }
+
+        final Object arrayProperty2 = jsonObjectAsMap.get("arrayProperty2");
+        assertTrue(arrayProperty2 instanceof List);
+        final List<String> arrayProperty2AsList = (List<String>) arrayProperty2;
+        assertEquals(3, arrayProperty2AsList.size());
+        for (int i = 0; i < arrayProperty2AsList.size(); i++) {
+            assertEquals("value" + i, arrayProperty2AsList.get(i));
+        }
+
+        final Object objectProperty = jsonObjectAsMap.get("objectProperty");
+        assertTrue(objectProperty instanceof Map);
+        final Map<String, Object> objectPropertyAsMap = (Map<String, Object>) objectProperty;
+        assertEquals(4, objectPropertyAsMap.keySet().size());
+        assertTrue(objectPropertyAsMap.containsKey("string"));
+        assertEquals(innerObject.get("string").getAsString(), objectPropertyAsMap.get("string"));
+        assertEquals(innerObject.get("int").getAsInt(), objectPropertyAsMap.get("int"));
+        assertEquals(innerObject.get("float").getAsDouble(), objectPropertyAsMap.get("float"));
+        assertNull(objectPropertyAsMap.get("null"));
+    }
 }