Raised JUnit coverage for tosca package

Raised JUnit coverage for package: sdc.be.tosca

Change-Id: Ib372b546b7ab19f1b1642d93ff58d7773d7a2d14
Issue-ID: SDC-1333
Signed-off-by: Idan Amit <ia096e@intl.att.com>

7 files changed, 3231 insertions, 306 deletions

diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabiltyRequirementConvertorTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabiltyRequirementConvertorTest.java
index b00bd0f6b1..5f051b7970 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabiltyRequirementConvertorTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CapabiltyRequirementConvertorTest.java
@@ -1,5 +1,4 @@
 package org.openecomp.sdc.be.tosca;
-//
 
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -9,116 +8,689 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
 
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.model.CapabilityDefinition;
 import org.openecomp.sdc.be.model.Component;
 import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.RequirementDefinition;
 import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.tosca.ToscaUtils.SubstituitionEntry;
+import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
+import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
+import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
+import org.openecomp.sdc.be.tosca.model.ToscaTemplateCapability;
+
+import fj.data.Either;
+import mockit.Deencapsulation;
 
 public class CapabiltyRequirementConvertorTest {
 
-    CapabiltyRequirementConvertor capabiltyRequirementConvertor =  Mockito.spy(new CapabiltyRequirementConvertor());
-    ComponentInstance instanceProxy  =  Mockito.spy( new ComponentInstance() );
-    ComponentInstance vfInstance  =  Mockito.spy( new ComponentInstance() );
-    Component vfComponent =  Mockito.spy( new Resource() );
-    ComponentInstance vfcInstance  =  Mockito.spy( new ComponentInstance() );
-    Component vfcComponent  =  Mockito.spy( new Resource() );
-
-    @Test
-    public void getReducedPathByOwner() throws Exception {
-        List<String> pathList = new ArrayList<>();
-        String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
-
-        String exerpt = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
-        String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
-        pathList.add(exerpt);
-        pathList.add(duplicate);
-        pathList.add(duplicate);
-        pathList.add(uniqueId);
-  
-        pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
-        pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
-
-        List<String> reducedMap = new CapabiltyRequirementConvertor().getReducedPathByOwner( pathList , uniqueId );
-
-        assertThat( reducedMap ).isNotNull().doesNotContain(exerpt).containsOnlyOnce(duplicate).hasSize(4);
-    }
-
-    //generate stub capability
-    private Map<String, List<CapabilityDefinition>> newCapabilities(String capabilityName){
-        Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
-        List<CapabilityDefinition> list = new ArrayList<>();
-        CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
-        capabilityDefinition.setName( capabilityName );
-        capabilityDefinition.setType("att.Node");
-        List<String> pathList = new ArrayList<>();
-
-        capabilityDefinition.setOwnerId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693");
-        pathList.add("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
-        //pathList.add("a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi");
-        pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
-        pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
-
-        capabilityDefinition.setPath(pathList);
-        list.add(capabilityDefinition);
-        capabilities.put(capabilityDefinition.getType() , list );
-
-        return capabilities;
-    }
-
-
-    @Test
-    public void testBuildName(){
-        doReturn("1").when(instanceProxy).getActualComponentUid();
-        doReturn("2").when(vfInstance).getActualComponentUid();
-        doReturn("3").when(vfcInstance).getActualComponentUid();
-        //region proxy
-        Component proxyOrigin = new Resource();
-
-        proxyOrigin.setName( "vepdgtp4837svc_proxy0" );
-        proxyOrigin.setComponentType(ComponentTypeEnum.RESOURCE);
-        proxyOrigin.setComponentInstances( asList( vfInstance ) );
-
-        //endregion
-        //region vf+vfc
-        vfInstance.setName("vepdgtp4837vf0");
-        vfInstance.setNormalizedName("vepdgtp4837vf0");
-        vfInstance.setUniqueId("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
-        vfComponent.setName("vepdgtp4837vf0"); //origin
-        vfComponent.setComponentInstances(Arrays.asList(vfcInstance));
-        vfcInstance.setUniqueId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
-        vfcInstance.setName("lb_1");
-        vfcInstance.setNormalizedName("lb_1");
-        vfcInstance.setName("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
-        vfcComponent.setName("lb_1");
-        //endregion
-        Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
-        vfcComponent.setCapabilities(capabilities);
-        Map<Component, ComponentInstance> map = Collections.unmodifiableMap(new HashMap<Component, ComponentInstance>() {
-            {
-                put( proxyOrigin, null );
-                put( vfComponent, vfInstance );
-                put( vfcComponent, vfcInstance );
-            } } ) ;
-        Map<String, Component> cache = Collections.unmodifiableMap(new HashMap<String, Component>() {{
-                                                                            put( "1",proxyOrigin);
-                                                                            put( "2" ,vfComponent);
-                                                                            put( "3" ,vfcComponent);
-        }});
-        instanceProxy.setCapabilities(capabilities);
-        proxyOrigin.setCapabilities( capabilities );
-        List<CapabilityDefinition> flatList = capabilities.values().stream().flatMap(List::stream).collect(Collectors.toList());
-        flatList.stream().forEach( (CapabilityDefinition capabilityDefinition) -> {
-            String name = capabiltyRequirementConvertor.buildCapabilityNameForComponentInstance(cache, instanceProxy, capabilityDefinition);
-            System.out.println("built name -> " + name);
-            assertThat(name).isEqualTo( "vepdgtp4837vf0.lb_1."+capabilityDefinition.getName() );
-        });
-    }
-}
+	@InjectMocks
+	CapabiltyRequirementConvertor testSubject;
+
+	@Mock
+	ToscaOperationFacade toscaOperationFacade;
+
+	CapabiltyRequirementConvertor capabiltyRequirementConvertor = Mockito.spy(new CapabiltyRequirementConvertor());
+	ComponentInstance instanceProxy = Mockito.spy(new ComponentInstance());
+	ComponentInstance vfInstance = Mockito.spy(new ComponentInstance());
+	Component vfComponent = Mockito.spy(new Resource());
+	ComponentInstance vfcInstance = Mockito.spy(new ComponentInstance());
+	Component vfcComponent = Mockito.spy(new Resource());
+
+	@Before
+	public void setUpMock() throws Exception {
+		MockitoAnnotations.initMocks(this);
+	}
+
+	@Test
+	public void testGetInstance() {
+		CapabiltyRequirementConvertor.getInstance();
+	}
+
+	@Test
+	public void testConvertComponentInstanceCapabilties() {
+		Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
+		vfInstance.setCapabilities(capabilities);
+		ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
+		Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
+
+		capabilities.get("att.Node").clear();
+		testSubject.convertComponentInstanceCapabilties(vfInstance, testDataTypes, nodeTemplate);
+
+		capabilities = newCapabilities("port");
+		vfInstance.setCapabilities(capabilities);
+		vfInstance.setComponentUid("uid");
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		testSubject.convertComponentInstanceCapabilties(vfInstance, testDataTypes, nodeTemplate);
+
+	}
+
+	@Test
+	public void testConvertComponentInstanceCapabilties_1() {
+		Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
+		ToscaNodeTemplate nodeTemplate = new ToscaNodeTemplate();
+		Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
+
+		vfInstance.setComponentUid("uid");
+
+		vfInstance.setCapabilities(capabilities);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		testSubject.convertComponentInstanceCapabilties(vfInstance, testDataTypes, nodeTemplate);
+
+	}
+
+	@Test
+	public void testConvertOverridenProperty() {
+		ComponentInstance instance = new ComponentInstance();
+		Map<String, DataTypeDefinition> testDataTypes = new HashMap<String, DataTypeDefinition>();
+		Map<String, ToscaTemplateCapability> capabilities = new HashMap<>();
+		ComponentInstanceProperty p = new ComponentInstanceProperty();
+		SchemaDefinition entrySchema = new SchemaDefinition();
+		entrySchema.setProperty(new PropertyDataDefinition());
+		p.setSchema(entrySchema);
+
+		Deencapsulation.invoke(testSubject, "convertOverridenProperty", instance, testDataTypes, capabilities, p,
+				"port");
+	}
+
+	@Test
+	public void testConvertRequirements() {
+		ToscaNodeType nodeType = new ToscaNodeType();
+
+		testSubject.convertRequirements(vfComponent, nodeType);
+
+	}
+
+	@Test
+	public void testConvertRequirements_1() {
+		ToscaNodeType nodeType = new ToscaNodeType();
+		Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
+
+		List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
+		RequirementDefinition definition = new RequirementDefinition();
+		definition.setOwnerId("id");
+		requirementsArray.add(definition);
+		requirementsMap.put("key", requirementsArray);
+		vfComponent.setRequirements(requirementsMap);
+		vfComponent.setUniqueId("id");
+
+		testSubject.convertRequirements(vfComponent, nodeType);
+
+	}
+
+	@Test
+	public void testConvertSubstitutionMappingRequirements() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		SubstitutionMapping substitution = new SubstitutionMapping();
+		Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
+		List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
+		RequirementDefinition definition = new RequirementDefinition();
+		definition.setOwnerId("id");
+		definition.setName("name");
+		definition.setParentName("parentName");
+		List<String> path = new ArrayList<>();
+		path.add("path1");
+		path.add("path2");
+		definition.setPath(path);
+		requirementsArray.add(definition);
+		requirementsMap.put("key", requirementsArray);
+		List<ComponentInstance> instances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("uid");
+		instances.add(instance);
+		vfComponent.setRequirements(requirementsMap);
+		vfComponent.setComponentInstances(instances);
+
+		testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
+	}
+
+	@Test
+	public void testConvertSubstitutionMappingRequirements_1() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		SubstitutionMapping substitution = new SubstitutionMapping();
+		Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
+		List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
+		RequirementDefinition definition = new RequirementDefinition();
+		definition.setName("name");
+		definition.setParentName("parentName");
+		List<String> path = new ArrayList<>();
+		path.add("path1.");
+		path.add("id");
+		definition.setPath(path);
+		requirementsArray.add(definition);
+		requirementsMap.put("key", requirementsArray);
+		List<ComponentInstance> instances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("id");
+		instances.add(instance);
+		vfComponent.setRequirements(requirementsMap);
+		vfComponent.setComponentInstances(instances);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(vfcComponent));
+
+		testSubject.convertSubstitutionMappingRequirements(componentsCache, vfComponent, substitution);
+	}
+
+	@Test
+	public void testConvertSubstitutionMappingRequirementsAsMap() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		vfComponent.setRequirements(null);
+
+		Deencapsulation.invoke(testSubject, "convertSubstitutionMappingRequirementsAsMap", componentsCache,
+				vfComponent);
+	}
+
+	@Test
+	public void testBuildAddSubstitutionMappingsRequirements() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		Map<String, List<RequirementDefinition>> requirementsMap = new HashMap<String, List<RequirementDefinition>>();
+		List<RequirementDefinition> requirementsArray = new ArrayList<RequirementDefinition>();
+		RequirementDefinition definition = new RequirementDefinition();
+		definition.setOwnerId("id");
+		definition.setName("name");
+		definition.setParentName("parentName");
+		List<String> path = new ArrayList<>();
+		path.add("path1");
+		path.add("path2");
+		definition.setPath(path);
+		requirementsArray.add(definition);
+		requirementsMap.put("key", requirementsArray);
+		vfComponent.setRequirements(requirementsMap);
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsRequirements", componentsCache, vfComponent,
+				requirementsMap);
+	}
+
+	@Test
+	public void testBuildAddSubstitutionMappingsCapabilities() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
+
+		Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
+				capabilities);
+	}
+
+	@Test
+	public void testBuildAddSubstitutionMappingsCapabilities_1() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
+		List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
+		CapabilityDefinition definition = new CapabilityDefinition();
+		definition.setOwnerId("id");
+		definition.setName("name");
+		definition.setParentName("parentName");
+		List<String> path = new ArrayList<>();
+		path.add("path1");
+		path.add("path2");
+		definition.setPath(path);
+		capabilitiesArray.add(definition);
+		capabilitiesMap.put("key", capabilitiesArray);
+		vfComponent.setCapabilities(capabilitiesMap);
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "buildAddSubstitutionMappingsCapabilities", componentsCache, vfComponent,
+				capabilitiesMap);
+	}
+
+	@Test
+	public void testBuildSubstitutedNamePerInstance() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		String name = "name";
+		String ownerId = "id";
+		List<String> path = new ArrayList<>();
+		path.add("id");
+		SubstituitionEntry entry = new SubstituitionEntry();
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("uid");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Deencapsulation.invoke(testSubject, "buildSubstitutedNamePerInstance", componentsCache, vfComponent, name, path,
+				ownerId, entry);
+	}
+
+	@Test
+	public void testConvertRequirement() {
+		RequirementDefinition definition = new RequirementDefinition();
+		List<String> path = new ArrayList<>();
+		path.add("value");
+		path.add("id");
+		definition.setName("name");
+		definition.setPath(path);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "convertRequirement", vfComponent, false, definition);
+	}
+
+	@Test
+	public void testConvertRequirement_1() {
+		RequirementDefinition definition = new RequirementDefinition();
+		List<String> path = new ArrayList<>();
+		path.add("id");
+		definition.setName("name");
+		definition.setPath(path);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "convertRequirement", vfComponent, false, definition);
+	}
+
+	@Test
+	public void testConvertRequirement_2() {
+		RequirementDefinition definition = new RequirementDefinition();
+		List<String> path = new ArrayList<>();
+		path.add("id");
+		definition.setName("name");
+		definition.setPath(path);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		path.add("value");
+		definition.setPath(path);
+		definition.setMaxOccurrences("1000");
+
+		Deencapsulation.invoke(testSubject, "convertRequirement", vfComponent, false, definition);
+	}
+
+	@Test
+	public void testConvertCapabilities() {
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+
+		testSubject.convertCapabilities(vfComponent, dataTypes);
 
+		Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
+		List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
+		CapabilityDefinition definition = new CapabilityDefinition();
+		definition.setOwnerId("id");
+		capabilitiesArray.add(definition);
+		capabilitiesMap.put("key", capabilitiesArray);
+		vfComponent.setUniqueId("id");
+		vfComponent.setCapabilities(capabilitiesMap);
+
+		testSubject.convertCapabilities(vfComponent, dataTypes);
+	}
+
+	@Test
+	public void testConvertProxyCapabilities() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
+	}
+
+	@Test
+	public void testConvertProxyCapabilitiesWhenCapabilitiesNotNull() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
+		List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
+		CapabilityDefinition definition = new CapabilityDefinition();
+		definition.setOwnerId("id");
+		capabilitiesArray.add(definition);
+		capabilitiesMap.put("key", capabilitiesArray);
+		vfComponent.setUniqueId("id");
+
+		instance.setCapabilities(capabilitiesMap);
+		instance.setComponentUid("uid");
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		testSubject.convertProxyCapabilities(componentsCache, vfComponent, vfComponent, instance, dataTypes);
+	}
+
+	@Test
+	public void testConvertSubstitutionMappingCapabilities() {
+		Map<String, Component> componentsCache = new HashMap<>();
+
+		testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
+
+		Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
+		List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
+		CapabilityDefinition definition = new CapabilityDefinition();
+		definition.setOwnerId("id");
+		definition.setName("name");
+		definition.setParentName("parentName");
+		List<String> path = new ArrayList<>();
+		path.add("path1");
+		path.add("id");
+		definition.setPath(path);
+		capabilitiesArray.add(definition);
+		capabilitiesMap.put("key", capabilitiesArray);
+		vfComponent.setCapabilities(capabilitiesMap);
+
+		List<ComponentInstance> instances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("uid");
+		instances.add(instance);
+		vfComponent.setComponentInstances(instances);
+
+		testSubject.convertSubstitutionMappingCapabilities(componentsCache, vfComponent);
+	}
+
+	@Test
+	public void testGetCapabilityPath() {
+		CapabilityDefinition definition = new CapabilityDefinition();
+		List<String> path = new ArrayList<>();
+		path.add("value");
+		path.add("id");
+		definition.setName("name");
+		definition.setPath(path);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "getCapabilityPath", definition, vfComponent);
+	}
+
+	@Test
+	public void testGetCapabilityPath_1() {
+		CapabilityDefinition definition = new CapabilityDefinition();
+		List<String> path = new ArrayList<>();
+		path.add("id");
+		definition.setName("name");
+		definition.setPath(path);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "getCapabilityPath", definition, vfComponent);
+	}
+
+	@Test
+	public void testGetCapabilityPath_2() {
+		CapabilityDefinition definition = new CapabilityDefinition();
+		List<String> path = new ArrayList<>();
+		path.add("id");
+		definition.setName("name");
+		definition.setPath(path);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		path.add("value");
+		definition.setPath(path);
+
+		Deencapsulation.invoke(testSubject, "getCapabilityPath", definition, vfComponent);
+	}
+
+	@Test
+	public void testConvertCapability_1() {
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+
+		Map<String, List<CapabilityDefinition>> capabilitiesMap = new HashMap<String, List<CapabilityDefinition>>();
+		List<CapabilityDefinition> capabilitiesArray = new ArrayList<CapabilityDefinition>();
+		CapabilityDefinition definition = new CapabilityDefinition();
+		List<ComponentInstanceProperty> properties = new ArrayList<>();
+		properties.add(new ComponentInstanceProperty());
+		definition.setOwnerId("id");
+		definition.setName("name");
+		definition.setProperties(properties);
+		definition.setMaxOccurrences("1000");
+		List<String> path = new ArrayList<>();
+		path.add("value");
+		path.add("id");
+		definition.setPath(path);
+		capabilitiesArray.add(definition);
+		capabilitiesMap.put("key", capabilitiesArray);
+		vfComponent.setUniqueId("id");
+		vfComponent.setCapabilities(capabilitiesMap);
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		vfComponent.setComponentInstances(componentInstances);
+
+		Deencapsulation.invoke(testSubject, "convertCapabilty", vfComponent, new HashMap<>(), false, definition,
+				dataTypes, "name");
+	}
+
+	@Test
+	public void testBuildSubstitutedName() {
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		resourceInstances.add(instance);
+		vfComponent.setComponentInstances(resourceInstances);
+
+		List<String> path = new ArrayList<>();
+		path.add("notId");
+
+		Deencapsulation.invoke(testSubject, "buildSubstitutedName", new HashMap<>(), vfComponent, path, "name");
+	}
+
+	@Test
+	public void testAppendNameRecursively() {
+		Map<String, Component> componentsCache = new HashMap<>();
+		StringBuilder builder = new StringBuilder();
+		List<String> path = new ArrayList<>();
+
+		path.add("id");
+		Iterator<String> iter = path.iterator();
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("uid");
+		resourceInstances.add(instance);
+		vfComponent.setComponentInstances(resourceInstances);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Deencapsulation.invoke(testSubject, "appendNameRecursively", componentsCache, vfComponent, iter, builder);
+
+	}
+
+	@Test
+	public void testGetFilter() {
+		ComponentInstance instance = new ComponentInstance();
+		instance.setIsProxy(true);
+
+		Deencapsulation.invoke(testSubject, "getFilter", instance);
+	}
+
+	@Test
+	public void testGetReducedPathByOwner() throws Exception {
+		List<String> pathList = new ArrayList<>();
+		String uniqueId = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_2";
+
+		String exerpt = "41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1";
+		String duplicate = "a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi";
+		pathList.add(exerpt);
+		pathList.add(duplicate);
+		pathList.add(duplicate);
+		pathList.add(uniqueId);
+
+		pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
+		pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
+
+		List<String> reducedMap = new CapabiltyRequirementConvertor().getReducedPathByOwner(pathList, uniqueId);
+
+		assertThat(reducedMap).isNotNull().doesNotContain(exerpt).containsOnlyOnce(duplicate).hasSize(4);
+
+		List<String> path = new ArrayList<String>();
+
+		capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
+
+		path.add("");
+		capabiltyRequirementConvertor.getReducedPathByOwner(path, uniqueId);
+		capabiltyRequirementConvertor.getReducedPathByOwner(path, "");
+	}
+
+	// generate stub capability
+	private Map<String, List<CapabilityDefinition>> newCapabilities(String capabilityName) {
+		Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
+		List<CapabilityDefinition> list = new ArrayList<>();
+		CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
+		capabilityDefinition.setName(capabilityName);
+		capabilityDefinition.setType("att.Node");
+		List<ComponentInstanceProperty> properties = new ArrayList<>();
+		ComponentInstanceProperty prop = new ComponentInstanceProperty();
+		prop.setValue("value");
+		properties.add(prop);
+		capabilityDefinition.setProperties(properties);
+		List<String> pathList = new ArrayList<>();
+
+		capabilityDefinition.setOwnerId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693");
+		pathList.add("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
+		// pathList.add("a77df84e-83eb-4edc-9823-d1f9f6549693.c79e9a4a-b172-4323-a2e2-1c48d6603241.lb_swu_direct_4_rvmi");
+		pathList.add("5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
+		pathList.add("86ae128e-3d0a-41f7-a957-db1df9fe598c.9cc8f8ac-6869-4dd6-a6e1-74ecb9570dc4.vepdgtp4837svc_proxy0");
+
+		capabilityDefinition.setPath(pathList);
+		list.add(capabilityDefinition);
+		capabilities.put(capabilityDefinition.getType(), list);
+
+		return capabilities;
+	}
+
+	@Test
+	public void testBuildName() {
+		doReturn("1").when(instanceProxy).getActualComponentUid();
+		doReturn("2").when(vfInstance).getActualComponentUid();
+		doReturn("3").when(vfcInstance).getActualComponentUid();
+		// region proxy
+		Component proxyOrigin = new Resource();
+
+		proxyOrigin.setName("vepdgtp4837svc_proxy0");
+		proxyOrigin.setComponentType(ComponentTypeEnum.RESOURCE);
+		proxyOrigin.setComponentInstances(asList(vfInstance));
+
+		// endregion
+		// region vf+vfc
+		vfInstance.setName("vepdgtp4837vf0");
+		vfInstance.setNormalizedName("vepdgtp4837vf0");
+		vfInstance.setUniqueId(
+				"5f172af9-1588-443e-8897-1432b19aad8c.2cb7514a-1e50-4280-8457-baacb97b50bf.vepdgtp4837vf0");
+		vfComponent.setName("vepdgtp4837vf0"); // origin
+		vfComponent.setComponentInstances(Arrays.asList(vfcInstance));
+		vfcInstance.setUniqueId("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
+		vfcInstance.setName("lb_1");
+		vfcInstance.setNormalizedName("lb_1");
+		vfcInstance.setName("41d3a665-1313-4b5e-9bf0-e901ecf4b806.a77df84e-83eb-4edc-9823-d1f9f6549693.lb_1");
+		vfcComponent.setName("lb_1");
+		// endregion
+		Map<String, List<CapabilityDefinition>> capabilities = newCapabilities("port");
+		vfcComponent.setCapabilities(capabilities);
+		Map<Component, ComponentInstance> map = Collections
+				.unmodifiableMap(new HashMap<Component, ComponentInstance>() {
+					{
+						put(proxyOrigin, null);
+						put(vfComponent, vfInstance);
+						put(vfcComponent, vfcInstance);
+					}
+				});
+		Map<String, Component> cache = Collections.unmodifiableMap(new HashMap<String, Component>() {
+			{
+				put("1", proxyOrigin);
+				put("2", vfComponent);
+				put("3", vfcComponent);
+			}
+		});
+		instanceProxy.setCapabilities(capabilities);
+		proxyOrigin.setCapabilities(capabilities);
+		List<CapabilityDefinition> flatList = capabilities.values().stream().flatMap(List::stream)
+				.collect(Collectors.toList());
+		flatList.stream().forEach((CapabilityDefinition capabilityDefinition) -> {
+			String name = capabiltyRequirementConvertor.buildCapabilityNameForComponentInstance(cache, instanceProxy,
+					capabilityDefinition);
+			System.out.println("built name -> " + name);
+			assertThat(name).isEqualTo("vepdgtp4837vf0.lb_1." + capabilityDefinition.getName());
+		});
+	}
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CsarUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CsarUtilsTest.java
index 5ac1467a5c..adee99efab 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CsarUtilsTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/CsarUtilsTest.java
@@ -22,70 +22,1289 @@ package org.openecomp.sdc.be.tosca;
 
 import static org.junit.Assert.assertTrue;
 
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
 
+import org.apache.commons.io.output.ByteArrayOutputStream;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.ImmutableTriple;
+import org.apache.commons.lang3.tuple.Triple;
 import org.junit.Before;
 import org.junit.Test;
-import org.openecomp.sdc.be.config.ConfigurationManager;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.onap.sdc.generator.data.ArtifactType;
+import org.openecomp.sdc.be.components.BeConfDependentTest;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic;
+import org.openecomp.sdc.be.components.impl.ArtifactsBusinessLogic.ArtifactOperationInfo;
+import org.openecomp.sdc.be.dao.api.ActionStatus;
+import org.openecomp.sdc.be.dao.cassandra.ArtifactCassandraDao;
+import org.openecomp.sdc.be.dao.cassandra.CassandraOperationStatus;
+import org.openecomp.sdc.be.dao.cassandra.SdcSchemaFilesCassandraDao;
+import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
+import org.openecomp.sdc.be.impl.ComponentsUtils;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.InterfaceDefinition;
+import org.openecomp.sdc.be.model.LifecycleStateEnum;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.User;
+import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.resources.data.ESArtifactData;
+import org.openecomp.sdc.be.resources.data.SdcSchemaFilesData;
 import org.openecomp.sdc.be.tosca.CsarUtils.NonMetaArtifactInfo;
-import org.openecomp.sdc.common.api.ConfigurationSource;
-import org.openecomp.sdc.common.impl.ExternalConfiguration;
-import org.openecomp.sdc.common.impl.FSConfigurationSource;
+import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
+import org.openecomp.sdc.common.api.ArtifactGroupTypeEnum;
+import org.openecomp.sdc.common.api.ArtifactTypeEnum;
+import org.openecomp.sdc.exception.ResponseFormat;
 
 import fj.data.Either;
+import mockit.Deencapsulation;
 
-public class CsarUtilsTest {
-    @Before
-    public void setup() {
-        ExternalConfiguration.setAppName("catalog-be");
-
-        // init Configuration
-        String appConfigDir = "src/test/resources/config/catalog-be";
-        ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
-        ConfigurationManager configurationManager = new ConfigurationManager(configurationSource);
-    }
-
-    @Test
-    public void testValidateNonMetaArtifactHappyScenario(){
-        String artifactPath = "Artifacts/Deployment/YANG_XML/myYang.xml";
-        byte[] payloadData = "some payload data".getBytes();
-        Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
-        Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
-        assertTrue(eitherNonMetaArtifact.isLeft() );
-        assertTrue(collectedWarningMessages.isEmpty() );
-
-        artifactPath = "Artifacts/Informational/OTHER/someArtifact.xml";
-        eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
-        assertTrue(eitherNonMetaArtifact.isLeft() );
-        assertTrue(collectedWarningMessages.isEmpty() );
-    }
-
-    @Test
-    public void testValidateNonMetaArtifactScenarioWithWarnnings(){
-        String artifactPath = "Artifacts/Deployment/Buga/myYang.xml";
-        byte[] payloadData = "some payload data".getBytes();
-        Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
-        Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
-        assertTrue(eitherNonMetaArtifact.isLeft() );
-
-        artifactPath = "Artifacts/Informational/Buga2/someArtifact.xml";
-        eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
-        assertTrue(eitherNonMetaArtifact.isLeft() );
-
-        assertTrue(collectedWarningMessages.size() == 1 );
-        assertTrue(collectedWarningMessages.values().iterator().next().size() == 2);
-    }
-
-    @Test
-    public void testValidateNonMetaArtifactUnhappyScenario(){
-        String artifactPath = "Artifacts/Buga/YANG_XML/myYang.xml";
-        byte[] payloadData = "some payload data".getBytes();
-        Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
-        Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
-        assertTrue(eitherNonMetaArtifact.isRight() );
-        assertTrue( !collectedWarningMessages.isEmpty() );
-    }
+public class CsarUtilsTest extends BeConfDependentTest {
+
+	@InjectMocks
+	CsarUtils testSubject;
+
+	@Mock
+	private ArtifactCassandraDao artifactCassandraDao;
+
+	@Mock
+	private ComponentsUtils componentsUtils;
+
+	@Mock
+	private ToscaExportHandler toscaExportUtils;
+
+	@Mock
+	private SdcSchemaFilesCassandraDao sdcSchemaFilesCassandraDao;
+
+	@Mock
+	private ToscaOperationFacade toscaOperationFacade;
+
+	@Mock
+	private ArtifactsBusinessLogic artifactsBusinessLogic;
+
+	@Before
+	public void setUpMock() throws Exception {
+		MockitoAnnotations.initMocks(this);
+		
+	}
+
+	private NonMetaArtifactInfo createNonMetaArtifactInfoTestSubject() {
+		return new CsarUtils.NonMetaArtifactInfo("mock", "mock", ArtifactTypeEnum.AAI_SERVICE_MODEL,
+				ArtifactGroupTypeEnum.DEPLOYMENT, new byte[0], "mock", true);
+	}
+
+	@Test
+	public void testCreateCsar() {
+		Component component = new Resource();
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class)))
+				.thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
+
+		Mockito.when(componentsUtils.convertFromStorageResponse(Mockito.any(StorageOperationStatus.class)))
+				.thenReturn(ActionStatus.GENERAL_ERROR);
+
+		testSubject.createCsar(component, true, true);
+	}
+
+	@Test
+	public void testCreateCsarWithGenerateCsarZipResponseIsLeft() {
+		Component component = new Resource();
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		toscaTemplate.setDependencies(dependencies);
+
+		List<SdcSchemaFilesData> filesData = new ArrayList<>();
+		SdcSchemaFilesData filedata = new SdcSchemaFilesData();
+		filedata.setPayloadAsArray(data);
+		filesData.add(filedata);
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(componentsUtils.convertFromStorageResponse(Mockito.any(StorageOperationStatus.class)))
+				.thenReturn(ActionStatus.GENERAL_ERROR);
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.left(filesData));
+
+		testSubject.createCsar(component, false, true);
+	}
+
+	@Test
+	public void testGenerateCsarZipThrowsIOException() {
+		Deencapsulation.invoke(testSubject, "generateCsarZip", byte[].class, byte[].class, new Resource(), true, false,
+				false);
+	}
+
+	@Test
+	public void testPopulateZipWhenGetDependenciesIsRight() {
+		Component component = new Service();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.right(ToscaError.GENERAL_ERROR));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, false, false);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenExportComponentIsRight() {
+		Component component = new Resource();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class)))
+				.thenReturn(Either.right(ToscaError.GENERAL_ERROR));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, false, false);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenComponentIsServiceAndCollectComponentCsarDefinitionIsRight() {
+		Component component = new Service();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		component.setVersion("1.0");
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("uid");
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		List<SdcSchemaFilesData> filesData = new ArrayList<>();
+		SdcSchemaFilesData filedata = new SdcSchemaFilesData();
+		filedata.setPayloadAsArray(data);
+		filesData.add(filedata);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		Triple<String, String, Component> triple = Triple.of("fileName", "cassandraId", component);
+		dependencies.add(triple);
+		toscaTemplate.setDependencies(dependencies);
+
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.left(filesData));
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Mockito.when(artifactsBusinessLogic.validateUserExists(Mockito.any(String.class), Mockito.any(String.class),
+				Mockito.any(Boolean.class))).thenReturn(Either.left(new User()));
+
+		Mockito.when(artifactsBusinessLogic.validateAndHandleArtifact(Mockito.any(String.class),
+				Mockito.any(ComponentTypeEnum.class), Mockito.any(ArtifactOperationInfo.class), Mockito.isNull(),
+				Mockito.any(ArtifactDefinition.class), Mockito.any(String.class), Mockito.any(String.class),
+				Mockito.isNull(), Mockito.isNull(), Mockito.any(User.class), Mockito.any(Component.class),
+				Mockito.any(Boolean.class), Mockito.any(Boolean.class), Mockito.any(Boolean.class)))
+				.thenReturn(Either.left(Mockito.any(Either.class)));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenGetEntryDataIsRight() {
+		Component component = new Service();
+		boolean getFromCS = true;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		component.setVersion("1.0");
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("uid");
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		Triple<String, String, Component> triple = Triple.of("fileName", "", component);
+		dependencies.add(triple);
+		toscaTemplate.setDependencies(dependencies);
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class)))
+				.thenReturn(Either.right(ToscaError.GENERAL_ERROR));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenGetEntryDataOfInnerComponentIsRight() {
+		Component component = new Service();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		component.setVersion("1.0");
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("uid");
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		Triple<String, String, Component> triple = Triple.of("fileName", "", component);
+		dependencies.add(triple);
+		toscaTemplate.setDependencies(dependencies);
+
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca),
+				Either.left(tosca), Either.right(ToscaError.GENERAL_ERROR));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenLatestSchemaFilesFromCassandraIsRight() {
+		Component component = new Service();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		component.setVersion("1.0");
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("uid");
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		Triple<String, String, Component> triple = Triple.of("fileName", "", component);
+		dependencies.add(triple);
+		toscaTemplate.setDependencies(dependencies);
+
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenAddSchemaFilesFromCassandraIsRight() {
+		Component component = new Service();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		component.setVersion("1.0");
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("uid");
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		Triple<String, String, Component> triple = Triple.of("fileName", "", component);
+		dependencies.add(triple);
+		toscaTemplate.setDependencies(dependencies);
+
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		List<SdcSchemaFilesData> schemaList = new ArrayList<>();
+		SdcSchemaFilesData schemaData = new SdcSchemaFilesData();
+		schemaData.setPayloadAsArray(null);
+		schemaList.add(schemaData);
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.left(schemaList));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testPopulateZipWhenHandleAllAAIArtifactsInDataModelIsRight() {
+		Component component = new Service();
+		boolean getFromCS = false;
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		component.setLifecycleState(LifecycleStateEnum.NOT_CERTIFIED_CHECKIN);
+		component.setVersion("1.0");
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("uid");
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		Triple<String, String, Component> triple = Triple.of("fileName", "", component);
+		dependencies.add(triple);
+		toscaTemplate.setDependencies(dependencies);
+
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		List<SdcSchemaFilesData> schemaList = new ArrayList<>();
+		SdcSchemaFilesData schemaData = new SdcSchemaFilesData();
+		schemaData.setPayloadAsArray(data);
+		schemaList.add(schemaData);
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData));
+
+		Mockito.when(toscaExportUtils.exportComponent(Mockito.any(Component.class))).thenReturn(Either.left(tosca));
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.left(schemaList));
+
+		Mockito.when(artifactsBusinessLogic.validateUserExists(Mockito.any(String.class), Mockito.any(String.class),
+				Mockito.any(Boolean.class))).thenReturn(Either.right(new ResponseFormat(500)));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "populateZip", component, getFromCS, zip, true, true);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testAddSchemaFilesFromCassandra() {
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream();
+				ZipOutputStream zip = new ZipOutputStream(out);
+				ByteArrayOutputStream outMockStream = new ByteArrayOutputStream();
+				ZipOutputStream outMock = new ZipOutputStream(outMockStream);) {
+
+			outMock.putNextEntry(new ZipEntry("mock1"));
+			outMock.write(new byte[1]);
+			outMock.putNextEntry(new ZipEntry("mock2"));
+			outMock.write(new byte[3]);
+			outMock.close();
+			byte[] byteArray = outMockStream.toByteArray();
+			Deencapsulation.invoke(testSubject, "addSchemaFilesFromCassandra", zip, byteArray);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	@Test
+	public void testAddInnerComponentsToCache() {
+		Map<String, ImmutableTriple<String, String, Component>> componentCache = new HashMap<>();
+		Component childComponent = new Resource();
+		Component componentRI = new Service();
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setComponentUid("resourceUid");
+		componentInstances.add(instance);
+		childComponent.setComponentInstances(componentInstances);
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		componentRI.setToscaArtifacts(toscaArtifacts);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class)))
+				.thenReturn(Either.left(componentRI));
+
+		Deencapsulation.invoke(testSubject, "addInnerComponentsToCache", componentCache, childComponent);
+	}
+
+	@Test
+	public void testAddInnerComponentsToCacheWhenGetToscaElementIsRight() {
+		Map<String, ImmutableTriple<String, String, Component>> componentCache = new HashMap<>();
+		Component childComponent = new Resource();
+
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		componentInstances.add(instance);
+		childComponent.setComponentInstances(componentInstances);
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		Component componentRI = new Service();
+
+		componentRI.setToscaArtifacts(toscaArtifacts);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Deencapsulation.invoke(testSubject, "addInnerComponentsToCache", componentCache, childComponent);
+	}
+
+	@Test
+	public void testAddComponentToCache() {
+		Map<String, ImmutableTriple<String, String, Component>> componentCache = new HashMap<>();
+		String id = "id";
+		String fileName = "fileName";
+		Component component = new Resource();
+		component.setInvariantUUID("key");
+		component.setVersion("1.0");
+
+		Component cachedComponent = new Resource();
+		cachedComponent.setVersion("0.3");
+
+		componentCache.put("key", new ImmutableTriple<String, String, Component>(id, fileName, cachedComponent));
+
+		Deencapsulation.invoke(testSubject, "addComponentToCache", componentCache, id, fileName, component);
+	}
+
+	@Test
+	public void testWriteComponentInterface() {
+		String fileName = "name.hello";
+		ToscaRepresentation tosca = new ToscaRepresentation();
+		tosca.setMainYaml("value");
+
+		Mockito.when(toscaExportUtils.exportComponentInterface(Mockito.any(Component.class)))
+				.thenReturn(Either.left(tosca));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeComponentInterface", new Resource(), zip, fileName);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	@Test
+	public void testHandleAAIArtifacts() {
+		Component component = new Service();
+		component.setComponentType(ComponentTypeEnum.SERVICE);
+		byte[] data = "value".getBytes();
+
+		List<ImmutablePair<Component, byte[]>> generatorInputs = new ArrayList<>();
+		generatorInputs.add(new ImmutablePair<Component, byte[]>(component, data));
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		artifact.setArtifactGroupType(ArtifactGroupTypeEnum.DEPLOYMENT);
+		artifact.setDescription("description");
+		artifact.setArtifactLabel("artifactLabel");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setVersion("1.3");
+
+		Deencapsulation.invoke(testSubject, "handleAAIArtifacts", component, false, generatorInputs);
+	}
+
+	@Test
+	public void testHandleAllAAIArtifactsInDataModelWhenArtifactOperationDeleteAndCreateIsRight() {
+		Component component = new Resource();
+		List<ArtifactDefinition> artifactsFromAAI = new ArrayList<>();
+		ArtifactDefinition AAIartifact = new ArtifactDefinition();
+		AAIartifact.setArtifactLabel("artifactLabel");
+		AAIartifact.setGenerated(true);
+		Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
+		artifactsFromAAI.add(AAIartifact);
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactLabel("label");
+		artifact.setGenerated(true);
+		deploymentArtifacts.put("label", artifact);
+		component.setDeploymentArtifacts(deploymentArtifacts);
+		component.setArtifacts(deploymentArtifacts);
+		component.setLastUpdaterUserId("userId");
+		component.setUniqueId("id");
+
+		Mockito.when(artifactsBusinessLogic.validateUserExists(Mockito.any(String.class), Mockito.any(String.class),
+				Mockito.any(Boolean.class))).thenReturn(Either.left(new User()));
+
+		Mockito.when(artifactsBusinessLogic.validateAndHandleArtifact(Mockito.any(String.class),
+				Mockito.any(ComponentTypeEnum.class), Mockito.any(ArtifactOperationInfo.class), Mockito.isNull(),
+				Mockito.any(ArtifactDefinition.class), Mockito.any(String.class), Mockito.any(String.class),
+				Mockito.isNull(), Mockito.isNull(), Mockito.any(User.class), Mockito.any(Component.class),
+				Mockito.any(Boolean.class), Mockito.any(Boolean.class), Mockito.any(Boolean.class)))
+				.thenReturn(Either.right(new ResponseFormat()));
+
+		Deencapsulation.invoke(testSubject, "handleAllAAIArtifactsInDataModel", component, artifactsFromAAI, true,
+				true);
+	}
+
+	@Test
+	public void testCheckAaiForUpdateWithGetGeneratedFalse() {
+		Component component = new Resource();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactLabel("label");
+		artifact.setGenerated(false);
+		Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
+		deploymentArtifacts.put("label", artifact);
+		component.setDeploymentArtifacts(deploymentArtifacts);
+
+		Deencapsulation.invoke(testSubject, "checkAaiForUpdate", component, artifact);
+	}
+
+	@Test
+	public void testCheckAaiForUpdateWithGetGeneratedTrue() {
+		Component component = new Resource();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactLabel("label");
+		artifact.setGenerated(true);
+		Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
+		deploymentArtifacts.put("label", artifact);
+		component.setDeploymentArtifacts(deploymentArtifacts);
+
+		Deencapsulation.invoke(testSubject, "checkAaiForUpdate", component, artifact);
+	}
+
+	@Test
+	public void testCheckAaiForUpdateWithDeploymentArtifactIsNull() {
+		Component component = new Resource();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactLabel("label1");
+		artifact.setGenerated(true);
+		Map<String, ArtifactDefinition> deploymentArtifacts = new HashMap<>();
+		deploymentArtifacts.put("label", artifact);
+		component.setDeploymentArtifacts(deploymentArtifacts);
+
+		Deencapsulation.invoke(testSubject, "checkAaiForUpdate", component, artifact);
+	}
+
+	@Test
+	public void testGetEntryData() {
+		String cassandraId = "id";
+		Component childComponent = new Resource();
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class)))
+				.thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
+
+		Deencapsulation.invoke(testSubject, "getEntryData", cassandraId, childComponent);
+	}
+
+	@Test
+	public void testGetLatestSchemaFilesFromCassandraWhenListOfSchemasIsEmpty() {
+		List<SdcSchemaFilesData> filesData = new ArrayList<>();
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.left(filesData));
+		Deencapsulation.invoke(testSubject, "getLatestSchemaFilesFromCassandra");
+	}
+
+	@Test
+	public void testArtifactGenerator() {
+		Component component = new Resource();
+
+		component.setVersion("1.0");
+
+		Deencapsulation.invoke(testSubject, "artifactGenerator", new ArrayList<>(), ArtifactType.class, component);
+	}
+
+	@Test
+	public void testExtractVfcsArtifactsFromCsar() {
+		String key = "Artifacts/org.openecomp.resource.some/path/to/resource";
+		byte[] data = "value".getBytes();
+
+		Map<String, byte[]> csar = new HashMap<>();
+		csar.put(key, data);
+
+		CsarUtils.extractVfcsArtifactsFromCsar(csar);
+	}
+
+	@Test
+	public void testAddExtractedVfcArtifactWhenArtifactsContainsExtractedArtifactKey() {
+		ImmutablePair<String, ArtifactDefinition> extractedVfcArtifact = new ImmutablePair<String, ArtifactDefinition>(
+				"key", new ArtifactDefinition());
+		Map<String, List<ArtifactDefinition>> artifacts = new HashMap<>();
+		artifacts.put("key", new ArrayList<>());
+
+		Deencapsulation.invoke(testSubject, "addExtractedVfcArtifact", extractedVfcArtifact, artifacts);
+	}
+
+	@Test
+	public void testAddExtractedVfcArtifactWhenArtifactsDoesntContainsExtractedArtifactKey() {
+		ImmutablePair<String, ArtifactDefinition> extractedVfcArtifact = new ImmutablePair<String, ArtifactDefinition>(
+				"key", new ArtifactDefinition());
+		Map<String, List<ArtifactDefinition>> artifacts = new HashMap<>();
+		artifacts.put("key1", new ArrayList<>());
+
+		Deencapsulation.invoke(testSubject, "addExtractedVfcArtifact", extractedVfcArtifact, artifacts);
+	}
+
+	@Test
+	public void testExtractVfcArtifact() {
+		String path = "path/to/informational/artificat";
+		Map<String, byte[]> map = new HashMap<>();
+		map.put(path, "value".getBytes());
+		Entry<String, byte[]> entry = map.entrySet().iterator().next();
+
+		Deencapsulation.invoke(testSubject, "extractVfcArtifact", entry, new HashMap<>());
+	}
+
+	@Test
+	public void testDetectArtifactGroupTypeWithExceptionBeingCaught() {
+		Deencapsulation.invoke(testSubject, "detectArtifactGroupType", "type", Map.class);
+	}
+
+	@Test
+	public void testDetectArtifactGroupTypeWWhenCollectedWarningMessagesContainesKey() {
+		Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
+
+		collectedWarningMessages.put("Warning - unrecognized artifact group type {} was received.", new HashSet<>());
+		Deencapsulation.invoke(testSubject, "detectArtifactGroupType", "type", collectedWarningMessages);
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoCtor() {
+		createNonMetaArtifactInfoTestSubject();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetPath() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getPath();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetArtifactName() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getArtifactName();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetArtifactType() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getArtifactType();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetDisplayName() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getDisplayName();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetArtifactGroupType() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getArtifactGroupType();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetArtifactLabel() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getArtifactLabel();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetIsFromCsar() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.isFromCsar();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetPayloadData() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getPayloadData();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetArtifaactChecksum() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getArtifactChecksum();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfoGetArtifactUniqueId() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.getArtifactUniqueId();
+	}
+
+	@Test
+	public void testNonMetaArtifactInfosetArtifactUniqueId() {
+		NonMetaArtifactInfo testSubject = createNonMetaArtifactInfoTestSubject();
+
+		testSubject.setArtifactUniqueId("artifactUniqueId");
+	}
+
+	@Test
+	public void testValidateNonMetaArtifactWithExceptionCaught() {
+		CsarUtils.validateNonMetaArtifact("", new byte[0], new HashMap<>());
+	}
+
+	@Test
+	public void testWriteAllFilesToCsarWhenWriteOperationsArtifactsToCsarIsRight() {
+		Component component = new Resource();
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+		Map<String, InterfaceDefinition> interfaces = new HashMap<>();
+		InterfaceDefinition interfaceDef = new InterfaceDefinition();
+		Map<String, OperationDataDefinition> operations = new HashMap<>();
+		OperationDataDefinition operation = new OperationDataDefinition();
+		ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+		implementation.setArtifactUUID("artifactUUID");
+		implementation.setArtifactName("artifactName");
+		operation.setImplementation(implementation);
+		operations.put("key", operation);
+		interfaceDef.setOperations(operations);
+		interfaces.put("key", interfaceDef);
+		((Resource) component).setInterfaces(interfaces);
+
+		ESArtifactData artifactData = new ESArtifactData();
+		byte[] data = "value".getBytes();
+		artifactData.setDataAsArray(data);
+
+		ToscaTemplate toscaTemplate = new ToscaTemplate("version");
+		List<Triple<String, String, Component>> dependencies = new ArrayList<>();
+		toscaTemplate.setDependencies(dependencies);
+
+		List<SdcSchemaFilesData> filesData = new ArrayList<>();
+		SdcSchemaFilesData filedata = new SdcSchemaFilesData();
+		filedata.setPayloadAsArray(data);
+		filesData.add(filedata);
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(artifactData),
+				Either.right(CassandraOperationStatus.GENERAL_ERROR));
+
+		Mockito.when(componentsUtils.convertFromStorageResponse(Mockito.any(StorageOperationStatus.class)))
+				.thenReturn(ActionStatus.GENERAL_ERROR);
+
+		Mockito.when(toscaExportUtils.getDependencies(Mockito.any(Component.class)))
+				.thenReturn(Either.left(toscaTemplate));
+
+		Mockito.when(
+				sdcSchemaFilesCassandraDao.getSpecificSchemaFiles(Mockito.any(String.class), Mockito.any(String.class)))
+				.thenReturn(Either.left(filesData));
+
+		testSubject.createCsar(component, false, true);
+	}
+
+	@Test
+	public void testWriteOperationsArtifactsToCsarWhenComponentIsService() {
+		Component component = new Service();
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testWriteOperationsArtifactsToCsarWhenOperationGetImplementaionIsNull() {
+		Component component = new Resource();
+		Map<String, InterfaceDefinition> interfaces = new HashMap<>();
+		InterfaceDefinition interfaceDef = new InterfaceDefinition();
+		Map<String, OperationDataDefinition> operations = new HashMap<>();
+		operations.put("key", new OperationDataDefinition());
+		interfaceDef.setOperations(operations);
+		interfaces.put("key", interfaceDef);
+
+		((Resource) component).setInterfaces(interfaces);
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testWriteOperationsArtifactsToCsarWhenOperationGetArtifactNameIsNull() {
+		Component component = new Resource();
+
+		Map<String, InterfaceDefinition> interfaces = new HashMap<>();
+		InterfaceDefinition interfaceDef = new InterfaceDefinition();
+		Map<String, OperationDataDefinition> operations = new HashMap<>();
+		OperationDataDefinition operation = new OperationDataDefinition();
+		ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+		operation.setImplementation(implementation);
+		operations.put("key", operation);
+		interfaceDef.setOperations(operations);
+		interfaces.put("key", interfaceDef);
+		((Resource) component).setInterfaces(interfaces);
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testWriteOperationsArtifactsToCsarWhenGettingArtifactFromCassandra() {
+		Component component = new Resource();
+
+		Map<String, InterfaceDefinition> interfaces = new HashMap<>();
+		InterfaceDefinition interfaceDef = new InterfaceDefinition();
+		Map<String, OperationDataDefinition> operations = new HashMap<>();
+		OperationDataDefinition operation = new OperationDataDefinition();
+		ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+		implementation.setArtifactName("artifactName");
+		implementation.setArtifactUUID("artifactUUID");
+		operation.setImplementation(implementation);
+		operations.put("key", operation);
+		interfaceDef.setOperations(operations);
+		interfaceDef.setToscaResourceName("toscaResourceName");
+		interfaces.put("key", interfaceDef);
+		((Resource) component).setInterfaces(interfaces);
+		component.setNormalizedName("normalizedName");
+
+		ESArtifactData data = new ESArtifactData();
+		data.setDataAsArray("data".getBytes());
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class))).thenReturn(Either.left(data));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testWriteOperationsArtifactsToCsarWhenNullPointerExceptionIsCaught() {
+		Component component = new Resource();
+
+		Map<String, InterfaceDefinition> interfaces = new HashMap<>();
+		InterfaceDefinition interfaceDef = new InterfaceDefinition();
+		Map<String, OperationDataDefinition> operations = new HashMap<>();
+		OperationDataDefinition operation = new OperationDataDefinition();
+		ArtifactDataDefinition implementation = new ArtifactDataDefinition();
+		implementation.setArtifactName("artifactName");
+		implementation.setArtifactUUID("artifactUUID");
+		operation.setImplementation(implementation);
+		operations.put("key", operation);
+		interfaceDef.setOperations(operations);
+		interfaceDef.setToscaResourceName("toscaResourceName");
+		interfaces.put("key", interfaceDef);
+		((Resource) component).setInterfaces(interfaces);
+		component.setNormalizedName("normalizedName");
+
+		Mockito.when(artifactCassandraDao.getArtifact(Mockito.any(String.class)))
+				.thenReturn(Either.left(new ESArtifactData()));
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeOperationsArtifactsToCsar", component, zip);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testWriteArtifactDefinition() {
+		Component component = new Service();
+		List<ArtifactDefinition> artifactDefinitionList = new ArrayList<>();
+		String artifactPathAndFolder = "";
+
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactType(ArtifactTypeEnum.HEAT_ENV.getType());
+		artifactDefinitionList.add(artifact);
+
+		try (ByteArrayOutputStream out = new ByteArrayOutputStream(); ZipOutputStream zip = new ZipOutputStream(out);) {
+			Deencapsulation.invoke(testSubject, "writeArtifactDefinition", component, zip, artifactDefinitionList,
+					artifactPathAndFolder, false);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	@Test
+	public void testCollectComponentCsarDefinitionWhenComponentIsServiceAndGetToscaElementIsLeft() {
+		Component component = new Service();
+		component.setUniqueId("uniqueId");
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setComponentUid("resourceUid");
+		instance.setOriginType(OriginTypeEnum.SERVICE);
+		resourceInstances.add(instance);
+		component.setComponentInstances(resourceInstances);
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class))).thenReturn(Either.left(component),
+				Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Deencapsulation.invoke(testSubject, "collectComponentCsarDefinition", component);
+
+	}
+
+	@Test
+	public void testCollectComponentTypeArtifactsWhenFetchedComponentHasComponentInstances() {
+		Component component = new Service();
+		Component fetchedComponent = new Resource();
+		component.setUniqueId("uniqueId");
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setComponentUid("resourceUid");
+		instance.setOriginType(OriginTypeEnum.SERVICE);
+		resourceInstances.add(instance);
+		component.setComponentInstances(resourceInstances);
+		fetchedComponent.setComponentInstances(resourceInstances);
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("YANG");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+
+		fetchedComponent.setToscaArtifacts(toscaArtifacts);
+		fetchedComponent.setDeploymentArtifacts(toscaArtifacts);
+		fetchedComponent.setArtifacts(toscaArtifacts);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class))).thenReturn(Either.left(component),
+				Either.left(fetchedComponent), Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Deencapsulation.invoke(testSubject, "collectComponentCsarDefinition", component);
+	}
+
+	@Test
+	public void testCollectComponentTypeArtifactsWhenFetchedComponentDontHaveComponentInstances() {
+		Component component = new Service();
+		Component fetchedComponent = new Resource();
+		component.setUniqueId("uniqueId");
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setComponentUid("resourceUid");
+		instance.setOriginType(OriginTypeEnum.SERVICE);
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("artifactName");
+		artifact.setEsId("esId");
+		artifact.setArtifactUUID("artifactUUID");
+		artifact.setArtifactType("PLAN");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+
+		instance.setDeploymentArtifacts(toscaArtifacts);
+
+		resourceInstances.add(instance);
+		component.setComponentInstances(resourceInstances);
+
+		component.setToscaArtifacts(toscaArtifacts);
+		component.setDeploymentArtifacts(toscaArtifacts);
+		component.setArtifacts(toscaArtifacts);
+
+		fetchedComponent.setToscaArtifacts(toscaArtifacts);
+		fetchedComponent.setDeploymentArtifacts(toscaArtifacts);
+		fetchedComponent.setArtifacts(toscaArtifacts);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class))).thenReturn(Either.left(component),
+				Either.left(fetchedComponent));
+
+		Deencapsulation.invoke(testSubject, "collectComponentCsarDefinition", component);
+	}
+
+	@Test
+	public void testValidateNonMetaArtifactHappyScenario() {
+		String artifactPath = "Artifacts/Deployment/YANG_XML/myYang.xml";
+		byte[] payloadData = "some payload data".getBytes();
+		Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
+		Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath,
+				payloadData, collectedWarningMessages);
+		assertTrue(eitherNonMetaArtifact.isLeft());
+		assertTrue(collectedWarningMessages.isEmpty());
+
+		artifactPath = "Artifacts/Informational/OTHER/someArtifact.xml";
+		eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
+		assertTrue(eitherNonMetaArtifact.isLeft());
+		assertTrue(collectedWarningMessages.isEmpty());
+	}
+
+	@Test
+	public void testValidateNonMetaArtifactScenarioWithWarnnings() {
+		String artifactPath = "Artifacts/Deployment/Buga/myYang.xml";
+		byte[] payloadData = "some payload data".getBytes();
+		Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
+		Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath,
+				payloadData, collectedWarningMessages);
+		assertTrue(eitherNonMetaArtifact.isLeft());
+
+		artifactPath = "Artifacts/Informational/Buga2/someArtifact.xml";
+		eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath, payloadData, collectedWarningMessages);
+		assertTrue(eitherNonMetaArtifact.isLeft());
+
+		assertTrue(collectedWarningMessages.size() == 1);
+		assertTrue(collectedWarningMessages.values().iterator().next().size() == 2);
+	}
+
+	@Test
+	public void testValidateNonMetaArtifactUnhappyScenario() {
+		String artifactPath = "Artifacts/Buga/YANG_XML/myYang.xml";
+		byte[] payloadData = "some payload data".getBytes();
+		Map<String, Set<List<String>>> collectedWarningMessages = new HashMap<>();
+		Either<NonMetaArtifactInfo, Boolean> eitherNonMetaArtifact = CsarUtils.validateNonMetaArtifact(artifactPath,
+				payloadData, collectedWarningMessages);
+		assertTrue(eitherNonMetaArtifact.isRight());
+		assertTrue(!collectedWarningMessages.isEmpty());
+	}
 }
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java
index 139de137d9..18e2ec9fa0 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/PropertyConvertorTest.java
@@ -16,6 +16,7 @@ import java.util.Map;
 import org.junit.Before;
 import org.junit.Test;
 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
