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