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

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