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