catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  * Modifications copyright (c) 2020, Nordix Foundation
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.tosca;
  24
  25 import static org.junit.jupiter.api.Assertions.assertEquals;
  26 import static org.junit.jupiter.api.Assertions.assertFalse;
  27 import static org.junit.jupiter.api.Assertions.assertNotNull;
  28 import static org.junit.jupiter.api.Assertions.assertThrows;
  29 import static org.junit.jupiter.api.Assertions.assertTrue;
  30 import static org.mockito.ArgumentMatchers.any;
  31 import static org.mockito.ArgumentMatchers.anyBoolean;
  32 import static org.mockito.ArgumentMatchers.anyList;
  33 import static org.mockito.ArgumentMatchers.anyMap;
  34 import static org.mockito.ArgumentMatchers.anyString;
  35 import static org.mockito.ArgumentMatchers.eq;
  36 import static org.mockito.ArgumentMatchers.isNull;
  37 import static org.mockito.Mockito.doReturn;
  38 import static org.mockito.Mockito.times;
  39 import static org.mockito.Mockito.verify;
  40 import static org.mockito.Mockito.when;
  41 import static org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum.VF;
  42 import static org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType.PROPERTY;
  43
  44 import fj.data.Either;
  45 import java.util.ArrayList;
  46 import java.util.Arrays;
  47 import java.util.Collections;
  48 import java.util.HashMap;
  49 import java.util.LinkedList;
  50 import java.util.List;
  51 import java.util.Map;
  52 import java.util.stream.Collectors;
  53 import mockit.Deencapsulation;
  54 import org.apache.commons.collections.MapUtils;
  55 import org.apache.commons.lang3.tuple.ImmutablePair;
  56 import org.apache.commons.lang3.tuple.Triple;
  57 import org.junit.jupiter.api.BeforeAll;
  58 import org.junit.jupiter.api.BeforeEach;
  59 import org.junit.jupiter.api.Test;
  60 import org.mockito.InjectMocks;
  61 import org.mockito.Mock;
  62 import org.mockito.MockitoAnnotations;
  63 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
  64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  65 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  66 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  67 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
  68 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  69 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  70 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
  71 import org.openecomp.sdc.be.exception.ToscaExportException;
  72 import org.openecomp.sdc.be.model.ArtifactDefinition;
  73 import org.openecomp.sdc.be.model.AttributeDefinition;
  74 import org.openecomp.sdc.be.model.CapabilityDefinition;
  75 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  76 import org.openecomp.sdc.be.model.Component;
  77 import org.openecomp.sdc.be.model.ComponentInstance;
  78 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
  79 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  80 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  81 import org.openecomp.sdc.be.model.ComponentParametersView;
  82 import org.openecomp.sdc.be.model.DataTypeDefinition;
  83 import org.openecomp.sdc.be.model.GroupDefinition;
  84 import org.openecomp.sdc.be.model.GroupInstance;
  85 import org.openecomp.sdc.be.model.InputDefinition;
  86 import org.openecomp.sdc.be.model.InterfaceDefinition;
  87 import org.openecomp.sdc.be.model.OutputDefinition;
  88 import org.openecomp.sdc.be.model.PropertyDefinition;
  89 import org.openecomp.sdc.be.model.RelationshipInfo;
  90 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  91 import org.openecomp.sdc.be.model.RequirementDefinition;
  92 import org.openecomp.sdc.be.model.Resource;
  93 import org.openecomp.sdc.be.model.Service;
  94 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  95 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  96 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  97 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  98 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
  99 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 100 import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
 101 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
 102 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
 103 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
 104 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
 105 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
 106 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
 107 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
 108 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
 109 import org.openecomp.sdc.be.tosca.utils.InputConverter;
 110 import org.openecomp.sdc.be.tosca.utils.OutputConverter;
 111 import org.openecomp.sdc.common.test.BaseConfDependent;
 112
 113 class ToscaExportHandlerTest extends BaseConfDependent {
 114
 115     private static final String COMPONENT_PROPERTY_NAME = "prop1";
 116     private static final String COMPONENT_PROPERTY_TYPE = "string";
 117     private static final String COMPONENT_INPUT_NAME = "input1";
 118     private static final String COMPONENT_OUTPUT_NAME = "output1";
 119     private static final String COMPONENT_INPUT_TYPE = "integer";
 120     private static final String COMPONENT_OUTPUT_TYPE = "integer";
 121     private static final String RESOURCE_NAME = "resource";
 122     private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
 123     private static final String LOCAL_INTERFACE_TYPE = "Local";
 124     public static final String UNIQUE_ID = "1L";
 125
 126     @InjectMocks
 127     private ToscaExportHandler testSubject;
 128
 129     @Mock
 130     private ApplicationDataTypeCache applicationDataTypeCache;
 131
 132     @Mock
 133     private ToscaOperationFacade toscaOperationFacade;
 134
 135     @Mock
 136     private CapabilityRequirementConverter capabilityRequirementConverter;
 137
 138     @Mock
 139     private InputConverter inputConverter;
 140
 141     @Mock
 142     private OutputConverter outputConverter;
 143
 144     @Mock
 145     private GroupExportParser groupExportParser;
 146
 147     @Mock
 148     private PropertyConvertor propertyConvertor;
 149
 150     @Mock
 151     private GroupExportParserImpl groupExportParserImpl;
 152
 153     @Mock
 154     private InterfaceLifecycleOperation interfaceLifecycleOperation;
 155
 156     @Mock
 157     private InterfacesOperationsConverter interfacesOperationsConverter;
 158
 159     @Mock
 160     private PolicyExportParser policyExportParser;
 161
 162     @Mock
 163     private AttributeConverter attributeConverter;
 164
 165     @BeforeAll
 166     public static void setupBeforeClass() {
 167         componentName = "catalog-be";
 168         confPath = "src/test/resources/config";
 169         setUp();
 170     }
 171
 172     @BeforeEach
 173     void setUpMock() {
 174         MockitoAnnotations.openMocks(this);
 175         doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
 176         doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter).getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean());
 177     }
 178
 179     private Resource getNewResource() {
 180         Resource resource = new Resource();
 181         resource.setUniqueId("resourceUniqueId");
 182         List<CategoryDefinition> categories = new ArrayList<>();
 183         CategoryDefinition category = new CategoryDefinition();
 184         List<SubCategoryDefinition> subcategories = new ArrayList<>();
 185         SubCategoryDefinition subcategory = new SubCategoryDefinition();
 186         List<DataTypeDefinition> dataTypes = new ArrayList<>();
 187         DataTypeDefinition dataType = new DataTypeDefinition();
 188         dataType.setName("dataTypeName");
 189         dataType.setDerivedFromName("tosca.datatypes.Root");
 190         PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
 191             .setName("property")
 192             .setType("type")
 193             .build();
 194         List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
 195         dataType.setPropertiesData(propDataList);
 196         List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
 197             .collect(Collectors.toList());
 198         dataType.setProperties(propList);
 199         dataTypes.add(dataType);
 200
 201         subcategory.setName("name");
 202         subcategories.add(subcategory);
 203         category.setName("name");
 204         category.setSubcategories(subcategories);
 205         categories.add(category);
 206
 207         final List<PropertyDefinition> properties = new ArrayList<>();
 208         properties.add(new PropertyDefinition());
 209         resource.setProperties(properties);
 210         Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
 211         proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
 212         resource.setInterfaces(proxyInterfaces);
 213
 214         resource.setCategories(categories);
 215         resource.setVersion("version");
 216         resource.setVendorName("vendorName");
 217         resource.setVendorRelease("vendorRelease");
 218         resource.setResourceVendorModelNumber("resourceVendorModelNumber");
 219         resource.setDataTypes(dataTypes);
 220
 221         return resource;
 222     }
 223
 224     private Service getNewService() {
 225         Service service = new Service();
 226         List<CategoryDefinition> categories = new ArrayList<>();
 227         CategoryDefinition category = new CategoryDefinition();
 228         List<SubCategoryDefinition> subcategories = new ArrayList<>();
 229         SubCategoryDefinition subcategory = new SubCategoryDefinition();
 230
 231         subcategory.setName("name");
 232         subcategories.add(subcategory);
 233         category.setName("name");
 234         category.setSubcategories(subcategories);
 235         categories.add(category);
 236
 237         service.setCategories(categories);
 238         service.setComponentType(ComponentTypeEnum.SERVICE);
 239         service.setServiceType("serviceType");
 240         service.setServiceRole("serviceRole");
 241         service.setEnvironmentContext("environmentContext");
 242
 243         return service;
 244     }
 245
 246     @Test
 247     void testExportComponent() {
 248         Component component = getNewResource();
 249         Either<ToscaRepresentation, ToscaError> result;
 250
 251         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 252         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
 253             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 254         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
 255             .thenReturn(Either.left(Collections.emptyMap()));
 256
 257         // default test when component is Resource
 258         result = testSubject.exportComponent(component);
 259         assertNotNull(result);
 260
 261         component = getNewService();
 262         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
 263             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 264         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 265
 266         // default test when component is Service
 267         result = testSubject.exportComponent(component);
 268         assertNotNull(result);
 269     }
 270
 271     @Test
 272     void testExportComponentInterface() {
 273         Resource component = getNewResource();
 274         Either<ToscaRepresentation, ToscaError> result;
 275
 276         component.setInterfaces(new HashMap<>());
 277
 278         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 279         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
 280             .thenReturn(Either.left(Collections.emptyMap()));
 281         // default test when convertInterfaceNodeType is right
 282         result = testSubject.exportComponentInterface(component, false);
 283         assertNotNull(result);
 284
 285         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 286         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
 287             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 288
 289         // default test when convertInterfaceNodeType is left
 290         result = testSubject.exportComponentInterface(component, false);
 291         assertNotNull(result);
 292     }
 293
 294     @Test
 295     void testExportDataType() {
 296         DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
 297         dataTypeDefinition.setUniqueId("uniqueId");
 298         Either<ToscaRepresentation, ToscaError> result;
 299         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 300         result = testSubject.exportDataType(dataTypeDefinition);
 301         assertNotNull(result);
 302     }
 303
 304     @Test
 305     void testConvertInterfaceNodeTypeProperties() {
 306
 307         Resource component = getNewResource();
 308
 309         component.setInterfaces(new HashMap<>());
 310         InputDefinition input = new InputDefinition();
 311         input.setName(COMPONENT_INPUT_NAME);
 312         input.setType(COMPONENT_INPUT_TYPE);
 313         component.setInputs(Collections.singletonList(input));
 314         PropertyDefinition property = new PropertyDefinition();
 315         property.setName(COMPONENT_PROPERTY_NAME);
 316         property.setType(COMPONENT_PROPERTY_TYPE);
 317         component.setProperties(Collections.singletonList(property));
 318         component.setName(RESOURCE_NAME);
 319         component.setToscaResourceName(RESOURCE_NAME);
 320
 321         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
 322             .thenReturn(Either.left(Collections.emptyMap()));
 323         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 324         // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
 325         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
 326             any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
 327
 328         final var result = testSubject.convertInterfaceNodeType(new HashMap<String, Component>(), component,
 329             new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
 330         assertNotNull(result);
 331         assertTrue(result.isLeft());
 332         Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
 333         assertNotNull(nodeTypeMap);
 334         assertEquals(1, nodeTypeMap.size());
 335         ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
 336         assertNotNull(toscaNodeType);
 337         Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
 338         // Check if inputs and properties in component are merged properly
 339         assertNotNull(propertyMap);
 340         assertEquals(1, propertyMap.size());
 341         assertFalse(propertyMap.containsKey(COMPONENT_INPUT_NAME));
 342         assertTrue(propertyMap.containsKey(COMPONENT_PROPERTY_NAME));
 343     }
 344
 345     @Test
 346     void testGetDependencies() {
 347
 348         Component component = new Resource();
 349         Either<ToscaTemplate, ToscaError> result;
 350
 351         // default test
 352         result = testSubject.getDependencies(component);
 353         assertNotNull(result);
 354     }
 355
 356     @Test
 357     void testSetImports() {
 358         Resource resource = new Resource();
 359         resource.setResourceType(ResourceTypeEnum.PNF);
 360
 361         resource.setName("TestResourceName");
 362         Map<String, ArtifactDefinition> artifactList = new HashMap<>();
 363         ArtifactDefinition artifact = new ArtifactDefinition();
 364         artifact.setArtifactName("name.name2");
 365         artifactList.put("assettoscatemplate", artifact);
 366         resource.setArtifacts(artifactList);
 367         resource.setToscaArtifacts(artifactList);
 368         ToscaTemplate toscaTemplate = new ToscaTemplate("");
 369
 370         ComponentInstance ci = new ComponentInstance();
 371         ci.setComponentUid("name");
 372         ci.setOriginType(OriginTypeEnum.PNF);
 373         ci.setSourceModelUid("modelName");
 374         List<ComponentInstance> componentInstanceList = new LinkedList<>();
 375         componentInstanceList.add(ci);
 376         resource.setComponentInstances(componentInstanceList);
 377
 378         when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(resource));
 379
 380         Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
 381         result = Deencapsulation.invoke(testSubject, "fillImports", resource, toscaTemplate);
 382
 383         verify(toscaOperationFacade, times(1)).getToscaFullElement("name");
 384         assertTrue(result.isLeft());
 385         ToscaTemplate toscaTemplateRes = result.left().value().left;
 386         assertEquals(8, toscaTemplateRes.getImports().size());
 387         assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface"));
 388         assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName"));
 389         assertEquals(1, toscaTemplateRes.getDependencies().size());
 390         assertEquals("name.name2", toscaTemplateRes.getDependencies().get(0).getLeft());
 391     }
 392
 393     @Test
 394     void testConvertToscaTemplate() throws Exception {
 395
 396         final Component component = getNewResource();
 397         final ToscaTemplate toscaNode = new ToscaTemplate("");
 398         Either<ToscaTemplate, ToscaError> result;
 399         final List<ComponentInstance> resourceInstances = new ArrayList<>();
 400         final ComponentInstance instance = new ComponentInstance();
 401
 402         instance.setOriginType(OriginTypeEnum.SERVICE);
 403         instance.setSourceModelUid("targetModelUid");
 404         resourceInstances.add(instance);
 405
 406         component.setComponentInstances(resourceInstances);
 407
 408         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 409         when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
 410
 411         final Map<String, ToscaProperty> map = new HashMap<>();
 412         map.put("mock", new ToscaProperty());
 413         doReturn(map).when(outputConverter).convert(any(), any());
 414
 415         // default test
 416         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
 417         assertNotNull(result);
 418     }
 419
 420     @Test
 421     void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException {
 422         Component component = getNewResource();
 423         ToscaTemplate toscaNode = new ToscaTemplate("");
 424         component.setComponentInstances(new ArrayList<>());
 425
 426         List<GroupDefinition> groups = new ArrayList<>();
 427         GroupDefinition group = new GroupDefinition();
 428         List<String> artifacts = new ArrayList<>();
 429         artifacts.add("artifact");
 430         group.setType("org.openecomp.groups.VfModule");
 431         group.setArtifacts(artifacts);
 432         groups.add(group);
 433         component.setGroups(groups);
 434
 435         final var input = new InputDefinition();
 436         input.setName(COMPONENT_INPUT_NAME);
 437         input.setType(COMPONENT_INPUT_TYPE);
 438         component.setInputs(Collections.singletonList(input));
 439
 440         final var output = new OutputDefinition();
 441         output.setName(COMPONENT_OUTPUT_NAME);
 442         output.setType(COMPONENT_OUTPUT_TYPE);
 443         component.setOutputs(Collections.singletonList(output));
 444
 445         Map<String, String[]> substitutionMappingMap = new HashMap<>();
 446         String[] array = {"value1", "value2"};
 447         substitutionMappingMap.put("key", array);
 448
 449         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(),
 450             any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
 451
 452         when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
 453             .thenReturn(Either.left(Collections.emptyMap()));
 454
 455         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 456
 457         when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
 458
 459         when(groupExportParser.getGroups(component)).thenReturn(null);
 460
 461         final Map<String, ToscaProperty> map = new HashMap<>();
 462         map.put("mock", new ToscaProperty());
 463         doReturn(map).when(outputConverter).convert(any(), any());
 464
 465         // test component contains group
 466         final var result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
 467         assertNotNull(result);
 468     }
 469
 470     @Test
 471     void testConvertToscaTemplateWhenComponentIsService() throws Exception {
 472         Component component = getNewService();
 473         ToscaTemplate toscaNode = new ToscaTemplate("");
 474         Either<ToscaTemplate, ToscaError> result;
 475         component.setComponentInstances(new ArrayList<>());
 476
 477         List<GroupDefinition> groups = new ArrayList<>();
 478         GroupDefinition group = new GroupDefinition();
 479         List<String> artifacts = new ArrayList<>();
 480         artifacts.add("artifact");
 481         group.setType("org.openecomp.groups.VfModule");
 482         group.setArtifacts(artifacts);
 483         groups.add(group);
 484         component.setGroups(groups);
 485
 486         Map<String, String[]> substitutionMappingMap = new HashMap<>();
 487         String[] array = {"value1", "value2"};
 488         substitutionMappingMap.put("key", array);
 489
 490         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
 491             .thenReturn(Either.left(substitutionMappingMap));
 492
 493         when(capabilityRequirementConverter
 494             .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
 495             .thenReturn(Either.left(Collections.emptyMap()));
 496
 497         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 498
 499         when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
 500         final Map<String, ToscaProperty> map = new HashMap<>();
 501         map.put("mock", new ToscaProperty());
 502         doReturn(map).when(outputConverter).convert(any(), any());
 503
 504         // test component contains group
 505         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
 506         assertNotNull(result);
 507     }
 508
 509     @Test
 510     void testConvertMetadata_1() {
 511
 512         Component component = getNewResource();
 513         boolean isInstance = true;
 514         ComponentInstance componentInstance = new ComponentInstance();
 515         componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
 516         componentInstance.setSourceModelInvariant("targetModelInvariant");
 517
 518         // default test
 519         Map<String, String> result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
 520         assertNotNull(result);
 521     }
 522
 523     @Test
 524     void testFillImports() {
 525
 526         Component component = getNewService();
 527         ToscaTemplate toscaTemplate = new ToscaTemplate("");
 528         Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
 529
 530         ComponentInstance instance = new ComponentInstance();
 531         List<ComponentInstance> resourceInstances = new ArrayList<>();
 532         instance.setComponentUid("name");
 533         resourceInstances.add(instance);
 534         component.setComponentInstances(resourceInstances);
 535         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 536         ArtifactDefinition artifact = new ArtifactDefinition();
 537         artifact.setArtifactName("name.name2");
 538         toscaArtifacts.put("assettoscatemplate", artifact);
 539         component.setToscaArtifacts(toscaArtifacts);
 540
 541         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 542             .thenReturn(Either.left(component));
 543
 544         Resource baseType = getNewResource();
 545         Map<String, ArtifactDefinition> baseTypeToscaArtifacts = new HashMap<>();
 546         ArtifactDefinition baseTypeArtifact = new ArtifactDefinition();
 547         baseTypeArtifact.setArtifactName("typeA");
 548         baseTypeToscaArtifacts.put("assettoscatemplate", baseTypeArtifact);
 549         baseType.setToscaArtifacts(baseTypeToscaArtifacts);
 550
 551         component.setDerivedFromGenericType("org.typeA");
 552         component.setDerivedFromGenericVersion("1.0");
 553         when(toscaOperationFacade.getByToscaResourceNameAndVersion("org.typeA", "1.0", null)).thenReturn(Either.left(baseType));
 554
 555         // default test
 556         result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
 557         assertNotNull(result);
 558     }
 559
 560     @Test
 561     void testCreateDependency() {
 562
 563         Map<String, Component> componentCache = new HashMap<>();
 564         List<Map<String, Map<String, String>>> imports = new ArrayList<>();
 565         List<Triple<String, String, Component>> dependecies = new ArrayList<>();
 566         ComponentInstance ci = new ComponentInstance();
 567         Component component = getNewResource();
 568
 569         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 570         ArtifactDefinition artifact = new ArtifactDefinition();
 571         artifact.setArtifactName("name.name2");
 572         toscaArtifacts.put("assettoscatemplate", artifact);
 573         component.setToscaArtifacts(toscaArtifacts);
 574         ci.setComponentUid("name");
 575         ci.setOriginType(OriginTypeEnum.ServiceProxy);
 576         ci.setSourceModelUid("modelName");
 577
 578         when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
 579
 580         when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service()));
 581
 582         // default test
 583         Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
 584         assertFalse(componentCache.isEmpty());
 585     }
 586
 587     @Test
 588     void testGetInterfaceFilename() {
 589         String artifactName = "artifact.name";
 590         String result;
 591
 592         // default test
 593         result = ToscaExportHandler.getInterfaceFilename(artifactName);
 594         assertNotNull(result);
 595     }
 596
 597     @Test
 598     void testConvertNodeType() {
 599         Component component = new Resource();
 600         ToscaTemplate toscaNode = new ToscaTemplate("");
 601         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 602         Either<ToscaTemplate, ToscaError> result;
 603
 604         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 605         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
 606             .thenReturn(Either.left(Collections.emptyMap()));
 607         // default test
 608         result = Deencapsulation
 609             .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
 610         assertNotNull(result);
 611     }
 612
 613     @Test
 614     void testConvertInterfaceNodeType() {
 615         Component component = getNewResource();
 616         ToscaTemplate toscaNode = new ToscaTemplate("");
 617         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 618         Either<ToscaTemplate, ToscaError> result;
 619         List<InputDefinition> inputs = new ArrayList<>();
 620         inputs.add(new InputDefinition());
 621         component.setInputs(inputs);
 622
 623         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 624         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
 625             .thenReturn(Either.left(Collections.emptyMap()));
 626
 627         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
 628             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 629
 630         // default test
 631         result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
 632             , nodeTypes, false);
 633         assertNotNull(result);
 634     }
 635
 636     @Test
 637     void testConvertReqCapAndTypeName() {
 638         Component component = new Resource();
 639         ToscaTemplate toscaNode = new ToscaTemplate("");
 640         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 641         ToscaNodeType toscaNodeType = new ToscaNodeType();
 642         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 643         Either<ToscaTemplate, ToscaError> result;
 644
 645         when(
 646             capabilityRequirementConverter
 647                 .convertCapabilities(anyMap(), any(Resource.class), anyMap()))
 648             .thenReturn(new HashMap<>());
 649
 650         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
 651             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 652
 653         // default test
 654         result = Deencapsulation
 655             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 656                 toscaNodeType, dataTypes);
 657         assertNotNull(result);
 658
 659         component = new Service();
 660
 661         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
 662             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 663
 664         // test when component is service
 665         result = Deencapsulation
 666             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 667                 toscaNodeType, dataTypes);
 668         assertNotNull(result);
 669     }
 670
 671     @Test
 672     void testConvertNodeTemplatesWhenComponentIsService() {
 673         final Component component = getNewService();
 674         final List<ComponentInstance> componentInstances = new ArrayList<>();
 675         final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 676         final Map<String, Component> componentCache = new HashMap<>();
 677         final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 678         final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 679         final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 680         final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 681         final List<ComponentInstanceInput> inputs = new ArrayList<>();
 682         final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
 683         componentInstanceInput.setUniqueId("uuid");
 684         inputs.add(componentInstanceInput);
 685         componentInstancesInputs.put("uuid", inputs);
 686         final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 687         final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 688         reldef.setFromNode("node");
 689         resourceInstancesRelations.add(reldef);
 690         component.setComponentInstancesRelations(resourceInstancesRelations);
 691
 692         final ComponentInstance instance = new ComponentInstance();
 693         instance.setUniqueId("id");
 694         instance.setComponentUid("uid");
 695         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 696         final List<GroupInstance> groupInstances = new ArrayList<>();
 697         final GroupInstance groupInst = new GroupInstance();
 698         final List<String> artifacts = new ArrayList<>();
 699         artifacts.add("artifact");
 700         groupInst.setArtifacts(artifacts);
 701         groupInst.setType("type");
 702         groupInstances.add(groupInst);
 703         instance.setGroupInstances(groupInstances);
 704
 705         final List<PropertyDefinition> properties = new ArrayList<>();
 706         properties.add(new PropertyDefinition());
 707         instance.setProperties(properties);
 708
 709         instance.setUniqueId("uuid");
 710         instance.setDescription("desc");
 711         instance.setSourceModelUid("sourceModelUid");
 712
 713         componentInstances.add(instance);
 714
 715         component.setComponentInstances(componentInstances);
 716
 717         component.setComponentInstancesInputs(componentInstancesInputs);
 718         component.setInvariantUUID("uuid");
 719         component.setUUID("uuid");
 720         component.setDescription("desc");
 721         component.setUniqueId("uid");
 722
 723         componentCache.put("uid", component);
 724
 725         final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
 726         componentInstanceProperties.add(new ComponentInstanceProperty());
 727
 728         componentInstancesProperties.put("uuid", componentInstanceProperties);
 729         component.setComponentInstancesProperties(componentInstancesProperties);
 730
 731         final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
 732         final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
 733         final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
 734         componentInstanceAttribute.setDefaultValue("def value");
 735         componentInstanceAttributes.add(componentInstanceAttribute);
 736
 737         componentInstancesAttributes.put("uuid", componentInstanceAttributes);
 738         component.setComponentInstancesAttributes(componentInstancesAttributes);
 739
 740         ComponentInstanceProperty cip = new ComponentInstanceProperty();
 741         cip.setInstanceUniqueId("id");
 742
 743         List<ComponentInstanceProperty> list = new ArrayList<>();
 744         list.add(cip);
 745
 746         componentInstancesProperties.put("id", list);
 747         component.setComponentInstancesProperties(componentInstancesProperties);
 748
 749         when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
 750         when(capabilityRequirementConverter
 751             .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
 752             .thenReturn(Either.left(new ToscaNodeTemplate()));
 753         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
 754         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 755         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
 756             .thenReturn(Either.left(new ToscaNodeType()));
 757         when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
 758         when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
 759         when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
 760         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(getNewResource()));
 761
 762         final Map<String, String[]> substitutionMappingMap = new HashMap<>();
 763         final String[] array = {"value1", "value2"};
 764         substitutionMappingMap.put("key", array);
 765         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
 766             .thenReturn(Either.left(substitutionMappingMap));
 767
 768         when(capabilityRequirementConverter
 769             .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
 770             .thenReturn(Either.left(Collections.emptyMap()));
 771
 772         // default test
 773         final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
 774         assertNotNull(toscaRepresentationToscaErrorEither);
 775
 776     }
 777
 778     @Test
 779     void testConvertNodeTemplatesWhenComponentIsResource() {
 780         final Resource component = getNewResource();
 781         component.setResourceType(VF);
 782         final List<ComponentInstance> componentInstances = new ArrayList<>();
 783         final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 784         final Map<String, Component> componentCache = new HashMap<>();
 785         final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 786         final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 787         final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 788         final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 789         final List<ComponentInstanceInput> inputs = new ArrayList<>();
 790         final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
 791         componentInstanceInput.setUniqueId("uuid");
 792         inputs.add(componentInstanceInput);
 793         componentInstancesInputs.put("uuid", inputs);
 794         final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 795         final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 796         reldef.setFromNode("node");
 797         resourceInstancesRelations.add(reldef);
 798         component.setComponentInstancesRelations(resourceInstancesRelations);
 799
 800         final ComponentInstance instance = new ComponentInstance();
 801         instance.setUniqueId("id");
 802         instance.setComponentUid("uid");
 803         instance.setOriginType(OriginTypeEnum.VFC);
 804         final List<GroupInstance> groupInstances = new ArrayList<>();
 805         final GroupInstance groupInst = new GroupInstance();
 806         final List<String> artifacts = new ArrayList<>();
 807         artifacts.add("artifact");
 808         groupInst.setArtifacts(artifacts);
 809         groupInst.setType("type");
 810         groupInstances.add(groupInst);
 811         instance.setGroupInstances(groupInstances);
 812
 813         final List<PropertyDefinition> properties = new ArrayList<>();
 814         properties.add(new PropertyDefinition());
 815         instance.setProperties(properties);
 816         component.setProperties(properties);
 817
 818         instance.setUniqueId("uuid");
 819         instance.setDescription("desc");
 820         instance.setSourceModelUid("sourceModelUid");
 821         final Map<String, ArtifactDefinition> artifactList = new HashMap<>();
 822         final ArtifactDefinition artifact = new ArtifactDefinition();
 823         artifact.setArtifactName("name.name2");
 824         artifactList.put("assettoscatemplate", artifact);
 825         instance.setArtifacts(artifactList);
 826
 827         Map<String, ToscaArtifactDataDefinition> toscaArtifactDataDefinitionMap = new HashMap<>();
 828         toscaArtifactDataDefinitionMap.put("assettoscatemplate", new ToscaArtifactDataDefinition());
 829         instance.setToscaArtifacts(toscaArtifactDataDefinitionMap);
 830
 831         componentInstances.add(instance);
 832
 833         component.setComponentInstances(componentInstances);
 834
 835         component.setComponentInstancesInputs(componentInstancesInputs);
 836         component.setInvariantUUID("uuid");
 837         component.setUUID("uuid");
 838         component.setDescription("desc");
 839         component.setUniqueId("uid");
 840
 841         componentCache.put("uid", component);
 842
 843         final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
 844         componentInstanceProperties.add(new ComponentInstanceProperty());
 845
 846         componentInstancesProperties.put("uuid", componentInstanceProperties);
 847         component.setComponentInstancesProperties(componentInstancesProperties);
 848
 849         final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
 850         final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
 851         final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
 852         componentInstanceAttribute.setDefaultValue("def value");
 853         componentInstanceAttributes.add(componentInstanceAttribute);
 854
 855         componentInstancesAttributes.put("uuid", componentInstanceAttributes);
 856         component.setComponentInstancesAttributes(componentInstancesAttributes);
 857
 858         component.setArtifacts(artifactList);
 859         component.setToscaArtifacts(artifactList);
 860
 861         final List<AttributeDefinition> attributes = new ArrayList<>();
 862         final var attribute = new AttributeDefinition();
 863         attribute.setName("mock");
 864         attributes.add(attribute);
 865         component.setAttributes(attributes);
 866
 867         List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
 868         componentInstanceInputs.add(new ComponentInstanceInput());
 869
 870         componentInstancesInputs.put("id", componentInstanceInputs);
 871         component.setComponentInstancesInputs(componentInstancesInputs);
 872
 873         when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
 874         when(capabilityRequirementConverter
 875             .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
 876             .thenReturn(Either.left(new ToscaNodeTemplate()));
 877         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
 878         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 879         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
 880             .thenReturn(Either.left(new ToscaNodeType()));
 881         when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
 882         when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
 883         when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
 884
 885         Resource newResource = getNewResource();
 886         InputDefinition input = new InputDefinition();
 887         input.setName(COMPONENT_INPUT_NAME);
 888         input.setType(COMPONENT_INPUT_TYPE);
 889         newResource.setInputs(Collections.singletonList(input));
 890
 891         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(newResource));
 892
 893         final Map<String, String[]> substitutionMappingMap = new HashMap<>();
 894         final String[] array = {"value1", "value2"};
 895         substitutionMappingMap.put("key", array);
 896         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
 897             .thenReturn(Either.left(substitutionMappingMap));
 898
 899         when(capabilityRequirementConverter
 900             .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
 901             .thenReturn(Either.left(Collections.emptyMap()));
 902
 903         // default test
 904         final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(newResource);
 905         assertNotNull(toscaRepresentationToscaErrorEither);
 906
 907     }
 908
 909     @Test
 910     void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() {
 911         Component component = getNewResource();
 912         List<ComponentInstance> componentInstances = new ArrayList<>();
 913         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 914         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 915         Map<String, Component> componentCache = new HashMap<>();
 916         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 917         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 918         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 919         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 920         List<ComponentInstanceInput> inputs = new ArrayList<>();
 921         inputs.add(new ComponentInstanceInput());
 922         componentInstancesInputs.put("key", inputs);
 923         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 924         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 925         reldef.setFromNode("node");
 926         resourceInstancesRelations.add(reldef);
 927         component.setComponentInstancesRelations(resourceInstancesRelations);
 928
 929         ComponentInstance instance = new ComponentInstance();
 930         instance.setUniqueId("id");
 931         instance.setComponentUid("uid");
 932         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 933         componentInstances.add(instance);
 934         component.setComponentInstances(componentInstances);
 935
 936         component.setComponentInstancesInputs(componentInstancesInputs);
 937         component.setInvariantUUID("uuid");
 938         component.setUUID("uuid");
 939         component.setDescription("desc");
 940
 941         componentCache.put("uid", component);
 942
 943         when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
 944         when(capabilityRequirementConverter
 945             .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
 946             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 947         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
 948         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
 949         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
 950             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 951
 952         // default test
 953         final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
 954         assertNotNull(toscaRepresentationToscaErrorEither);
 955     }
 956
 957     @Test
 958     void testConvetNodeTemplateWhenGetOriginComponentIsRight() {
 959         Component component = getNewResource();
 960         List<ComponentInstance> componentInstances = new ArrayList<>();
 961         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 962         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 963         Map<String, Component> componentCache = new HashMap<>();
 964         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 965         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 966         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 967         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 968         List<ComponentInstanceInput> inputs = new ArrayList<>();
 969         inputs.add(new ComponentInstanceInput());
 970         componentInstancesInputs.put("key", inputs);
 971         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 972         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 973         reldef.setFromNode("id");
 974         resourceInstancesRelations.add(reldef);
 975         component.setComponentInstancesRelations(resourceInstancesRelations);
 976
 977         ComponentInstance instance = new ComponentInstance();
 978         instance.setUniqueId("id");
 979         instance.setComponentUid("uid");
 980         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 981         componentInstances.add(instance);
 982         component.setComponentInstances(componentInstances);
 983
 984         component.setComponentInstancesInputs(componentInstancesInputs);
 985         component.setInvariantUUID("uuid");
 986         component.setUUID("uuid");
 987         component.setDescription("desc");
 988
 989         final List<AttributeDefinition> attributes = new ArrayList<>();
 990         final var attribute = new AttributeDefinition();
 991         attribute.setName("mock");
 992         attributes.add(attribute);
 993         component.setAttributes(attributes);
 994
 995         componentCache.put("uid", component);
 996
 997         when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
 998         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
 999         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1000         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1001             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1002
1003         // default test
1004         final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
1005         assertNotNull(toscaRepresentationToscaErrorEither);
1006     }
1007
1008     @Test
1009     void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
1010         Resource component = getNewResource();
1011         component.setResourceType(VF);
1012         List<ComponentInstance> componentInstances = new ArrayList<>();
1013         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
1014         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
1015         Map<String, Component> componentCache = new HashMap<>();
1016         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1017         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
1018         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
1019         List<ComponentInstanceInput> inputs = new ArrayList<>();
1020         inputs.add(new ComponentInstanceInput());
1021         componentInstancesInputs.put("key", inputs);
1022         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
1023         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1024         reldef.setFromNode("id");
1025         reldef.setToNode("node");
1026         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1027         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1028         relationship.setRelation(new RelationshipInfo());
1029         relationships.add(relationship);
1030         reldef.setRelationships(relationships);
1031         resourceInstancesRelations.add(reldef);
1032         component.setComponentInstancesRelations(resourceInstancesRelations);
1033
1034         Map<String, ArtifactDefinition> artifactList = new HashMap<>();
1035         ArtifactDefinition artifact = new ArtifactDefinition();
1036         artifact.setArtifactName("name.name2");
1037         artifactList.put("assettoscatemplate", artifact);
1038         component.setArtifacts(artifactList);
1039         component.setToscaArtifacts(artifactList);
1040
1041         ComponentInstance instance = new ComponentInstance();
1042         instance.setUniqueId("id");
1043         instance.setComponentUid("id");
1044         instance.setOriginType(OriginTypeEnum.VF);
1045         componentInstances.add(instance);
1046         component.setComponentInstances(componentInstances);
1047
1048         component.setComponentInstancesInputs(componentInstancesInputs);
1049         component.setComponentInstances(componentInstances);
1050
1051         doReturn(Either.left(component)).when(toscaOperationFacade).getToscaFullElement("id");
1052         when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
1053         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1054         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1055         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1056             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1057         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1058             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1059
1060         // default test
1061         final Either<ToscaRepresentation, ToscaError> result = testSubject.exportComponent(component);
1062         assertNotNull(result);
1063     }
1064
1065     @Test
1066     void testCreateNodeType() {
1067
1068         Component component = new Resource();
1069         List<String> array = new ArrayList<>();
1070         array.add("value");
1071         ((Resource) component).setDerivedFrom(array);
1072         ToscaNodeType result;
1073
1074         // test when component is resource
1075         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1076         assertNotNull(result);
1077
1078         component = new Service();
1079         // test when component is service
1080         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1081         assertNotNull(result);
1082     }
1083
1084     @Test
1085     void testCreateProxyInterfaceTypesComponentNotFound() {
1086         Component container = new Service();
1087         Either<Map<String, ToscaNodeType>, ToscaError> result;
1088         List<ComponentInstance> componentInstances = new ArrayList<>();
1089         ComponentInstance instance = new ComponentInstance();
1090         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1091         instance.setSourceModelUid("targetModelUid");
1092         instance.setToscaComponentName("toscaComponentName");
1093
1094         componentInstances.add(instance);
1095         container.setComponentInstances(componentInstances);
1096         when(toscaOperationFacade.getToscaElement(any(String.class),
1097             any(ComponentParametersView.class)))
1098             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1099         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1100         assertTrue(result.isRight());
1101     }
1102
1103     @Test
1104     void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
1105         Component container = new Service();
1106         Either<Map<String, ToscaNodeType>, ToscaError> result;
1107         List<ComponentInstance> componentInstances = new ArrayList<>();
1108         ComponentInstance instance = new ComponentInstance();
1109         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1110         instance.setSourceModelUid("targetModelUid");
1111         instance.setToscaComponentName("toscaComponentName");
1112         componentInstances.add(instance);
1113         container.setComponentInstances(componentInstances);
1114
1115         when(toscaOperationFacade.getToscaElement(any(String.class),
1116             any(ComponentParametersView.class)))
1117             .thenReturn(Either.left(new Resource()));
1118         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1119             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1120         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1121         assertTrue(result.isRight());
1122     }
1123
1124     @Test
1125     void testCreateProxyInterfaceTypesPositive() {
1126         Component container = new Service();
1127         Either<Map<String, ToscaNodeType>, ToscaError> result;
1128         List<ComponentInstance> componentInstances = new ArrayList<>();
1129         ComponentInstance instance = new ComponentInstance();
1130         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1131         instance.setSourceModelUid("targetModelUid");
1132         instance.setToscaComponentName("toscaComponentName");
1133         componentInstances.add(instance);
1134         container.setComponentInstances(componentInstances);
1135
1136         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1137
1138         Component proxyResource = new Resource();
1139         Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1140         proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1141         proxyResource.setInterfaces(proxyInterfaces);
1142         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(proxyResource));
1143         when(interfacesOperationsConverter.addInterfaceTypeElement(any(Component.class), anyList()))
1144             .thenReturn(Collections.singletonMap(LOCAL_INTERFACE_TYPE, new HashMap<>()));
1145
1146         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1147         assertNotNull(result);
1148         assertTrue(result.isLeft());
1149         assertEquals(1, result.left().value().size());
1150     }
1151
1152     @Test
1153     void testCreateProxyNodeTypes() {
1154         Map<String, Component> componentCache = new HashMap<>();
1155         Component container = new Resource();
1156         Either<Map<String, ToscaNodeType>, ToscaError> result;
1157         List<ComponentInstance> componentInstances = new ArrayList<>();
1158         ComponentInstance instance = new ComponentInstance();
1159         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1160         instance.setSourceModelUid("targetModelUid");
1161
1162         componentInstances.add(instance);
1163         container.setComponentInstances(componentInstances);
1164
1165         when(toscaOperationFacade.getLatestByName("serviceProxy", null))
1166             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1167
1168         // test when getLatestByName return is right
1169         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1170         assertNotNull(result);
1171     }
1172
1173     @Test
1174     void testCreateServiceSubstitutionNodeTypes() {
1175         Map<String, Component> componentCache = new HashMap<>();
1176
1177         Component referencedService = getNewService();
1178         referencedService.setInvariantUUID("uuid");
1179         referencedService.setUUID("uuid");
1180         referencedService.setUniqueId("targetModelUid");
1181         referencedService.setDescription("desc");
1182         componentCache.put("targetModelUid", referencedService);
1183
1184         Component containerService = new Service();
1185         List<ComponentInstance> componentInstances = new ArrayList<>();
1186         ComponentInstance instance = new ComponentInstance();
1187         instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1188         instance.setSourceModelUid("targetModelUid");
1189
1190         componentInstances.add(instance);
1191         containerService.setComponentInstances(componentInstances);
1192
1193         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1194             .thenReturn(Either.left(Collections.emptyMap()));
1195         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1196         when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
1197             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1198
1199         ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1200
1201         Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1202         assertNotNull(toscaNode.getNode_types());
1203     }
1204
1205     @Test
1206     void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1207         Map<String, Component> componentCache = new HashMap<>();
1208         Component container = new Resource();
1209         Either<Map<String, ToscaNodeType>, ToscaError> result;
1210         List<ComponentInstance> componentInstances = new ArrayList<>();
1211         ComponentInstance instance = new ComponentInstance();
1212         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1213         instance.setSourceModelUid("targetModelUid");
1214
1215         componentInstances.add(instance);
1216         container.setComponentInstances(componentInstances);
1217
1218         when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
1219
1220         ComponentParametersView parameterView = new ComponentParametersView();
1221         parameterView.disableAll();
1222         parameterView.setIgnoreCategories(false);
1223
1224         when(toscaOperationFacade.getToscaElement(any(String.class),
1225             any(ComponentParametersView.class)))
1226             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1227
1228         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1229
1230         // test when getLatestByName is left
1231         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1232         assertNotNull(result);
1233     }
1234
1235     @Test
1236     void testCreateProxyNodeType() {
1237         Map<String, Component> componentCache = new HashMap<>();
1238         Component origComponent = new Resource();
1239         Component proxyComponent = new Resource();
1240         ComponentInstance instance = new ComponentInstance();
1241         ToscaNodeType result;
1242
1243         when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1244
1245         // default test
1246         result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1247             proxyComponent, instance);
1248         assertNotNull(result);
1249     }
1250
1251     @Test
1252     void testConvertComponentInstanceRequirements() {
1253         Component component = new Resource();
1254         ComponentInstance componentInstance = new ComponentInstance();
1255         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1256         ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1257         Component originComponent = new Resource();
1258         Map<String, Component> componentCache = new HashMap<>();
1259         Either<ToscaNodeTemplate, ToscaError> result;
1260
1261         // default test
1262         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1263             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1264         assertNotNull(result);
1265
1266         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1267         reldef.setFromNode("name");
1268         reldef.setToNode("name1");
1269         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1270         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1271         cap.setRelation(new RelationshipInfo());
1272         relationships.add(cap);
1273         reldef.setRelationships(relationships);
1274         relations.add(reldef);
1275         componentInstance.setUniqueId("name");
1276
1277         List<ComponentInstance> instances = new ArrayList<>();
1278         instances.add(componentInstance);
1279         component.setComponentInstances(instances);
1280
1281         // test when filteredRElations ins't empty
1282         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1283             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1284         assertNotNull(result);
1285     }
1286
1287     @Test
1288     void buildRequirementFailure() {
1289         final Component fromOriginComponent = new Resource();
1290         final ComponentInstance fromInstance = new ComponentInstance();
1291         final String fromInstanceUid = "fromInstanceUid";
1292         fromInstance.setUniqueId(fromInstanceUid);
1293         fromInstance.setComponentUid("componentUid");
1294         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1295         relationshipDefinition.setToNode("wrongNodeUid");
1296         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1297         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1298         relationship.setRequirement(new RequirementDataDefinition());
1299         relationshipList.add(relationship);
1300         relationshipDefinition.setRelationships(relationshipList);
1301         final List<ComponentInstance> instancesList = new ArrayList<>();
1302         instancesList.add(fromInstance);
1303         String expectedError = String
1304             .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1305                 relationshipDefinition.getToNode());
1306         assertThrows(ToscaExportException.class, () ->
1307             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1308                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1309
1310         try {
1311             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1312                 instancesList, relationshipDefinition, new HashMap<>());
1313         } catch (Exception e) {
1314             assertTrue(e instanceof ToscaExportException);
1315             assertEquals(expectedError, e.getMessage());
1316         }
1317
1318         final RelationshipInfo relation = new RelationshipInfo();
1319         final String requirementUid = "Uid";
1320         relation.setRequirementUid(requirementUid);
1321         final String requirementName = "requirementName";
1322         relation.setRequirement(requirementName);
1323         final String capabilityName = "capabilityName";
1324         relation.setCapability(capabilityName);
1325         final String capabilityOwnerId = "capabilityOwnerId";
1326         relation.setCapabilityOwnerId(capabilityOwnerId);
1327         relationship.setRelation(relation);
1328
1329         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1330         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1331         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1332         fromOriginComponent.setRequirements(requirementMap);
1333         relationshipDefinition.setToNode(fromInstanceUid);
1334
1335         expectedError = String
1336             .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1337                 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1338
1339         assertThrows(ToscaExportException.class, () ->
1340             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1341                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1342
1343         requirementDefinition.setName(requirementName);
1344
1345         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1346             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1347
1348         expectedError = String.format(
1349             "Failed to build substituted name for the requirement %s. "
1350                 + "Failed to get an origin component with uniqueId %s",
1351             requirementName, fromInstance.getActualComponentUid());
1352         assertThrows(ToscaExportException.class, () -> Deencapsulation
1353             .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1354                 relationshipDefinition, new HashMap<>()), expectedError);
1355
1356         final Component toOriginComponent = new Resource();
1357         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1358         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1359
1360         capabilityDefinition.setName(capabilityName);
1361         capabilityDefinition.setOwnerId(capabilityOwnerId);
1362         capabilityDefinition.setType("aType");
1363         final String capabilityPreviousName = "capabilityPreviousName";
1364         capabilityDefinition.setPreviousName(capabilityPreviousName);
1365         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1366         toOriginComponent.setCapabilities(capabilityMap);
1367         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1368             .thenReturn(Either.left(toOriginComponent));
1369
1370         requirementDefinition.setCapability(capabilityName);
1371         relation.setCapability("wrong");
1372         final String requirementPreviousName = "requirementPreviousName";
1373         requirementDefinition.setPreviousName(requirementPreviousName);
1374         requirementDefinition.setPath(new ArrayList<>());
1375
1376         expectedError = String
1377             .format("Failed to find a capability with name %s on a component with uniqueId %s",
1378                 relation.getCapability(), fromOriginComponent.getUniqueId());
1379
1380         assertThrows(ToscaExportException.class, () -> Deencapsulation
1381                 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1382                     relationshipDefinition, new HashMap<>()),
1383             expectedError);
1384     }
1385
1386     @Test
1387     void testBuildRequirement() {
1388         final ComponentInstance fromInstance = new ComponentInstance();
1389         fromInstance.setUniqueId("name");
1390         fromInstance.setComponentUid("string");
1391         final List<ComponentInstance> instancesList = new ArrayList<>();
1392
1393         final Map<String, Component> componentCache = new HashMap<>();
1394         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1395         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1396         relationship.setRequirement(new RequirementDataDefinition());
1397         final RelationshipInfo relation = new RelationshipInfo();
1398         final String requirementUid = "Uid";
1399         relation.setRequirementUid(requirementUid);
1400         final String requirementName = "requirementName";
1401         relation.setRequirement(requirementName);
1402         final String capabilityName = "capabilityName";
1403         relation.setCapability(capabilityName);
1404         final String capabilityOwnerId = "capabilityOwnerId";
1405         relation.setCapabilityOwnerId(capabilityOwnerId);
1406         relationship.setRelation(relation);
1407         relationshipList.add(relationship);
1408         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1409         relationshipDefinition.setRelationships(relationshipList);
1410         relationshipDefinition.setToNode("name");
1411         instancesList.add(fromInstance);
1412         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1413         requirementDefinition.setName(requirementName);
1414         requirementDefinition.setCapability(capabilityName);
1415         final String requirementPreviousName = "requirementPreviousName";
1416         requirementDefinition.setPreviousName(requirementPreviousName);
1417         requirementDefinition.setPath(new ArrayList<>());
1418         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1419         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1420         final Component fromOriginComponent = new Resource();
1421         fromOriginComponent.setRequirements(requirementMap);
1422
1423         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1424         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1425         capabilityDefinition.setName(capabilityName);
1426         capabilityDefinition.setOwnerId(capabilityOwnerId);
1427         final String capabilityPreviousName = "capabilityPreviousName";
1428         capabilityDefinition.setPreviousName(capabilityPreviousName);
1429         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1430         final Component toOriginComponent = new Resource();
1431         toOriginComponent.setCapabilities(capabilityMap);
1432
1433         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1434             .thenReturn(Either.left(toOriginComponent));
1435         final String builtCapabilityName = "builtCapabilityName";
1436         when(
1437             capabilityRequirementConverter
1438                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1439                     capabilityPreviousName), any()))
1440             .thenReturn(Either.left(builtCapabilityName));
1441
1442         final String builtRequirementName = "builtRequirementName";
1443         when(
1444             capabilityRequirementConverter
1445                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1446                     requirementPreviousName), any()))
1447             .thenReturn(Either.left(builtRequirementName));
1448
1449         final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1450             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1451                 instancesList, relationshipDefinition, componentCache);
1452         assertNotNull(actualRequirementMap);
1453         assertFalse(actualRequirementMap.isEmpty());
1454         assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1455         final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1456         assertNotNull(actualToscaTemplateRequirement);
1457         assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1458
1459         //to toOriginComponent not found
1460         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1461             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1462
1463         assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1464             instancesList, relationshipDefinition, componentCache));
1465     }
1466
1467     @Test
1468     void testAddRequirmentsWithBuildAndAddRequirements() {
1469         ComponentInstance fromInstance = new ComponentInstance();
1470         Component fromOriginComponent = new Resource();
1471         List<ComponentInstance> instancesList = new ArrayList<>();
1472         RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1473         List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1474         Map<String, Component> componentCache = new HashMap<>();
1475
1476         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1477         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1478         cap.setRequirement(new RequirementDataDefinition());
1479         RelationshipInfo relation = new RelationshipInfo();
1480         relation.setRequirementUid("Uid");
1481         relation.setRequirement("requirment");
1482         relation.setCapability("cap");
1483         relation.setCapabilityOwnerId("id");
1484         cap.setRelation(relation);
1485         relationships.add(cap);
1486         rel.setRelationships(relationships);
1487         rel.setToNode("name");
1488         fromInstance.setUniqueId("name");
1489         fromInstance.setComponentUid("string");
1490         instancesList.add(fromInstance);
1491         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1492
1493         List<RequirementDefinition> defs = new ArrayList<>();
1494         RequirementDefinition def = new RequirementDefinition();
1495         def.setName("requirment");
1496         def.setCapability("cap");
1497         defs.add(def);
1498         requirements.put("key", defs);
1499         fromOriginComponent.setRequirements(requirements);
1500
1501         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1502         List<CapabilityDefinition> caps = new ArrayList<>();
1503         CapabilityDefinition capdef = new CapabilityDefinition();
1504         capdef.setOwnerId("id");
1505         capdef.setName("cap");
1506         capdef.setPreviousName("before cap");
1507         capdef.setType("type");
1508         caps.add(capdef);
1509         capabilities.put("cap", caps);
1510         fromOriginComponent.setCapabilities(capabilities);
1511
1512         when(toscaOperationFacade.getToscaElement(any(String.class),
1513             any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1514
1515         when(
1516             capabilityRequirementConverter
1517                 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString(), any()))
1518             .thenReturn(Either.right(false));
1519
1520         final String expectedErrorMsg =
1521             String.format("Failed to build a substituted capability name for the capability "
1522                     + "with name %s on a component with uniqueId %s",
1523                 cap.getRequirement(), fromOriginComponent.getUniqueId());
1524
1525         assertThrows(ToscaExportException.class, () ->
1526             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1527                 rel, componentCache), expectedErrorMsg);
1528     }
1529
1530     @Test
1531     void testBuildAndAddRequirement() {
1532         Component fromOriginComponent = new Resource();
1533         Component toOriginComponent = new Resource();
1534         CapabilityDefinition capability = new CapabilityDefinition();
1535         RequirementDefinition requirement = new RequirementDefinition();
1536         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1537         ComponentInstance toInstance = new ComponentInstance();
1538         Map<String, Component> componentCache = new HashMap<>();
1539         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1540         capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1541         capability.setPath(new ArrayList<>());
1542         capability.setPreviousName("before cap");
1543         reqAndRelationshipPair.setCapability("cap");
1544         requirement.setPath(new ArrayList<>());
1545         requirement.setPreviousName("before req");
1546         reqAndRelationshipPair.setRequirement("req");
1547
1548         when(
1549             capabilityRequirementConverter
1550                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString(), any()))
1551             .thenReturn(Either.left("buildCapNameRes"));
1552
1553         when(
1554             capabilityRequirementConverter
1555                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString(), any()))
1556             .thenReturn(Either.left("buildReqNameRes"));
1557
1558         // default test
1559         final Map<String, ToscaTemplateRequirement> requirementMap =
1560             Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1561                 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1562         assertNotNull(requirementMap);
1563         assertFalse(requirementMap.isEmpty());
1564         assertTrue(requirementMap.containsKey("buildReqNameRes"));
1565         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1566         assertNotNull(actualToscaTemplateRequirement);
1567         assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1568     }
1569
1570     @Test
1571     void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1572         final Component fromOriginComponent = new Resource();
1573         final Component toOriginComponent = new Resource();
1574         final CapabilityDefinition capability = new CapabilityDefinition();
1575         final RequirementDefinition requirement = new RequirementDefinition();
1576         final RelationshipInfo relationship = new RelationshipInfo();
1577         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1578         capabilityRequirementRelationship.setRelation(relationship);
1579         ComponentInstance toInstance = new ComponentInstance();
1580         Map<String, Component> componentCache = new HashMap<>();
1581         capability.setPath(new ArrayList<>());
1582         relationship.setCapability("cap");
1583         requirement.setPath(new ArrayList<>());
1584         relationship.setRequirement("req");
1585
1586         final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1587         when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("cap"), any(), any()))
1588             .thenReturn(Either.left(builtCapabilityOrRequirementName));
1589         when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("req"), any(), any()))
1590             .thenReturn(Either.left(builtCapabilityOrRequirementName));
1591
1592         final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1593             .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1594                 capabilityRequirementRelationship, toInstance, componentCache);
1595         assertNotNull(requirementMap);
1596         assertFalse(requirementMap.isEmpty());
1597         assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1598         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1599         assertNotNull(actualToscaTemplateRequirement);
1600         assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1601     }
1602
1603     @Test
1604     void testIsRequirementBelongToRelation() {
1605
1606         Component originComponent = new Resource();
1607         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1608         RequirementDefinition requirement = new RequirementDefinition();
1609         String fromInstanceId = "";
1610         boolean result;
1611
1612         requirement.setName("name");
1613         reqAndRelationshipPair.setRequirement("name1");
1614
1615         // test return false
1616         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1617             reqAndRelationshipPair, requirement, fromInstanceId);
1618         assertFalse(result);
1619     }
1620
1621     @Test
1622     void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1623
1624         Component originComponent = new Service();
1625         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1626         RequirementDefinition requirement = new RequirementDefinition();
1627         requirement.setUniqueId(UNIQUE_ID);
1628         reqAndRelationshipPair.setRequirementUid(UNIQUE_ID);
1629         String fromInstanceId = "";
1630         boolean result;
1631
1632         // default test return true
1633         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1634             reqAndRelationshipPair, requirement, fromInstanceId);
1635         assertTrue(result);
1636     }
1637
1638     @Test
1639     void testIsRequirementBelongToOwner() {
1640
1641         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1642         RequirementDefinition requirement = new RequirementDefinition();
1643         String fromInstanceId = "";
1644         Component originComponent = new Resource();
1645         boolean result;
1646
1647         requirement.setOwnerId("owner1");
1648         reqAndRelationshipPair.setRequirementOwnerId("owner");
1649
1650         // default test
1651         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1652             fromInstanceId, originComponent);
1653         assertFalse(result);
1654     }
1655
1656     @Test
1657     void testIsCvfc() {
1658
1659         Component component = new Service();
1660         boolean result;
1661
1662         result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1663         assertFalse(result);
1664     }
1665
1666     @Test
1667     void testConvertCapabilities() {
1668         final Component component = new Resource();
1669         final Map<String, Component> componentCache = new HashMap<>();
1670
1671         final Either<Map<String, String[]>, ToscaError> expectedResult = Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR);
1672         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1673             .thenReturn(expectedResult);
1674
1675         // default test return isRight
1676         final Either<Map<String, String[]>, ToscaError> actualResult =
1677             Deencapsulation.invoke(testSubject, "convertSubstitutionMappingCapabilities", component, componentCache);
1678         assertNotNull(actualResult);
1679         assertEquals(expectedResult, actualResult);
1680     }
1681
1682     @Test
1683     void testConvertCapabilities_1() {
1684         Component component = new Resource();
1685         ToscaNodeType nodeType = new ToscaNodeType();
1686         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1687         Either<ToscaNodeType, ToscaError> result;
1688
1689         Map<String, ToscaCapability> capabilities = new HashMap<>();
1690         capabilities.put("key", new ToscaCapability());
1691
1692         // default test
1693         result = Deencapsulation
1694             .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1695         assertNotNull(result);
1696     }
1697
1698     @Test
1699     void testConvertToNodeTemplateArtifacts() {
1700         Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1701         ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1702         art.setFile("test_file");
1703         art.setType("test_type");
1704         Map<String, ToscaTemplateArtifact> result;
1705         container.put("test_art", art);
1706         result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1707         assertNotNull(result);
1708         assertTrue(MapUtils.isNotEmpty(result));
1709         assertEquals("test_file", result.get("test_art").getFile());
1710         assertEquals("test_type", result.get("test_art").getType());
1711     }
1712
1713     private Component getTestComponent() {
1714         Component component = new Service();
1715         component.setUniqueId("serviceUniqueId");
1716         component.setNormalizedName("normalizedServiceComponentName");
1717         InterfaceDefinition addedInterface = new InterfaceDefinition();
1718         addedInterface.setType("com.some.service.or.other.serviceName");
1719         final String interfaceType = "normalizedServiceComponentName-interface";
1720         component.setInterfaces(new HashMap<>());
1721         component.getInterfaces().put(interfaceType, addedInterface);
1722         return component;
1723     }
1724
1725     private PropertyDefinition createMockProperty(String propertyName, String defaultValue) {
1726         PropertyDefinition propertyDefinition = new PropertyDefinition();
1727         propertyDefinition.setName(propertyName);
1728         propertyDefinition.setType("string");
1729         propertyDefinition.setDefaultValue(defaultValue);
1730         return propertyDefinition;
1731     }
1732
1733     private InputDefinition createMockInput(String inputName, String defaultValue) {
1734         InputDefinition inputDefinition = new InputDefinition();
1735         inputDefinition.setName(inputName);
1736         inputDefinition.setType("string");
1737         inputDefinition.setDefaultValue(defaultValue);
1738         return inputDefinition;
1739     }
1740
1741 }