catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java

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