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         // default test
 526         result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
 527         Assert.assertNotNull(result);
 528     }
 529
 530     @Test
 531     public void testCreateDependency() throws Exception {
 532
 533         Map<String, Component> componentCache = new HashMap<>();
 534         List<Map<String, Map<String, String>>> imports = new ArrayList<>();
 535         List<Triple<String, String, Component>> dependecies = new ArrayList<>();
 536         ComponentInstance ci = new ComponentInstance();
 537         Component component = getNewResource();
 538
 539         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 540         ArtifactDefinition artifact = new ArtifactDefinition();
 541         artifact.setArtifactName("name.name2");
 542         toscaArtifacts.put("assettoscatemplate", artifact);
 543         component.setToscaArtifacts(toscaArtifacts);
 544         ci.setComponentUid("name");
 545         ci.setOriginType(OriginTypeEnum.ServiceProxy);
 546         ci.setSourceModelUid("modelName");
 547
 548         when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
 549
 550         when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service()));
 551
 552         // default test
 553         Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
 554         Assert.assertFalse(componentCache.isEmpty());
 555     }
 556
 557     @Test
 558     public void testGetInterfaceFilename() throws Exception {
 559         String artifactName = "artifact.name";
 560         String result;
 561
 562         // default test
 563         result = ToscaExportHandler.getInterfaceFilename(artifactName);
 564         Assert.assertNotNull(result);
 565     }
 566
 567     @Test
 568     public void testConvertNodeType() throws Exception {
 569         Component component = new Resource();
 570         ToscaTemplate toscaNode = new ToscaTemplate("");
 571         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 572         Either<ToscaTemplate, ToscaError> result;
 573
 574         when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 575         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 576             .thenReturn(Either.left(Collections.emptyMap()));
 577         // default test
 578         result = Deencapsulation
 579             .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
 580         Assert.assertNotNull(result);
 581     }
 582
 583     @Test
 584     public void testConvertInterfaceNodeType() throws Exception {
 585         Component component = getNewResource();
 586         ToscaTemplate toscaNode = new ToscaTemplate("");
 587         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 588         Either<ToscaTemplate, ToscaError> result;
 589         List<InputDefinition> inputs = new ArrayList<>();
 590         inputs.add(new InputDefinition());
 591         component.setInputs(inputs);
 592
 593         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 594         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 595             .thenReturn(Either.left(Collections.emptyMap()));
 596
 597         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 598                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 599
 600         // default test
 601         result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
 602             , nodeTypes, false);
 603         Assert.assertNotNull(result);
 604     }
 605
 606     @Test
 607     public void testConvertReqCapAndTypeName() throws Exception {
 608         Component component = new Resource();
 609         ToscaTemplate toscaNode = new ToscaTemplate("");
 610         Map<String, ToscaNodeType> nodeTypes = new HashMap();
 611         ToscaNodeType toscaNodeType = new ToscaNodeType();
 612         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 613         Either<ToscaTemplate, ToscaError> result;
 614
 615         when(
 616             capabilityRequirementConverter
 617                 .convertCapabilities(any(Map.class), any(Resource.class), any(Map.class)))
 618             .thenReturn(new HashMap<>());
 619
 620         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 621                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 622
 623         // default test
 624         result = Deencapsulation
 625             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 626                 toscaNodeType, dataTypes);
 627         Assert.assertNotNull(result);
 628
 629         component = new Service();
 630
 631         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
 632                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 633
 634         // test when component is service
 635         result = Deencapsulation
 636             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 637                 toscaNodeType, dataTypes);
 638         Assert.assertNotNull(result);
 639     }
 640
 641     @Test
 642     public void testConvertNodeTemplates() throws Exception {
 643         Component component = getNewResource();
 644         List<ComponentInstance> componentInstances = new ArrayList<>();
 645         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 646         Map<String, Component> componentCache = new HashMap<>();
 647         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 648         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 649         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 650         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 651         List<ComponentInstanceInput> inputs = new ArrayList<>();
 652         inputs.add(new ComponentInstanceInput());
 653         componentInstancesInputs.put("key", inputs);
 654         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 655         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 656         reldef.setFromNode("node");
 657         resourceInstancesRelations.add(reldef);
 658         component.setComponentInstancesRelations(resourceInstancesRelations);
 659
 660         ComponentInstance instance = new ComponentInstance();
 661         instance.setUniqueId("id");
 662         instance.setComponentUid("uid");
 663         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 664         List<GroupInstance> groupInstances = new ArrayList<>();
 665         GroupInstance groupInst = new GroupInstance();
 666         List<String> artifacts = new ArrayList<>();
 667         artifacts.add("artifact");
 668         groupInst.setArtifacts(artifacts);
 669         groupInst.setType("type");
 670         groupInstances.add(groupInst);
 671         instance.setGroupInstances(groupInstances);
 672         componentInstances.add(instance);
 673
 674         component.setComponentInstancesInputs(componentInstancesInputs);
 675         component.setInvariantUUID("uuid");
 676         component.setUUID("uuid");
 677         component.setDescription("desc");
 678
 679         componentCache.put("uid", component);
 680
 681         componentInstancesProperties.put("id", new ArrayList<>());
 682         componentInstancesInputs.put("id", new ArrayList<>());
 683
 684         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 685             any(ComponentInstance.class))).thenReturn(Either.left(component));
 686
 687         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 688             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 689             .thenReturn(Either.left(new ToscaNodeTemplate()));
 690
 691         // default test
 692         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 693             componentInstancesProperties, new HashMap<>(), componentCache, dataTypes, topologyTemplate);
 694         Assert.assertNotNull(result);
 695     }
 696
 697     @Test
 698     public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
 699         Component component = getNewService();
 700         List<ComponentInstance> componentInstances = new ArrayList<>();
 701         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 702         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 703         Map<String, Component> componentCache = new HashMap<>();
 704         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 705         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 706         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 707         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 708         List<ComponentInstanceInput> inputs = new ArrayList<>();
 709         inputs.add(new ComponentInstanceInput());
 710         componentInstancesInputs.put("key", inputs);
 711         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 712         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 713         reldef.setFromNode("node");
 714         resourceInstancesRelations.add(reldef);
 715         component.setComponentInstancesRelations(resourceInstancesRelations);
 716
 717         ComponentInstance instance = new ComponentInstance();
 718         instance.setUniqueId("id");
 719         instance.setComponentUid("uid");
 720         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 721         List<GroupInstance> groupInstances = new ArrayList<>();
 722         GroupInstance groupInst = new GroupInstance();
 723         List<String> artifacts = new ArrayList<>();
 724         artifacts.add("artifact");
 725         groupInst.setArtifacts(artifacts);
 726         groupInst.setType("type");
 727         groupInstances.add(groupInst);
 728         instance.setGroupInstances(groupInstances);
 729         componentInstances.add(instance);
 730
 731         component.setComponentInstancesInputs(componentInstancesInputs);
 732         component.setInvariantUUID("uuid");
 733         component.setUUID("uuid");
 734         component.setDescription("desc");
 735
 736         Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 737         ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
 738         ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
 739         path.setPathElements(list);
 740         forwardingPaths.put("key", path);
 741
 742         ((Service) component).setForwardingPaths(forwardingPaths);
 743
 744         componentCache.put("uid", component);
 745
 746         componentInstancesProperties.put("id", new ArrayList<>());
 747         componentInstancesInterfaces.put("id", new ArrayList<>());
 748         componentInstancesInputs.put("id", new ArrayList<>());
 749
 750         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 751             any(ComponentInstance.class))).thenReturn(Either.left(component));
 752
 753         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 754             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 755             .thenReturn(Either.left(new ToscaNodeTemplate()));
 756
 757         // default test
 758         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 759             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 760         Assert.assertNotNull(result);
 761     }
 762
 763     @Test
 764     public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
 765         Component component = getNewResource();
 766         List<ComponentInstance> componentInstances = new ArrayList<>();
 767         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 768         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 769         Map<String, Component> componentCache = new HashMap<>();
 770         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 771         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 772         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 773         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 774         List<ComponentInstanceInput> inputs = new ArrayList<>();
 775         inputs.add(new ComponentInstanceInput());
 776         componentInstancesInputs.put("key", inputs);
 777         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 778         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 779         reldef.setFromNode("node");
 780         resourceInstancesRelations.add(reldef);
 781         component.setComponentInstancesRelations(resourceInstancesRelations);
 782
 783         ComponentInstance instance = new ComponentInstance();
 784         instance.setUniqueId("id");
 785         instance.setComponentUid("uid");
 786         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 787         componentInstances.add(instance);
 788
 789         component.setComponentInstancesInputs(componentInstancesInputs);
 790         component.setInvariantUUID("uuid");
 791         component.setUUID("uuid");
 792         component.setDescription("desc");
 793
 794         componentCache.put("uid", component);
 795
 796         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 797             any(ComponentInstance.class))).thenReturn(Either.left(component));
 798
 799         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 800             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 801             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 802
 803         // default test
 804         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 805             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 806         Assert.assertNotNull(result);
 807     }
 808
 809     @Test
 810     public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
 811         Component component = getNewResource();
 812         List<ComponentInstance> componentInstances = new ArrayList<>();
 813         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 814         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 815         Map<String, Component> componentCache = new HashMap<>();
 816         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 817         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 818         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 819         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 820         List<ComponentInstanceInput> inputs = new ArrayList<>();
 821         inputs.add(new ComponentInstanceInput());
 822         componentInstancesInputs.put("key", inputs);
 823         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 824         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 825         reldef.setFromNode("id");
 826         resourceInstancesRelations.add(reldef);
 827         component.setComponentInstancesRelations(resourceInstancesRelations);
 828
 829         ComponentInstance instance = new ComponentInstance();
 830         instance.setUniqueId("id");
 831         instance.setComponentUid("uid");
 832         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 833         componentInstances.add(instance);
 834
 835         component.setComponentInstancesInputs(componentInstancesInputs);
 836         component.setInvariantUUID("uuid");
 837         component.setUUID("uuid");
 838         component.setDescription("desc");
 839
 840         componentCache.put("uid", component);
 841
 842         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 843             any(ComponentInstance.class))).thenReturn(Either.right(false));
 844
 845         // default test
 846         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 847             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 848         Assert.assertNotNull(result);
 849     }
 850
 851     @Test
 852     public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
 853         Component component = new Resource();
 854         List<ComponentInstance> componentInstances = new ArrayList<>();
 855         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 856         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 857         Map<String, Component> componentCache = new HashMap<>();
 858         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 859         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 860         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 861         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 862         List<ComponentInstanceInput> inputs = new ArrayList<>();
 863         inputs.add(new ComponentInstanceInput());
 864         componentInstancesInputs.put("key", inputs);
 865         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 866         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 867         reldef.setFromNode("id");
 868         reldef.setToNode("node");
 869         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 870         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 871         relationship.setRelation(new RelationshipInfo());
 872         relationships.add(relationship);
 873         reldef.setRelationships(relationships);
 874         resourceInstancesRelations.add(reldef);
 875         component.setComponentInstancesRelations(resourceInstancesRelations);
 876
 877         ComponentInstance instance = new ComponentInstance();
 878         instance.setUniqueId("id");
 879         componentInstances.add(instance);
 880
 881         component.setComponentInstancesInputs(componentInstancesInputs);
 882         component.setComponentInstances(componentInstances);
 883
 884         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 885             any(ComponentInstance.class))).thenReturn(Either.left(component));
 886
 887         // default test
 888         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 889             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 890         Assert.assertNotNull(result);
 891     }
 892
 893     @Test
 894     public void testAddComponentInstanceInputs() throws Exception {
 895
 896         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 897         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 898         ComponentInstance componentInstance = new ComponentInstance();
 899         String instanceUniqueId = "id";
 900         Map<String, Object> props = new HashMap<>();
 901
 902         List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
 903         componentInstanceInputs.add(new ComponentInstanceInput());
 904
 905         componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
 906
 907         // default test
 908         Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
 909             instanceUniqueId, props);
 910     }
 911
 912     @Test
 913     public void testAddPropertiesOfComponentInstance() throws Exception {
 914         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 915         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 916         ComponentInstance componentInstance = new ComponentInstance();
 917         String instanceUniqueId = "id";
 918         Map<String, Object> props = new HashMap<>();
 919
 920         ComponentInstanceProperty cip = new ComponentInstanceProperty();
 921         cip.setInstanceUniqueId("id");
 922
 923         List<ComponentInstanceProperty> list = new ArrayList<>();
 924         list.add(cip);
 925
 926         componentInstancesProperties.put("id", list);
 927
 928         // default test
 929         Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
 930             instanceUniqueId, props);
 931     }
 932
 933     @Test
 934     public void testAddPropertiesOfParentComponent() throws Exception {
 935         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 936         ComponentInstance componentInstance = new ComponentInstance();
 937         Component componentOfInstance = new Resource();
 938         Map<String, Object> props = new HashMap<>();
 939
 940         List<PropertyDefinition> properties = new ArrayList<>();
 941         properties.add(new PropertyDefinition());
 942
 943         ((Resource) componentOfInstance).setProperties(properties);
 944
 945         // default test
 946         Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
 947             componentOfInstance, props);
 948     }
 949
 950     @Test
 951     public void testCreateNodeType() throws Exception {
 952
 953         Component component = new Resource();
 954         List<String> array = new ArrayList<>();
 955         array.add("value");
 956         ((Resource) component).setDerivedFrom(array);
 957         ToscaNodeType result;
 958
 959         // test when component is resource
 960         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 961         Assert.assertNotNull(result);
 962
 963         component = new Service();
 964         // test when component is service
 965         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 966         Assert.assertNotNull(result);
 967     }
 968
 969     @Test
 970     public void testCreateProxyInterfaceTypesComponentNotFound() throws Exception {
 971         Component container = new Service();
 972         Either<Map<String, ToscaNodeType>, ToscaError> result;
 973         List<ComponentInstance> componentInstances = new ArrayList<>();
 974         ComponentInstance instance = new ComponentInstance();
 975         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 976         instance.setSourceModelUid("targetModelUid");
 977         instance.setToscaComponentName("toscaComponentName");
 978
 979         componentInstances.add(instance);
 980         container.setComponentInstances(componentInstances);
 981         when(toscaOperationFacade.getToscaElement(any(String.class),
 982             any(ComponentParametersView.class)))
 983             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 984         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
 985         Assert.assertTrue(result.isRight());
 986     }
 987
 988     @Test
 989     public void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
 990         Component container = new Service();
 991         Either<Map<String, ToscaNodeType>, ToscaError> result;
 992         List<ComponentInstance> componentInstances = new ArrayList<>();
 993         ComponentInstance instance = new ComponentInstance();
 994         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 995         instance.setSourceModelUid("targetModelUid");
 996         instance.setToscaComponentName("toscaComponentName");
 997         componentInstances.add(instance);
 998         container.setComponentInstances(componentInstances);
 999
