Test coverage-Corrections

Increase test coverage

Change-Id: I8268d31486b3410fbe8791c6d8c4eed4b237462c
Issue-ID: SDC-1673
Signed-off-by: siddharth0905 <siddharth.singh4@amdocs.com>
Signed-off-by: vempo <vitaliy.emporopulo@amdocs.com>

6 files changed, 729 insertions, 73 deletions

diff --git a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/HeatResourceUtilTest.java b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/HeatResourceUtilTest.java
new file mode 100644
index 0000000000..93f8fc9f23
--- /dev/null
+++ b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/HeatResourceUtilTest.java
@@ -0,0 +1,89 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ * /
+ *
+ */
+
+package org.openecomp.sdc.heat.services;
+
+import java.util.Optional;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
+
+public class HeatResourceUtilTest {
+
+    private static final String ROLE = "role";
+
+    @Test
+    public void testEvaluateNetworkRoleFromResourceIdEmpty() {
+        Assert.assertFalse(HeatResourceUtil.evaluateNetworkRoleFromResourceId(null, null).isPresent());
+    }
+
+    @Test
+    public void testEvaluateNetworkRoleFromResourceIdNeutronExternal() {
+        Optional<String> networkRole = HeatResourceUtil.evaluateNetworkRoleFromResourceId(
+                "vm_type_1_role_port_1", HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource());
+
+        Assert.assertTrue(networkRole.isPresent());
+        Assert.assertEquals(networkRole.get(), ROLE);
+    }
+
+    @Test
+    public void testEvaluateNetworkRoleFromResourceIdNeutronInternal() {
+        Optional<String> networkRole = HeatResourceUtil.evaluateNetworkRoleFromResourceId(
+                "vm_type_1_int_role_port_1", HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource());
+
+        Assert.assertTrue(networkRole.isPresent());
+        Assert.assertEquals(networkRole.get(), ROLE);
+    }
+
+    @Test
+    public void testEvaluateNetworkRoleFromResourceIdVMIExternal() {
+        Optional<String> networkRole = HeatResourceUtil.evaluateNetworkRoleFromResourceId(
+                "vm_type_1_role_vmi_1", HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE
+                        .getHeatResource());
+
+        Assert.assertTrue(networkRole.isPresent());
+        Assert.assertEquals(networkRole.get(), ROLE);
+    }
+
+    @Test
+    public void testEvaluateNetworkRoleFromResourceIdVMIInternal() {
+        Optional<String> networkRole = HeatResourceUtil.evaluateNetworkRoleFromResourceId(
+                "vm_type_1_int_role_vmi_1", HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE
+                        .getHeatResource());
+
+        Assert.assertTrue(networkRole.isPresent());
+        Assert.assertEquals(networkRole.get(), ROLE);
+    }
+
+    @Test
+    public void testExtractNetworkRoleFromSubInterfaceIdEmpty() {
+        Assert.assertFalse(HeatResourceUtil.extractNetworkRoleFromSubInterfaceId(null, null).isPresent());
+    }
+
+    @Test
+    public void testExtractNetworkRoleFromSubInterfaceId() {
+        Optional<String> networkRole = HeatResourceUtil.extractNetworkRoleFromSubInterfaceId(
+                "vm_type_1_subint_role_vmi_1", HeatResourcesTypes.CONTRAIL_V2_VIRTUAL_MACHINE_INTERFACE_RESOURCE_TYPE
+                        .getHeatResource());
+
+        Assert.assertTrue(networkRole.isPresent());
+        Assert.assertEquals(networkRole.get(), ROLE);
+    }
+}
diff --git a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/HeatStructureUtilTest.java b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/HeatStructureUtilTest.java
new file mode 100644
index 0000000000..70f149be2c
--- /dev/null
+++ b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/HeatStructureUtilTest.java
@@ -0,0 +1,146 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ * /
+ *
+ */
+
+package org.openecomp.sdc.heat.services;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.core.validation.types.GlobalValidationContext;
+import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
+
+public class HeatStructureUtilTest {
+
+    @Mock
+    private GlobalValidationContext globalValidationContextMock;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testIsResourceNestedFalse() {
+        Assert.assertFalse(HeatStructureUtil.isNestedResource("Test.txt"));
+    }
+
+    @Test
+    public void testIsResourceNestedNull() {
+        Assert.assertFalse(HeatStructureUtil.isNestedResource(null));
+    }
+
+    @Test
+    public void testIsResourceNestedTrue() {
+        Assert.assertTrue(HeatStructureUtil.isNestedResource("Test.yml"));
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNameAddMessageCall() {
+        Map<String, Object> propertyMap = new HashMap<>();
+        propertyMap.put(ResourceReferenceFunctions.GET_RESOURCE.getFunction(), Collections.emptyList());
+
+        Mockito.doNothing().when(globalValidationContextMock).addMessage(Mockito.anyString(), Mockito.any(),
+                Mockito.anyString());
+
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_RESOURCE.getFunction(), propertyMap, globalValidationContextMock);
+
+        Mockito.verify(globalValidationContextMock, Mockito.times(1))
+                .addMessage(Mockito.anyString(), Mockito.any(), Mockito.anyString());
+        Assert.assertTrue(valueNames.isEmpty());
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNameGetFile() {
+        Map<String, Object> propertyMap = new HashMap<>();
+        propertyMap.put(ResourceReferenceFunctions.GET_FILE.getFunction(), "file:///filename");
+
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_FILE.getFunction(), propertyMap, globalValidationContextMock);
+
+        Assert.assertFalse(valueNames.isEmpty());
+        Assert.assertTrue(valueNames.contains("filename"));
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNameGetFileValueList() {
+        Map<String, Object> propertyMap = new HashMap<>();
+        propertyMap
+                .put(ResourceReferenceFunctions.GET_FILE.getFunction(), Collections.singletonList("file:///filename"));
+
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_FILE.getFunction(), propertyMap, globalValidationContextMock);
+
+        Assert.assertFalse(valueNames.isEmpty());
+        Assert.assertTrue(valueNames.contains("filename"));
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNameGetFileValueListWithAnotherList() {
+        Map<String, Object> propertyMap = new HashMap<>();
+        propertyMap.put(ResourceReferenceFunctions.GET_FILE.getFunction(),
+                Collections.singletonList(Collections.emptyList()));
+
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_FILE.getFunction(), propertyMap, globalValidationContextMock);
+
+        Assert.assertTrue(valueNames.isEmpty());
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNamePassingPropertyMapWithSet() {
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_FILE.getFunction(), Collections.singletonList(new HashSet<>()),
+                globalValidationContextMock);
+
+        Assert.assertTrue(valueNames.isEmpty());
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNameGetFileValueListSet() {
+        Map<String, Object> propertyMap = new HashMap<>();
+        propertyMap.put(ResourceReferenceFunctions.GET_FILE.getFunction(),
+                new HashSet<>());
+
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_FILE.getFunction(), propertyMap, globalValidationContextMock);
+
+        Assert.assertTrue(valueNames.isEmpty());
+    }
+
+    @Test
+    public void testGetReferencedValuesByFunctionNameIncorrectKeyWithSet() {
+        Map<String, Object> propertyMap = new HashMap<>();
+        propertyMap.put("test", new HashSet<>());
+
+        Set<String> valueNames = HeatStructureUtil.getReferencedValuesByFunctionName("Main.yml",
+                ResourceReferenceFunctions.GET_FILE.getFunction(), propertyMap, globalValidationContextMock);
+
+        Assert.assertTrue(valueNames.isEmpty());
+    }
+}
diff --git a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/manifest/ManifestUtilTest.java b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/manifest/ManifestUtilTest.java
new file mode 100644
index 0000000000..13cf5c901e
--- /dev/null
+++ b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/manifest/ManifestUtilTest.java
@@ -0,0 +1,109 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ * /
+ *
+ */
+
+package org.openecomp.sdc.heat.services.manifest;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import org.junit.Assert;
+import org.junit.Test;
+import org.openecomp.sdc.heat.datatypes.manifest.FileData;
+import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
+
+public class ManifestUtilTest {
+
+    @Test
+    public void testGetFileAndItsEnvNull() {
+        Assert.assertTrue(ManifestUtil.getFileAndItsEnv(new ManifestContent()).isEmpty());
+    }
+
+    @Test
+    public void testGetFileAndItsEnv() {
+
+        Assert.assertEquals(ManifestUtil.getFileAndItsEnv(createManifestContent()).size(), 1);
+    }
+
+    @Test
+    public void testGetFileTypeMapDataNull() {
+        Assert.assertTrue(ManifestUtil.getFileTypeMap(new ManifestContent()).isEmpty());
+    }
+
+    @Test
+    public void testGetFileTypeMap() {
+        Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(createManifestContent());
+
+        Assert.assertEquals(fileTypeMap.size(), 2);
+        Assert.assertTrue(fileTypeMap.containsKey("Main.yml") && fileTypeMap.containsKey("Test.yml"));
+    }
+
+    @Test
+    public void testGetFileTypeMapDataBlank() {
+        ManifestContent manifestContent = new ManifestContent();
+        manifestContent.setData(Collections.emptyList());
+
+        Assert.assertTrue(ManifestUtil.getFileTypeMap(manifestContent).isEmpty());
+    }
+
+    @Test
+    public void testGetArtifactsDataNull() {
+        Assert.assertTrue(ManifestUtil.getArtifacts(new ManifestContent()).isEmpty());
+    }
+
+    @Test
+    public void testGetArtifacts() {
+        ManifestContent manifestContent = createManifestContent();
+        manifestContent.getData().get(0).getData().get(0).setType(FileData.Type.OTHER);
+
+        Set<String> typeSet = ManifestUtil.getArtifacts(manifestContent);
+        Assert.assertEquals(typeSet.size(), 1);
+        Assert.assertTrue(typeSet.contains("Test.yml"));
+    }
+
+    @Test
+    public void testGetBaseFilesDataNull() {
+        Assert.assertTrue(ManifestUtil.getArtifacts(new ManifestContent()).isEmpty());
+    }
+
+    @Test
+    public void testGetBaseFiles() {
+        Set<String> typeSet = ManifestUtil.getBaseFiles(createManifestContent());
+        Assert.assertEquals(typeSet.size(), 1);
+        Assert.assertTrue(typeSet.contains("Main.yml"));
+    }
+
+    private ManifestContent createManifestContent() {
+
+        FileData fileData1 = new FileData();
+        fileData1.setFile("Test.yml");
+        fileData1.setType(FileData.Type.HEAT_ENV);
+
+        FileData fileData = new FileData();
+        fileData.setFile("Main.yml");
+        fileData.setType(FileData.Type.HEAT_ENV);
+        fileData.setBase(true);
+
+        fileData.setData(Collections.singletonList(fileData1));
+
+        ManifestContent manifestContent = new ManifestContent();
+        manifestContent.setData(Collections.singletonList(fileData));
+
+        return manifestContent;
+    }
+}
diff --git a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/HeatTreeManagerTest.java b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/HeatTreeManagerTest.java
new file mode 100644
index 0000000000..e3e19792f5
--- /dev/null
+++ b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/HeatTreeManagerTest.java
@@ -0,0 +1,65 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ * /
+ *
+ */
+
+package org.openecomp.sdc.heat.services.tree;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.Test;
+import org.openecomp.core.utilities.file.FileUtils;
+import org.openecomp.sdc.common.utils.SdcCommon;
+import org.openecomp.sdc.heat.datatypes.structure.HeatStructureTree;
+
+public class HeatTreeManagerTest {
+
+    @Test
+    public void testCreateTree() throws IOException {
+        HeatTreeManager heatTreeManager = new HeatTreeManager();
+        addFile(heatTreeManager, "mock/model/MANIFEST.json", SdcCommon.MANIFEST_NAME);
+        addFile(heatTreeManager, "mock/model/first.yaml", "first.yaml");
+        addFile(heatTreeManager, "mock/model/second.yaml", "second.yaml");
+        addFile(heatTreeManager, "mock/model/first.env", "first.env");
+        addFile(heatTreeManager, "mock/model/base_cscf_volume.yaml", "base_cscf_volume.yaml");
+        addFile(heatTreeManager, "mock/model/network.yml", "network.yml");
+        addFile(heatTreeManager, "mock/model/testHeat.yml", "testHeat.yml");
+        addFile(heatTreeManager, "mock/model/nested.yml", "nested.yml");
+        addFile(heatTreeManager, "mock/model/base_cscf_volume.env", "base_cscf_volume.env");
+
+        heatTreeManager.createTree();
+
+        HeatStructureTree heatStructureTree = heatTreeManager.getTree();
+        Assert.assertNotNull(heatStructureTree);
+        Assert.assertEquals(1, heatStructureTree.getHeat().size());
+        Assert.assertEquals(1, heatStructureTree.getNetwork().size());
+    }
+
+    private void addFile(HeatTreeManager heatTreeManager, String fileLocation, String fileName)
+            throws IOException {
+
+        List<URL> urlList = FileUtils.getAllLocations(fileLocation);
+        try (InputStream inputStream = new FileInputStream(new File(urlList.get(0).getPath()))) {
+            heatTreeManager.addFile(fileName, inputStream);
+        }
+    }
+}
diff --git a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/HeatTreeManagerUtilTest.java b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/HeatTreeManagerUtilTest.java
new file mode 100644
index 0000000000..6e34350d19
--- /dev/null
+++ b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/HeatTreeManagerUtilTest.java
@@ -0,0 +1,230 @@
+/*
+ *
+ *  Copyright © 2017-2018 European Support Limited
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  * Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ * /
+ *
+ */
+
+package org.openecomp.sdc.heat.services.tree;
+
+import java.io.File;
+import java.net.URL;
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.core.utilities.file.FileContentHandler;
+import org.openecomp.core.utilities.file.FileUtils;
+import org.openecomp.core.validation.types.GlobalValidationContext;
+import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
+import org.openecomp.sdc.heat.datatypes.model.Resource;
+
+public class HeatTreeManagerUtilTest {
+
+    private static final String TEST_YML = "test.yml";
+    private static final String TEST = "test";
+    private static final String RESOURCE_DEF = "resource_def";
+
+    @Mock
+    private HeatTreeManager heatTreeManager;
+
+    @Before
+    public void setUp() throws Exception {
+        MockitoAnnotations.initMocks(this);
+    }
+
+    @Test
+    public void testInitHeatTreeManager() {
+        FileContentHandler fileContentHandler = getFileContentHandler();
+
+        Mockito.doNothing().when(heatTreeManager).addFile(Mockito.any(), Mockito.any());
+        HeatTreeManagerUtil.initHeatTreeManager(fileContentHandler);
+        Mockito.verify(heatTreeManager, Mockito.times(0)).addFile(Mockito.any(), Mockito.any());
+    }
+
+    @Test
+    public void testGetNestedFiles() {
+        HeatOrchestrationTemplate heatOrchestrationTemplate = new HeatOrchestrationTemplate();
+        heatOrchestrationTemplate.setResources(getResourceMap("Type1.yml"));
+        Set<String> nestedFilesSet = HeatTreeManagerUtil.getNestedFiles(heatOrchestrationTemplate);
+
+        Assert.assertNotNull(nestedFilesSet);
+        Assert.assertEquals(nestedFilesSet.size(), 1);
+    }
+
+    @Test
+    public void testGetResourceDefNested() {
+        HeatOrchestrationTemplate heatOrchestrationTemplate = new HeatOrchestrationTemplate();
+        heatOrchestrationTemplate.setResources(getResourceMap("OS::Heat::ResourceGroup"));
+
+        Set<String> nestedFilesSet = HeatTreeManagerUtil.getNestedFiles(heatOrchestrationTemplate);
+        Assert.assertNotNull(nestedFilesSet);
+        Assert.assertTrue(nestedFilesSet.size() ==  1 && nestedFilesSet.contains(TEST_YML));
+    }
+
+    @Test
+    public void testGetArtifactFiles() {
+        HeatOrchestrationTemplate heatOrchestrationTemplate = new HeatOrchestrationTemplate();
+        heatOrchestrationTemplate.setResources(getResourceMap("Type1.yml"));
+        Set<String> nestedFilesSet = HeatTreeManagerUtil.getArtifactFiles("filename.yml", heatOrchestrationTemplate,
+                null);
+
+        Assert.assertNotNull(nestedFilesSet);
+        Assert.assertTrue(nestedFilesSet.contains(TEST));
+    }
+
+    @Test
+    public void testGetResourceDefIfProvidedResourceIsNull() {
+        Assert.assertNull(HeatTreeManagerUtil.getResourceDef(new Resource()));
+    }
+
+    @Test
+    public void testGetResourceDef() {
+        Resource resource = new Resource();
+
+        Map<String, Object> resourceMap = new HashMap<>();
+        Map<String, String> nestedResourceMap = new HashMap<String, String>() {{
+            put("type", TEST_YML);
+        }};
+
+        resourceMap.put(RESOURCE_DEF, nestedResourceMap);
+        resource.setProperties(resourceMap);
+        Resource resultResource = HeatTreeManagerUtil.getResourceDef(resource);
+        Assert.assertNotNull(resultResource);
+        Assert.assertEquals(TEST_YML, resultResource.getType());
+    }
+
+    @Test
+    public void testCheckResourceGroupTypeValid() {
+        Resource resource = new Resource();
+
+        Map<String, Object> resourceMap = new HashMap<>();
+        Map<String, Object> nestedResourceMap = new HashMap<String, Object>() {{
+            put("type", Collections.emptyList());
+        }};
+
+        resourceMap.put(RESOURCE_DEF, nestedResourceMap);
+        resource.setProperties(resourceMap);
+
+        GlobalValidationContext globalValidationContextMock = Mockito.mock(GlobalValidationContext.class);
+        Mockito.doNothing().when(globalValidationContextMock).addMessage(Mockito.anyString(), Mockito.any(), Mockito
+                .anyString());
+
+        HeatTreeManagerUtil.checkResourceGroupTypeValid(TEST_YML, TEST, resource, globalValidationContextMock);
+
+        Mockito.verify(globalValidationContextMock, Mockito.times(1))
+                .addMessage(Mockito.anyString(), Mockito.any(), Mockito.anyString());
+    }
+
+    @Test
+    public void testCheckResourceTypeValid() {
+        Resource resource = new Resource();
+
+        Map<String, Object> resourceMap = new HashMap<>();
+        Map<String, Object> nestedResourceMap = new HashMap<String, Object>() {{
+            put("properties", Collections.emptyList());
+        }};
+
+        resourceMap.put(RESOURCE_DEF, nestedResourceMap);
+        resource.setProperties(resourceMap);
+
+        GlobalValidationContext globalValidationContextMock = Mockito.mock(GlobalValidationContext.class);
+        Mockito.doNothing().when(globalValidationContextMock).addMessage(Mockito.anyString(), Mockito.any(), Mockito
+                .anyString());
+
+        HeatTreeManagerUtil.checkResourceTypeValid(TEST_YML, TEST, resource, globalValidationContextMock);
+
+        Mockito.verify(globalValidationContextMock, Mockito.times(1))
+                .addMessage(Mockito.anyString(), Mockito.any(), Mockito.anyString());
+    }
+
+    @Test
+    public void testCheckIfResourceGroupTypeIsNested() {
+        Resource resource = new Resource();
+
+        Map<String, Object> resourceMap = new HashMap<>();
+        Map<String, Object> nestedResourceMap = new HashMap<String, Object>() {{
+            put("type", TEST_YML);
+        }};
+
+        resourceMap.put(RESOURCE_DEF, nestedResourceMap);
+        resource.setProperties(resourceMap);
+
+        GlobalValidationContext globalValidationContextMock = Mockito.mock(GlobalValidationContext.class);
+        Mockito.doNothing().when(globalValidationContextMock).addMessage(Mockito.anyString(), Mockito.any(), Mockito
+                .anyString());
+
+        boolean result = HeatTreeManagerUtil
+                .checkIfResourceGroupTypeIsNested(TEST_YML, TEST, resource, globalValidationContextMock);
+
+        Mockito.verify(globalValidationContextMock, Mockito.times(1))
+                .addMessage(Mockito.anyString(), Mockito.any(), Mockito.anyString());
+
+        Assert.assertTrue(result);
+    }
+
+    @Test
+    public void testCheckIfResourceGroupTypeIsNestedNull() {
+        Assert.assertFalse(HeatTreeManagerUtil.checkIfResourceGroupTypeIsNested(TEST_YML, TEST, new Resource(),
+                null));
+    }
+
+    private FileContentHandler getFileContentHandler() {
+        FileContentHandler fileContentHandler = new FileContentHandler();
+        Map<String, byte[]> filesByteMap = new HashMap<>();
+        List<URL> urlList = FileUtils.getAllLocations("mock/model");
+        File files = new File(urlList.get(0).getPath());
+        if (files.isDirectory()) {
+            int fileCount = 0;
+            for (File file : Objects.requireNonNull(files.listFiles())) {
+                byte[] bytesArray = new byte[(int) file.length()];
+                filesByteMap.put("File" + ++fileCount, bytesArray);
+            }
+        }
+
+        fileContentHandler.setFiles(filesByteMap);
+
+        return fileContentHandler;
+    }
+
+    private Map<String, Resource> getResourceMap(String type) {
+        Resource resource = new Resource();
+        resource.setType(type);
+        Map<String, String> map = new HashMap<>();
+        map.put("get_file", TEST);
+        resource.setProperties(new HashMap<String, Object>() {{
+            put("get_file", Collections.singletonList(map));
+            put("resource_def", new HashMap<String, Object>() {{
+                put("type", TEST_YML);
+            }});
+        }});
+
+
+        return Stream.of(new AbstractMap.SimpleEntry<>("Res1", resource))
+                .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
+    }
+}
diff --git a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/ToscaTreeManagerTest.java b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/ToscaTreeManagerTest.java
index 0cfac52318..4ccf7ea623 100644
--- a/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/ToscaTreeManagerTest.java
+++ b/openecomp-be/lib/openecomp-heat-lib/src/test/java/org/openecomp/sdc/heat/services/tree/ToscaTreeManagerTest.java
@@ -1,86 +1,103 @@
+/*
+ * Copyright © 2017-2018 European Support Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ **/
+
 package org.openecomp.sdc.heat.services.tree;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.regex.Pattern;
