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