1000         when(toscaOperationFacade.getToscaElement(any(String.class),
1001             any(ComponentParametersView.class)))
1002             .thenReturn(Either.left(new Resource()));
1003         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1004             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1005         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1006         Assert.assertTrue(result.isRight());
1007     }
1008
1009     @Test
1010     public void testCreateProxyInterfaceTypesPositive() {
1011         Component container = new Service();
1012         Either<Map<String, ToscaNodeType>, ToscaError> result;
1013         List<ComponentInstance> componentInstances = new ArrayList<>();
1014         ComponentInstance instance = new ComponentInstance();
1015         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1016         instance.setSourceModelUid("targetModelUid");
1017         instance.setToscaComponentName("toscaComponentName");
1018         componentInstances.add(instance);
1019         container.setComponentInstances(componentInstances);
1020
1021         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1022             .thenReturn(Either.left(Collections.emptyMap()));
1023
1024         Component proxyResource = new Resource();
1025         Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1026         proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1027         proxyResource.setInterfaces(proxyInterfaces);
1028         when(toscaOperationFacade.getToscaElement(any(String.class),
1029             any(ComponentParametersView.class)))
1030             .thenReturn(Either.left(proxyResource));
1031
1032         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1033         Assert.assertNotNull(result);
1034         Assert.assertTrue(result.isLeft());
1035         Assert.assertEquals(1, result.left().value().size());
1036     }
1037
1038     @Test
1039     public void testCreateProxyNodeTypes() throws Exception {
1040         Map<String, Component> componentCache = new HashMap<>();
1041         Component container = new Resource();
1042         Either<Map<String, ToscaNodeType>, ToscaError> result;
1043         List<ComponentInstance> componentInstances = new ArrayList<>();
1044         ComponentInstance instance = new ComponentInstance();
1045         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1046         instance.setSourceModelUid("targetModelUid");
1047
1048         componentInstances.add(instance);
1049         container.setComponentInstances(componentInstances);
1050
1051         when(toscaOperationFacade.getLatestByName("serviceProxy"))
1052             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1053
1054         // test when getLatestByName return is right
1055         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1056         Assert.assertNotNull(result);
1057     }
1058
1059     @Test
1060     public void testCreateServiceSubstitutionNodeTypes() throws Exception {
1061         Map<String, Component> componentCache = new HashMap<>();
1062
1063         Component referencedService = getNewService();
1064         referencedService.setInvariantUUID("uuid");
1065         referencedService.setUUID("uuid");
1066         referencedService.setUniqueId("targetModelUid");
1067         referencedService.setDescription("desc");
1068         componentCache.put("targetModelUid", referencedService);
1069
1070         Component containerService = new Service();
1071         List<ComponentInstance> componentInstances = new ArrayList<>();
1072         ComponentInstance instance = new ComponentInstance();
1073         instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1074         instance.setSourceModelUid("targetModelUid");
1075
1076         componentInstances.add(instance);
1077         containerService.setComponentInstances(componentInstances);
1078
1079         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1080             .thenReturn(Either.left(Collections.emptyMap()));
1081         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1082         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
1083             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1084
1085         ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1086
1087         Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1088         Assert.assertNotNull(toscaNode.getNode_types());
1089     }
1090
1091     @Test
1092     public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1093         Map<String, Component> componentCache = new HashMap<>();
1094         Component container = new Resource();
1095         Either<Map<String, ToscaNodeType>, ToscaError> result;
1096         List<ComponentInstance> componentInstances = new ArrayList<>();
1097         ComponentInstance instance = new ComponentInstance();
1098         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1099         instance.setSourceModelUid("targetModelUid");
1100
1101         componentInstances.add(instance);
1102         container.setComponentInstances(componentInstances);
1103
1104         when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
1105
1106         ComponentParametersView parameterView = new ComponentParametersView();
1107         parameterView.disableAll();
1108         parameterView.setIgnoreCategories(false);
1109
1110         when(toscaOperationFacade.getToscaElement(any(String.class),
1111             any(ComponentParametersView.class)))
1112             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1113
1114         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1115
1116         // test when getLatestByName is left
1117         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1118         Assert.assertNotNull(result);
1119     }
1120
1121     @Test
1122     public void testCreateProxyNodeType() throws Exception {
1123         Map<String, Component> componentCache = new HashMap<>();
1124         Component origComponent = new Resource();
1125         Component proxyComponent = new Resource();
1126         ComponentInstance instance = new ComponentInstance();
1127         ToscaNodeType result;
1128
1129         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1130
1131         // default test
1132         result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1133             proxyComponent, instance);
1134         Assert.assertNotNull(result);
1135     }
1136
1137     @Test
1138     public void testConvertComponentInstanceRequirements() throws Exception {
1139         Component component = new Resource();
1140         ComponentInstance componentInstance = new ComponentInstance();
1141         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1142         ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1143         Component originComponent = new Resource();
1144         Map<String, Component> componentCache = new HashMap<>();
1145         Either<ToscaNodeTemplate, ToscaError> result;
1146
1147         // default test
1148         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1149             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1150         Assert.assertNotNull(result);
1151
1152         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1153         reldef.setFromNode("name");
1154         reldef.setToNode("name1");
1155         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1156         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1157         cap.setRelation(new RelationshipInfo());
1158         relationships.add(cap);
1159         reldef.setRelationships(relationships);
1160         relations.add(reldef);
1161         componentInstance.setUniqueId("name");
1162
1163         List<ComponentInstance> instances = new ArrayList<>();
1164         instances.add(componentInstance);
1165         component.setComponentInstances(instances);
1166
1167         // test when filteredRElations ins't empty
1168         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1169             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1170         Assert.assertNotNull(result);
1171     }
1172
1173     @Test
1174     public void buildRequirementFailure() {
1175         final Component fromOriginComponent = new Resource();
1176         final ComponentInstance fromInstance = new ComponentInstance();
1177         final String fromInstanceUid = "fromInstanceUid";
1178         fromInstance.setUniqueId(fromInstanceUid);
1179         fromInstance.setComponentUid("componentUid");
1180         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1181         relationshipDefinition.setToNode("wrongNodeUid");
1182         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1183         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1184         relationship.setRequirement(new RequirementDataDefinition());
1185         relationshipList.add(relationship);
1186         relationshipDefinition.setRelationships(relationshipList);
1187         final List<ComponentInstance> instancesList = new ArrayList<>();
1188         instancesList.add(fromInstance);
1189         String expectedError = String
1190             .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1191                 relationshipDefinition.getToNode());
1192         assertThrows(ToscaExportException.class, () ->
1193             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1194                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1195
1196         try {
1197             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1198                 instancesList, relationshipDefinition, new HashMap<>());
1199         } catch (Exception e) {
1200             assertTrue(e instanceof ToscaExportException);
1201             assertEquals(expectedError, e.getMessage());
1202         }
1203
1204         final RelationshipInfo relation = new RelationshipInfo();
1205         final String requirementUid = "Uid";
1206         relation.setRequirementUid(requirementUid);
1207         final String requirementName = "requirementName";
1208         relation.setRequirement(requirementName);
1209         final String capabilityName = "capabilityName";
1210         relation.setCapability(capabilityName);
1211         final String capabilityOwnerId = "capabilityOwnerId";
1212         relation.setCapabilityOwnerId(capabilityOwnerId);
1213         relationship.setRelation(relation);
1214
1215         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1216         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1217         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1218         fromOriginComponent.setRequirements(requirementMap);
1219         relationshipDefinition.setToNode(fromInstanceUid);
1220
1221         expectedError = String
1222             .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1223                 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1224
1225
1226         assertThrows(ToscaExportException.class, () ->
1227             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1228                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1229
1230         requirementDefinition.setName(requirementName);
1231
1232         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1233             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1234
1235         expectedError = String.format(
1236             "Failed to build substituted name for the requirement %s. "
1237                 + "Failed to get an origin component with uniqueId %s",
1238             requirementName, fromInstance.getActualComponentUid());
1239         assertThrows(ToscaExportException.class, () -> Deencapsulation
1240             .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1241                 relationshipDefinition, new HashMap<>()), expectedError);
1242
1243         final Component toOriginComponent = new Resource();
1244         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1245         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1246
1247         capabilityDefinition.setName(capabilityName);
1248         capabilityDefinition.setOwnerId(capabilityOwnerId);
1249         capabilityDefinition.setType("aType");
1250         final String capabilityPreviousName = "capabilityPreviousName";
1251         capabilityDefinition.setPreviousName(capabilityPreviousName);
1252         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1253         toOriginComponent.setCapabilities(capabilityMap);
1254         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1255             .thenReturn(Either.left(toOriginComponent));
1256
1257
1258         requirementDefinition.setCapability(capabilityName);
1259         relation.setCapability("wrong");
1260         final String requirementPreviousName = "requirementPreviousName";
1261         requirementDefinition.setPreviousName(requirementPreviousName);
1262         requirementDefinition.setPath(new ArrayList<>());
1263
1264         expectedError = String
1265             .format("Failed to find a capability with name %s on a component with uniqueId %s",
1266                 relation.getCapability(), fromOriginComponent.getUniqueId());
1267
1268         assertThrows(ToscaExportException.class, () -> Deencapsulation
1269                 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1270                     relationshipDefinition, new HashMap<>()),
1271             expectedError);
1272     }
1273
1274     @Test
1275     public void testBuildRequirement() {
1276         final ComponentInstance fromInstance = new ComponentInstance();
1277         fromInstance.setUniqueId("name");
1278         fromInstance.setComponentUid("string");
1279         final List<ComponentInstance> instancesList = new ArrayList<>();
1280
1281         final Map<String, Component> componentCache = new HashMap<>();
1282         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1283         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1284         relationship.setRequirement(new RequirementDataDefinition());
1285         final RelationshipInfo relation = new RelationshipInfo();
1286         final String requirementUid = "Uid";
1287         relation.setRequirementUid(requirementUid);
1288         final String requirementName = "requirementName";
1289         relation.setRequirement(requirementName);
1290         final String capabilityName = "capabilityName";
1291         relation.setCapability(capabilityName);
1292         final String capabilityOwnerId = "capabilityOwnerId";
1293         relation.setCapabilityOwnerId(capabilityOwnerId);
1294         relationship.setRelation(relation);
1295         relationshipList.add(relationship);
1296         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1297         relationshipDefinition.setRelationships(relationshipList);
1298         relationshipDefinition.setToNode("name");
1299         instancesList.add(fromInstance);
1300         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1301         requirementDefinition.setName(requirementName);
1302         requirementDefinition.setCapability(capabilityName);
1303         final String requirementPreviousName = "requirementPreviousName";
1304         requirementDefinition.setPreviousName(requirementPreviousName);
1305         requirementDefinition.setPath(new ArrayList<>());
1306         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1307         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1308         final Component fromOriginComponent = new Resource();
1309         fromOriginComponent.setRequirements(requirementMap);
1310
1311         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1312         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1313         capabilityDefinition.setName(capabilityName);
1314         capabilityDefinition.setOwnerId(capabilityOwnerId);
1315         final String capabilityPreviousName = "capabilityPreviousName";
1316         capabilityDefinition.setPreviousName(capabilityPreviousName);
1317         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1318         final Component toOriginComponent = new Resource();
1319         toOriginComponent.setCapabilities(capabilityMap);
1320
1321         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1322             .thenReturn(Either.left(toOriginComponent));
1323         final String builtCapabilityName = "builtCapabilityName";
1324         when(
1325             capabilityRequirementConverter
1326                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1327                     capabilityPreviousName)))
1328             .thenReturn(Either.left(builtCapabilityName));
1329
1330         final String builtRequirementName = "builtRequirementName";
1331         when(
1332             capabilityRequirementConverter
1333                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1334                     requirementPreviousName)))
1335             .thenReturn(Either.left(builtRequirementName));
1336
1337         final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1338             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1339                 instancesList, relationshipDefinition, componentCache);
1340         assertNotNull(actualRequirementMap);
1341         assertFalse(actualRequirementMap.isEmpty());
1342         assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1343         final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1344         assertNotNull(actualToscaTemplateRequirement);
1345         assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1346
1347         //to toOriginComponent not found
1348         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1349             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1350
1351         assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1352             instancesList, relationshipDefinition, componentCache));
1353     }
1354
1355     @Test
1356     public void testAddRequirmentsWithBuildAndAddRequirements() {
1357         ComponentInstance fromInstance = new ComponentInstance();
1358         Component fromOriginComponent = new Resource();
1359         List<ComponentInstance> instancesList = new ArrayList<>();
1360         RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1361         List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1362         Map<String, Component> componentCache = new HashMap<>();
1363
1364         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1365         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1366         cap.setRequirement(new RequirementDataDefinition());
1367         RelationshipInfo relation = new RelationshipInfo();
1368         relation.setRequirementUid("Uid");
1369         relation.setRequirement("requirment");
1370         relation.setCapability("cap");
1371         relation.setCapabilityOwnerId("id");
1372         cap.setRelation(relation);
1373         relationships.add(cap);
1374         rel.setRelationships(relationships);
1375         rel.setToNode("name");
1376         fromInstance.setUniqueId("name");
1377         fromInstance.setComponentUid("string");
1378         instancesList.add(fromInstance);
1379         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1380
1381         List<RequirementDefinition> defs = new ArrayList<>();
1382         RequirementDefinition def = new RequirementDefinition();
1383         def.setName("requirment");
1384         def.setCapability("cap");
1385         defs.add(def);
1386         requirements.put("key", defs);
1387         fromOriginComponent.setRequirements(requirements);
1388
1389         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1390         List<CapabilityDefinition> caps = new ArrayList<>();
1391         CapabilityDefinition capdef = new CapabilityDefinition();
1392         capdef.setOwnerId("id");
1393         capdef.setName("cap");
1394         capdef.setPreviousName("before cap");
1395         capdef.setType("type");
1396         caps.add(capdef);
1397         capabilities.put("cap", caps);
1398         fromOriginComponent.setCapabilities(capabilities);
1399
1400         when(toscaOperationFacade.getToscaElement(any(String.class),
1401             any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1402
1403         when(
1404             capabilityRequirementConverter
1405                 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString()))
1406             .thenReturn(Either.right(false));
1407
1408         final String expectedErrorMsg =
1409             String.format("Failed to build a substituted capability name for the capability "
1410                     + "with name %s on a component with uniqueId %s",
1411                 cap.getRequirement(), fromOriginComponent.getUniqueId());
1412
1413         assertThrows(ToscaExportException.class, () ->
1414             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1415                 rel, componentCache), expectedErrorMsg);
1416     }
1417
1418     @Test
1419     public void testBuildAndAddRequirement() {
1420         Component fromOriginComponent = new Resource();
1421         Component toOriginComponent = new Resource();
1422         CapabilityDefinition capability = new CapabilityDefinition();
1423         RequirementDefinition requirement = new RequirementDefinition();
1424         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1425         ComponentInstance toInstance = new ComponentInstance();
1426         Map<String, Component> componentCache = new HashMap<>();
1427         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1428         capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1429         capability.setPath(new ArrayList<>());
1430         capability.setPreviousName("before cap");
1431         reqAndRelationshipPair.setCapability("cap");
1432         requirement.setPath(new ArrayList<>());
1433         requirement.setPreviousName("before req");
1434         reqAndRelationshipPair.setRequirement("req");
1435
1436         when(
1437             capabilityRequirementConverter
1438                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString()))
1439             .thenReturn(Either.left("buildCapNameRes"));
1440
1441         when(
1442             capabilityRequirementConverter
1443                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString()))
1444             .thenReturn(Either.left("buildReqNameRes"));
1445
1446         // default test
1447         final Map<String, ToscaTemplateRequirement> requirementMap =
1448             Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1449                 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1450         assertNotNull(requirementMap);
1451         assertFalse(requirementMap.isEmpty());
1452         assertTrue(requirementMap.containsKey("buildReqNameRes"));
1453         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1454         assertNotNull(actualToscaTemplateRequirement);
1455         assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1456     }
1457
1458     @Test
1459     public void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1460         final Component fromOriginComponent = new Resource();
1461         final Component toOriginComponent = new Resource();
1462         final CapabilityDefinition capability = new CapabilityDefinition();
1463         final RequirementDefinition requirement = new RequirementDefinition();
1464         final RelationshipInfo relationship = new RelationshipInfo();
1465         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1466         capabilityRequirementRelationship.setRelation(relationship);
1467         ComponentInstance toInstance = new ComponentInstance();
1468         Map<String, Component> componentCache = new HashMap<>();
1469         capability.setPath(new ArrayList<>());
1470         relationship.setCapability("cap");
1471         requirement.setPath(new ArrayList<>());
1472         relationship.setRequirement("req");
1473
1474         final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1475         when(capabilityRequirementConverter.buildSubstitutedName(any(), any(), any(), any(), any()))
1476             .thenReturn(Either.left(builtCapabilityOrRequirementName));
1477
1478         final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1479             .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1480                 capabilityRequirementRelationship, toInstance, componentCache);
1481         assertNotNull(requirementMap);
1482         assertFalse(requirementMap.isEmpty());
1483         assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1484         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1485         assertNotNull(actualToscaTemplateRequirement);
1486         assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1487     }
1488
1489     @Test
1490     public void testIsRequirementBelongToRelation() throws Exception {
1491
1492         Component originComponent = new Resource();
1493         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1494         RequirementDefinition requirement = new RequirementDefinition();
1495         String fromInstanceId = "";
1496         boolean result;
1497
1498         requirement.setName("name");
1499         reqAndRelationshipPair.setRequirement("name1");
1500
1501         // test return false
1502         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1503             reqAndRelationshipPair, requirement, fromInstanceId);
1504         Assert.assertFalse(result);
1505     }
1506
1507     @Test
1508     public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1509
1510         Component originComponent = new Service();
1511         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1512         RequirementDefinition requirement = new RequirementDefinition();
1513         String fromInstanceId = "";
1514         boolean result;
1515
1516         // default test return true
1517         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1518             reqAndRelationshipPair, requirement, fromInstanceId);
1519         Assert.assertTrue(result);
1520     }
1521
1522     @Test
1523     public void testIsRequirementBelongToOwner() throws Exception {
1524
1525         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1526         RequirementDefinition requirement = new RequirementDefinition();
1527         String fromInstanceId = "";
1528         Component originComponent = new Resource();
1529         boolean result;
1530
1531         requirement.setOwnerId("owner1");
1532         reqAndRelationshipPair.setRequirementOwnerId("owner");
1533
1534         // default test
1535         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1536             fromInstanceId, originComponent);
1537         Assert.assertFalse(result);
1538     }
1539
1540     @Test
1541     public void testIsCvfc() throws Exception {
1542
1543         Component component = new Service();
1544         boolean result;
1545
1546         result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1547         Assert.assertFalse(result);
1548     }
1549
1550     @Test
1551     public void testConvertCapabilities() throws Exception {
1552         Component component = new Resource();
1553         SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1554         Map<String, Component> componentCache = new HashMap<>();
1555         Either<SubstitutionMapping, ToscaError> result;
1556
1557         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1558             .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1559
1560         // default test return isRight
1561         result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1562             componentCache);
1563         Assert.assertNotNull(result);
1564     }
1565
1566     @Test
1567     public void testConvertCapabilities_1() throws Exception {
1568         Component component = new Resource();
1569         ToscaNodeType nodeType = new ToscaNodeType();
1570         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1571         Either<ToscaNodeType, ToscaError> result;
1572
1573         Map<String, ToscaCapability> capabilities = new HashMap<>();
1574         capabilities.put("key", new ToscaCapability());
1575
1576         // default test
1577         result = Deencapsulation
1578             .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1579         Assert.assertNotNull(result);
1580     }
1581
1582     @Test
1583     public void testConvertToNodeTemplateArtifacts() throws Exception {
1584         Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1585         ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1586         art.setFile("test_file");
1587         art.setType("test_type");
1588         Map<String, ToscaTemplateArtifact> result;
1589         container.put("test_art", art);
1590         result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1591         Assert.assertNotNull(result);
1592         Assert.assertTrue(MapUtils.isNotEmpty(result));
1593         Assert.assertEquals("test_file", result.get("test_art").getFile());
1594         Assert.assertEquals("test_type", result.get("test_art").getType());
1595     }
1596
1597     @Test
1598     public void testGetProxyNodeTypeInterfacesNoInterfaces() {
1599         Component service = new Service();
1600         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1601                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1602         Assert.assertFalse(proxyNodeTypeInterfaces.isPresent());
1603     }
1604
1605     @Test
1606     public void testGetProxyNodeTypeInterfaces() {
1607         Component service = getTestComponent();
1608         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1609                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1610         Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1611         Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1612         Assert.assertNotNull(componentInterfaces);
1613     }
1614
1615
1616     @Test
1617     public void testGetProxyNodeTypePropertiesComponentNull() {
1618         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1619                 testSubject.getProxyNodeTypeProperties(null, DATA_TYPES);
1620         Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1621     }
1622
1623     @Test
1624     public void testGetProxyNodeTypePropertiesNoProperties() {
1625         Component service = new Service();
1626         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1627                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1628         Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1629     }
1630
1631     @Test
1632     public void testGetProxyNodeTypeProperties() {
1633         Component service = getTestComponent();
1634         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1635                 createMockProperty("componentPropInt", null)));
1636         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1637                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1638         Assert.assertTrue(proxyNodeTypeProperties.isPresent());
1639         Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
1640         Assert.assertNotNull(componentProperties);
1641         Assert.assertEquals(2, componentProperties.size());
1642     }
1643
1644     @Test
1645     public void testAddInputsToPropertiesNoInputs() {
1646         Component service = getTestComponent();
1647         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1648                 createMockProperty("componentPropInt", null)));
1649         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1650                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1651
1652         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1653         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1654         testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties);
1655         Assert.assertNotNull(proxyNodeTypeProperties);
1656         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1657         testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties);
1658         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1659     }
1660
1661     @Test
1662     public void testAddInputsToPropertiesWithInputs() {
1663         Component service = getTestComponent();
1664         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1665                 createMockProperty("componentPropInt", null)));
1666         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1667                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1668         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1669                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1670
1671         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1672         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1673         testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1674         Assert.assertNotNull(proxyNodeTypeProperties);
1675         Assert.assertEquals(4, proxyNodeTypeProperties.size());
1676     }
1677
1678     @Test
1679     public void testAddInputsToPropertiesOnlyInputs() {
1680         Component service = getTestComponent();
1681         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1682                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1683         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1684                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1685
1686         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1687         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1688         testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1689         Assert.assertNotNull(proxyNodeTypeProperties);
1690         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1691     }
1692
1693     @Test
1694     public void testOperationImplementationInProxyNodeTypeNotPresent() {
1695         Component service = getTestComponent();
1696         InterfaceDefinition interfaceDefinition =
1697                 service.getInterfaces().get("normalizedServiceComponentName-interface");
1698         interfaceDefinition.setOperations(new HashMap<>());
1699         final OperationDataDefinition operation = new OperationDataDefinition();
1700         operation.setName("start");
1701         operation.setDescription("op description");
1702         final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
1703         implementation.setArtifactName("createBPMN.bpmn");
1704         operation.setImplementation(implementation);
1705         interfaceDefinition.getOperations().put(operation.getName(), operation);
1706         service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
1707         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1708                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1709         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1710                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1711         Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1712         Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1713         Assert.assertNotNull(componentInterfaces);
1714     }
1715
1716     private Component getTestComponent() {
1717         Component component = new Service();
1718         component.setNormalizedName("normalizedServiceComponentName");
1719         InterfaceDefinition addedInterface = new InterfaceDefinition();
1720         addedInterface.setType("com.some.service.or.other.serviceName");
1721         final String interfaceType = "normalizedServiceComponentName-interface";
1722         component.setInterfaces(new HashMap<>());
1723         component.getInterfaces().put(interfaceType, addedInterface);
1724         return component;
1725     }
1726
1727     private PropertyDefinition createMockProperty(String propertyName, String defaultValue){
1728         PropertyDefinition propertyDefinition = new PropertyDefinition();
1729         propertyDefinition.setName(propertyName);
1730         propertyDefinition.setType("string");
1731         propertyDefinition.setDefaultValue(defaultValue);
1732         return propertyDefinition;
1733     }
1734
1735     private InputDefinition createMockInput(String inputName, String defaultValue){
1736         InputDefinition inputDefinition = new InputDefinition();
1737         inputDefinition.setName(inputName);
1738         inputDefinition.setType("string");
1739         inputDefinition.setDefaultValue(defaultValue);
1740         return inputDefinition;
1741     }
1742
1743 }