diff options
Diffstat (limited to 'catalog-be/src/test/java')
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 |