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