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