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