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