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