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