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

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