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

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