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