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