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