+import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
 import org.openecomp.sdc.be.model.DataTypeDefinition;
 import org.openecomp.sdc.be.model.PropertyDefinition;
 import org.openecomp.sdc.be.model.Resource;
@@ -38,6 +39,15 @@ public class PropertyConvertorTest {
         dataTypes.put(property.getName(), new DataTypeDefinition());
     }
 
+    @Test
+    public void testConvertProperty() {
+    	SchemaDefinition schema = new SchemaDefinition();
+    	schema.setProperty(property);
+    	
+    	property.setSchema(schema);
+    	
+    	PropertyConvertor.getInstance().convertProperty(dataTypes, property, true);
+    }
 
     @Test
     public void convertPropertyWhenValueAndDefaultNull() {
@@ -141,5 +151,28 @@ public class PropertyConvertorTest {
         ToscaProperty toscaProperty = PropertyConvertor.getInstance().convertProperty(Collections.emptyMap(), property1, false);
         assertThat(toscaProperty.getDefaultp()).isEqualTo("/");
     }
+    
+    @Test
+    public void testConvertToToscaObject() {
+		dataTypes.put(ToscaPropertyType.Root.getType(), new DataTypeDefinition());
+    	
+    	PropertyConvertor.getInstance().convertToToscaObject(ToscaPropertyType.Root.getType(), "", "innerType", dataTypes);   	
+    }
+    
+    @Test
+    public void testConvertToToscaObjectWhenPropertyTypeAndInnerTypeNull() {
+    	dataTypes.put(ToscaPropertyType.Root.getType(), new DataTypeDefinition());
+    	
+    	PropertyConvertor.getInstance().convertToToscaObject(null, "value", null, dataTypes);
+    }
+    
+    @Test
+    public void testConvertToToscaObjectWhenIsScalarTypeIsNotNull() {
+    	DataTypeDefinition def = new DataTypeDefinition();
+    	def.setName("integer");
+    	dataTypes.put("type", def);
+    	
+    	PropertyConvertor.getInstance().convertToToscaObject("type", "value", "innerType", dataTypes);
+    }
 
 }
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
new file mode 100644
index 0000000000..92819ca012
--- /dev/null
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java
@@ -0,0 +1,1244 @@
+package org.openecomp.sdc.be.tosca;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Triple;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.openecomp.sdc.be.components.BeConfDependentTest;
+import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
+import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
+import org.openecomp.sdc.be.datatypes.elements.SchemaDefinition;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
+import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
+import org.openecomp.sdc.be.model.ArtifactDefinition;
+import org.openecomp.sdc.be.model.CapabilityDefinition;
+import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
+import org.openecomp.sdc.be.model.Component;
+import org.openecomp.sdc.be.model.ComponentInstance;
+import org.openecomp.sdc.be.model.ComponentInstanceInput;
+import org.openecomp.sdc.be.model.ComponentInstanceProperty;
+import org.openecomp.sdc.be.model.ComponentParametersView;
+import org.openecomp.sdc.be.model.DataTypeDefinition;
+import org.openecomp.sdc.be.model.GroupDefinition;
+import org.openecomp.sdc.be.model.GroupInstance;
+import org.openecomp.sdc.be.model.GroupProperty;
+import org.openecomp.sdc.be.model.InputDefinition;
+import org.openecomp.sdc.be.model.PropertyDefinition;
+import org.openecomp.sdc.be.model.RelationshipInfo;
+import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
+import org.openecomp.sdc.be.model.RequirementDefinition;
+import org.openecomp.sdc.be.model.Resource;
+import org.openecomp.sdc.be.model.Service;
+import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
+import org.openecomp.sdc.be.model.category.CategoryDefinition;
+import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
+import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
+import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
+import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
+import org.openecomp.sdc.be.tosca.model.ToscaCapability;
+import org.openecomp.sdc.be.tosca.model.ToscaGroupTemplate;
+import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
+import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
+import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
+import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
+import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
+import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
+
+import fj.data.Either;
+import mockit.Deencapsulation;
+
+public class ToscaExportHandlerTest extends BeConfDependentTest {
+
+	@InjectMocks
+	ToscaExportHandler testSubject;
+
+	@Mock
+	ApplicationDataTypeCache dataTypeCache;
+
+	@Mock
+	ToscaOperationFacade toscaOperationFacade;
+
+	@Mock
+	CapabiltyRequirementConvertor capabiltyRequirementConvertor;
+
+	@Before
+	public void setUpMock() throws Exception {
+		MockitoAnnotations.initMocks(this);
+	}
+
+	private Resource getNewResource() {
+		Resource resource = new Resource();
+		List<CategoryDefinition> categories = new ArrayList<>();
+		CategoryDefinition category = new CategoryDefinition();
+		List<SubCategoryDefinition> subcategories = new ArrayList<>();
+		SubCategoryDefinition subcategory = new SubCategoryDefinition();
+
+		subcategory.setName("name");
+		subcategories.add(subcategory);
+		category.setName("name");
+		category.setSubcategories(subcategories);
+		categories.add(category);
+
+		resource.setCategories(categories);
+		resource.setVersion("version");
+		resource.setVendorName("vendorName");
+		resource.setVendorRelease("vendorRelease");
+		resource.setResourceVendorModelNumber("resourceVendorModelNumber");
+
+		return resource;
+	}
+
+	private Service getNewService() {
+		Service service = new Service();
+		List<CategoryDefinition> categories = new ArrayList<>();
+		CategoryDefinition category = new CategoryDefinition();
+		List<SubCategoryDefinition> subcategories = new ArrayList<>();
+		SubCategoryDefinition subcategory = new SubCategoryDefinition();
+
+		subcategory.setName("name");
+		subcategories.add(subcategory);
+		category.setName("name");
+		category.setSubcategories(subcategories);
+		categories.add(category);
+
+		service.setCategories(categories);
+		service.setComponentType(ComponentTypeEnum.SERVICE);
+		service.setServiceType("serviceType");
+		service.setServiceRole("serviceRole");
+		service.setEnvironmentContext("environmentContext");
+
+		return service;
+	}
+
+	@Test
+	public void testExportComponent() throws Exception {
+		Component component = getNewResource();
+		Either<ToscaRepresentation, ToscaError> result;
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Resource.class),
+				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
+
+		// default test when component is Resource
+		result = testSubject.exportComponent(component);
+
+		component = getNewService();
+		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Service.class),
+				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
+
+		// default test when component is Service
+		result = testSubject.exportComponent(component);
+	}
+
+	@Test
+	public void testExportComponentInterface() throws Exception {
+		Component component = getNewResource();
+		Either<ToscaRepresentation, ToscaError> result;
+
+		((Resource) component).setInterfaces(new HashMap<>());
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
+
+		// default test when convertInterfaceNodeType is right
+		result = testSubject.exportComponentInterface(component);
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Resource.class),
+				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
+
+		// default test when convertInterfaceNodeType is left
+		result = testSubject.exportComponentInterface(component);
+
+	}
+
+	@Test
+	public void testCreateToscaRepresentation() throws Exception {
+		ToscaTemplate toscaTemplate = new ToscaTemplate("");
+		ToscaRepresentation result;
+
+		// default test
+		result = testSubject.createToscaRepresentation(toscaTemplate);
+	}
+
+	@Test
+	public void testGetDependencies() throws Exception {
+
+		Component component = new Resource();
+		Either<ToscaTemplate, ToscaError> result;
+
+		// default test
+		result = testSubject.getDependencies(component);
+	}
+
+	@Test
+	public void testConvertToscaTemplate() throws Exception {
+
+		Component component = getNewResource();
+		ToscaTemplate toscaNode = new ToscaTemplate("");
+		Either<ToscaTemplate, ToscaError> result;
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+
+		instance.setOriginType(OriginTypeEnum.SERVICE);
+		instance.setSourceModelUid("targetModelUid");
+		resourceInstances.add(instance);
+
+		component.setComponentInstances(resourceInstances);
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+		Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
+				Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
+	}
+
+	@Test
+	public void testConvertToscaTemplateWhenComponentContainsGroup() {
+		Component component = getNewResource();
+		ToscaTemplate toscaNode = new ToscaTemplate("");
+		Either<ToscaTemplate, ToscaError> result;
+		component.setComponentInstances(new ArrayList<>());
+
+		List<GroupDefinition> groups = new ArrayList<>();
+		GroupDefinition group = new GroupDefinition();
+		List<String> artifacts = new ArrayList<>();
+		artifacts.add("artifact");
+		group.setType("org.openecomp.groups.VfModule");
+		group.setArtifacts(artifacts);
+		groups.add(group);
+		component.setGroups(groups);
+
+		Map<String, String[]> substitutionMappingMap = new HashMap<>();
+		String[] array = { "value1", "value2" };
+		substitutionMappingMap.put("key", array);
+
+		Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
+				Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
+
+		Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
+				Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
+				.thenReturn(Either.left(new SubstitutionMapping()));
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+
+		// test component contains group
+		result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
+	}
+
+	@Test
+	public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
+		Component component = getNewService();
+		ToscaTemplate toscaNode = new ToscaTemplate("");
+		Either<ToscaTemplate, ToscaError> result;
+		component.setComponentInstances(new ArrayList<>());
+
+		List<GroupDefinition> groups = new ArrayList<>();
+		GroupDefinition group = new GroupDefinition();
+		List<String> artifacts = new ArrayList<>();
+		artifacts.add("artifact");
+		group.setType("org.openecomp.groups.VfModule");
+		group.setArtifacts(artifacts);
+		groups.add(group);
+		component.setGroups(groups);
+
+		Map<String, String[]> substitutionMappingMap = new HashMap<>();
+		String[] array = { "value1", "value2" };
+		substitutionMappingMap.put("key", array);
+
+		Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
+				Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
+
+		Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
+				Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
+				.thenReturn(Either.left(new SubstitutionMapping()));
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+
+		// test component contains group
+		result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
+	}
+
+	@Test
+	public void testFillInputs() throws Exception {
+		Component component = new Resource();
+		ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		Either<ToscaTopolgyTemplate, ToscaError> result;
+
+		InputDefinition input = new InputDefinition();
+
+		List<InputDefinition> inputs = new ArrayList<>();
+		inputs.add(input);
+		component.setInputs(inputs);
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "fillInputs", component, topologyTemplate, dataTypes);
+	}
+
+	@Test
+	public void testConvertMetadata_1() throws Exception {
+
+		Component component = getNewResource();
+		boolean isInstance = true;
+		ComponentInstance componentInstance = new ComponentInstance();
+		componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
+		componentInstance.setSourceModelInvariant("targetModelInvariant");
+
+		ToscaMetadata result;
+
+		// default test
+
+		result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
+	}
+
+	@Test
+	public void testFillImports() throws Exception {
+
+		Component component = getNewService();
+		ToscaTemplate toscaTemplate = new ToscaTemplate("");
+		Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
+
+		ComponentInstance instance = new ComponentInstance();
+		List<ComponentInstance> resourceInstances = new ArrayList<>();
+		instance.setComponentUid("name");
+		resourceInstances.add(instance);
+		component.setComponentInstances(resourceInstances);
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("name.name2");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+		component.setToscaArtifacts(toscaArtifacts);
+
+		Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.any(String.class)))
+				.thenReturn(Either.left(component));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
+	}
+
+	@Test
+	public void testCreateDependency() throws Exception {
+
+		Map<String, Component> componentCache = new HashMap<>();
+		List<Map<String, Map<String, String>>> imports = new ArrayList<>();
+		List<Triple<String, String, Component>> dependecies = new ArrayList<>();
+		ComponentInstance ci = new ComponentInstance();
+		Component component = getNewResource();
+
+		Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
+		ArtifactDefinition artifact = new ArtifactDefinition();
+		artifact.setArtifactName("name.name2");
+		toscaArtifacts.put("assettoscatemplate", artifact);
+		component.setToscaArtifacts(toscaArtifacts);
+		ci.setComponentUid("name");
+		ci.setOriginType(OriginTypeEnum.ServiceProxy);
+		ci.setSourceModelUid("modelName");
+
+		Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("name"))).thenReturn(Either.left(component));
+
+		Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("modelName")))
+				.thenReturn(Either.left(new Service()));
+
+		// default test
+		Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
+	}
+
+	@Test
+	public void testGetInterfaceFilename() throws Exception {
+		String artifactName = "artifact.name";
+		String result;
+
+		// default test
+		result = ToscaExportHandler.getInterfaceFilename(artifactName);
+	}
+
+	@Test
+	public void testConvertNodeType() throws Exception {
+		Component component = new Resource();
+		ToscaTemplate toscaNode = new ToscaTemplate("");
+		Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
+		Either<ToscaTemplate, ToscaError> result;
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.ALREADY_EXIST));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertNodeType", component, toscaNode, nodeTypes);
+	}
+
+	@Test
+	public void testConvertInterfaceNodeType() throws Exception {
+		Component component = getNewResource();
+		ToscaTemplate toscaNode = new ToscaTemplate("");
+		Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
+		Either<ToscaTemplate, ToscaError> result;
+		List<InputDefinition> inputs = new ArrayList<>();
+		inputs.add(new InputDefinition());
+		component.setInputs(inputs);
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+
+		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Resource.class),
+				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", component, toscaNode, nodeTypes);
+	}
+
+	@Test
+	public void testConvertReqCapAndTypeName() throws Exception {
+		Component component = new Resource();
+		ToscaTemplate toscaNode = new ToscaTemplate("");
+		Map<String, ToscaNodeType> nodeTypes = new HashMap();
+		ToscaNodeType toscaNodeType = new ToscaNodeType();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		Either<ToscaTemplate, ToscaError> result;
+
+		Mockito.when(
+				capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Resource.class), Mockito.any(Map.class)))
+				.thenReturn(new HashMap<>());
+
+		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Resource.class),
+				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
+				toscaNodeType, dataTypes);
+
+		component = new Service();
+
+		Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Service.class),
+				Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
+
+		// test when component is service
+		result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
+				toscaNodeType, dataTypes);
+	}
+
+	@Test
+	public void testConvertNodeTemplates() throws Exception {
+		Component component = getNewResource();
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
+		Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
+		Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
+		List<ComponentInstanceInput> inputs = new ArrayList<>();
+		inputs.add(new ComponentInstanceInput());
+		componentInstancesInputs.put("key", inputs);
+		List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
+		RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
+		reldef.setFromNode("node");
+		resourceInstancesRelations.add(reldef);
+		component.setComponentInstancesRelations(resourceInstancesRelations);
+
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("uid");
+		instance.setOriginType(OriginTypeEnum.ServiceProxy);
+		List<GroupInstance> groupInstances = new ArrayList<>();
+		GroupInstance groupInst = new GroupInstance();
+		List<String> artifacts = new ArrayList<>();
+		artifacts.add("artifact");
+		groupInst.setArtifacts(artifacts);
+		groupInst.setType("type");
+		groupInstances.add(groupInst);
+		instance.setGroupInstances(groupInstances);
+		componentInstances.add(instance);
+
+		component.setComponentInstancesInputs(componentInstancesInputs);
+		component.setInvariantUUID("uuid");
+		component.setUUID("uuid");
+		component.setDescription("desc");
+
+		componentCache.put("uid", component);
+
+		componentInstancesProperties.put("id", new ArrayList<>());
+		componentInstancesInputs.put("id", new ArrayList<>());
+
+		Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
+				Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
+
+		Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilties(
+				Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
+				.thenReturn(Either.left(new ToscaNodeTemplate()));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
+				componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
+	}
+
+	@Test
+	public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
+		Component component = getNewService();
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
+		Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
+		Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
+		List<ComponentInstanceInput> inputs = new ArrayList<>();
+		inputs.add(new ComponentInstanceInput());
+		componentInstancesInputs.put("key", inputs);
+		List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
+		RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
+		reldef.setFromNode("node");
+		resourceInstancesRelations.add(reldef);
+		component.setComponentInstancesRelations(resourceInstancesRelations);
+
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("uid");
+		instance.setOriginType(OriginTypeEnum.ServiceProxy);
+		List<GroupInstance> groupInstances = new ArrayList<>();
+		GroupInstance groupInst = new GroupInstance();
+		List<String> artifacts = new ArrayList<>();
+		artifacts.add("artifact");
+		groupInst.setArtifacts(artifacts);
+		groupInst.setType("type");
+		groupInstances.add(groupInst);
+		instance.setGroupInstances(groupInstances);
+		componentInstances.add(instance);
+
+		component.setComponentInstancesInputs(componentInstancesInputs);
+		component.setInvariantUUID("uuid");
+		component.setUUID("uuid");
+		component.setDescription("desc");
+
+		Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
+		ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
+		ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
+		path.setPathElements(list);
+		forwardingPaths.put("key", path);
+
+		((Service) component).setForwardingPaths(forwardingPaths);
+
+		componentCache.put("uid", component);
+
+		componentInstancesProperties.put("id", new ArrayList<>());
+		componentInstancesInputs.put("id", new ArrayList<>());
+
+		Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
+				Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
+
+		Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilties(
+				Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
+				.thenReturn(Either.left(new ToscaNodeTemplate()));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
+				componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
+	}
+
+	@Test
+	public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
+		Component component = getNewResource();
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
+		Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
+		Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
+		List<ComponentInstanceInput> inputs = new ArrayList<>();
+		inputs.add(new ComponentInstanceInput());
+		componentInstancesInputs.put("key", inputs);
+		List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
+		RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
+		reldef.setFromNode("node");
+		resourceInstancesRelations.add(reldef);
+		component.setComponentInstancesRelations(resourceInstancesRelations);
+
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("uid");
+		instance.setOriginType(OriginTypeEnum.ServiceProxy);
+		componentInstances.add(instance);
+
+		component.setComponentInstancesInputs(componentInstancesInputs);
+		component.setInvariantUUID("uuid");
+		component.setUUID("uuid");
+		component.setDescription("desc");
+
+		componentCache.put("uid", component);
+
+		Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
+				Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
+
+		Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilties(
+				Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
+				.thenReturn(Either.right(ToscaError.GENERAL_ERROR));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
+				componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
+	}
+
+	@Test
+	public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
+		Component component = getNewResource();
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
+		Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
+		Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
+		List<ComponentInstanceInput> inputs = new ArrayList<>();
+		inputs.add(new ComponentInstanceInput());
+		componentInstancesInputs.put("key", inputs);
+		List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
+		RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
+		reldef.setFromNode("id");
+		resourceInstancesRelations.add(reldef);
+		component.setComponentInstancesRelations(resourceInstancesRelations);
+
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		instance.setComponentUid("uid");
+		instance.setOriginType(OriginTypeEnum.ServiceProxy);
+		componentInstances.add(instance);
+
+		component.setComponentInstancesInputs(componentInstancesInputs);
+		component.setInvariantUUID("uuid");
+		component.setUUID("uuid");
+		component.setDescription("desc");
+
+		componentCache.put("uid", component);
+
+		Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
+				Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
+				componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
+	}
+
+	@Test
+	public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
+		Component component = new Resource();
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
+		Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
+		Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
+		List<ComponentInstanceInput> inputs = new ArrayList<>();
+		inputs.add(new ComponentInstanceInput());
+		componentInstancesInputs.put("key", inputs);
+		List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
+		RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
+		reldef.setFromNode("id");
+		reldef.setToNode("node");
+		List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+		CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
+		relationship.setRelation(new RelationshipInfo());
+		relationships.add(relationship);
+		reldef.setRelationships(relationships);
+		resourceInstancesRelations.add(reldef);
+		component.setComponentInstancesRelations(resourceInstancesRelations);
+
+		ComponentInstance instance = new ComponentInstance();
+		instance.setUniqueId("id");
+		componentInstances.add(instance);
+
+		component.setComponentInstancesInputs(componentInstancesInputs);
+		component.setComponentInstances(componentInstances);
+
+		Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
+				Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
+				componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
+	}
+
+	@Test
+	public void testAddComponentInstanceInputs() throws Exception {
+
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
+		ComponentInstance componentInstance = new ComponentInstance();
+		String instanceUniqueId = "id";
+		Map<String, Object> props = new HashMap<>();
+
+		List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
+		componentInstanceInputs.add(new ComponentInstanceInput());
+
+		componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
+
+		// default test
+		Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
+				componentInstance, instanceUniqueId, props);
+	}
+
+	@Test
+	public void testAddPropertiesOfComponentInstance() throws Exception {
+		Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ComponentInstance componentInstance = new ComponentInstance();
+		String instanceUniqueId = "id";
+		Map<String, Object> props = new HashMap<>();
+
+		ComponentInstanceProperty cip = new ComponentInstanceProperty();
+		cip.setInstanceUniqueId("id");
+
+		List<ComponentInstanceProperty> list = new ArrayList<>();
+		list.add(cip);
+
+		componentInstancesProperties.put("id", list);
+
+		// default test
+		Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
+				componentInstance, instanceUniqueId, props);
+	}
+
+	@Test
+	public void testAddPropertiesOfParentComponent() throws Exception {
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ComponentInstance componentInstance = new ComponentInstance();
+		Component componentOfInstance = new Resource();
+		Map<String, Object> props = new HashMap<>();
+
+		List<PropertyDefinition> properties = new ArrayList<>();
+		properties.add(new PropertyDefinition());
+
+		((Resource) componentOfInstance).setProperties(properties);
+
+		// default test
+		Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes, componentInstance,
+				componentOfInstance, props);
+	}
+
+	@Test
+	public void testConvertAndAddValue() throws Exception {
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ComponentInstance componentInstance = new ComponentInstance();
+		Map<String, Object> props = new HashMap<>();
+		PropertyDefinition prop = new PropertyDefinition();
+		Supplier<String> supplier = () -> "";
+
+		// default test
+		Deencapsulation.invoke(testSubject, "convertAndAddValue", dataTypes, componentInstance, props, prop, supplier);
+	}
+
+	@Test
+	public void testConvertValue() throws Exception {
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		ComponentInstance componentInstance = new ComponentInstance();
+		Supplier<String> supplier = () -> "";
+		PropertyDefinition input = new PropertyDefinition();
+		SchemaDefinition schema = new SchemaDefinition();
+		schema.setProperty(new PropertyDataDefinition());
+		input.setSchema(schema);
+		Object result;
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertValue", dataTypes, componentInstance, input, supplier);
+
+	}
+
+	@Test
+	public void testConvertGroupInstance() throws Exception {
+
+		GroupInstance groupInstance = new GroupInstance();
+		groupInstance.setType("type");
+		ToscaGroupTemplate result;
+
+		// default test
+
+		result = Deencapsulation.invoke(testSubject, "convertGroupInstance", groupInstance);
+	}
+
+	@Test
+	public void testFillGroupProperties() throws Exception {
+		List<GroupProperty> groupProps = new ArrayList<>();
+		GroupProperty property = new GroupProperty();
+		property.setName("isBase");
+		groupProps.add(property);
+		Map<String, Object> result;
+
+		// test when property name is 'isBase'
+		result = Deencapsulation.invoke(testSubject, "fillGroupProperties", groupProps);
+
+		groupProps.get(0).setName("name");
+		groupProps.get(0).setType("integer");
+		groupProps.get(0).setValue("123");
+
+		// test when property name isn't 'isBase' and value type is integer
+		result = Deencapsulation.invoke(testSubject, "fillGroupProperties", groupProps);
+
+		groupProps.get(0).setType("boolean");
+		groupProps.get(0).setValue("false");
+
+		// test when property name isn't 'isBase' and value type is boolean
+		result = Deencapsulation.invoke(testSubject, "fillGroupProperties", groupProps);
+
+	}
+
+	@Test
+	public void testCreateNodeType() throws Exception {
+
+		Component component = new Resource();
+		List<String> array = new ArrayList<>();
+		array.add("value");
+		((Resource) component).setDerivedFrom(array);
+		ToscaNodeType result;
+
+		// test when component is resource
+		result = Deencapsulation.invoke(testSubject, "createNodeType", component);
+
+		component = new Service();
+		// test when component is service
+		result = Deencapsulation.invoke(testSubject, "createNodeType", component);
+	}
+
+	@Test
+	public void testCreateProxyNodeTypes() throws Exception {
+		Map<String, Component> componentCache = new HashMap<>();
+		Component container = new Resource();
+		Either<Map<String, ToscaNodeType>, ToscaError> result;
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setOriginType(OriginTypeEnum.ServiceProxy);
+		instance.setSourceModelUid("targetModelUid");
+
+		componentInstances.add(instance);
+		container.setComponentInstances(componentInstances);
+
+		Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		// test when getLatestByName return is right
+		result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
+
+	}
+
+	@Test
+	public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
+		Map<String, Component> componentCache = new HashMap<>();
+		Component container = new Resource();
+		Either<Map<String, ToscaNodeType>, ToscaError> result;
+		List<ComponentInstance> componentInstances = new ArrayList<>();
+		ComponentInstance instance = new ComponentInstance();
+		instance.setOriginType(OriginTypeEnum.ServiceProxy);
+		instance.setSourceModelUid("targetModelUid");
+
+		componentInstances.add(instance);
+		container.setComponentInstances(componentInstances);
+
+		Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
+
+		ComponentParametersView parameterView = new ComponentParametersView();
+		parameterView.disableAll();
+		parameterView.setIgnoreCategories(false);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+
+		// test when getLatestByName is left
+		result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
+	}
+
+	@Test
+	public void testCreateProxyNodeType() throws Exception {
+		Map<String, Component> componentCache = new HashMap<>();
+		Component origComponent = new Resource();
+		Component proxyComponent = new Resource();
+		ComponentInstance instance = new ComponentInstance();
+		ToscaNodeType result;
+
+		Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
+				proxyComponent, instance);
+	}
+
+	@Test
+	public void testConvertComponentInstanceRequirements() throws Exception {
+		Component component = new Resource();
+		ComponentInstance componentInstance = new ComponentInstance();
+		List<RequirementCapabilityRelDef> relations = new ArrayList<>();
+		ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
+		Component originComponent = new Resource();
+		Map<String, Component> componentCache = new HashMap<>();
+		Either<ToscaNodeTemplate, ToscaError> result;
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
+				componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
+
+		RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
+		reldef.setFromNode("name");
+		reldef.setToNode("name1");
+		List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+		CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
+		cap.setRelation(new RelationshipInfo());
+		relationships.add(cap);
+		reldef.setRelationships(relationships);
+		relations.add(reldef);
+		componentInstance.setUniqueId("name");
+
+		List<ComponentInstance> instances = new ArrayList<>();
+		instances.add(componentInstance);
+		component.setComponentInstances(instances);
+
+		// test when filteredRElations ins't empty
+		result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
+				componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
+	}
+
+	@Test
+	public void testAddRequirement() throws Exception {
+		ComponentInstance fromInstance = new ComponentInstance();
+		Component fromOriginComponent = new Resource();
+		List<ComponentInstance> instancesList = new ArrayList<>();
+		RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
+		List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		boolean result;
+
+		List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+		CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
+		cap.setRequirement(new RequirementDataDefinition());
+		RelationshipInfo relation = new RelationshipInfo();
+		relation.setRequirementUid("Uid");
+		relation.setRequirement("requirment");
+		relation.setCapability("cap");
+		relation.setCapabilityOwnerId("id1");
+		cap.setRelation(relation);
+		relationships.add(cap);
+		rel.setRelationships(relationships);
+		rel.setToNode("name");
+		fromInstance.setUniqueId("name");
+		fromInstance.setComponentUid("string");
+		instancesList.add(fromInstance);
+		Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+		fromOriginComponent.setRequirements(requirements);
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
+				rel, toscaRequirements, componentCache);
+
+	}
+
+	@Test
+	public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
+
+		ComponentInstance fromInstance = new ComponentInstance();
+		Component fromOriginComponent = new Resource();
+		List<ComponentInstance> instancesList = new ArrayList<>();
+		RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
+		List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		boolean result;
+
+		List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+		CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
+		cap.setRequirement(new RequirementDataDefinition());
+		RelationshipInfo relation = new RelationshipInfo();
+		relation.setRequirementUid("Uid");
+		relation.setRequirement("requirment");
+		relation.setCapability("cap");
+		relation.setCapabilityOwnerId("id1");
+		cap.setRelation(relation);
+		relationships.add(cap);
+		rel.setRelationships(relationships);
+		rel.setToNode("name");
+		fromInstance.setUniqueId("name");
+		fromInstance.setComponentUid("string");
+		instancesList.add(fromInstance);
+		Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+
+		List<RequirementDefinition> defs = new ArrayList<>();
+		RequirementDefinition def = new RequirementDefinition();
+		def.setName("requirment");
+		def.setCapability("cap");
+		defs.add(def);
+		requirements.put("key", defs);
+		fromOriginComponent.setRequirements(requirements);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class)))
+				.thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
+				rel, toscaRequirements, componentCache);
+	}
+
+	@Test
+	public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
+		ComponentInstance fromInstance = new ComponentInstance();
+		Component fromOriginComponent = new Resource();
+		List<ComponentInstance> instancesList = new ArrayList<>();
+		RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
+		List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		boolean result;
+
+		List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+		CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
+		cap.setRequirement(new RequirementDataDefinition());
+		RelationshipInfo relation = new RelationshipInfo();
+		relation.setRequirementUid("Uid");
+		relation.setRequirement("requirment");
+		relation.setCapability("cap");
+		relation.setCapabilityOwnerId("id1");
+		cap.setRelation(relation);
+		relationships.add(cap);
+		rel.setRelationships(relationships);
+		rel.setToNode("name");
+		fromInstance.setUniqueId("name");
+		fromInstance.setComponentUid("string");
+		instancesList.add(fromInstance);
+		Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+
+		List<RequirementDefinition> defs = new ArrayList<>();
+		RequirementDefinition def = new RequirementDefinition();
+		def.setName("requirment");
+		def.setCapability("cap");
+		defs.add(def);
+		requirements.put("key", defs);
+		fromOriginComponent.setRequirements(requirements);
+
+		Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
+		List<CapabilityDefinition> caps = new ArrayList<>();
+		CapabilityDefinition capdef = new CapabilityDefinition();
+		capdef.setOwnerId("id");
+		capdef.setName("name");
+		capdef.setType("type");
+		caps.add(capdef);
+		capabilities.put("cap", caps);
+
+		fromOriginComponent.setCapabilities(capabilities);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
+				rel, toscaRequirements, componentCache);
+	}
+
+	@Test
+	public void testAddRequirmentsWithBuildAndAddRequirements() {
+		ComponentInstance fromInstance = new ComponentInstance();
+		Component fromOriginComponent = new Resource();
+		List<ComponentInstance> instancesList = new ArrayList<>();
+		RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
+		List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
+		Map<String, Component> componentCache = new HashMap<>();
+		boolean result;
+
+		List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
+		CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
+		cap.setRequirement(new RequirementDataDefinition());
+		RelationshipInfo relation = new RelationshipInfo();
+		relation.setRequirementUid("Uid");
+		relation.setRequirement("requirment");
+		relation.setCapability("cap");
+		relation.setCapabilityOwnerId("id");
+		cap.setRelation(relation);
+		relationships.add(cap);
+		rel.setRelationships(relationships);
+		rel.setToNode("name");
+		fromInstance.setUniqueId("name");
+		fromInstance.setComponentUid("string");
+		instancesList.add(fromInstance);
+		Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
+
+		List<RequirementDefinition> defs = new ArrayList<>();
+		RequirementDefinition def = new RequirementDefinition();
+		def.setName("requirment");
+		def.setCapability("cap");
+		defs.add(def);
+		requirements.put("key", defs);
+		fromOriginComponent.setRequirements(requirements);
+
+		Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
+		List<CapabilityDefinition> caps = new ArrayList<>();
+		CapabilityDefinition capdef = new CapabilityDefinition();
+		capdef.setOwnerId("id");
+		capdef.setName("cap");
+		capdef.setType("type");
+		caps.add(capdef);
+		capabilities.put("cap", caps);
+		fromOriginComponent.setCapabilities(capabilities);
+
+		Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
+				Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
+
+		Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
+				Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString()))
+				.thenReturn(Either.right(false));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
+				rel, toscaRequirements, componentCache);
+	}
+
+	@Test
+	public void testBuildAndAddRequirement() throws Exception {
+		List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
+		Component fromOriginComponent = new Resource();
+		Component toOriginComponent = new Resource();
+		CapabilityDefinition capability = new CapabilityDefinition();
+		RequirementDefinition requirement = new RequirementDefinition();
+		RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
+		ComponentInstance toInstance = new ComponentInstance();
+		Map<String, Component> componentCache = new HashMap<>();
+		boolean result;
+		capability.setPath(new ArrayList<>());
+		reqAndRelationshipPair.setCapability("cap");
+		requirement.setPath(new ArrayList<>());
+		reqAndRelationshipPair.setRequirement("req");
+
+		Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
+				new ArrayList<>(), "cap")).thenReturn(Either.left("buildCapNameRes"));
+
+		Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
+				new ArrayList<>(), "req")).thenReturn(Either.right(false));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
+				toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
+	}
+
+	@Test
+	public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
+		List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
+		Component fromOriginComponent = new Resource();
+		Component toOriginComponent = new Resource();
+		CapabilityDefinition capability = new CapabilityDefinition();
+		RequirementDefinition requirement = new RequirementDefinition();
+		RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
+		ComponentInstance toInstance = new ComponentInstance();
+		Map<String, Component> componentCache = new HashMap<>();
+		boolean result;
+		capability.setPath(new ArrayList<>());
+		reqAndRelationshipPair.setCapability("cap");
+		requirement.setPath(new ArrayList<>());
+		reqAndRelationshipPair.setRequirement("req");
+
+		Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
+				Mockito.anyList(), Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
+				toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
+	}
+
+	@Test
+	public void testIsRequirementBelongToRelation() throws Exception {
+
+		Component originComponent = new Resource();
+		RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
+		RequirementDefinition requirement = new RequirementDefinition();
+		String fromInstanceId = "";
+		boolean result;
+
+		requirement.setName("name");
+		reqAndRelationshipPair.setRequirement("name1");
+
+		// test return false
+		result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
+				reqAndRelationshipPair, requirement, fromInstanceId);
+	}
+
+	@Test
+	public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
+
+		Component originComponent = new Service();
+		RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
+		RequirementDefinition requirement = new RequirementDefinition();
+		String fromInstanceId = "";
+		boolean result;
+
+		// default test return true
+		result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
+				reqAndRelationshipPair, requirement, fromInstanceId);
+	}
+
+	@Test
+	public void testIsRequirementBelongToOwner() throws Exception {
+
+		RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
+		RequirementDefinition requirement = new RequirementDefinition();
+		String fromInstanceId = "";
+		Component originComponent = new Resource();
+		boolean result;
+
+		requirement.setOwnerId("owner1");
+		reqAndRelationshipPair.setRequirementOwnerId("owner");
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
+				fromInstanceId, originComponent);
+	}
+
+	@Test
+	public void testIsCvfc() throws Exception {
+
+		Component component = new Resource();
+		boolean result;
+
+		component = new Service();
+
+		result = Deencapsulation.invoke(testSubject, "isCvfc", component);
+	}
+
+	@Test
+	public void testConvertCapabilities() throws Exception {
+		Component component = new Resource();
+		SubstitutionMapping substitutionMappings = new SubstitutionMapping();
+		Map<String, Component> componentCache = new HashMap<>();
+		Either<SubstitutionMapping, ToscaError> result;
+
+		Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
+				.thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
+
+		// default test return isRight
+		result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
+				componentCache);
+	}
+
+	@Test
+	public void testConvertCapabilities_1() throws Exception {
+		Component component = new Resource();
+		ToscaNodeType nodeType = new ToscaNodeType();
+		Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
+		Either<ToscaNodeType, ToscaError> result;
+
+		Map<String, ToscaCapability> capabilities = new HashMap<>();
+		capabilities.put("key", new ToscaCapability());
+
+		Mockito.when(capabiltyRequirementConvertor.convertCapabilities(component, dataTypes)).thenReturn(capabilities);
+
+		// default test
+		result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);
+	}
+}
\ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java
deleted file mode 100644
index 041973a0b4..0000000000
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportUtilsTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package org.openecomp.sdc.be.tosca;
-
-import org.junit.Test;
-import org.openecomp.sdc.be.components.impl.ComponentInstanceBusinessLogic;
-import org.openecomp.sdc.be.model.operations.impl.ComponentInstanceOperation;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-
-public class ToscaExportUtilsTest {
-    private static final Logger log = LoggerFactory.getLogger(ToscaExportUtilsTest.class);
-    @javax.annotation.Resource
-    private ComponentInstanceBusinessLogic componentInstanceBusinessLogic;
-    @Autowired
-    private ToscaExportHandler exportUtils;
-    @Autowired
-    private ComponentInstanceOperation componentInstanceOperation;
-
-    Gson gson = new GsonBuilder().setPrettyPrinting().create();
-
-    @Test
-    public void testExportService() {
-    /*    Resource resource1 = ResourceTestUtils.prepareResource(0);
-        resource1.setResourceType(ResourceTypeEnum.VF);
-        Either<Resource, ResponseFormat> createResource1 = resourceBusinessLogic.createResource(resource1, getAdminUser(), null, null);
-        assertTrue(createResource1.isLeft());
-        Resource certifiedVFC1 = changeResourceStateToCertify(createResource1.left().value());
-
-        Resource resource2 = ResourceTestUtils.prepareResource(1);
-        resource2.setResourceType(ResourceTypeEnum.VF);
-        Either<Resource, ResponseFormat> createResource2 = resourceBusinessLogic.createResource(resource2, getAdminUser(), null, null);
-        assertTrue(createResource2.isLeft());
-        Resource certifiedVFC2 = changeResourceStateToCertify(createResource2.left().value());
-
-        Service service = ResourceTestUtils.prepareService(0);
-        Either<Service, ResponseFormat> createService = serviceBusinessLogic.createService(service, getAdminUser());
-        assertTrue(createService.isLeft());
-
-        // add VFC instance to VF
-        ComponentInstance vfcResourceInstance1 = new ComponentInstance();
-        vfcResourceInstance1.setDescription("VFC instance 1");
-        vfcResourceInstance1.setName(certifiedVFC1.getName());
-        vfcResourceInstance1.setComponentUid(certifiedVFC1.getUniqueId());
-
-        Either<ComponentInstance, ResponseFormat> createResourceVfcInstance1 = serviceInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, createService.left().value().getUniqueId(), adminUser.getAttuid(),
-                vfcResourceInstance1);
-        assertTrue(createResourceVfcInstance1.isLeft());
-
-        ComponentInstance vfcResourceInstance2 = new ComponentInstance();
-        vfcResourceInstance2.setDescription("VFC instance 2");
-        vfcResourceInstance2.setName(certifiedVFC2.getName());
-        vfcResourceInstance2.setComponentUid(certifiedVFC2.getUniqueId());
-        Either<ComponentInstance, ResponseFormat> createResourceVfcInstance2 = serviceInstanceBusinessLogic.createComponentInstance(ComponentTypeEnum.SERVICE_PARAM_NAME, createService.left().value().getUniqueId(), adminUser.getAttuid(),
-                vfcResourceInstance2);
-        assertTrue(createResourceVfcInstance2.isLeft());
-
-        Either<Service, ResponseFormat> serviceFetch = serviceBusinessLogic.getService(createService.left().value().getUniqueId(), adminUser);
-        assertTrue(serviceFetch.isLeft());
-
-        List<ComponentInstance> componentInstances = serviceFetch.left().value().getComponentInstances();
-        String ciname1 = null;
-        String ciname2 = null;
-
-        for (ComponentInstance ci : componentInstances) {
-            if (ci.getComponentUid().equals(certifiedVFC1.getUniqueId())) {
-                ciname1 = ci.getName();
-            }
-            if (ci.getComponentUid().equals(certifiedVFC2.getUniqueId())) {
-                ciname2 = ci.getName();
-            }
-        }
-
-        Either<ToscaRepresentation, ToscaError> result = exportUtils.exportComponent(serviceFetch.left().value());
-        assertTrue(result.isLeft());
-
-        String mainYaml = result.left().value().getMainYaml();
-        assertNotNull(mainYaml);
-
-        YamlToObjectConverter yamlToObjectConverter = new YamlToObjectConverter();
-        assertTrue(yamlToObjectConverter.isValidYaml(mainYaml.getBytes()));
-        log.debug(mainYaml);
-
-        Yaml yaml = new Yaml();
-
-        InputStream inputStream = new ByteArrayInputStream(mainYaml.getBytes());
-        Map<String, Object> load = (Map<String, Object>) yaml.load(inputStream);
-        Map<String, Object> imports = (Map<String, Object>) load.get("imports");
-        assertNotNull(imports);
-        assertEquals("Validate imports size in yml", 2, imports.size());
-
-        Map<String, Object> metadata = (Map<String, Object>) load.get("metadata");
-        assertNotNull(metadata);
-        validateMetadata(metadata, serviceFetch.left().value(), false);
-
-        Map<String, Object> vf1 = (Map<String, Object>) imports.get(certifiedVFC1.getName());
-        String fileName = (String) vf1.get(ToscaExportHandler.IMPORTS_FILE_KEY);
-        ArtifactDefinition artifactDefinition = certifiedVFC1.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE);
-        assertEquals("Validate 1 file name", artifactDefinition.getArtifactName(), fileName);
-
-        Map<String, Object> topology_template = (Map<String, Object>) load.get("topology_template");
-        Map<String, Object> node_templates = (Map<String, Object>) topology_template.get("node_templates");
-        Map<String, Object> inst1 = (Map<String, Object>) node_templates.get(ciname1);
-        Map<String, Object> inst2 = (Map<String, Object>) node_templates.get(ciname2);
-
-        Map<String, Object> inst1MD = (Map<String, Object>) inst1.get("metadata");
-        Map<String, Object> inst2MD = (Map<String, Object>) inst2.get("metadata");
-
-        validateMetadata(inst1MD, certifiedVFC1, true);
-
-        Map<String, Object> vf2 = (Map<String, Object>) imports.get(certifiedVFC2.getName());
-        fileName = (String) vf2.get(ToscaExportHandler.IMPORTS_FILE_KEY);
-        artifactDefinition = certifiedVFC2.getToscaArtifacts().get(ToscaExportHandler.ASSET_TOSCA_TEMPLATE);
-        assertEquals("Validate 2 file name", artifactDefinition.getArtifactName(), fileName);
-
-        validateMetadata(inst2MD, certifiedVFC2, true);*/
-    }
-
-}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaRepresentationTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaRepresentationTest.java
index f7c6f72932..fad85b2fd8 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaRepresentationTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaRepresentationTest.java
@@ -50,10 +50,10 @@ public class ToscaRepresentationTest {
 	@Test
 	public void testSetDependencies() throws Exception {
 		ToscaRepresentation testSubject;
-		List<Triple<String, String, Component>> dependancies = null;
+		List<Triple<String, String, Component>> dependencies = null;
 
 		// default test
 		testSubject = createTestSubject();
-		testSubject.setDependencies(dependancies);
+		testSubject.setDependencies(dependencies);
 	}
 }
