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