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