\ No newline at end of file
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaUtilsTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaUtilsTest.java
index a9c87f7f61..0c7d5cf5ce 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaUtilsTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaUtilsTest.java
@@ -1,54 +1,32 @@
 package org.openecomp.sdc.be.tosca;
 
-import java.util.List;
 import java.util.Map;
 
 import org.junit.Test;
+import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
 import org.openecomp.sdc.be.model.Component;
-
-import com.datastax.driver.core.UserType.Field;
+import org.openecomp.sdc.be.model.Resource;
 
 public class ToscaUtilsTest {
-
-	private ToscaUtils createTestSubject() {
-		return new ToscaUtils();
-	}
-
-	
-	@Test
-	public void testIsAtomicType() throws Exception {
-		Component component = null;
-		boolean result;
-
-		// default test
-	}
-
 	
 	@Test
 	public void testIsComplexVfc() throws Exception {
-		Component component = null;
+		Component component = new Resource();		
+		component.setComponentType(ComponentTypeEnum.RESOURCE);
 		boolean result;
 
 		// default test
+		ToscaUtils.isComplexVfc(component);
 	}
 
 	
 	@Test
 	public void testObjectToMap() throws Exception {
 		Object objectToConvert = null;
-		Class clazz = null;
+		Object obj = new Object();
 		Map<String, Object> result;
 
 		// default test
-	}
-
-	
-	@Test
-	public void testGetAllFields() throws Exception {
-		List<Field> fields = null;
-		Class<?> type = null;
-		List<Field> result;
-
-		// default test
+		ToscaUtils.objectToMap(objectToConvert, obj.getClass());
 	}
 }
\ No newline at end of file