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