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