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, Component> componentCache = new HashMap<>();
 502                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 503                 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 504                 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 505                 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 506                 List<ComponentInstanceInput> inputs = new ArrayList<>();
 507                 inputs.add(new ComponentInstanceInput());
 508                 componentInstancesInputs.put("key", inputs);
 509                 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 510                 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 511                 reldef.setFromNode("node");
 512                 resourceInstancesRelations.add(reldef);
 513                 component.setComponentInstancesRelations(resourceInstancesRelations);
 514
 515                 ComponentInstance instance = new ComponentInstance();
 516                 instance.setUniqueId("id");
 517                 instance.setComponentUid("uid");
 518                 instance.setOriginType(OriginTypeEnum.ServiceProxy);
 519                 List<GroupInstance> groupInstances = new ArrayList<>();
 520                 GroupInstance groupInst = new GroupInstance();
 521                 List<String> artifacts = new ArrayList<>();
 522                 artifacts.add("artifact");
 523                 groupInst.setArtifacts(artifacts);
 524                 groupInst.setType("type");
 525                 groupInstances.add(groupInst);
 526                 instance.setGroupInstances(groupInstances);
 527                 componentInstances.add(instance);
 528
 529                 component.setComponentInstancesInputs(componentInstancesInputs);
 530                 component.setInvariantUUID("uuid");
 531                 component.setUUID("uuid");
 532                 component.setDescription("desc");
 533
 534                 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 535                 ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
 536                 ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
 537                 path.setPathElements(list);
 538                 forwardingPaths.put("key", path);
 539
 540                 ((Service) component).setForwardingPaths(forwardingPaths);
 541
 542                 componentCache.put("uid", component);
 543
 544                 componentInstancesProperties.put("id", new ArrayList<>());
 545                 componentInstancesInputs.put("id", new ArrayList<>());
 546
 547                 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
 548                                 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
 549
 550                 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
 551                                 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
 552                                 .thenReturn(Either.left(new ToscaNodeTemplate()));
 553
 554                 // default test
 555                 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 556                                 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
 557         }
 558
 559         @Test
 560         public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
 561                 Component component = getNewResource();
 562                 List<ComponentInstance> componentInstances = new ArrayList<>();
 563                 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 564                 Map<String, Component> componentCache = new HashMap<>();
 565                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 566                 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 567                 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 568                 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 569                 List<ComponentInstanceInput> inputs = new ArrayList<>();
 570                 inputs.add(new ComponentInstanceInput());
 571                 componentInstancesInputs.put("key", inputs);
 572                 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 573                 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 574                 reldef.setFromNode("node");
 575                 resourceInstancesRelations.add(reldef);
 576                 component.setComponentInstancesRelations(resourceInstancesRelations);
 577
 578                 ComponentInstance instance = new ComponentInstance();
 579                 instance.setUniqueId("id");
 580                 instance.setComponentUid("uid");
 581                 instance.setOriginType(OriginTypeEnum.ServiceProxy);
 582                 componentInstances.add(instance);
 583
 584                 component.setComponentInstancesInputs(componentInstancesInputs);
 585                 component.setInvariantUUID("uuid");
 586                 component.setUUID("uuid");
 587                 component.setDescription("desc");
 588
 589                 componentCache.put("uid", component);
 590
 591                 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
 592                                 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
 593
 594                 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
 595                                 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
 596                                 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 597
 598                 // default test
 599                 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 600                                 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
 601         }
 602
 603         @Test
 604         public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
 605                 Component component = getNewResource();
 606                 List<ComponentInstance> componentInstances = new ArrayList<>();
 607                 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 608                 Map<String, Component> componentCache = new HashMap<>();
 609                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 610                 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 611                 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 612                 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 613                 List<ComponentInstanceInput> inputs = new ArrayList<>();
 614                 inputs.add(new ComponentInstanceInput());
 615                 componentInstancesInputs.put("key", inputs);
 616                 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 617                 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 618                 reldef.setFromNode("id");
 619                 resourceInstancesRelations.add(reldef);
 620                 component.setComponentInstancesRelations(resourceInstancesRelations);
 621
 622                 ComponentInstance instance = new ComponentInstance();
 623                 instance.setUniqueId("id");
 624                 instance.setComponentUid("uid");
 625                 instance.setOriginType(OriginTypeEnum.ServiceProxy);
 626                 componentInstances.add(instance);
 627
 628                 component.setComponentInstancesInputs(componentInstancesInputs);
 629                 component.setInvariantUUID("uuid");
 630                 component.setUUID("uuid");
 631                 component.setDescription("desc");
 632
 633                 componentCache.put("uid", component);
 634
 635                 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
 636                                 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
 637
 638                 // default test
 639                 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 640                                 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
 641         }
 642
 643         @Test
 644         public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
 645                 Component component = new Resource();
 646                 List<ComponentInstance> componentInstances = new ArrayList<>();
 647                 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 648                 Map<String, Component> componentCache = new HashMap<>();
 649                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 650                 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 651                 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 652                 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 653                 List<ComponentInstanceInput> inputs = new ArrayList<>();
 654                 inputs.add(new ComponentInstanceInput());
 655                 componentInstancesInputs.put("key", inputs);
 656                 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 657                 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 658                 reldef.setFromNode("id");
 659                 reldef.setToNode("node");
 660                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 661                 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 662                 relationship.setRelation(new RelationshipInfo());
 663                 relationships.add(relationship);
 664                 reldef.setRelationships(relationships);
 665                 resourceInstancesRelations.add(reldef);
 666                 component.setComponentInstancesRelations(resourceInstancesRelations);
 667
 668                 ComponentInstance instance = new ComponentInstance();
 669                 instance.setUniqueId("id");
 670                 componentInstances.add(instance);
 671
 672                 component.setComponentInstancesInputs(componentInstancesInputs);
 673                 component.setComponentInstances(componentInstances);
 674
 675                 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
 676                                 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
 677
 678                 // default test
 679                 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 680                                 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
 681         }
 682
 683         @Test
 684         public void testAddComponentInstanceInputs() throws Exception {
 685
 686                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 687                 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 688                 ComponentInstance componentInstance = new ComponentInstance();
 689                 String instanceUniqueId = "id";
 690                 Map<String, Object> props = new HashMap<>();
 691
 692                 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
 693                 componentInstanceInputs.add(new ComponentInstanceInput());
 694
 695                 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
 696
 697                 // default test
 698                 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
 699                                  instanceUniqueId, props);
 700         }
 701
 702         @Test
 703         public void testAddPropertiesOfComponentInstance() throws Exception {
 704                 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 705                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 706                 ComponentInstance componentInstance = new ComponentInstance();
 707                 String instanceUniqueId = "id";
 708                 Map<String, Object> props = new HashMap<>();
 709
 710                 ComponentInstanceProperty cip = new ComponentInstanceProperty();
 711                 cip.setInstanceUniqueId("id");
 712
 713                 List<ComponentInstanceProperty> list = new ArrayList<>();
 714                 list.add(cip);
 715
 716                 componentInstancesProperties.put("id", list);
 717
 718                 // default test
 719                 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
 720                                  instanceUniqueId, props);
 721         }
 722
 723         @Test
 724         public void testAddPropertiesOfParentComponent() throws Exception {
 725                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 726                 ComponentInstance componentInstance = new ComponentInstance();
 727                 Component componentOfInstance = new Resource();
 728                 Map<String, Object> props = new HashMap<>();
 729
 730                 List<PropertyDefinition> properties = new ArrayList<>();
 731                 properties.add(new PropertyDefinition());
 732
 733                 ((Resource) componentOfInstance).setProperties(properties);
 734
 735                 // default test
 736                 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
 737                                 componentOfInstance, props);
 738         }
 739
 740
 741         @Test
 742         public void testCreateNodeType() throws Exception {
 743
 744                 Component component = new Resource();
 745                 List<String> array = new ArrayList<>();
 746                 array.add("value");
 747                 ((Resource) component).setDerivedFrom(array);
 748                 ToscaNodeType result;
 749
 750                 // test when component is resource
 751                 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 752
 753                 component = new Service();
 754                 // test when component is service
 755                 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 756         }
 757
 758         @Test
 759         public void testCreateProxyNodeTypes() throws Exception {
 760                 Map<String, Component> componentCache = new HashMap<>();
 761                 Component container = new Resource();
 762                 Either<Map<String, ToscaNodeType>, ToscaError> result;
 763                 List<ComponentInstance> componentInstances = new ArrayList<>();
 764                 ComponentInstance instance = new ComponentInstance();
 765                 instance.setOriginType(OriginTypeEnum.ServiceProxy);
 766                 instance.setSourceModelUid("targetModelUid");
 767
 768                 componentInstances.add(instance);
 769                 container.setComponentInstances(componentInstances);
 770
 771                 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
 772                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 773
 774                 // test when getLatestByName return is right
 775                 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
 776
 777         }
 778
 779         @Test
 780         public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
 781                 Map<String, Component> componentCache = new HashMap<>();
 782                 Component container = new Resource();
 783                 Either<Map<String, ToscaNodeType>, ToscaError> result;
 784                 List<ComponentInstance> componentInstances = new ArrayList<>();
 785                 ComponentInstance instance = new ComponentInstance();
 786                 instance.setOriginType(OriginTypeEnum.ServiceProxy);
 787                 instance.setSourceModelUid("targetModelUid");
 788
 789                 componentInstances.add(instance);
 790                 container.setComponentInstances(componentInstances);
 791
 792                 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
 793
 794                 ComponentParametersView parameterView = new ComponentParametersView();
 795                 parameterView.disableAll();
 796                 parameterView.setIgnoreCategories(false);
 797
 798                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 799                                 Mockito.any(ComponentParametersView.class)))
 800                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 801
 802                 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 803
 804                 // test when getLatestByName is left
 805                 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
 806         }
 807
 808         @Test
 809         public void testCreateProxyNodeType() throws Exception {
 810                 Map<String, Component> componentCache = new HashMap<>();
 811                 Component origComponent = new Resource();
 812                 Component proxyComponent = new Resource();
 813                 ComponentInstance instance = new ComponentInstance();
 814                 ToscaNodeType result;
 815
 816                 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 817
 818                 // default test
 819                 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
 820                                 proxyComponent, instance);
 821         }
 822
 823         @Test
 824         public void testConvertComponentInstanceRequirements() throws Exception {
 825                 Component component = new Resource();
 826                 ComponentInstance componentInstance = new ComponentInstance();
 827                 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
 828                 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
 829                 Component originComponent = new Resource();
 830                 Map<String, Component> componentCache = new HashMap<>();
 831                 Either<ToscaNodeTemplate, ToscaError> result;
 832
 833                 // default test
 834                 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
 835                                 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
 836
 837                 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 838                 reldef.setFromNode("name");
 839                 reldef.setToNode("name1");
 840                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 841                 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
 842                 cap.setRelation(new RelationshipInfo());
 843                 relationships.add(cap);
 844                 reldef.setRelationships(relationships);
 845                 relations.add(reldef);
 846                 componentInstance.setUniqueId("name");
 847
 848                 List<ComponentInstance> instances = new ArrayList<>();
 849                 instances.add(componentInstance);
 850                 component.setComponentInstances(instances);
 851
 852                 // test when filteredRElations ins't empty
 853                 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
 854                                 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
 855         }
 856
 857         @Test
 858         public void testAddRequirement() throws Exception {
 859                 ComponentInstance fromInstance = new ComponentInstance();
 860                 Component fromOriginComponent = new Resource();
 861                 List<ComponentInstance> instancesList = new ArrayList<>();
 862                 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
 863                 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
 864                 Map<String, Component> componentCache = new HashMap<>();
 865                 boolean result;
 866
 867                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 868                 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
 869                 cap.setRequirement(new RequirementDataDefinition());
 870                 RelationshipInfo relation = new RelationshipInfo();
 871                 relation.setRequirementUid("Uid");
 872                 relation.setRequirement("requirment");
 873                 relation.setCapability("cap");
 874                 relation.setCapabilityOwnerId("id1");
 875                 cap.setRelation(relation);
 876                 relationships.add(cap);
 877                 rel.setRelationships(relationships);
 878                 rel.setToNode("name");
 879                 fromInstance.setUniqueId("name");
 880                 fromInstance.setComponentUid("string");
 881                 instancesList.add(fromInstance);
 882                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 883                 fromOriginComponent.setRequirements(requirements);
 884
 885                 // default test
 886                 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
 887                                 rel, toscaRequirements, componentCache);
 888
 889         }
 890
 891         @Test
 892         public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
 893
 894                 ComponentInstance fromInstance = new ComponentInstance();
 895                 Component fromOriginComponent = new Resource();
 896                 List<ComponentInstance> instancesList = new ArrayList<>();
 897                 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
 898                 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
 899                 Map<String, Component> componentCache = new HashMap<>();
 900                 boolean result;
 901
 902                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 903                 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
 904                 cap.setRequirement(new RequirementDataDefinition());
 905                 RelationshipInfo relation = new RelationshipInfo();
 906                 relation.setRequirementUid("Uid");
 907                 relation.setRequirement("requirment");
 908                 relation.setCapability("cap");
 909                 relation.setCapabilityOwnerId("id1");
 910                 cap.setRelation(relation);
 911                 relationships.add(cap);
 912                 rel.setRelationships(relationships);
 913                 rel.setToNode("name");
 914                 fromInstance.setUniqueId("name");
 915                 fromInstance.setComponentUid("string");
 916                 instancesList.add(fromInstance);
 917                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 918
 919                 List<RequirementDefinition> defs = new ArrayList<>();
 920                 RequirementDefinition def = new RequirementDefinition();
 921                 def.setName("requirment");
 922                 def.setCapability("cap");
 923                 defs.add(def);
 924                 requirements.put("key", defs);
 925                 fromOriginComponent.setRequirements(requirements);
 926
 927                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 928                                 Mockito.any(ComponentParametersView.class)))
 929                                 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 930
 931                 // default test
 932                 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
 933                                 rel, toscaRequirements, componentCache);
 934         }
 935
 936         @Test
 937         public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
 938                 ComponentInstance fromInstance = new ComponentInstance();
 939                 Component fromOriginComponent = new Resource();
 940                 List<ComponentInstance> instancesList = new ArrayList<>();
 941                 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
 942                 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
 943                 Map<String, Component> componentCache = new HashMap<>();
 944                 boolean result;
 945
 946                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 947                 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
 948                 cap.setRequirement(new RequirementDataDefinition());
 949                 RelationshipInfo relation = new RelationshipInfo();
 950                 relation.setRequirementUid("Uid");
 951                 relation.setRequirement("requirment");
 952                 relation.setCapability("cap");
 953                 relation.setCapabilityOwnerId("id1");
 954                 cap.setRelation(relation);
 955                 relationships.add(cap);
 956                 rel.setRelationships(relationships);
 957                 rel.setToNode("name");
 958                 fromInstance.setUniqueId("name");
 959                 fromInstance.setComponentUid("string");
 960                 instancesList.add(fromInstance);
 961                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
 962
 963                 List<RequirementDefinition> defs = new ArrayList<>();
 964                 RequirementDefinition def = new RequirementDefinition();
 965                 def.setName("requirment");
 966                 def.setCapability("cap");
 967                 defs.add(def);
 968                 requirements.put("key", defs);
 969                 fromOriginComponent.setRequirements(requirements);
 970
 971                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
 972                 List<CapabilityDefinition> caps = new ArrayList<>();
 973                 CapabilityDefinition capdef = new CapabilityDefinition();
 974                 capdef.setOwnerId("id");
 975                 capdef.setName("name");
 976                 capdef.setType("type");
 977                 caps.add(capdef);
 978                 capabilities.put("cap", caps);
 979
 980                 fromOriginComponent.setCapabilities(capabilities);
 981
 982                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
 983                                 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
 984
 985                 // default test
 986                 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
 987                                 rel, toscaRequirements, componentCache);
 988         }
 989         @Ignore("need to fix change in injected class.")
 990         @Test
 991         public void testAddRequirmentsWithBuildAndAddRequirements() {
 992                 ComponentInstance fromInstance = new ComponentInstance();
 993                 Component fromOriginComponent = new Resource();
 994                 List<ComponentInstance> instancesList = new ArrayList<>();
 995                 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
 996                 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
 997                 Map<String, Component> componentCache = new HashMap<>();
 998                 boolean result;
 999
1000                 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1001                 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1002                 cap.setRequirement(new RequirementDataDefinition());
1003                 RelationshipInfo relation = new RelationshipInfo();
1004                 relation.setRequirementUid("Uid");
1005                 relation.setRequirement("requirment");
1006                 relation.setCapability("cap");
1007                 relation.setCapabilityOwnerId("id");
1008                 cap.setRelation(relation);
1009                 relationships.add(cap);
1010                 rel.setRelationships(relationships);
1011                 rel.setToNode("name");
1012                 fromInstance.setUniqueId("name");
1013                 fromInstance.setComponentUid("string");
1014                 instancesList.add(fromInstance);
1015                 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1016
1017                 List<RequirementDefinition> defs = new ArrayList<>();
1018                 RequirementDefinition def = new RequirementDefinition();
1019                 def.setName("requirment");
1020                 def.setCapability("cap");
1021                 defs.add(def);
1022                 requirements.put("key", defs);
1023                 fromOriginComponent.setRequirements(requirements);
1024
1025                 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1026                 List<CapabilityDefinition> caps = new ArrayList<>();
1027                 CapabilityDefinition capdef = new CapabilityDefinition();
1028                 capdef.setOwnerId("id");
1029                 capdef.setName("cap");
1030                 capdef.setType("type");
1031                 caps.add(capdef);
1032                 capabilities.put("cap", caps);
1033                 fromOriginComponent.setCapabilities(capabilities);
1034
1035                 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1036                                 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1037
1038                 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
1039                                 Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString(),Mockito.anyString()))
1040                                 .thenReturn(Either.right(false));
1041
1042                 // default test
1043                 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1044                                 rel, toscaRequirements, componentCache);
1045         }
1046         @Ignore("need to fix change in injected class.")
1047         @Test
1048         public void testBuildAndAddRequirement() throws Exception {
1049                 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1050                 Component fromOriginComponent = new Resource();
1051                 Component toOriginComponent = new Resource();
1052                 CapabilityDefinition capability = new CapabilityDefinition();
1053                 RequirementDefinition requirement = new RequirementDefinition();
1054                 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1055                 ComponentInstance toInstance = new ComponentInstance();
1056                 Map<String, Component> componentCache = new HashMap<>();
1057                 boolean result;
1058                 capability.setPath(new ArrayList<>());
1059                 reqAndRelationshipPair.setCapability("cap");
1060                 requirement.setPath(new ArrayList<>());
1061                 reqAndRelationshipPair.setRequirement("req");
1062
1063                 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
1064                                 new ArrayList<>(),Mockito.anyString(), "cap")).thenReturn(Either.left("buildCapNameRes"));
1065
1066                 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
1067                                 new ArrayList<>(),Mockito.anyString(), "req")).thenReturn(Either.right(false));
1068
1069                 // default test
1070                 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1071                                 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1072         }
1073
1074         @Ignore("need to fix change in injected class.")
1075         @Test
1076         public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
1077                 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1078                 Component fromOriginComponent = new Resource();
1079                 Component toOriginComponent = new Resource();
1080                 CapabilityDefinition capability = new CapabilityDefinition();
1081                 RequirementDefinition requirement = new RequirementDefinition();
1082                 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1083                 ComponentInstance toInstance = new ComponentInstance();
1084                 Map<String, Component> componentCache = new HashMap<>();
1085                 boolean result;
1086                 capability.setPath(new ArrayList<>());
1087                 reqAndRelationshipPair.setCapability("cap");
1088                 requirement.setPath(new ArrayList<>());
1089                 reqAndRelationshipPair.setRequirement("req");
1090
1091                 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
1092                                 Mockito.anyList(), Mockito.anyString(),Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
1093
1094                 // default test
1095                 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1096                                 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1097         }
1098
1099         @Test
1100         public void testIsRequirementBelongToRelation() throws Exception {
1101
1102                 Component originComponent = new Resource();
1103                 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1104                 RequirementDefinition requirement = new RequirementDefinition();
1105                 String fromInstanceId = "";
1106                 boolean result;
1107
1108                 requirement.setName("name");
1109                 reqAndRelationshipPair.setRequirement("name1");
1110
1111                 // test return false
1112                 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1113                                 reqAndRelationshipPair, requirement, fromInstanceId);
1114         }
1115
1116         @Test
1117         public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1118
1119                 Component originComponent = new Service();
1120                 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1121                 RequirementDefinition requirement = new RequirementDefinition();
1122                 String fromInstanceId = "";
1123                 boolean result;
1124
1125                 // default test return true
1126                 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1127                                 reqAndRelationshipPair, requirement, fromInstanceId);
1128         }
1129
1130         @Test
1131         public void testIsRequirementBelongToOwner() throws Exception {
1132
1133                 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1134                 RequirementDefinition requirement = new RequirementDefinition();
1135                 String fromInstanceId = "";
1136                 Component originComponent = new Resource();
1137                 boolean result;
1138
1139                 requirement.setOwnerId("owner1");
1140                 reqAndRelationshipPair.setRequirementOwnerId("owner");
1141
1142                 // default test
1143                 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1144                                 fromInstanceId, originComponent);
1145         }
1146
1147         @Test
1148         public void testIsCvfc() throws Exception {
1149
1150                 Component component = new Resource();
1151                 boolean result;
1152
1153                 component = new Service();
1154
1155                 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1156         }
1157
1158         @Test
1159         public void testConvertCapabilities() throws Exception {
1160                 Component component = new Resource();
1161                 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1162                 Map<String, Component> componentCache = new HashMap<>();
1163                 Either<SubstitutionMapping, ToscaError> result;
1164
1165                 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
1166                                 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1167
1168                 // default test return isRight
1169                 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1170                                 componentCache);
1171         }
1172         @Ignore("need to fix change in injected class.")
1173         @Test
1174         public void testConvertCapabilities_1() throws Exception {
1175                 Component component = new Resource();
1176                 ToscaNodeType nodeType = new ToscaNodeType();
1177                 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1178                 Either<ToscaNodeType, ToscaError> result;
1179
1180                 Map<String, ToscaCapability> capabilities = new HashMap<>();
1181                 capabilities.put("key", new ToscaCapability());
1182
1183                 Mockito.when(capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class), component, dataTypes)).thenReturn(capabilities);
1184
1185                 // default test
1186                 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);
1187         }
1188 }