catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java

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