1 files changed, 197 insertions, 0 deletions
diff --git a/src/test/java/org/onap/sdc/tosca/parser/impl/ToscaParserNodeTemplateMockTest.java b/src/test/java/org/onap/sdc/tosca/parser/impl/ToscaParserNodeTemplateMockTest.java
new file mode 100644
index 0000000..ae9f5b3
--- /dev/null
+++ b/src/test/java/org/onap/sdc/tosca/parser/impl/ToscaParserNodeTemplateMockTest.java
@@ -0,0 +1,197 @@
+package org.onap.sdc.tosca.parser.impl;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.sdc.tosca.parser.api.ISdcCsarHelper;
+import org.onap.sdc.tosca.parser.enums.PropertySchemaType;
+import org.onap.sdc.tosca.parser.utils.PropertyUtils;
+import org.onap.sdc.toscaparser.api.NodeTemplate;
+import org.onap.sdc.toscaparser.api.Property;
+import org.onap.sdc.toscaparser.api.ToscaTemplate;
+import org.onap.sdc.toscaparser.api.elements.Metadata;
+
+import java.util.LinkedHashMap;
+import java.util.NoSuchElementException;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertFalse;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ToscaParserNodeTemplateMockTest {
+    @Mock
+    private NodeTemplate nodeTemplate;
+
+    @Mock
+    private Metadata metadata;
+
+    @Mock
+    private ToscaTemplate toscaTemplate;
+
+    @Mock
+    private Property property;
+
+    private static final String dataTypeA = String.format(".%s.aaa", PropertySchemaType.DATATYPE.getSchemaTypeName());
+    private static final String dataTypeB = String.format(".%s.bbb", PropertySchemaType.DATATYPE.getSchemaTypeName());
+    private static final String dataTypeD = String.format(".%s.ddd", PropertySchemaType.DATATYPE.getSchemaTypeName());
+    private static final String dataTypeR = String.format(".%s.rrr", PropertySchemaType.DATATYPE.getSchemaTypeName());
+
+    @Before
+    public void setUp() {
+        when(property.getType()).thenReturn(dataTypeA);
+    }
+
+
+    @Test
+    public void verifyCorrectPropertyPath() {
+        String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
+        LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "q", PropertySchemaType.STRING.getSchemaTypeName());
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(cProp)
+                .thenReturn(dProp);
+
+        assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+    @Test
+    public void verifyPropertyPathWithMapOfStringsType() {
+        String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.MAP.getSchemaTypeName());
+        LinkedHashMap<String, Object> dProp = fillDataTypeEntry(PropertySchemaType.MAP.getSchemaTypeName(), "q", PropertySchemaType.STRING.getSchemaTypeName());
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(cProp)
+                .thenReturn(dProp);
+
+        assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+    @Test
+    public void verifyPropertyPathWithMapType() {
+        String[] path = String.format("%s#%s#%s", "x", "y", "z").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.MAP.getSchemaTypeName());
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(cProp);
+
+        assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+
+    @Test
+    public void verifyPropertyPathWithListOfDataTypeShouldBeRejected() {
+        String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "m").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
+        LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "m", PropertySchemaType.LIST.getSchemaTypeName(), dataTypeR);
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(cProp)
+                .thenReturn(dProp);
+
+        assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+    @Test
+    public void verifyPropertyPathWithListOfIntegersAsType() {
+        String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "m").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> cProp = fillDataTypeEntry(dataTypeB, "z", dataTypeD);
+        LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeD, "m", PropertySchemaType.LIST.getSchemaTypeName(), PropertySchemaType.INTEGER.getSchemaTypeName());
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(cProp)
+                .thenReturn(dProp);
+
+        assertTrue(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+    @Test
+    public void propertyPathIsRejectedAsShorterThanExpected() {
+        String[] path = String.format("%s#%s", "x", "y").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.STRING.getSchemaTypeName());
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(dProp);
+
+        assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void propertyPathIsRejectedAsLongerThanExpected() {
+        String[] path = String.format("%s#%s#%s#%s", "x", "y", "z", "q").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "y", dataTypeB);
+        LinkedHashMap<String, Object> dProp = fillDataTypeEntry(dataTypeB, "z", PropertySchemaType.STRING.getSchemaTypeName());
+
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp)
+                .thenReturn(dProp);
+
+        PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property);
+    }
+
+    @Test(expected = NoSuchElementException.class)
+    public void propertyPathIsRejectedAsPropertyIsNotFound() {
+        String[] path = String.format("%s#%s", "x", "y").split("#");
+        LinkedHashMap<String, Object> bProp = fillDataTypeEntry(dataTypeA, "t", dataTypeB);
+        when(nodeTemplate.getCustomDef())
+                .thenReturn(bProp);
+
+        assertFalse(PropertyUtils.isPropertyTypeSimpleOrListOfSimpleTypes(nodeTemplate, path, property));
+    }
+
+    @Test
+    public void verifyNodeTypeIsNotSupported() {
+        when(nodeTemplate.getMetaData()).thenReturn(metadata);
+        when(metadata.getValue(SdcPropertyNames.PROPERTY_NAME_TYPE)).thenReturn("VFC-TEST");
+
+        ISdcCsarHelper sdcCsarHelper = new SdcCsarHelperImpl(toscaTemplate);
+        assertFalse(sdcCsarHelper.isNodeTypeSupported(nodeTemplate));
+    }
+
+
+    private LinkedHashMap<String, Object> fillDataTypeEntry(String dataTypeName, String propertyName, String type) {
+        return fillDataTypeEntry(dataTypeName, propertyName, type, "");
+    }
+
+    private LinkedHashMap<String, Object> fillDataTypeEntry(String dataTypeName, String propertyName, String type, String entrySchemaType) {
+        LinkedHashMap<String, Object> dataTypes = new LinkedHashMap<>();
+        LinkedHashMap<String, Object> properties = new LinkedHashMap<>();
+        LinkedHashMap<String, Object> property = new LinkedHashMap<>();
+        LinkedHashMap<String, Object> dataType = new LinkedHashMap<>();
+        property.put(SdcPropertyNames.PROPERTY_NAME_TYPE, type);
+        property.put(SdcPropertyNames.PROPERTY_NAME_NAME, propertyName);
+
+        PropertySchemaType propertySchemaType = PropertySchemaType.getEnumByValue(type);
+
+        if (!StringUtils.isEmpty(entrySchemaType) &&
+                (propertySchemaType.getSchemaTypeComplexity() == PropertySchemaType.PropertySchemaComplexity.Complex)) {
+            LinkedHashMap<String, Object> entry_schema = new LinkedHashMap<>();
+            entry_schema.put(SdcPropertyNames.PROPERTY_NAME_TYPE, entrySchemaType);
+            property.put(SdcPropertyNames.PROPERTY_NAME_ENTRY_SCHEMA, entry_schema);
+        }
+        properties.put(propertyName, property);
+        dataType.put(SdcPropertyNames.PROPERTY_NAME_PROPERTIES,  properties);
+        dataTypes.put(dataTypeName, dataType);
+        return dataTypes;
+    }
+
+
+
+}