X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=catalog-be%2Fsrc%2Ftest%2Fjava%2Forg%2Fopenecomp%2Fsdc%2Fbe%2Ftosca%2FToscaExportHandlerTest.java;h=0b3796261a12144a2dd7039d66a449b474ccbd47;hb=28e1a54e6074f50dcc06f7ea4eb3943ad873b448;hp=7cb2ef7cf8f090a7d8d2b6ad3e071f6df533160e;hpb=568db59e15471bf56289ff07dfaca6e2a9081dc4;p=sdc.git 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 index 7cb2ef7cf8..0b3796261a 100644 --- 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 @@ -1,36 +1,1872 @@ +/*- + * ============LICENSE_START======================================================= + * SDC + * ================================================================================ + * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + * Modifications copyright (c) 2020, Nordix Foundation + * ================================================================================ + */ + package org.openecomp.sdc.be.tosca; -import javax.annotation.Generated; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.anyMap; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.ArgumentMatchers.isNull; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum.VF; +import static org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType.PROPERTY; -import org.junit.Test; +import fj.data.Either; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import mockit.Deencapsulation; +import org.apache.commons.collections.MapUtils; +import org.apache.commons.lang3.tuple.ImmutablePair; +import org.apache.commons.lang3.tuple.Triple; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder; +import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus; +import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition; +import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition; +import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ConstraintType; +import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum; +import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum; +import org.openecomp.sdc.be.exception.ToscaExportException; +import org.openecomp.sdc.be.model.ArtifactDefinition; +import org.openecomp.sdc.be.model.AttributeDefinition; +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.ComponentInstanceAttribute; +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.InputDefinition; +import org.openecomp.sdc.be.model.InterfaceDefinition; +import org.openecomp.sdc.be.model.OutputDefinition; +import org.openecomp.sdc.be.model.PropertyDefinition; +import org.openecomp.sdc.be.model.RelationshipImpl; +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.jsonjanusgraph.operations.ToscaOperationFacade; +import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation; +import org.openecomp.sdc.be.tosca.exception.ToscaConversionException; +import org.openecomp.sdc.be.tosca.model.ToscaCapability; +import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate; +import org.openecomp.sdc.be.tosca.model.ToscaNodeType; +import org.openecomp.sdc.be.tosca.model.ToscaProperty; import org.openecomp.sdc.be.tosca.model.ToscaTemplate; +import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact; +import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement; +import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate; +import org.openecomp.sdc.be.tosca.utils.InputConverter; +import org.openecomp.sdc.be.tosca.utils.OutputConverter; +import org.openecomp.sdc.common.test.BaseConfDependent; -import fj.data.Either; +class ToscaExportHandlerTest extends BaseConfDependent { + + private static final String COMPONENT_PROPERTY_NAME = "prop1"; + private static final String COMPONENT_PROPERTY_TYPE = "string"; + private static final String COMPONENT_INPUT_NAME = "input1"; + private static final String COMPONENT_OUTPUT_NAME = "output1"; + private static final String COMPONENT_INPUT_TYPE = "integer"; + private static final String COMPONENT_OUTPUT_TYPE = "integer"; + private static final String RESOURCE_NAME = "resource"; + private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1"; + private static final String LOCAL_INTERFACE_TYPE = "Local"; + private static final String UNIQUE_ID = "1L"; + + @InjectMocks + private ToscaExportHandler testSubject; + + @Mock + private ApplicationDataTypeCache applicationDataTypeCache; + + @Mock + private ToscaOperationFacade toscaOperationFacade; + + @Mock + private CapabilityRequirementConverter capabilityRequirementConverter; + + @Mock + private InputConverter inputConverter; + + @Mock + private OutputConverter outputConverter; + + @Mock + private GroupExportParser groupExportParser; + + @Mock + private PropertyConvertor propertyConvertor; + + @Mock + private GroupExportParserImpl groupExportParserImpl; + + @Mock + private InterfaceLifecycleOperation interfaceLifecycleOperation; + + @Mock + private InterfacesOperationsConverter interfacesOperationsConverter; + + @Mock + private PolicyExportParser policyExportParser; + + @Mock + private AttributeConverter attributeConverter; + + @BeforeAll + public static void setupBeforeClass() { + componentName = "catalog-be"; + confPath = "src/test/resources/config"; + setUp(); + } + + @BeforeEach + void setUpMock() { + MockitoAnnotations.openMocks(this); + doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY)); + doReturn(new HashMap()).when(interfacesOperationsConverter) + .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean()); + } + + private Resource getNewResource() { + Resource resource = new Resource(); + resource.setUniqueId("resourceUniqueId"); + List categories = new ArrayList<>(); + CategoryDefinition category = new CategoryDefinition(); + List subcategories = new ArrayList<>(); + SubCategoryDefinition subcategory = new SubCategoryDefinition(); + List dataTypes = new ArrayList<>(); + DataTypeDefinition dataType = new DataTypeDefinition(); + dataType.setName("dataTypeName"); + dataType.setDerivedFromName("tosca.datatypes.Root"); + PropertyDataDefinition propData = new PropertyDataDefinitionBuilder() + .setName("property") + .setType("type") + .build(); + List propDataList = Arrays.asList(propData); + dataType.setPropertiesData(propDataList); + List propList = propDataList.stream().map(PropertyDefinition::new) + .collect(Collectors.toList()); + dataType.setProperties(propList); + dataTypes.add(dataType); + + subcategory.setName("name"); + subcategories.add(subcategory); + category.setName("name"); + category.setSubcategories(subcategories); + categories.add(category); + + final List properties = new ArrayList<>(); + properties.add(new PropertyDefinition()); + resource.setProperties(properties); + Map proxyInterfaces = new HashMap<>(); + proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>())); + resource.setInterfaces(proxyInterfaces); + + resource.setCategories(categories); + resource.setVersion("version"); + resource.setVendorName("vendorName"); + resource.setVendorRelease("vendorRelease"); + resource.setResourceVendorModelNumber("resourceVendorModelNumber"); + resource.setDataTypes(dataTypes); + + return resource; + } + + private Service getNewService() { + Service service = new Service(); + List categories = new ArrayList<>(); + CategoryDefinition category = new CategoryDefinition(); + List 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 + void testExportComponent() { + Component component = getNewResource(); + Either result; + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.left(Collections.emptyMap())); + + // default test when component is Resource + result = testSubject.exportComponent(component); + assertNotNull(result); + + component = getNewService(); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)); + + // default test when component is Service + result = testSubject.exportComponent(component); + assertNotNull(result); + } + + @Test + void testExportComponentInterface() { + Resource component = getNewResource(); + Either result; + + component.setInterfaces(new HashMap<>()); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND)); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.left(Collections.emptyMap())); + // default test when convertInterfaceNodeType is right + result = testSubject.exportComponentInterface(component, false); + assertNotNull(result); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + // default test when convertInterfaceNodeType is left + result = testSubject.exportComponentInterface(component, false); + assertNotNull(result); + } + + @Test + void testExportDataType() { + DataTypeDefinition dataTypeDefinition = new DataTypeDefinition(); + dataTypeDefinition.setUniqueId("uniqueId"); + Either result; + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + result = testSubject.exportDataType(dataTypeDefinition); + assertNotNull(result); + } + + @Test + void testConvertInterfaceNodeTypeProperties() { + + Resource component = getNewResource(); + + component.setInterfaces(new HashMap<>()); + InputDefinition input = new InputDefinition(); + input.setName(COMPONENT_INPUT_NAME); + input.setType(COMPONENT_INPUT_TYPE); + component.setInputs(Collections.singletonList(input)); + PropertyDefinition property = new PropertyDefinition(); + property.setName(COMPONENT_PROPERTY_NAME); + property.setType(COMPONENT_PROPERTY_TYPE); + component.setProperties(Collections.singletonList(property)); + component.setName(RESOURCE_NAME); + component.setToscaResourceName(RESOURCE_NAME); + + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + // when convertRequirements is called, make it return the same value as 3rd (index=2) argument. + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2))); + + final var result = testSubject.convertInterfaceNodeType(new HashMap(), component, + new ToscaTemplate(TOSCA_VERSION), new HashMap(), false); + assertNotNull(result); + assertTrue(result.isLeft()); + Map nodeTypeMap = result.left().value().getNode_types(); + assertNotNull(nodeTypeMap); + assertEquals(1, nodeTypeMap.size()); + ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next(); + assertNotNull(toscaNodeType); + Map propertyMap = toscaNodeType.getProperties(); + // Check if inputs and properties in component are merged properly + assertNotNull(propertyMap); + assertEquals(1, propertyMap.size()); + assertFalse(propertyMap.containsKey(COMPONENT_INPUT_NAME)); + assertTrue(propertyMap.containsKey(COMPONENT_PROPERTY_NAME)); + } + + @Test + void testGetDependencies() { + + Component component = new Resource(); + Either result; + + // default test + result = testSubject.getDependencies(component); + assertNotNull(result); + } + + @Test + void testSetImports() { + Resource resource = new Resource(); + resource.setResourceType(ResourceTypeEnum.PNF); + + resource.setName("TestResourceName"); + Map artifactList = new HashMap<>(); + ArtifactDefinition artifact = new ArtifactDefinition(); + artifact.setArtifactName("name.name2"); + artifactList.put("assettoscatemplate", artifact); + resource.setArtifacts(artifactList); + resource.setToscaArtifacts(artifactList); + ToscaTemplate toscaTemplate = new ToscaTemplate(""); + + ComponentInstance ci = new ComponentInstance(); + ci.setComponentUid("name"); + ci.setOriginType(OriginTypeEnum.PNF); + ci.setSourceModelUid("modelName"); + List componentInstanceList = new LinkedList<>(); + componentInstanceList.add(ci); + resource.setComponentInstances(componentInstanceList); + + when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(resource)); + + Either>, ToscaError> result; + result = Deencapsulation.invoke(testSubject, "fillImports", resource, toscaTemplate, false); + + verify(toscaOperationFacade, times(1)).getToscaFullElement("name"); + assertTrue(result.isLeft()); + ToscaTemplate toscaTemplateRes = result.left().value().left; + assertEquals(8, toscaTemplateRes.getImports().size()); + assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface")); + assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName")); + assertEquals(1, toscaTemplateRes.getDependencies().size()); + assertEquals("name.name2", toscaTemplateRes.getDependencies().get(0).getLeft()); + } + + @Test + void testConvertToscaTemplate() throws Exception { + + final Component component = getNewResource(); + final ToscaTemplate toscaNode = new ToscaTemplate(""); + Either result; + final List resourceInstances = new ArrayList<>(); + final ComponentInstance instance = new ComponentInstance(); + + instance.setOriginType(OriginTypeEnum.SERVICE); + instance.setSourceModelUid("targetModelUid"); + resourceInstances.add(instance); + + component.setComponentInstances(resourceInstances); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false)); + + final Map map = new HashMap<>(); + map.put("mock", new ToscaProperty()); + doReturn(map).when(outputConverter).convert(any(), any()); + + // default test + result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode, false); + assertNotNull(result); + } + + @Test + void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException { + Component component = getNewResource(); + ToscaTemplate toscaNode = new ToscaTemplate(""); + component.setComponentInstances(new ArrayList<>()); + + List groups = new ArrayList<>(); + GroupDefinition group = new GroupDefinition(); + List artifacts = new ArrayList<>(); + artifacts.add("artifact"); + group.setType("org.openecomp.groups.VfModule"); + group.setArtifacts(artifacts); + groups.add(group); + component.setGroups(groups); + + final var input = new InputDefinition(); + input.setName(COMPONENT_INPUT_NAME); + input.setType(COMPONENT_INPUT_TYPE); + component.setInputs(Collections.singletonList(input)); + + final var output = new OutputDefinition(); + output.setName(COMPONENT_OUTPUT_NAME); + output.setType(COMPONENT_OUTPUT_TYPE); + component.setOutputs(Collections.singletonList(output)); + + Map substitutionMappingMap = new HashMap<>(); + String[] array = {"value1", "value2"}; + substitutionMappingMap.put("key", array); + + when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), + any(Component.class))).thenReturn(Either.left(substitutionMappingMap)); + + when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Component.class), anyMap())) + .thenReturn(Either.left(Collections.emptyMap())); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + + when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>()); + + when(groupExportParser.getGroups(component)).thenReturn(null); + + final Map map = new HashMap<>(); + map.put("mock", new ToscaProperty()); + doReturn(map).when(outputConverter).convert(any(), any()); + + // test component contains group + final var result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode, false); + assertNotNull(result); + } + + @Test + void testConvertToscaTemplateWhenComponentIsService() throws Exception { + Component component = getNewService(); + ToscaTemplate toscaNode = new ToscaTemplate(""); + Either result; + component.setComponentInstances(new ArrayList<>()); + + List groups = new ArrayList<>(); + GroupDefinition group = new GroupDefinition(); + List artifacts = new ArrayList<>(); + artifacts.add("artifact"); + group.setType("org.openecomp.groups.VfModule"); + group.setArtifacts(artifacts); + groups.add(group); + component.setGroups(groups); + + Map substitutionMappingMap = new HashMap<>(); + String[] array = {"value1", "value2"}; + substitutionMappingMap.put("key", array); + + when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class))) + .thenReturn(Either.left(substitutionMappingMap)); + + when(capabilityRequirementConverter + .convertSubstitutionMappingRequirements(any(Component.class), anyMap())) + .thenReturn(Either.left(Collections.emptyMap())); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + + when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>()); + final Map map = new HashMap<>(); + map.put("mock", new ToscaProperty()); + doReturn(map).when(outputConverter).convert(any(), any()); + + // test component contains group + result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode, false); + assertNotNull(result); + } + + @Test + void testConvertMetadata_1() { + + Component component = getNewResource(); + boolean isInstance = true; + ComponentInstance componentInstance = new ComponentInstance(); + componentInstance.setOriginType(OriginTypeEnum.ServiceProxy); + componentInstance.setSourceModelInvariant("targetModelInvariant"); + + // default test + Map result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance); + assertNotNull(result); + } + + @Test + void testFillImports() { + + Component component = getNewService(); + ToscaTemplate toscaTemplate = new ToscaTemplate(""); + Either>, ToscaError> result; + + ComponentInstance instance = new ComponentInstance(); + List resourceInstances = new ArrayList<>(); + instance.setComponentUid("name"); + resourceInstances.add(instance); + component.setComponentInstances(resourceInstances); + Map toscaArtifacts = new HashMap<>(); + ArtifactDefinition artifact = new ArtifactDefinition(); + artifact.setArtifactName("name.name2"); + toscaArtifacts.put("assettoscatemplate", artifact); + component.setToscaArtifacts(toscaArtifacts); + + when(toscaOperationFacade.getToscaFullElement(any(String.class))) + .thenReturn(Either.left(component)); + + Resource baseType = getNewResource(); + Map baseTypeToscaArtifacts = new HashMap<>(); + ArtifactDefinition baseTypeArtifact = new ArtifactDefinition(); + baseTypeArtifact.setArtifactName("typeA"); + baseTypeToscaArtifacts.put("assettoscatemplate", baseTypeArtifact); + baseType.setToscaArtifacts(baseTypeToscaArtifacts); + + component.setDerivedFromGenericType("org.typeA"); + component.setDerivedFromGenericVersion("1.0"); + when(toscaOperationFacade.getByToscaResourceNameAndVersion("org.typeA", "1.0", null)).thenReturn(Either.left(baseType)); + + // default test + result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate, false); + assertNotNull(result); + } + + @Test + void testCreateDependency() { + + Map componentCache = new HashMap<>(); + List>> imports = new ArrayList<>(); + List> dependecies = new ArrayList<>(); + ComponentInstance ci = new ComponentInstance(); + Component component = getNewResource(); + + Map 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"); + + when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component)); + + when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service())); + + // default test + Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci, false); + assertFalse(componentCache.isEmpty()); + } + + @Test + void testGetInterfaceFilename() { + String artifactName = "artifact.name"; + String result; + + // default test + result = ToscaExportHandler.getInterfaceFilename(artifactName); + assertNotNull(result); + } + + @Test + void testConvertNodeType() { + Component component = new Resource(); + ToscaTemplate toscaNode = new ToscaTemplate(""); + Map nodeTypes = new HashMap<>(); + Either result; + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST)); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.left(Collections.emptyMap())); + // default test + result = Deencapsulation + .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes); + assertNotNull(result); + } + + @Test + void testConvertInterfaceNodeType() { + Component component = getNewResource(); + ToscaTemplate toscaNode = new ToscaTemplate(""); + Map nodeTypes = new HashMap<>(); + Either result; + List inputs = new ArrayList<>(); + inputs.add(new InputDefinition()); + component.setInputs(inputs); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.left(Collections.emptyMap())); + + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + // default test + result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode + , nodeTypes, false); + assertNotNull(result); + } + + @Test + void testConvertReqCapAndTypeName() { + Component component = new Resource(); + ToscaTemplate toscaNode = new ToscaTemplate(""); + Map nodeTypes = new HashMap<>(); + ToscaNodeType toscaNodeType = new ToscaNodeType(); + Map dataTypes = new HashMap<>(); + Either result; + + when( + capabilityRequirementConverter + .convertCapabilities(anyMap(), any(Resource.class), anyMap())) + .thenReturn(new HashMap<>()); + + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + // default test + result = Deencapsulation + .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes, + toscaNodeType, dataTypes); + assertNotNull(result); + + component = new Service(); + + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + // test when component is service + result = Deencapsulation + .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes, + toscaNodeType, dataTypes); + assertNotNull(result); + } + + @Test + void testConvertNodeTemplatesWhenComponentIsService() { + final Component component = getNewService(); + final List componentInstances = new ArrayList<>(); + final Map> componentInstancesProperties = new HashMap<>(); + final Map componentCache = new HashMap<>(); + final Map dataTypes = new HashMap<>(); + final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate(); + final Either, ToscaError> result; + final Map> componentInstancesInputs = new HashMap<>(); + final List inputs = new ArrayList<>(); + final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput(); + componentInstanceInput.setUniqueId("uuid"); + inputs.add(componentInstanceInput); + componentInstancesInputs.put("uuid", inputs); + final List resourceInstancesRelations = new ArrayList<>(); + final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef(); + reldef.setFromNode("node"); + resourceInstancesRelations.add(reldef); + component.setComponentInstancesRelations(resourceInstancesRelations); + + final ComponentInstance instance = new ComponentInstance(); + instance.setUniqueId("id"); + instance.setComponentUid("uid"); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + final List groupInstances = new ArrayList<>(); + final GroupInstance groupInst = new GroupInstance(); + final List artifacts = new ArrayList<>(); + artifacts.add("artifact"); + groupInst.setArtifacts(artifacts); + groupInst.setType("type"); + groupInstances.add(groupInst); + instance.setGroupInstances(groupInstances); + + final List properties = new ArrayList<>(); + properties.add(new PropertyDefinition()); + instance.setProperties(properties); + + instance.setUniqueId("uuid"); + instance.setDescription("desc"); + instance.setSourceModelUid("sourceModelUid"); + + componentInstances.add(instance); + + component.setComponentInstances(componentInstances); + + component.setComponentInstancesInputs(componentInstancesInputs); + component.setInvariantUUID("uuid"); + component.setUUID("uuid"); + component.setDescription("desc"); + component.setUniqueId("uid"); + + componentCache.put("uid", component); + + final List componentInstanceProperties = new ArrayList<>(); + componentInstanceProperties.add(new ComponentInstanceProperty()); + + componentInstancesProperties.put("uuid", componentInstanceProperties); + component.setComponentInstancesProperties(componentInstancesProperties); + + final Map> componentInstancesAttributes = new HashMap<>(); + final List componentInstanceAttributes = new ArrayList<>(); + final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute(); + componentInstanceAttribute.setDefaultValue("def value"); + componentInstanceAttributes.add(componentInstanceAttribute); + + componentInstancesAttributes.put("uuid", componentInstanceAttributes); + component.setComponentInstancesAttributes(componentInstancesAttributes); + + ComponentInstanceProperty cip = new ComponentInstanceProperty(); + cip.setInstanceUniqueId("id"); + + List list = new ArrayList<>(); + list.add(cip); + + componentInstancesProperties.put("id", list); + component.setComponentInstancesProperties(componentInstancesProperties); + + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component)); + when(capabilityRequirementConverter + .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class))) + .thenReturn(Either.left(new ToscaNodeTemplate())); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class))) + .thenReturn(Either.left(new ToscaNodeType())); + when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component)); + when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component)); + when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource())); + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(getNewResource())); + + final Map substitutionMappingMap = new HashMap<>(); + final String[] array = {"value1", "value2"}; + substitutionMappingMap.put("key", array); + when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class))) + .thenReturn(Either.left(substitutionMappingMap)); + + when(capabilityRequirementConverter + .convertSubstitutionMappingRequirements(any(Component.class), anyMap())) + .thenReturn(Either.left(Collections.emptyMap())); + + // default test + final Either toscaRepresentationToscaErrorEither = testSubject.exportComponent(component); + assertNotNull(toscaRepresentationToscaErrorEither); + + } + + @Test + void testConvertWithBooleanNodeFilterWhenComponentIsService() { + final Component component = getNewService(); + final List componentInstances = new ArrayList<>(); + final Map> componentInstancesProperties = new HashMap<>(); + final Map componentCache = new HashMap<>(); + final Map> componentInstancesInputs = new HashMap<>(); + final Map componentInstanceNodeFilters = new HashMap<>(); + CINodeFilterDataDefinition nodeFilter = new CINodeFilterDataDefinition(); + PropertyFilterDataDefinition prop = new PropertyFilterDataDefinition(); + prop.setName("nodeFilterPropBoolean"); + prop.setType("boolean"); + PropertyFilterConstraintDataDefinition constr = new PropertyFilterConstraintDataDefinition(); + constr.setPropertyName(prop.getName()); + constr.setOperator(ConstraintType.EQUAL); + constr.setValue("true"); + constr.setOriginalType("boolean"); + prop.setConstraints(List.of(constr)); + ListDataDefinition lstDataDef = new ListDataDefinition<>(); + lstDataDef.add(prop); + nodeFilter.setProperties(lstDataDef); + final List inputs = new ArrayList<>(); + final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput(); + componentInstanceInput.setUniqueId("uuid"); + inputs.add(componentInstanceInput); + componentInstancesInputs.put("uuid", inputs); + componentInstanceNodeFilters.put("uuid", nodeFilter); + final List resourceInstancesRelations = new ArrayList<>(); + final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef(); + reldef.setFromNode("node"); + resourceInstancesRelations.add(reldef); + component.setComponentInstancesRelations(resourceInstancesRelations); + + final ComponentInstance instance = new ComponentInstance(); + instance.setNodeFilter(nodeFilter); + instance.setUniqueId("id"); + instance.setComponentUid("uid"); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + final List groupInstances = new ArrayList<>(); + final GroupInstance groupInst = new GroupInstance(); + final List artifacts = new ArrayList<>(); + artifacts.add("artifact"); + groupInst.setArtifacts(artifacts); + groupInst.setType("type"); + groupInstances.add(groupInst); + instance.setGroupInstances(groupInstances); + + final List properties = new ArrayList<>(); + properties.add(new PropertyDefinition()); + instance.setProperties(properties); + + instance.setUniqueId("uuid"); + instance.setDescription("desc"); + instance.setSourceModelUid("sourceModelUid"); + + componentInstances.add(instance); + + component.setComponentInstances(componentInstances); + component.setNodeFilterComponents(componentInstanceNodeFilters); + component.setComponentInstancesInputs(componentInstancesInputs); + + component.setInvariantUUID("uuid"); + component.setUUID("uuid"); + component.setDescription("desc"); + component.setUniqueId("uid"); + + componentCache.put("uid", component); + + final List componentInstanceProperties = new ArrayList<>(); + componentInstanceProperties.add(new ComponentInstanceProperty()); + + componentInstancesProperties.put("uuid", componentInstanceProperties); + component.setComponentInstancesProperties(componentInstancesProperties); + + final Map> componentInstancesAttributes = new HashMap<>(); + final List componentInstanceAttributes = new ArrayList<>(); + final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute(); + componentInstanceAttribute.setDefaultValue("def value"); + componentInstanceAttributes.add(componentInstanceAttribute); + + componentInstancesAttributes.put("uuid", componentInstanceAttributes); + component.setComponentInstancesAttributes(componentInstancesAttributes); + + ComponentInstanceProperty cip = new ComponentInstanceProperty(); + cip.setInstanceUniqueId("id"); + + List list = new ArrayList<>(); + list.add(cip); + + componentInstancesProperties.put("id", list); + component.setComponentInstancesProperties(componentInstancesProperties); + + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component)); + when(capabilityRequirementConverter + .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class))) + .thenReturn(Either.left(new ToscaNodeTemplate())); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class))) + .thenReturn(Either.left(new ToscaNodeType())); + when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component)); + when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component)); + when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource())); + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(getNewResource())); + + final Map substitutionMappingMap = new HashMap<>(); + final String[] array = {"value1", "value2"}; + substitutionMappingMap.put("key", array); + when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class))) + .thenReturn(Either.left(substitutionMappingMap)); + + when(capabilityRequirementConverter + .convertSubstitutionMappingRequirements(any(Component.class), anyMap())) + .thenReturn(Either.left(Collections.emptyMap())); + + // default test + final Either toscaRepresentationToscaErrorEither = testSubject.exportComponent(component); + assertNotNull(toscaRepresentationToscaErrorEither); + } + + @Test + void testConvertNodeTemplatesWhenComponentIsResource() { + final Resource component = getNewResource(); + component.setResourceType(VF); + final List componentInstances = new ArrayList<>(); + final Map> componentInstancesProperties = new HashMap<>(); + final Map componentCache = new HashMap<>(); + final Map dataTypes = new HashMap<>(); + final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate(); + final Either, ToscaError> result; + final Map> componentInstancesInputs = new HashMap<>(); + final List inputs = new ArrayList<>(); + final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput(); + componentInstanceInput.setUniqueId("uuid"); + inputs.add(componentInstanceInput); + componentInstancesInputs.put("uuid", inputs); + final List resourceInstancesRelations = new ArrayList<>(); + final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef(); + reldef.setFromNode("node"); + resourceInstancesRelations.add(reldef); + component.setComponentInstancesRelations(resourceInstancesRelations); + + final ComponentInstance instance = new ComponentInstance(); + instance.setUniqueId("id"); + instance.setComponentUid("uid"); + instance.setOriginType(OriginTypeEnum.VFC); + final List groupInstances = new ArrayList<>(); + final GroupInstance groupInst = new GroupInstance(); + final List artifacts = new ArrayList<>(); + artifacts.add("artifact"); + groupInst.setArtifacts(artifacts); + groupInst.setType("type"); + groupInstances.add(groupInst); + instance.setGroupInstances(groupInstances); + + final List properties = new ArrayList<>(); + properties.add(new PropertyDefinition()); + instance.setProperties(properties); + component.setProperties(properties); + + instance.setUniqueId("uuid"); + instance.setDescription("desc"); + instance.setSourceModelUid("sourceModelUid"); + final Map artifactList = new HashMap<>(); + final ArtifactDefinition artifact = new ArtifactDefinition(); + artifact.setArtifactName("name.name2"); + artifactList.put("assettoscatemplate", artifact); + instance.setArtifacts(artifactList); + + Map toscaArtifactDataDefinitionMap = new HashMap<>(); + toscaArtifactDataDefinitionMap.put("assettoscatemplate", new ToscaArtifactDataDefinition()); + instance.setToscaArtifacts(toscaArtifactDataDefinitionMap); + + componentInstances.add(instance); + + component.setComponentInstances(componentInstances); + + component.setComponentInstancesInputs(componentInstancesInputs); + component.setInvariantUUID("uuid"); + component.setUUID("uuid"); + component.setDescription("desc"); + component.setUniqueId("uid"); + + componentCache.put("uid", component); + + final List componentInstanceProperties = new ArrayList<>(); + componentInstanceProperties.add(new ComponentInstanceProperty()); + + componentInstancesProperties.put("uuid", componentInstanceProperties); + component.setComponentInstancesProperties(componentInstancesProperties); + + final Map> componentInstancesAttributes = new HashMap<>(); + final List componentInstanceAttributes = new ArrayList<>(); + final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute(); + componentInstanceAttribute.setDefaultValue("def value"); + componentInstanceAttributes.add(componentInstanceAttribute); + + componentInstancesAttributes.put("uuid", componentInstanceAttributes); + component.setComponentInstancesAttributes(componentInstancesAttributes); + + component.setArtifacts(artifactList); + component.setToscaArtifacts(artifactList); + + final List attributes = new ArrayList<>(); + final var attribute = new AttributeDefinition(); + attribute.setName("mock"); + attributes.add(attribute); + component.setAttributes(attributes); + + List componentInstanceInputs = new ArrayList<>(); + componentInstanceInputs.add(new ComponentInstanceInput()); + + componentInstancesInputs.put("id", componentInstanceInputs); + component.setComponentInstancesInputs(componentInstancesInputs); + + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component)); + when(capabilityRequirementConverter + .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class))) + .thenReturn(Either.left(new ToscaNodeTemplate())); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class))) + .thenReturn(Either.left(new ToscaNodeType())); + when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component)); + when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component)); + when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource())); + + Resource newResource = getNewResource(); + InputDefinition input = new InputDefinition(); + input.setName(COMPONENT_INPUT_NAME); + input.setType(COMPONENT_INPUT_TYPE); + newResource.setInputs(Collections.singletonList(input)); + + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(newResource)); + + final Map substitutionMappingMap = new HashMap<>(); + final String[] array = {"value1", "value2"}; + substitutionMappingMap.put("key", array); + when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class))) + .thenReturn(Either.left(substitutionMappingMap)); + + when(capabilityRequirementConverter + .convertSubstitutionMappingRequirements(any(Component.class), anyMap())) + .thenReturn(Either.left(Collections.emptyMap())); + + // default test + final Either toscaRepresentationToscaErrorEither = testSubject.exportComponent(newResource); + assertNotNull(toscaRepresentationToscaErrorEither); + + } + + @Test + void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() { + Component component = getNewResource(); + List componentInstances = new ArrayList<>(); + Map> componentInstancesProperties = new HashMap<>(); + Map> componentInstancesInterfaces = new HashMap<>(); + Map componentCache = new HashMap<>(); + Map dataTypes = new HashMap<>(); + ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate(); + Either, ToscaError> result; + Map> componentInstancesInputs = new HashMap<>(); + List inputs = new ArrayList<>(); + inputs.add(new ComponentInstanceInput()); + componentInstancesInputs.put("key", inputs); + List 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.setComponentInstances(componentInstances); + + component.setComponentInstancesInputs(componentInstancesInputs); + component.setInvariantUUID("uuid"); + component.setUUID("uuid"); + component.setDescription("desc"); + + componentCache.put("uid", component); + + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component)); + when(capabilityRequirementConverter + .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class))) + .thenReturn(Either.right(ToscaError.GENERAL_ERROR)); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + // default test + final Either toscaRepresentationToscaErrorEither = testSubject.exportComponent(component); + assertNotNull(toscaRepresentationToscaErrorEither); + } + + @Test + void testConvetNodeTemplateWhenGetOriginComponentIsRight() { + Component component = getNewResource(); + List componentInstances = new ArrayList<>(); + Map> componentInstancesProperties = new HashMap<>(); + Map> componentInstancesInterfaces = new HashMap<>(); + Map componentCache = new HashMap<>(); + Map dataTypes = new HashMap<>(); + ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate(); + Either, ToscaError> result; + Map> componentInstancesInputs = new HashMap<>(); + List inputs = new ArrayList<>(); + inputs.add(new ComponentInstanceInput()); + componentInstancesInputs.put("key", inputs); + List 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.setComponentInstances(componentInstances); + + component.setComponentInstancesInputs(componentInstancesInputs); + component.setInvariantUUID("uuid"); + component.setUUID("uuid"); + component.setDescription("desc"); + + final List attributes = new ArrayList<>(); + final var attribute = new AttributeDefinition(); + attribute.setName("mock"); + attributes.add(attribute); + component.setAttributes(attributes); + + componentCache.put("uid", component); + + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false)); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + // default test + final Either toscaRepresentationToscaErrorEither = testSubject.exportComponent(component); + assertNotNull(toscaRepresentationToscaErrorEither); + } + + @Test + void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() { + Resource component = getNewResource(); + component.setResourceType(VF); + List componentInstances = new ArrayList<>(); + Map> componentInstancesProperties = new HashMap<>(); + Map> componentInstancesInterfaces = new HashMap<>(); + Map componentCache = new HashMap<>(); + Map dataTypes = new HashMap<>(); + ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate(); + Map> componentInstancesInputs = new HashMap<>(); + List inputs = new ArrayList<>(); + inputs.add(new ComponentInstanceInput()); + componentInstancesInputs.put("key", inputs); + List resourceInstancesRelations = new ArrayList<>(); + RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef(); + reldef.setFromNode("id"); + reldef.setToNode("node"); + List relationships = new ArrayList<>(); + CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); + relationship.setRelation(new RelationshipInfo("requirement", new RelationshipImpl())); + relationships.add(relationship); + reldef.setRelationships(relationships); + resourceInstancesRelations.add(reldef); + component.setComponentInstancesRelations(resourceInstancesRelations); + + Map artifactList = new HashMap<>(); + ArtifactDefinition artifact = new ArtifactDefinition(); + artifact.setArtifactName("name.name2"); + artifactList.put("assettoscatemplate", artifact); + component.setArtifacts(artifactList); + component.setToscaArtifacts(artifactList); + component.setRequirements(Collections.singletonMap("mock", Collections.singletonList(new RequirementDefinition()))); + + ComponentInstance instance = new ComponentInstance(); + instance.setUniqueId("id"); + instance.setComponentUid("id"); + instance.setOriginType(OriginTypeEnum.VF); + Map> requirements = new HashMap<>(); + requirements.put("mock1", Collections.singletonList(new RequirementDefinition())); + instance.setRequirements(requirements); + componentInstances.add(instance); + + component.setComponentInstancesInputs(componentInstancesInputs); + component.setComponentInstances(componentInstances); + + doReturn(Either.left(component)).when(toscaOperationFacade).getToscaFullElement("id"); + when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component)); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))) + .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); + + // default test + final Either result = testSubject.exportComponent(component); + assertNotNull(result); + } + + @Test + void testCreateNodeType() { + + Component component = new Resource(); + List array = new ArrayList<>(); + array.add("value"); + ((Resource) component).setDerivedFrom(array); + ToscaNodeType result; + + // test when component is resource + result = Deencapsulation.invoke(testSubject, "createNodeType", component); + assertNotNull(result); + + component = new Service(); + // test when component is service + result = Deencapsulation.invoke(testSubject, "createNodeType", component); + assertNotNull(result); + } + + @Test + void testCreateProxyInterfaceTypesComponentNotFound() { + Component container = new Service(); + Either, ToscaError> result; + List componentInstances = new ArrayList<>(); + ComponentInstance instance = new ComponentInstance(); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + instance.setSourceModelUid("targetModelUid"); + instance.setToscaComponentName("toscaComponentName"); + + componentInstances.add(instance); + container.setComponentInstances(componentInstances); + when(toscaOperationFacade.getToscaElement(any(String.class), + any(ComponentParametersView.class))) + .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); + result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container); + assertTrue(result.isRight()); + } + + @Test + void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() { + Component container = new Service(); + Either, ToscaError> result; + List componentInstances = new ArrayList<>(); + ComponentInstance instance = new ComponentInstance(); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + instance.setSourceModelUid("targetModelUid"); + instance.setToscaComponentName("toscaComponentName"); + componentInstances.add(instance); + container.setComponentInstances(componentInstances); + + when(toscaOperationFacade.getToscaElement(any(String.class), + any(ComponentParametersView.class))) + .thenReturn(Either.left(new Resource())); + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); + result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container); + assertTrue(result.isRight()); + } + + @Test + void testCreateProxyInterfaceTypesPositive() { + Component container = new Service(); + Either, ToscaError> result; + List componentInstances = new ArrayList<>(); + ComponentInstance instance = new ComponentInstance(); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + instance.setSourceModelUid("targetModelUid"); + instance.setToscaComponentName("toscaComponentName"); + componentInstances.add(instance); + container.setComponentInstances(componentInstances); + + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap())); + + Component proxyResource = new Resource(); + Map proxyInterfaces = new HashMap<>(); + proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>())); + proxyResource.setInterfaces(proxyInterfaces); + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(proxyResource)); + when(interfacesOperationsConverter.addInterfaceTypeElement(any(Component.class), anyList())) + .thenReturn(Collections.singletonMap(LOCAL_INTERFACE_TYPE, new HashMap<>())); + + result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container); + assertNotNull(result); + assertTrue(result.isLeft()); + assertEquals(1, result.left().value().size()); + } + + @Test + void testCreateProxyNodeTypes() { + Map componentCache = new HashMap<>(); + Component container = new Resource(); + Either, ToscaError> result; + List componentInstances = new ArrayList<>(); + ComponentInstance instance = new ComponentInstance(); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + instance.setSourceModelUid("targetModelUid"); + + componentInstances.add(instance); + container.setComponentInstances(componentInstances); + + when(toscaOperationFacade.getLatestByName("serviceProxy", null)) + .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); + + // test when getLatestByName return is right + result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container); + assertNotNull(result); + } + + @Test + void testCreateServiceSubstitutionNodeTypes() { + Map componentCache = new HashMap<>(); + + Component referencedService = getNewService(); + referencedService.setInvariantUUID("uuid"); + referencedService.setUUID("uuid"); + referencedService.setUniqueId("targetModelUid"); + referencedService.setDescription("desc"); + componentCache.put("targetModelUid", referencedService); + + Component containerService = new Service(); + List componentInstances = new ArrayList<>(); + ComponentInstance instance = new ComponentInstance(); + instance.setOriginType(OriginTypeEnum.ServiceSubstitution); + instance.setSourceModelUid("targetModelUid"); + + componentInstances.add(instance); + containerService.setComponentInstances(componentInstances); + + when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())) + .thenReturn(Either.left(Collections.emptyMap())); + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class), + any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType())); + + ToscaTemplate toscaNode = new ToscaTemplate("1_1"); + + Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode); + assertNotNull(toscaNode.getNode_types()); + } + + @Test + void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() { + Map componentCache = new HashMap<>(); + Component container = new Resource(); + Either, ToscaError> result; + List componentInstances = new ArrayList<>(); + ComponentInstance instance = new ComponentInstance(); + instance.setOriginType(OriginTypeEnum.ServiceProxy); + instance.setSourceModelUid("targetModelUid"); + + componentInstances.add(instance); + container.setComponentInstances(componentInstances); + + when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource())); + + ComponentParametersView parameterView = new ComponentParametersView(); + parameterView.disableAll(); + parameterView.setIgnoreCategories(false); + + when(toscaOperationFacade.getToscaElement(any(String.class), + any(ComponentParametersView.class))) + .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + + // test when getLatestByName is left + result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container); + assertNotNull(result); + } + + @Test + void testCreateProxyNodeType() { + Map componentCache = new HashMap<>(); + Component origComponent = new Resource(); + Component proxyComponent = new Resource(); + ComponentInstance instance = new ComponentInstance(); + ToscaNodeType result; + + when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>())); + + // default test + result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent, + proxyComponent, instance); + assertNotNull(result); + } + + @Test + void testConvertComponentInstanceRequirements() { + Component component = new Resource(); + ComponentInstance componentInstance = new ComponentInstance(); + List relations = new ArrayList<>(); + ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate(); + Component originComponent = new Resource(); + Map componentCache = new HashMap<>(); + Either result; + + // default test + result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component, + componentInstance, relations, nodeTypeTemplate, originComponent, componentCache); + assertNotNull(result); + + RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef(); + reldef.setFromNode("name"); + reldef.setToNode("name1"); + List relationships = new ArrayList<>(); + CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship(); + cap.setRelation(new RelationshipInfo()); + relationships.add(cap); + reldef.setRelationships(relationships); + relations.add(reldef); + componentInstance.setUniqueId("name"); + + List 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); + assertNotNull(result); + } + + @Test + void buildRequirementFailure() { + final Component fromOriginComponent = new Resource(); + final ComponentInstance fromInstance = new ComponentInstance(); + final String fromInstanceUid = "fromInstanceUid"; + fromInstance.setUniqueId(fromInstanceUid); + fromInstance.setComponentUid("componentUid"); + final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef(); + relationshipDefinition.setToNode("wrongNodeUid"); + final List relationshipList = new ArrayList<>(); + final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); + relationship.setRequirement(new RequirementDataDefinition()); + relationshipList.add(relationship); + relationshipDefinition.setRelationships(relationshipList); + final List instancesList = new ArrayList<>(); + instancesList.add(fromInstance); + String expectedError = String + .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(), + relationshipDefinition.getToNode()); + assertDoesNotThrow(() -> + Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, + instancesList, relationshipDefinition, new HashMap<>()), expectedError); + + try { + Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, + instancesList, relationshipDefinition, new HashMap<>()); + } catch (Exception e) { + assertTrue(e instanceof ToscaExportException); + assertEquals(expectedError, e.getMessage()); + } + + final RelationshipInfo relation = new RelationshipInfo(); + final String requirementUid = "Uid"; + relation.setRequirementUid(requirementUid); + final String requirementName = "requirementName"; + relation.setRequirement(requirementName); + final String capabilityName = "capabilityName"; + relation.setCapability(capabilityName); + final String capabilityOwnerId = "capabilityOwnerId"; + relation.setCapabilityOwnerId(capabilityOwnerId); + relationship.setRelation(relation); + + final Map> requirementMap = new HashMap<>(); + final RequirementDefinition requirementDefinition = new RequirementDefinition(); + requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition)); + fromOriginComponent.setRequirements(requirementMap); + relationshipDefinition.setToNode(fromInstanceUid); + + expectedError = String + .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s", + relation.getRequirementUid(), fromOriginComponent.getUniqueId()); + + assertThrows(ToscaExportException.class, () -> + Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, + instancesList, relationshipDefinition, new HashMap<>()), expectedError); + + requirementDefinition.setName(requirementName); + + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + + expectedError = String.format( + "Failed to build substituted name for the requirement %s. " + + "Failed to get an origin component with uniqueId %s", + requirementName, fromInstance.getActualComponentUid()); + assertThrows(ToscaExportException.class, () -> Deencapsulation + .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList, + relationshipDefinition, new HashMap<>()), expectedError); + + final Component toOriginComponent = new Resource(); + final Map> capabilityMap = new HashMap<>(); + final CapabilityDefinition capabilityDefinition = new CapabilityDefinition(); + + capabilityDefinition.setName(capabilityName); + capabilityDefinition.setOwnerId(capabilityOwnerId); + capabilityDefinition.setType("aType"); + final String capabilityPreviousName = "capabilityPreviousName"; + capabilityDefinition.setPreviousName(capabilityPreviousName); + capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition)); + toOriginComponent.setCapabilities(capabilityMap); + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))) + .thenReturn(Either.left(toOriginComponent)); + + requirementDefinition.setCapability(capabilityName); + relation.setCapability("wrong"); + final String requirementPreviousName = "requirementPreviousName"; + requirementDefinition.setPreviousName(requirementPreviousName); + requirementDefinition.setPath(new ArrayList<>()); + + expectedError = String + .format("Failed to find a capability with name %s on a component with uniqueId %s", + relation.getCapability(), fromOriginComponent.getUniqueId()); + + assertThrows(ToscaExportException.class, () -> Deencapsulation + .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList, + relationshipDefinition, new HashMap<>()), + expectedError); + } + + @Test + void testBuildRequirement() { + final ComponentInstance fromInstance = new ComponentInstance(); + fromInstance.setUniqueId("name"); + fromInstance.setComponentUid("string"); + final List instancesList = new ArrayList<>(); + + final Map componentCache = new HashMap<>(); + final List relationshipList = new ArrayList<>(); + final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship(); + relationship.setRequirement(new RequirementDataDefinition()); + final RelationshipInfo relation = new RelationshipInfo(); + final String requirementUid = "Uid"; + relation.setRequirementUid(requirementUid); + final String requirementName = "requirementName"; + relation.setRequirement(requirementName); + final String capabilityName = "capabilityName"; + relation.setCapability(capabilityName); + final String capabilityOwnerId = "capabilityOwnerId"; + relation.setCapabilityOwnerId(capabilityOwnerId); + relationship.setRelation(relation); + relationshipList.add(relationship); + final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef(); + relationshipDefinition.setRelationships(relationshipList); + relationshipDefinition.setToNode("name"); + instancesList.add(fromInstance); + final RequirementDefinition requirementDefinition = new RequirementDefinition(); + requirementDefinition.setName(requirementName); + requirementDefinition.setCapability(capabilityName); + final String requirementPreviousName = "requirementPreviousName"; + requirementDefinition.setPreviousName(requirementPreviousName); + requirementDefinition.setPath(new ArrayList<>()); + final Map> requirementMap = new HashMap<>(); + requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition)); + final Component fromOriginComponent = new Resource(); + fromOriginComponent.setRequirements(requirementMap); + + final Map> capabilityMap = new HashMap<>(); + final CapabilityDefinition capabilityDefinition = new CapabilityDefinition(); + capabilityDefinition.setName(capabilityName); + capabilityDefinition.setOwnerId(capabilityOwnerId); + final String capabilityPreviousName = "capabilityPreviousName"; + capabilityDefinition.setPreviousName(capabilityPreviousName); + capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition)); + final Component toOriginComponent = new Resource(); + toOriginComponent.setCapabilities(capabilityMap); + + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))) + .thenReturn(Either.left(toOriginComponent)); + final String builtCapabilityName = "builtCapabilityName"; + when( + capabilityRequirementConverter + .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq( + capabilityPreviousName), any())) + .thenReturn(Either.left(builtCapabilityName)); + + final String builtRequirementName = "builtRequirementName"; + when( + capabilityRequirementConverter + .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq( + requirementPreviousName), any())) + .thenReturn(Either.left(builtRequirementName)); + + final Map actualRequirementMap = + Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, + instancesList, relationshipDefinition, componentCache); + assertNotNull(actualRequirementMap); + assertFalse(actualRequirementMap.isEmpty()); + assertTrue(actualRequirementMap.containsKey(builtRequirementName)); + final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName); + assertNotNull(actualToscaTemplateRequirement); + assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability()); + + //to toOriginComponent not found + when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))) + .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); + + assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, + instancesList, relationshipDefinition, componentCache)); + } + + @Test + void testAddRequirmentsWithBuildAndAddRequirements() { + ComponentInstance fromInstance = new ComponentInstance(); + Component fromOriginComponent = new Resource(); + List instancesList = new ArrayList<>(); + RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef(); + List> toscaRequirements = new ArrayList<>(); + Map componentCache = new HashMap<>(); + + List 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> requirements = new HashMap<>(); + + List defs = new ArrayList<>(); + RequirementDefinition def = new RequirementDefinition(); + def.setName("requirment"); + def.setCapability("cap"); + defs.add(def); + requirements.put("key", defs); + fromOriginComponent.setRequirements(requirements); + + Map> capabilities = new HashMap<>(); + List caps = new ArrayList<>(); + CapabilityDefinition capdef = new CapabilityDefinition(); + capdef.setOwnerId("id"); + capdef.setName("cap"); + capdef.setPreviousName("before cap"); + capdef.setType("type"); + caps.add(capdef); + capabilities.put("cap", caps); + fromOriginComponent.setCapabilities(capabilities); + + when(toscaOperationFacade.getToscaElement(any(String.class), + any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent)); + + when( + capabilityRequirementConverter + .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString(), any())) + .thenReturn(Either.right(false)); + + final String expectedErrorMsg = + String.format("Failed to build a substituted capability name for the capability " + + "with name %s on a component with uniqueId %s", + cap.getRequirement(), fromOriginComponent.getUniqueId()); + + assertThrows(ToscaExportException.class, () -> + Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList, + rel, componentCache), expectedErrorMsg); + } + + @Test + void testBuildAndAddRequirement() { + 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 componentCache = new HashMap<>(); + final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship(); + capabilityRequirementRelationship.setRelation(reqAndRelationshipPair); + capability.setPath(new ArrayList<>()); + capability.setPreviousName("before cap"); + reqAndRelationshipPair.setCapability("cap"); + requirement.setPath(new ArrayList<>()); + requirement.setPreviousName("before req"); + reqAndRelationshipPair.setRequirement("req"); + + when( + capabilityRequirementConverter + .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString(), any())) + .thenReturn(Either.left("buildCapNameRes")); + + when( + capabilityRequirementConverter + .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString(), any())) + .thenReturn(Either.left("buildReqNameRes")); + + // default test + final Map requirementMap = + Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, + capability, requirement, capabilityRequirementRelationship, toInstance, componentCache); + assertNotNull(requirementMap); + assertFalse(requirementMap.isEmpty()); + assertTrue(requirementMap.containsKey("buildReqNameRes")); + final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes"); + assertNotNull(actualToscaTemplateRequirement); + assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability()); + } + + @Test + void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() { + final Component fromOriginComponent = new Resource(); + final Component toOriginComponent = new Resource(); + final CapabilityDefinition capability = new CapabilityDefinition(); + final RequirementDefinition requirement = new RequirementDefinition(); + final RelationshipInfo relationship = new RelationshipInfo(); + final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship(); + capabilityRequirementRelationship.setRelation(relationship); + ComponentInstance toInstance = new ComponentInstance(); + Map componentCache = new HashMap<>(); + capability.setPath(new ArrayList<>()); + relationship.setCapability("cap"); + requirement.setPath(new ArrayList<>()); + relationship.setRequirement("req"); + + final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName"; + when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("cap"), any(), any())) + .thenReturn(Either.left(builtCapabilityOrRequirementName)); + when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("req"), any(), any())) + .thenReturn(Either.left(builtCapabilityOrRequirementName)); + + final Map requirementMap = Deencapsulation + .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement, + capabilityRequirementRelationship, toInstance, componentCache); + assertNotNull(requirementMap); + assertFalse(requirementMap.isEmpty()); + assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName)); + final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName); + assertNotNull(actualToscaTemplateRequirement); + assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability()); + } + + @Test + void testIsRequirementBelongToRelation() { + + 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); + assertFalse(result); + } + + @Test + void testIsRequirementBelongToRelationWithNonAtomicComponent() { + + Component originComponent = new Service(); + RelationshipInfo reqAndRelationshipPair = new RelationshipInfo(); + RequirementDefinition requirement = new RequirementDefinition(); + requirement.setUniqueId(UNIQUE_ID); + reqAndRelationshipPair.setRequirementUid(UNIQUE_ID); + String fromInstanceId = ""; + boolean result; + + // default test return true + result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent, + reqAndRelationshipPair, requirement, fromInstanceId); + assertTrue(result); + } + + @Test + void testIsRequirementBelongToOwner() { + + 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); + assertFalse(result); + } + + @Test + void testIsCvfc() { + + Component component = new Service(); + boolean result; + + result = Deencapsulation.invoke(testSubject, "isCvfc", component); + assertFalse(result); + } + + @Test + void testConvertCapabilities() { + final Component component = new Resource(); + final Map componentCache = new HashMap<>(); + + final Either, ToscaError> expectedResult = Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR); + when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component)) + .thenReturn(expectedResult); + + // default test return isRight + final Either, ToscaError> actualResult = + Deencapsulation.invoke(testSubject, "convertSubstitutionMappingCapabilities", component, componentCache); + assertNotNull(actualResult); + assertEquals(expectedResult, actualResult); + } + + @Test + void testConvertCapabilities_1() { + Component component = new Resource(); + ToscaNodeType nodeType = new ToscaNodeType(); + Map dataTypes = new HashMap<>(); + Either result; + + Map capabilities = new HashMap<>(); + capabilities.put("key", new ToscaCapability()); -public class ToscaExportHandlerTest { + // default test + result = Deencapsulation + .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes); + assertNotNull(result); + } - private ToscaExportHandler createTestSubject() { - return new ToscaExportHandler(); - } + @Test + void testConvertToNodeTemplateArtifacts() { + Map container = new HashMap<>(); + ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition(); + art.setFile("test_file"); + art.setType("test_type"); + Map result; + container.put("test_art", art); + result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container); + assertNotNull(result); + assertTrue(MapUtils.isNotEmpty(result)); + assertEquals("test_file", result.get("test_art").getFile()); + assertEquals("test_type", result.get("test_art").getType()); + } - - @Test - public void testGetDependencies() throws Exception { - ToscaExportHandler testSubject; - Component component = null; - Either result; + private Component getTestComponent() { + Component component = new Service(); + component.setUniqueId("serviceUniqueId"); + component.setNormalizedName("normalizedServiceComponentName"); + InterfaceDefinition addedInterface = new InterfaceDefinition(); + addedInterface.setType("com.some.service.or.other.serviceName"); + final String interfaceType = "normalizedServiceComponentName-interface"; + component.setInterfaces(new HashMap<>()); + component.getInterfaces().put(interfaceType, addedInterface); + return component; + } - // default test - testSubject = createTestSubject(); - } + private PropertyDefinition createMockProperty(String propertyName, String defaultValue) { + PropertyDefinition propertyDefinition = new PropertyDefinition(); + propertyDefinition.setName(propertyName); + propertyDefinition.setType("string"); + propertyDefinition.setDefaultValue(defaultValue); + return propertyDefinition; + } - - @Test - public void testGetInterfaceFilename() throws Exception { - String artifactName = ""; - String result; + private InputDefinition createMockInput(String inputName, String defaultValue) { + InputDefinition inputDefinition = new InputDefinition(); + inputDefinition.setName(inputName); + inputDefinition.setType("string"); + inputDefinition.setDefaultValue(defaultValue); + return inputDefinition; + } - // default test - } -} \ No newline at end of file +}