+
 import org.junit.Assert;
 import org.junit.Test;
 import org.openecomp.core.utilities.file.FileUtils;
 import org.openecomp.core.utilities.json.JsonUtil;
 import org.openecomp.sdc.heat.datatypes.structure.HeatStructureTree;
 
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.util.regex.Pattern;
-
 public class ToscaTreeManagerTest {
-  private static final String BASE_DIR = "/mock/toscaTree/";
-  private static final String IN = "in";
-  private static final String OUT = "out";
-  private static final String EXPECTED_TREE_FILE = "/expectedTree.json";
-  private ToscaTreeManager toscaTreeManager = new ToscaTreeManager();
-
-  @Test
-  public void testTreeWithDiffFileNames() throws IOException {
-    String inputDirectory = BASE_DIR + "diffFileNames/" + IN;
-    String outputFileName = BASE_DIR + "diffFileNames/" + OUT + EXPECTED_TREE_FILE;
-
-    testTreeManager(inputDirectory, outputFileName);
-  }
-
-  @Test
-  public void testDirectoriesWithSimilarNameUnderDifferentRoots() throws IOException {
-    String inputDirectory = BASE_DIR + "similarDirectoryName/" + IN;
-    String outputFileName = BASE_DIR + "similarDirectoryName/" + OUT + EXPECTED_TREE_FILE;
-
-    testTreeManager(inputDirectory, outputFileName);
-  }
-
-  @Test
-  public void testTwoFilesUnderSameDirectory() throws IOException {
-    String inputDirectory = BASE_DIR + "twoFilesUnderSameDirectory/" + IN;
-    String outputFileName = BASE_DIR + "twoFilesUnderSameDirectory/" + OUT + EXPECTED_TREE_FILE;
-
-    testTreeManager(inputDirectory, outputFileName);
-  }
-
-  private void testTreeManager(String inputDirectory, String outputFileName) throws IOException {
-    initTreeManager(inputDirectory);
-    toscaTreeManager.createTree();
-    HeatStructureTree tree = toscaTreeManager.getTree();
-
-    validateToscaTree(outputFileName, tree);
-  }
-
-  private void validateToscaTree(String outputFileName, HeatStructureTree tree) throws IOException {
-    String actualTree = JsonUtil.object2Json(tree);
-    File expectedTreeFile = new File(this.getClass().getResource(outputFileName).getFile());
-
-    String expectedTree;
-    try(FileInputStream fis = new FileInputStream(expectedTreeFile)) {
-      expectedTree = new String(FileUtils.toByteArray(fis));
+
+    private static final String BASE_DIR = "/mock/toscaTree/";
+    private static final String IN = "in";
+    private static final String OUT = "out";
+    private static final String EXPECTED_TREE_FILE = "/expectedTree.json";
+    private ToscaTreeManager toscaTreeManager = new ToscaTreeManager();
+
+    @Test
+    public void testTreeWithDiffFileNames() throws IOException {
+        String inputDirectory = BASE_DIR + "diffFileNames/" + IN;
+        String outputFileName = BASE_DIR + "diffFileNames/" + OUT + EXPECTED_TREE_FILE;
+
+        testTreeManager(inputDirectory, outputFileName);
+    }
+
+    @Test
+    public void testDirectoriesWithSimilarNameUnderDifferentRoots() throws IOException {
+        String inputDirectory = BASE_DIR + "similarDirectoryName/" + IN;
+        String outputFileName = BASE_DIR + "similarDirectoryName/" + OUT + EXPECTED_TREE_FILE;
+
+        testTreeManager(inputDirectory, outputFileName);
+    }
+
+    @Test
+    public void testTwoFilesUnderSameDirectory() throws IOException {
+        String inputDirectory = BASE_DIR + "twoFilesUnderSameDirectory/" + IN;
+        String outputFileName = BASE_DIR + "twoFilesUnderSameDirectory/" + OUT + EXPECTED_TREE_FILE;
+
+        testTreeManager(inputDirectory, outputFileName);
     }
-    Assert.assertNotNull(expectedTree);
-    expectedTree = expectedTree.trim().replace("\r", "");
-    Assert.assertEquals(expectedTree, actualTree);
-  }
-
-  private void initTreeManager(String inputDir) throws IOException {
-    String fileName = inputDir.replace("/", File.separator);
-    File directory = new File(this.getClass().getResource(inputDir).getFile());
-
-    addFilesToTreeManager(fileName, directory.listFiles());
-  }
-
-  private void addFilesToTreeManager(String baseDir, File[] listFiles) throws IOException {
-    for (File file : listFiles) {
-      if (file.isDirectory()) {
-        addFilesToTreeManager(baseDir, file.listFiles());
-      } else {
-        toscaTreeManager.addFile(getFileNameWithoutTestDirectory(baseDir, file.getPath()), new byte[2]);
-      }
+
+    private void testTreeManager(String inputDirectory, String outputFileName) throws IOException {
+        initTreeManager(inputDirectory);
+        toscaTreeManager.createTree();
+        HeatStructureTree tree = toscaTreeManager.getTree();
+
+        validateToscaTree(outputFileName, tree);
     }
-  }
 
-  private String getFileNameWithoutTestDirectory(String baseDir, String fileName) {
-    return fileName.split(Pattern.quote(baseDir) + Pattern.quote(File.separator))[1];
-  }
+    private void validateToscaTree(String outputFileName, HeatStructureTree tree) throws IOException {
+        File expectedTreeFile = new File(this.getClass().getResource(outputFileName).getFile());
+
+        String expectedTree;
+        try (FileInputStream fis = new FileInputStream(expectedTreeFile)) {
+            expectedTree = new String(FileUtils.toByteArray(fis));
+        }
+        Assert.assertNotNull(expectedTree);
+        expectedTree = expectedTree.trim().replace("\r", "");
+        String actualTree = JsonUtil.object2Json(tree);
+        Assert.assertEquals(expectedTree, actualTree);
+    }
+
+    private void initTreeManager(String inputDir) {
+        String fileName = inputDir.replace("/", File.separator);
+        File directory = new File(this.getClass().getResource(inputDir).getFile());
+
+        addFilesToTreeManager(fileName, directory.listFiles());
+    }
+
+    private void addFilesToTreeManager(String baseDir, File[] listFiles) {
+        for (File file : listFiles) {
+            if (file.isDirectory()) {
+                addFilesToTreeManager(baseDir, file.listFiles());
+            } else {
+                toscaTreeManager.addFile(getFileNameWithoutTestDirectory(baseDir, file.getPath()), new byte[2]);
+            }
+        }
+    }
+
+    private String getFileNameWithoutTestDirectory(String baseDir, String fileName) {
+        return fileName.split(Pattern.quote(baseDir) + Pattern.quote(File.separator))[1];
+    }
 }
\ No newline at end of file