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  * Modifications copyright (c) 2020, Nordix Foundation
  20  * ================================================================================
  21  */
  22
  23 package org.openecomp.sdc.be.tosca;
  24
  25 import static org.hamcrest.CoreMatchers.is;
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertFalse;
  28 import static org.junit.Assert.assertThat;
  29 import static org.junit.Assert.assertTrue;
  30 import static org.junit.jupiter.api.Assertions.assertNotNull;
  31 import static org.junit.jupiter.api.Assertions.assertThrows;
  32 import static org.mockito.ArgumentMatchers.any;
  33 import static org.mockito.ArgumentMatchers.anyBoolean;
  34 import static org.mockito.ArgumentMatchers.anyList;
  35 import static org.mockito.ArgumentMatchers.anyMap;
  36 import static org.mockito.ArgumentMatchers.anyString;
  37 import static org.mockito.ArgumentMatchers.eq;
  38 import static org.mockito.ArgumentMatchers.isNull;
  39 import static org.mockito.Mockito.doReturn;
  40 import static org.mockito.Mockito.when;
  41 import static org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType.PROPERTY;
  42
  43 import fj.data.Either;
  44 import java.util.ArrayList;
  45 import java.util.Arrays;
  46 import java.util.Collections;
  47 import java.util.HashMap;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.Optional;
  51 import java.util.stream.Collectors;
  52 import mockit.Deencapsulation;
  53 import org.apache.commons.collections.MapUtils;
  54 import org.apache.commons.lang3.tuple.ImmutablePair;
  55 import org.apache.commons.lang3.tuple.Triple;
  56 import org.junit.Assert;
  57 import org.junit.Before;
  58 import org.junit.Test;
  59 import org.mockito.InjectMocks;
  60 import org.mockito.Mock;
  61 import org.mockito.MockitoAnnotations;
  62 import org.openecomp.sdc.be.components.BeConfDependentTest;
  63 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
  64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
  65 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
  66 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
  67 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
  68 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
  69 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
  70 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
  71 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
  72 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
  73 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
  74 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
  75 import org.openecomp.sdc.be.exception.ToscaExportException;
  76 import org.openecomp.sdc.be.model.ArtifactDefinition;
  77 import org.openecomp.sdc.be.model.CapabilityDefinition;
  78 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
  79 import org.openecomp.sdc.be.model.Component;
  80 import org.openecomp.sdc.be.model.ComponentInstance;
  81 import org.openecomp.sdc.be.model.ComponentInstanceInput;
  82 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
  83 import org.openecomp.sdc.be.model.ComponentParametersView;
  84 import org.openecomp.sdc.be.model.DataTypeDefinition;
  85 import org.openecomp.sdc.be.model.GroupDefinition;
  86 import org.openecomp.sdc.be.model.GroupInstance;
  87 import org.openecomp.sdc.be.model.InputDefinition;
  88 import org.openecomp.sdc.be.model.InterfaceDefinition;
  89 import org.openecomp.sdc.be.model.PropertyDefinition;
  90 import org.openecomp.sdc.be.model.RelationshipInfo;
  91 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
  92 import org.openecomp.sdc.be.model.RequirementDefinition;
  93 import org.openecomp.sdc.be.model.Resource;
  94 import org.openecomp.sdc.be.model.Service;
  95 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
  96 import org.openecomp.sdc.be.model.category.CategoryDefinition;
  97 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
  98 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
  99 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 100 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
 101 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
 102 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
 103 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
 104 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
 105 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
 106 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
 107 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
 108 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
 109 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
 110 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
 111 import org.openecomp.sdc.be.tosca.utils.InputConverter;
 112
 113 public class ToscaExportHandlerTest extends BeConfDependentTest {
 114
 115     private static final String COMPONENT_PROPERTY_NAME = "prop1";
 116     private static final String COMPONENT_PROPERTY_TYPE = "string";
 117     private static final String COMPONENT_INPUT_NAME = "input1";
 118     private static final String COMPONENT_INPUT_TYPE = "integer";
 119     private static final String RESOURCE_NAME = "resource";
 120     private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
 121     private static final Map<String, DataTypeDefinition> DATA_TYPES = new HashMap<>();
 122
 123     @InjectMocks
 124     private ToscaExportHandler testSubject;
 125
 126     @Mock
 127     private ApplicationDataTypeCache dataTypeCache;
 128
 129     @Mock
 130     private ToscaOperationFacade toscaOperationFacade;
 131
 132     @Mock
 133     private CapabilityRequirementConverter capabilityRequirementConverter;
 134
 135     @Mock
 136     private InputConverter inputConverter;
 137
 138     @Mock
 139     private GroupExportParser groupExportParser;
 140
 141     @Mock
 142     private PropertyConvertor propertyConvertor;
 143
 144     @Mock
 145     private GroupExportParserImpl groupExportParserImpl;
 146
 147     @Mock
 148     private InterfaceLifecycleOperation interfaceLifecycleOperation;
 149
 150     @Mock
 151     private InterfacesOperationsConverter interfacesOperationsConverter;
 152
 153     @Mock
 154     private PolicyExportParser policyExportParser;
 155
 156     @Before
 157     public void setUpMock() {
 158         MockitoAnnotations.initMocks(this);
 159                 doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
 160         doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter)
 161                 .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean(), anyBoolean());
 162     }
 163
 164     private Resource getNewResource() {
 165         Resource resource = new Resource();
 166         List<CategoryDefinition> categories = new ArrayList<>();
 167         CategoryDefinition category = new CategoryDefinition();
 168         List<SubCategoryDefinition> subcategories = new ArrayList<>();
 169         SubCategoryDefinition subcategory = new SubCategoryDefinition();
 170         List<DataTypeDefinition> dataTypes = new ArrayList<>();
 171         DataTypeDefinition dataType = new DataTypeDefinition();
 172         dataType.setName("dataTypeName");
 173         dataType.setDerivedFromName("tosca.datatypes.Root");
 174         PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
 175             .setName("property")
 176             .setType("type")
 177             .build();
 178         List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
 179         dataType.setPropertiesData(propDataList);
 180         List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
 181             .collect(Collectors.toList());
 182         dataType.setProperties(propList);
 183         dataTypes.add(dataType);
 184
 185         subcategory.setName("name");
 186         subcategories.add(subcategory);
 187         category.setName("name");
 188         category.setSubcategories(subcategories);
 189         categories.add(category);
 190
 191         resource.setCategories(categories);
 192         resource.setVersion("version");
 193         resource.setVendorName("vendorName");
 194         resource.setVendorRelease("vendorRelease");
 195         resource.setResourceVendorModelNumber("resourceVendorModelNumber");
 196         resource.setDataTypes(dataTypes);
 197
 198         return resource;
 199     }
 200
 201     private Service getNewService() {
 202         Service service = new Service();
 203         List<CategoryDefinition> categories = new ArrayList<>();
 204         CategoryDefinition category = new CategoryDefinition();
 205         List<SubCategoryDefinition> subcategories = new ArrayList<>();
 206         SubCategoryDefinition subcategory = new SubCategoryDefinition();
 207
 208         subcategory.setName("name");
 209         subcategories.add(subcategory);
 210         category.setName("name");
 211         category.setSubcategories(subcategories);
 212         categories.add(category);
 213
 214         service.setCategories(categories);
 215         service.setComponentType(ComponentTypeEnum.SERVICE);
 216         service.setServiceType("serviceType");
 217         service.setServiceRole("serviceRole");
 218         service.setEnvironmentContext("environmentContext");
 219
 220         return service;
 221     }
 222
 223     @Test
 224     public void testExportComponent() throws Exception {
 225         Component component = getNewResource();
 226         Either<ToscaRepresentation, ToscaError> result;
 227
 228         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 229         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 230                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 231         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 232             .thenReturn(Either.left(Collections.emptyMap()));
 233
 234         // default test when component is Resource
 235         result = testSubject.exportComponent(component);
 236         Assert.assertNotNull(result);
 237
 238         component = getNewService();
 239         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
 240                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 241         when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 242
 243         // default test when component is Service
 244         result = testSubject.exportComponent(component);
 245         Assert.assertNotNull(result);
 246     }
 247
 248     @Test
 249     public void testExportComponentInterface() throws Exception {
 250         Component component = getNewResource();
 251         Either<ToscaRepresentation, ToscaError> result;
 252
 253         ((Resource) component).setInterfaces(new HashMap<>());
 254
 255         when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
 256         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 257             .thenReturn(Either.left(Collections.emptyMap()));
 258         // default test when convertInterfaceNodeType is right
 259         result = testSubject.exportComponentInterface(component, false);
 260         Assert.assertNotNull(result);
 261
 262         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 263         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 264                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 265
 266         // default test when convertInterfaceNodeType is left
 267         result = testSubject.exportComponentInterface(component, false);
 268         Assert.assertNotNull(result);
 269     }
 270
 271     @Test
 272     public void testConvertInterfaceNodeTypeProperties() throws Exception {
 273
 274         Resource component = getNewResource();
 275
 276         component.setInterfaces(new HashMap<>());
 277         InputDefinition input = new InputDefinition();
 278         input.setName(COMPONENT_INPUT_NAME);
 279         input.setType(COMPONENT_INPUT_TYPE);
 280         component.setInputs(Collections.singletonList(input));
 281         PropertyDefinition property = new PropertyDefinition();
 282         property.setName(COMPONENT_PROPERTY_NAME);
 283         property.setType(COMPONENT_PROPERTY_TYPE);
 284         component.setProperties(Collections.singletonList(property));
 285         component.setName(RESOURCE_NAME);
 286         component.setToscaResourceName(RESOURCE_NAME);
 287
 288         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 289             .thenReturn(Either.left(Collections.emptyMap()));
 290         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 291         // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
 292         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 293                 any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
 294
 295         Either<ToscaTemplate, ToscaError> result = (Either<ToscaTemplate, ToscaError>) Deencapsulation
 296             .invoke(testSubject, "convertInterfaceNodeType", new HashMap<String, Component>(), component,
 297                 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
 298         Assert.assertNotNull(result);
 299         assertThat(result.isLeft(), is(true));
 300         Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
 301         assertThat(nodeTypeMap.size(), is(1));
 302         ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
 303         Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
 304         // Check if inputs and properties in component are merged properly
 305         assertThat(propertyMap.size(), is(2));
 306         assertThat(propertyMap.containsKey(COMPONENT_INPUT_NAME), is(true));
 307         assertThat(propertyMap.containsKey(COMPONENT_PROPERTY_NAME), is(true));
 308     }
 309
 310     @Test
 311     public void testCreateToscaRepresentation() throws Exception {
 312         ToscaTemplate toscaTemplate = new ToscaTemplate("");
 313         ToscaRepresentation result;
 314
 315         // default test
 316         result = testSubject.createToscaRepresentation(toscaTemplate);
 317         Assert.assertNotNull(result);
 318     }
 319
 320     @Test
 321     public void testGetDependencies() throws Exception {
 322
 323         Component component = new Resource();
 324         Either<ToscaTemplate, ToscaError> result;
 325
 326         // default test
 327         result = testSubject.getDependencies(component);
 328         Assert.assertNotNull(result);
 329     }
 330
 331     @Test
 332     public void testConvertToscaTemplate() throws Exception {
 333
 334         Component component = getNewResource();
 335         ToscaTemplate toscaNode = new ToscaTemplate("");
 336         Either<ToscaTemplate, ToscaError> result;
 337         List<ComponentInstance> resourceInstances = new ArrayList<>();
 338         ComponentInstance instance = new ComponentInstance();
 339
 340         instance.setOriginType(OriginTypeEnum.SERVICE);
 341         instance.setSourceModelUid("targetModelUid");
 342         resourceInstances.add(instance);
 343
 344         component.setComponentInstances(resourceInstances);
 345
 346         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 347         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 348             any(ComponentInstance.class))).thenReturn(Either.right(false));
 349
 350         // default test
 351         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
 352         Assert.assertNotNull(result);
 353     }
 354
 355     @Test
 356     public void testConvertToscaTemplateWhenComponentContainsGroup() {
 357         Component component = getNewResource();
 358         ToscaTemplate toscaNode = new ToscaTemplate("");
 359         Either<ToscaTemplate, ToscaError> result;
 360         component.setComponentInstances(new ArrayList<>());
 361
 362         List<GroupDefinition> groups = new ArrayList<>();
 363         GroupDefinition group = new GroupDefinition();
 364         List<String> artifacts = new ArrayList<>();
 365         artifacts.add("artifact");
 366         group.setType("org.openecomp.groups.VfModule");
 367         group.setArtifacts(artifacts);
 368         groups.add(group);
 369         component.setGroups(groups);
 370
 371         Map<String, String[]> substitutionMappingMap = new HashMap<>();
 372         String[] array = {"value1", "value2"};
 373         substitutionMappingMap.put("key", array);
 374
 375         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(any(Map.class),
 376             any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
 377
 378         when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Map.class),
 379             any(Component.class), any(SubstitutionMapping.class)))
 380             .thenReturn(Either.left(new SubstitutionMapping()));
 381
 382         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 383
 384         when(inputConverter.convertInputs(any(List.class), any(Map.class))).thenReturn(new HashMap<>());
 385
 386         when(groupExportParser.getGroups(component))
 387             .thenReturn(null);
 388
 389         // test component contains group
 390         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
 391         Assert.assertNotNull(result);
 392     }
 393
 394     @Test
 395     public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
 396         Component component = getNewService();
 397         ToscaTemplate toscaNode = new ToscaTemplate("");
 398         Either<ToscaTemplate, ToscaError> result;
 399         component.setComponentInstances(new ArrayList<>());
 400
 401         List<GroupDefinition> groups = new ArrayList<>();
 402         GroupDefinition group = new GroupDefinition();
 403         List<String> artifacts = new ArrayList<>();
 404         artifacts.add("artifact");
 405         group.setType("org.openecomp.groups.VfModule");
 406         group.setArtifacts(artifacts);
 407         groups.add(group);
 408         component.setGroups(groups);
 409
 410         Map<String, String[]> substitutionMappingMap = new HashMap<>();
 411         String[] array = {"value1", "value2"};
 412         substitutionMappingMap.put("key", array);
 413
 414         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
 415             .thenReturn(Either.left(substitutionMappingMap));
 416
 417         when(capabilityRequirementConverter
 418             .convertSubstitutionMappingRequirements(anyMap(), any(Component.class), any(SubstitutionMapping.class)))
 419             .thenReturn(Either.left(new SubstitutionMapping()));
 420
 421         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 422
 423         when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
 424         // test component contains group
 425         result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
 426         Assert.assertNotNull(result);
 427     }
 428
 429     @Test
 430     public void testConvertMetadata_1() throws Exception {
 431
 432         Component component = getNewResource();
 433         boolean isInstance = true;
 434         ComponentInstance componentInstance = new ComponentInstance();
 435         componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
 436         componentInstance.setSourceModelInvariant("targetModelInvariant");
 437
 438         // default test
 439         Map<String, String> result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
 440         Assert.assertNotNull(result);
 441     }
 442
 443     @Test
 444     public void testFillImports() throws Exception {
 445
 446         Component component = getNewService();
 447         ToscaTemplate toscaTemplate = new ToscaTemplate("");
 448         Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
 449
 450         ComponentInstance instance = new ComponentInstance();
 451         List<ComponentInstance> resourceInstances = new ArrayList<>();
 452         instance.setComponentUid("name");
 453         resourceInstances.add(instance);
 454         component.setComponentInstances(resourceInstances);
 455         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 456         ArtifactDefinition artifact = new ArtifactDefinition();
 457         artifact.setArtifactName("name.name2");
 458         toscaArtifacts.put("assettoscatemplate", artifact);
 459         component.setToscaArtifacts(toscaArtifacts);
 460
 461         when(toscaOperationFacade.getToscaFullElement(any(String.class)))
 462             .thenReturn(Either.left(component));
 463
 464         // default test
 465         result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
 466         Assert.assertNotNull(result);
 467     }
 468
 469     @Test
 470     public void testCreateDependency() throws Exception {
 471
 472         Map<String, Component> componentCache = new HashMap<>();
 473         List<Map<String, Map<String, String>>> imports = new ArrayList<>();
 474         List<Triple<String, String, Component>> dependecies = new ArrayList<>();
 475         ComponentInstance ci = new ComponentInstance();
 476         Component component = getNewResource();
 477
 478         Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
 479         ArtifactDefinition artifact = new ArtifactDefinition();
 480         artifact.setArtifactName("name.name2");
 481         toscaArtifacts.put("assettoscatemplate", artifact);
 482         component.setToscaArtifacts(toscaArtifacts);
 483         ci.setComponentUid("name");
 484         ci.setOriginType(OriginTypeEnum.ServiceProxy);
 485         ci.setSourceModelUid("modelName");
 486
 487         when(toscaOperationFacade.getToscaFullElement(eq("name"))).thenReturn(Either.left(component));
 488
 489         when(toscaOperationFacade.getToscaFullElement(eq("modelName")))
 490             .thenReturn(Either.left(new Service()));
 491
 492         // default test
 493         Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
 494     }
 495
 496     @Test
 497     public void testGetInterfaceFilename() throws Exception {
 498         String artifactName = "artifact.name";
 499         String result;
 500
 501         // default test
 502         result = ToscaExportHandler.getInterfaceFilename(artifactName);
 503         Assert.assertNotNull(result);
 504     }
 505
 506     @Test
 507     public void testConvertNodeType() throws Exception {
 508         Component component = new Resource();
 509         ToscaTemplate toscaNode = new ToscaTemplate("");
 510         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 511         Either<ToscaTemplate, ToscaError> result;
 512
 513         when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 514         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 515             .thenReturn(Either.left(Collections.emptyMap()));
 516         // default test
 517         result = Deencapsulation
 518             .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
 519         Assert.assertNotNull(result);
 520     }
 521
 522     @Test
 523     public void testConvertInterfaceNodeType() throws Exception {
 524         Component component = getNewResource();
 525         ToscaTemplate toscaNode = new ToscaTemplate("");
 526         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 527         Either<ToscaTemplate, ToscaError> result;
 528         List<InputDefinition> inputs = new ArrayList<>();
 529         inputs.add(new InputDefinition());
 530         component.setInputs(inputs);
 531
 532         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 533         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 534             .thenReturn(Either.left(Collections.emptyMap()));
 535
 536         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 537                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 538
 539         // default test
 540         result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
 541             , nodeTypes, false);
 542         Assert.assertNotNull(result);
 543     }
 544
 545     @Test
 546     public void testConvertReqCapAndTypeName() throws Exception {
 547         Component component = new Resource();
 548         ToscaTemplate toscaNode = new ToscaTemplate("");
 549         Map<String, ToscaNodeType> nodeTypes = new HashMap();
 550         ToscaNodeType toscaNodeType = new ToscaNodeType();
 551         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 552         Either<ToscaTemplate, ToscaError> result;
 553
 554         when(
 555             capabilityRequirementConverter
 556                 .convertCapabilities(any(Map.class), any(Resource.class), any(Map.class)))
 557             .thenReturn(new HashMap<>());
 558
 559         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 560                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 561
 562         // default test
 563         result = Deencapsulation
 564             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 565                 toscaNodeType, dataTypes);
 566         Assert.assertNotNull(result);
 567
 568         component = new Service();
 569
 570         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
 571                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 572
 573         // test when component is service
 574         result = Deencapsulation
 575             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 576                 toscaNodeType, dataTypes);
 577         Assert.assertNotNull(result);
 578     }
 579
 580     @Test
 581     public void testConvertNodeTemplates() throws Exception {
 582         Component component = getNewResource();
 583         List<ComponentInstance> componentInstances = new ArrayList<>();
 584         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 585         Map<String, Component> componentCache = new HashMap<>();
 586         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 587         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 588         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 589         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 590         List<ComponentInstanceInput> inputs = new ArrayList<>();
 591         inputs.add(new ComponentInstanceInput());
 592         componentInstancesInputs.put("key", inputs);
 593         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 594         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 595         reldef.setFromNode("node");
 596         resourceInstancesRelations.add(reldef);
 597         component.setComponentInstancesRelations(resourceInstancesRelations);
 598
 599         ComponentInstance instance = new ComponentInstance();
 600         instance.setUniqueId("id");
 601         instance.setComponentUid("uid");
 602         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 603         List<GroupInstance> groupInstances = new ArrayList<>();
 604         GroupInstance groupInst = new GroupInstance();
 605         List<String> artifacts = new ArrayList<>();
 606         artifacts.add("artifact");
 607         groupInst.setArtifacts(artifacts);
 608         groupInst.setType("type");
 609         groupInstances.add(groupInst);
 610         instance.setGroupInstances(groupInstances);
 611         componentInstances.add(instance);
 612
 613         component.setComponentInstancesInputs(componentInstancesInputs);
 614         component.setInvariantUUID("uuid");
 615         component.setUUID("uuid");
 616         component.setDescription("desc");
 617
 618         componentCache.put("uid", component);
 619
 620         componentInstancesProperties.put("id", new ArrayList<>());
 621         componentInstancesInputs.put("id", new ArrayList<>());
 622
 623         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 624             any(ComponentInstance.class))).thenReturn(Either.left(component));
 625
 626         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 627             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 628             .thenReturn(Either.left(new ToscaNodeTemplate()));
 629
 630         // default test
 631         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 632             componentInstancesProperties, new HashMap<>(), componentCache, dataTypes, topologyTemplate);
 633         Assert.assertNotNull(result);
 634     }
 635
 636     @Test
 637     public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
 638         Component component = getNewService();
 639         List<ComponentInstance> componentInstances = new ArrayList<>();
 640         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 641         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 642         Map<String, Component> componentCache = new HashMap<>();
 643         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 644         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 645         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 646         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 647         List<ComponentInstanceInput> inputs = new ArrayList<>();
 648         inputs.add(new ComponentInstanceInput());
 649         componentInstancesInputs.put("key", inputs);
 650         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 651         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 652         reldef.setFromNode("node");
 653         resourceInstancesRelations.add(reldef);
 654         component.setComponentInstancesRelations(resourceInstancesRelations);
 655
 656         ComponentInstance instance = new ComponentInstance();
 657         instance.setUniqueId("id");
 658         instance.setComponentUid("uid");
 659         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 660         List<GroupInstance> groupInstances = new ArrayList<>();
 661         GroupInstance groupInst = new GroupInstance();
 662         List<String> artifacts = new ArrayList<>();
 663         artifacts.add("artifact");
 664         groupInst.setArtifacts(artifacts);
 665         groupInst.setType("type");
 666         groupInstances.add(groupInst);
 667         instance.setGroupInstances(groupInstances);
 668         componentInstances.add(instance);
 669
 670         component.setComponentInstancesInputs(componentInstancesInputs);
 671         component.setInvariantUUID("uuid");
 672         component.setUUID("uuid");
 673         component.setDescription("desc");
 674
 675         Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 676         ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
 677         ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
 678         path.setPathElements(list);
 679         forwardingPaths.put("key", path);
 680
 681         ((Service) component).setForwardingPaths(forwardingPaths);
 682
 683         componentCache.put("uid", component);
 684
 685         componentInstancesProperties.put("id", new ArrayList<>());
 686         componentInstancesInterfaces.put("id", new ArrayList<>());
 687         componentInstancesInputs.put("id", new ArrayList<>());
 688
 689         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 690             any(ComponentInstance.class))).thenReturn(Either.left(component));
 691
 692         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 693             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 694             .thenReturn(Either.left(new ToscaNodeTemplate()));
 695
 696         // default test
 697         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 698             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 699         Assert.assertNotNull(result);
 700     }
 701
 702     @Test
 703     public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
 704         Component component = getNewResource();
 705         List<ComponentInstance> componentInstances = new ArrayList<>();
 706         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 707         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 708         Map<String, Component> componentCache = new HashMap<>();
 709         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 710         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 711         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 712         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 713         List<ComponentInstanceInput> inputs = new ArrayList<>();
 714         inputs.add(new ComponentInstanceInput());
 715         componentInstancesInputs.put("key", inputs);
 716         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 717         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 718         reldef.setFromNode("node");
 719         resourceInstancesRelations.add(reldef);
 720         component.setComponentInstancesRelations(resourceInstancesRelations);
 721
 722         ComponentInstance instance = new ComponentInstance();
 723         instance.setUniqueId("id");
 724         instance.setComponentUid("uid");
 725         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 726         componentInstances.add(instance);
 727
 728         component.setComponentInstancesInputs(componentInstancesInputs);
 729         component.setInvariantUUID("uuid");
 730         component.setUUID("uuid");
 731         component.setDescription("desc");
 732
 733         componentCache.put("uid", component);
 734
 735         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 736             any(ComponentInstance.class))).thenReturn(Either.left(component));
 737
 738         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 739             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 740             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 741
 742         // default test
 743         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 744             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 745         Assert.assertNotNull(result);
 746     }
 747
 748     @Test
 749     public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
 750         Component component = getNewResource();
 751         List<ComponentInstance> componentInstances = new ArrayList<>();
 752         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 753         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 754         Map<String, Component> componentCache = new HashMap<>();
 755         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 756         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 757         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 758         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 759         List<ComponentInstanceInput> inputs = new ArrayList<>();
 760         inputs.add(new ComponentInstanceInput());
 761         componentInstancesInputs.put("key", inputs);
 762         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 763         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 764         reldef.setFromNode("id");
 765         resourceInstancesRelations.add(reldef);
 766         component.setComponentInstancesRelations(resourceInstancesRelations);
 767
 768         ComponentInstance instance = new ComponentInstance();
 769         instance.setUniqueId("id");
 770         instance.setComponentUid("uid");
 771         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 772         componentInstances.add(instance);
 773
 774         component.setComponentInstancesInputs(componentInstancesInputs);
 775         component.setInvariantUUID("uuid");
 776         component.setUUID("uuid");
 777         component.setDescription("desc");
 778
 779         componentCache.put("uid", component);
 780
 781         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 782             any(ComponentInstance.class))).thenReturn(Either.right(false));
 783
 784         // default test
 785         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 786             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 787         Assert.assertNotNull(result);
 788     }
 789
 790     @Test
 791     public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
 792         Component component = new Resource();
 793         List<ComponentInstance> componentInstances = new ArrayList<>();
 794         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 795         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 796         Map<String, Component> componentCache = new HashMap<>();
 797         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 798         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 799         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 800         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 801         List<ComponentInstanceInput> inputs = new ArrayList<>();
 802         inputs.add(new ComponentInstanceInput());
 803         componentInstancesInputs.put("key", inputs);
 804         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 805         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 806         reldef.setFromNode("id");
 807         reldef.setToNode("node");
 808         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 809         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 810         relationship.setRelation(new RelationshipInfo());
 811         relationships.add(relationship);
 812         reldef.setRelationships(relationships);
 813         resourceInstancesRelations.add(reldef);
 814         component.setComponentInstancesRelations(resourceInstancesRelations);
 815
 816         ComponentInstance instance = new ComponentInstance();
 817         instance.setUniqueId("id");
 818         componentInstances.add(instance);
 819
 820         component.setComponentInstancesInputs(componentInstancesInputs);
 821         component.setComponentInstances(componentInstances);
 822
 823         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 824             any(ComponentInstance.class))).thenReturn(Either.left(component));
 825
 826         // default test
 827         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 828             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 829         Assert.assertNotNull(result);
 830     }
 831
 832     @Test
 833     public void testAddComponentInstanceInputs() throws Exception {
 834
 835         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 836         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 837         ComponentInstance componentInstance = new ComponentInstance();
 838         String instanceUniqueId = "id";
 839         Map<String, Object> props = new HashMap<>();
 840
 841         List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
 842         componentInstanceInputs.add(new ComponentInstanceInput());
 843
 844         componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
 845
 846         // default test
 847         Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
 848             instanceUniqueId, props);
 849     }
 850
 851     @Test
 852     public void testAddPropertiesOfComponentInstance() throws Exception {
 853         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 854         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 855         ComponentInstance componentInstance = new ComponentInstance();
 856         String instanceUniqueId = "id";
 857         Map<String, Object> props = new HashMap<>();
 858
 859         ComponentInstanceProperty cip = new ComponentInstanceProperty();
 860         cip.setInstanceUniqueId("id");
 861
 862         List<ComponentInstanceProperty> list = new ArrayList<>();
 863         list.add(cip);
 864
 865         componentInstancesProperties.put("id", list);
 866
 867         // default test
 868         Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
 869             instanceUniqueId, props);
 870     }
 871
 872     @Test
 873     public void testAddPropertiesOfParentComponent() throws Exception {
 874         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 875         ComponentInstance componentInstance = new ComponentInstance();
 876         Component componentOfInstance = new Resource();
 877         Map<String, Object> props = new HashMap<>();
 878
 879         List<PropertyDefinition> properties = new ArrayList<>();
 880         properties.add(new PropertyDefinition());
 881
 882         ((Resource) componentOfInstance).setProperties(properties);
 883
 884         // default test
 885         Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
 886             componentOfInstance, props);
 887     }
 888
 889     @Test
 890     public void testCreateNodeType() throws Exception {
 891
 892         Component component = new Resource();
 893         List<String> array = new ArrayList<>();
 894         array.add("value");
 895         ((Resource) component).setDerivedFrom(array);
 896         ToscaNodeType result;
 897
 898         // test when component is resource
 899         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 900         Assert.assertNotNull(result);
 901
 902         component = new Service();
 903         // test when component is service
 904         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 905         Assert.assertNotNull(result);
 906     }
 907
 908     @Test
 909     public void testCreateProxyInterfaceTypesComponentNotFound() throws Exception {
 910         Component container = new Service();
 911         Either<Map<String, ToscaNodeType>, ToscaError> result;
 912         List<ComponentInstance> componentInstances = new ArrayList<>();
 913         ComponentInstance instance = new ComponentInstance();
 914         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 915         instance.setSourceModelUid("targetModelUid");
 916         instance.setToscaComponentName("toscaComponentName");
 917
 918         componentInstances.add(instance);
 919         container.setComponentInstances(componentInstances);
 920         when(toscaOperationFacade.getToscaElement(any(String.class),
 921             any(ComponentParametersView.class)))
 922             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 923         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
 924         Assert.assertTrue(result.isRight());
 925     }
 926
 927     @Test
 928     public void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
 929         Component container = new Service();
 930         Either<Map<String, ToscaNodeType>, ToscaError> result;
 931         List<ComponentInstance> componentInstances = new ArrayList<>();
 932         ComponentInstance instance = new ComponentInstance();
 933         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 934         instance.setSourceModelUid("targetModelUid");
 935         instance.setToscaComponentName("toscaComponentName");
 936         componentInstances.add(instance);
 937         container.setComponentInstances(componentInstances);
 938
 939         when(toscaOperationFacade.getToscaElement(any(String.class),
 940             any(ComponentParametersView.class)))
 941             .thenReturn(Either.left(new Resource()));
 942         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 943             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 944         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
 945         Assert.assertTrue(result.isRight());
 946     }
 947
 948     @Test
 949     public void testCreateProxyInterfaceTypesPositive() {
 950         Component container = new Service();
 951         Either<Map<String, ToscaNodeType>, ToscaError> result;
 952         List<ComponentInstance> componentInstances = new ArrayList<>();
 953         ComponentInstance instance = new ComponentInstance();
 954         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 955         instance.setSourceModelUid("targetModelUid");
 956         instance.setToscaComponentName("toscaComponentName");
 957         componentInstances.add(instance);
 958         container.setComponentInstances(componentInstances);
 959
 960         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 961             .thenReturn(Either.left(Collections.emptyMap()));
 962
 963         Component proxyResource = new Resource();
 964         Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
 965         proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
 966         proxyResource.setInterfaces(proxyInterfaces);
 967         when(toscaOperationFacade.getToscaElement(any(String.class),
 968             any(ComponentParametersView.class)))
 969             .thenReturn(Either.left(proxyResource));
 970
 971         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
 972         Assert.assertNotNull(result);
 973         Assert.assertTrue(result.isLeft());
 974         Assert.assertEquals(1, result.left().value().size());
 975     }
 976
 977     @Test
 978     public void testCreateProxyNodeTypes() throws Exception {
 979         Map<String, Component> componentCache = new HashMap<>();
 980         Component container = new Resource();
 981         Either<Map<String, ToscaNodeType>, ToscaError> result;
 982         List<ComponentInstance> componentInstances = new ArrayList<>();
 983         ComponentInstance instance = new ComponentInstance();
 984         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 985         instance.setSourceModelUid("targetModelUid");
 986
 987         componentInstances.add(instance);
 988         container.setComponentInstances(componentInstances);
 989
 990         when(toscaOperationFacade.getLatestByName("serviceProxy"))
 991             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 992
 993         // test when getLatestByName return is right
 994         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
 995         Assert.assertNotNull(result);
 996     }
 997
 998     @Test
 999     public void testCreateServiceSubstitutionNodeTypes() throws Exception {
1000         Map<String, Component> componentCache = new HashMap<>();
1001
1002         Component referencedService = getNewService();
1003         referencedService.setInvariantUUID("uuid");
1004         referencedService.setUUID("uuid");
1005         referencedService.setUniqueId("targetModelUid");
1006         referencedService.setDescription("desc");
1007         componentCache.put("targetModelUid", referencedService);
1008
1009         Component containerService = new Service();
1010         List<ComponentInstance> componentInstances = new ArrayList<>();
1011         ComponentInstance instance = new ComponentInstance();
1012         instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1013         instance.setSourceModelUid("targetModelUid");
1014
1015         componentInstances.add(instance);
1016         containerService.setComponentInstances(componentInstances);
1017
1018         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1019             .thenReturn(Either.left(Collections.emptyMap()));
1020         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1021         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
1022             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1023
1024         ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1025
1026         Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1027         Assert.assertNotNull(toscaNode.getNode_types());
1028     }
1029
1030     @Test
1031     public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1032         Map<String, Component> componentCache = new HashMap<>();
1033         Component container = new Resource();
1034         Either<Map<String, ToscaNodeType>, ToscaError> result;
1035         List<ComponentInstance> componentInstances = new ArrayList<>();
1036         ComponentInstance instance = new ComponentInstance();
1037         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1038         instance.setSourceModelUid("targetModelUid");
1039
1040         componentInstances.add(instance);
1041         container.setComponentInstances(componentInstances);
1042
1043         when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
1044
1045         ComponentParametersView parameterView = new ComponentParametersView();
1046         parameterView.disableAll();
1047         parameterView.setIgnoreCategories(false);
1048
1049         when(toscaOperationFacade.getToscaElement(any(String.class),
1050             any(ComponentParametersView.class)))
1051             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1052
1053         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1054
1055         // test when getLatestByName is left
1056         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1057         Assert.assertNotNull(result);
1058     }
1059
1060     @Test
1061     public void testCreateProxyNodeType() throws Exception {
1062         Map<String, Component> componentCache = new HashMap<>();
1063         Component origComponent = new Resource();
1064         Component proxyComponent = new Resource();
1065         ComponentInstance instance = new ComponentInstance();
1066         ToscaNodeType result;
1067
1068         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1069
1070         // default test
1071         result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1072             proxyComponent, instance);
1073         Assert.assertNotNull(result);
1074     }
1075
1076     @Test
1077     public void testConvertComponentInstanceRequirements() throws Exception {
1078         Component component = new Resource();
1079         ComponentInstance componentInstance = new ComponentInstance();
1080         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1081         ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1082         Component originComponent = new Resource();
1083         Map<String, Component> componentCache = new HashMap<>();
1084         Either<ToscaNodeTemplate, ToscaError> result;
1085
1086         // default test
1087         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1088             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1089         Assert.assertNotNull(result);
1090
1091         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1092         reldef.setFromNode("name");
1093         reldef.setToNode("name1");
1094         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1095         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1096         cap.setRelation(new RelationshipInfo());
1097         relationships.add(cap);
1098         reldef.setRelationships(relationships);
1099         relations.add(reldef);
1100         componentInstance.setUniqueId("name");
1101
1102         List<ComponentInstance> instances = new ArrayList<>();
1103         instances.add(componentInstance);
1104         component.setComponentInstances(instances);
1105
1106         // test when filteredRElations ins't empty
1107         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1108             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1109         Assert.assertNotNull(result);
1110     }
1111
1112     @Test
1113     public void buildRequirementFailure() {
1114         final Component fromOriginComponent = new Resource();
1115         final ComponentInstance fromInstance = new ComponentInstance();
1116         final String fromInstanceUid = "fromInstanceUid";
1117         fromInstance.setUniqueId(fromInstanceUid);
1118         fromInstance.setComponentUid("componentUid");
1119         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1120         relationshipDefinition.setToNode("wrongNodeUid");
1121         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1122         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1123         relationship.setRequirement(new RequirementDataDefinition());
1124         relationshipList.add(relationship);
1125         relationshipDefinition.setRelationships(relationshipList);
1126         final List<ComponentInstance> instancesList = new ArrayList<>();
1127         instancesList.add(fromInstance);
1128         String expectedError = String
1129             .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1130                 relationshipDefinition.getToNode());
1131         assertThrows(ToscaExportException.class, () ->
1132             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1133                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1134
1135         try {
1136             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1137                 instancesList, relationshipDefinition, new HashMap<>());
1138         } catch (Exception e) {
1139             assertTrue(e instanceof ToscaExportException);
1140             assertEquals(expectedError, e.getMessage());
1141         }
1142
1143         final RelationshipInfo relation = new RelationshipInfo();
1144         final String requirementUid = "Uid";
1145         relation.setRequirementUid(requirementUid);
1146         final String requirementName = "requirementName";
1147         relation.setRequirement(requirementName);
1148         final String capabilityName = "capabilityName";
1149         relation.setCapability(capabilityName);
1150         final String capabilityOwnerId = "capabilityOwnerId";
1151         relation.setCapabilityOwnerId(capabilityOwnerId);
1152         relationship.setRelation(relation);
1153
1154         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1155         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1156         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1157         fromOriginComponent.setRequirements(requirementMap);
1158         relationshipDefinition.setToNode(fromInstanceUid);
1159
1160         expectedError = String
1161             .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1162                 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1163
1164
1165         assertThrows(ToscaExportException.class, () ->
1166             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1167                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1168
1169         requirementDefinition.setName(requirementName);
1170
1171         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1172             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1173
1174         expectedError = String.format(
1175             "Failed to build substituted name for the requirement %s. "
1176                 + "Failed to get an origin component with uniqueId %s",
1177             requirementName, fromInstance.getActualComponentUid());
1178         assertThrows(ToscaExportException.class, () -> Deencapsulation
1179             .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1180                 relationshipDefinition, new HashMap<>()), expectedError);
1181
1182         final Component toOriginComponent = new Resource();
1183         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1184         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1185
1186         capabilityDefinition.setName(capabilityName);
1187         capabilityDefinition.setOwnerId(capabilityOwnerId);
1188         capabilityDefinition.setType("aType");
1189         final String capabilityPreviousName = "capabilityPreviousName";
1190         capabilityDefinition.setPreviousName(capabilityPreviousName);
1191         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1192         toOriginComponent.setCapabilities(capabilityMap);
1193         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1194             .thenReturn(Either.left(toOriginComponent));
1195
1196
1197         requirementDefinition.setCapability(capabilityName);
1198         relation.setCapability("wrong");
1199         final String requirementPreviousName = "requirementPreviousName";
1200         requirementDefinition.setPreviousName(requirementPreviousName);
1201         requirementDefinition.setPath(new ArrayList<>());
1202
1203         expectedError = String
1204             .format("Failed to find a capability with name %s on a component with uniqueId %s",
1205                 relation.getCapability(), fromOriginComponent.getUniqueId());
1206
1207         assertThrows(ToscaExportException.class, () -> Deencapsulation
1208                 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1209                     relationshipDefinition, new HashMap<>()),
1210             expectedError);
1211     }
1212
1213     @Test
1214     public void testBuildRequirement() {
1215         final ComponentInstance fromInstance = new ComponentInstance();
1216         fromInstance.setUniqueId("name");
1217         fromInstance.setComponentUid("string");
1218         final List<ComponentInstance> instancesList = new ArrayList<>();
1219
1220         final Map<String, Component> componentCache = new HashMap<>();
1221         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1222         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1223         relationship.setRequirement(new RequirementDataDefinition());
1224         final RelationshipInfo relation = new RelationshipInfo();
1225         final String requirementUid = "Uid";
1226         relation.setRequirementUid(requirementUid);
1227         final String requirementName = "requirementName";
1228         relation.setRequirement(requirementName);
1229         final String capabilityName = "capabilityName";
1230         relation.setCapability(capabilityName);
1231         final String capabilityOwnerId = "capabilityOwnerId";
1232         relation.setCapabilityOwnerId(capabilityOwnerId);
1233         relationship.setRelation(relation);
1234         relationshipList.add(relationship);
1235         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1236         relationshipDefinition.setRelationships(relationshipList);
1237         relationshipDefinition.setToNode("name");
1238         instancesList.add(fromInstance);
1239         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1240         requirementDefinition.setName(requirementName);
1241         requirementDefinition.setCapability(capabilityName);
1242         final String requirementPreviousName = "requirementPreviousName";
1243         requirementDefinition.setPreviousName(requirementPreviousName);
1244         requirementDefinition.setPath(new ArrayList<>());
1245         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1246         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1247         final Component fromOriginComponent = new Resource();
1248         fromOriginComponent.setRequirements(requirementMap);
1249
1250         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1251         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1252         capabilityDefinition.setName(capabilityName);
1253         capabilityDefinition.setOwnerId(capabilityOwnerId);
1254         final String capabilityPreviousName = "capabilityPreviousName";
1255         capabilityDefinition.setPreviousName(capabilityPreviousName);
1256         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1257         final Component toOriginComponent = new Resource();
1258         toOriginComponent.setCapabilities(capabilityMap);
1259
1260         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1261             .thenReturn(Either.left(toOriginComponent));
1262         final String builtCapabilityName = "builtCapabilityName";
1263         when(
1264             capabilityRequirementConverter
1265                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1266                     capabilityPreviousName)))
1267             .thenReturn(Either.left(builtCapabilityName));
1268
1269         final String builtRequirementName = "builtRequirementName";
1270         when(
1271             capabilityRequirementConverter
1272                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1273                     requirementPreviousName)))
1274             .thenReturn(Either.left(builtRequirementName));
1275
1276         final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1277             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1278                 instancesList, relationshipDefinition, componentCache);
1279         assertNotNull(actualRequirementMap);
1280         assertFalse(actualRequirementMap.isEmpty());
1281         assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1282         final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1283         assertNotNull(actualToscaTemplateRequirement);
1284         assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1285
1286         //to toOriginComponent not found
1287         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1288             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1289
1290         assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1291             instancesList, relationshipDefinition, componentCache));
1292     }
1293
1294     @Test
1295     public void testAddRequirmentsWithBuildAndAddRequirements() {
1296         ComponentInstance fromInstance = new ComponentInstance();
1297         Component fromOriginComponent = new Resource();
1298         List<ComponentInstance> instancesList = new ArrayList<>();
1299         RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1300         List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1301         Map<String, Component> componentCache = new HashMap<>();
1302
1303         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1304         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1305         cap.setRequirement(new RequirementDataDefinition());
1306         RelationshipInfo relation = new RelationshipInfo();
1307         relation.setRequirementUid("Uid");
1308         relation.setRequirement("requirment");
1309         relation.setCapability("cap");
1310         relation.setCapabilityOwnerId("id");
1311         cap.setRelation(relation);
1312         relationships.add(cap);
1313         rel.setRelationships(relationships);
1314         rel.setToNode("name");
1315         fromInstance.setUniqueId("name");
1316         fromInstance.setComponentUid("string");
1317         instancesList.add(fromInstance);
1318         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1319
1320         List<RequirementDefinition> defs = new ArrayList<>();
1321         RequirementDefinition def = new RequirementDefinition();
1322         def.setName("requirment");
1323         def.setCapability("cap");
1324         defs.add(def);
1325         requirements.put("key", defs);
1326         fromOriginComponent.setRequirements(requirements);
1327
1328         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1329         List<CapabilityDefinition> caps = new ArrayList<>();
1330         CapabilityDefinition capdef = new CapabilityDefinition();
1331         capdef.setOwnerId("id");
1332         capdef.setName("cap");
1333         capdef.setPreviousName("before cap");
1334         capdef.setType("type");
1335         caps.add(capdef);
1336         capabilities.put("cap", caps);
1337         fromOriginComponent.setCapabilities(capabilities);
1338
1339         when(toscaOperationFacade.getToscaElement(any(String.class),
1340             any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1341
1342         when(
1343             capabilityRequirementConverter
1344                 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString()))
1345             .thenReturn(Either.right(false));
1346
1347         final String expectedErrorMsg =
1348             String.format("Failed to build a substituted capability name for the capability "
1349                     + "with name %s on a component with uniqueId %s",
1350                 cap.getRequirement(), fromOriginComponent.getUniqueId());
1351
1352         assertThrows(ToscaExportException.class, () ->
1353             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1354                 rel, componentCache), expectedErrorMsg);
1355     }
1356
1357     @Test
1358     public void testBuildAndAddRequirement() {
1359         Component fromOriginComponent = new Resource();
1360         Component toOriginComponent = new Resource();
1361         CapabilityDefinition capability = new CapabilityDefinition();
1362         RequirementDefinition requirement = new RequirementDefinition();
1363         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1364         ComponentInstance toInstance = new ComponentInstance();
1365         Map<String, Component> componentCache = new HashMap<>();
1366         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1367         capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1368         capability.setPath(new ArrayList<>());
1369         capability.setPreviousName("before cap");
1370         reqAndRelationshipPair.setCapability("cap");
1371         requirement.setPath(new ArrayList<>());
1372         requirement.setPreviousName("before req");
1373         reqAndRelationshipPair.setRequirement("req");
1374
1375         when(
1376             capabilityRequirementConverter
1377                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString()))
1378             .thenReturn(Either.left("buildCapNameRes"));
1379
1380         when(
1381             capabilityRequirementConverter
1382                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString()))
1383             .thenReturn(Either.left("buildReqNameRes"));
1384
1385         // default test
1386         final Map<String, ToscaTemplateRequirement> requirementMap =
1387             Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1388                 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1389         assertNotNull(requirementMap);
1390         assertFalse(requirementMap.isEmpty());
1391         assertTrue(requirementMap.containsKey("buildReqNameRes"));
1392         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1393         assertNotNull(actualToscaTemplateRequirement);
1394         assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1395     }
1396
1397     @Test
1398     public void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1399         final Component fromOriginComponent = new Resource();
1400         final Component toOriginComponent = new Resource();
1401         final CapabilityDefinition capability = new CapabilityDefinition();
1402         final RequirementDefinition requirement = new RequirementDefinition();
1403         final RelationshipInfo relationship = new RelationshipInfo();
1404         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1405         capabilityRequirementRelationship.setRelation(relationship);
1406         ComponentInstance toInstance = new ComponentInstance();
1407         Map<String, Component> componentCache = new HashMap<>();
1408         capability.setPath(new ArrayList<>());
1409         relationship.setCapability("cap");
1410         requirement.setPath(new ArrayList<>());
1411         relationship.setRequirement("req");
1412
1413         final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1414         when(capabilityRequirementConverter.buildSubstitutedName(any(), any(), any(), any(), any()))
1415             .thenReturn(Either.left(builtCapabilityOrRequirementName));
1416
1417         final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1418             .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1419                 capabilityRequirementRelationship, toInstance, componentCache);
1420         assertNotNull(requirementMap);
1421         assertFalse(requirementMap.isEmpty());
1422         assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1423         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1424         assertNotNull(actualToscaTemplateRequirement);
1425         assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1426     }
1427
1428     @Test
1429     public void testIsRequirementBelongToRelation() throws Exception {
1430
1431         Component originComponent = new Resource();
1432         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1433         RequirementDefinition requirement = new RequirementDefinition();
1434         String fromInstanceId = "";
1435         boolean result;
1436
1437         requirement.setName("name");
1438         reqAndRelationshipPair.setRequirement("name1");
1439
1440         // test return false
1441         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1442             reqAndRelationshipPair, requirement, fromInstanceId);
1443         Assert.assertNotNull(result);
1444     }
1445
1446     @Test
1447     public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1448
1449         Component originComponent = new Service();
1450         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1451         RequirementDefinition requirement = new RequirementDefinition();
1452         String fromInstanceId = "";
1453         boolean result;
1454
1455         // default test return true
1456         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1457             reqAndRelationshipPair, requirement, fromInstanceId);
1458         Assert.assertNotNull(result);
1459     }
1460
1461     @Test
1462     public void testIsRequirementBelongToOwner() throws Exception {
1463
1464         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1465         RequirementDefinition requirement = new RequirementDefinition();
1466         String fromInstanceId = "";
1467         Component originComponent = new Resource();
1468         boolean result;
1469
1470         requirement.setOwnerId("owner1");
1471         reqAndRelationshipPair.setRequirementOwnerId("owner");
1472
1473         // default test
1474         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1475             fromInstanceId, originComponent);
1476         Assert.assertNotNull(result);
1477     }
1478
1479     @Test
1480     public void testIsCvfc() throws Exception {
1481
1482         Component component = new Resource();
1483         boolean result;
1484
1485         component = new Service();
1486
1487         result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1488         Assert.assertNotNull(result);
1489     }
1490
1491     @Test
1492     public void testConvertCapabilities() throws Exception {
1493         Component component = new Resource();
1494         SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1495         Map<String, Component> componentCache = new HashMap<>();
1496         Either<SubstitutionMapping, ToscaError> result;
1497
1498         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1499             .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1500
1501         // default test return isRight
1502         result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1503             componentCache);
1504         Assert.assertNotNull(result);
1505     }
1506
1507     @Test
1508     public void testConvertCapabilities_1() throws Exception {
1509         Component component = new Resource();
1510         ToscaNodeType nodeType = new ToscaNodeType();
1511         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1512         Either<ToscaNodeType, ToscaError> result;
1513
1514         Map<String, ToscaCapability> capabilities = new HashMap<>();
1515         capabilities.put("key", new ToscaCapability());
1516
1517         // default test
1518         result = Deencapsulation
1519             .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1520         Assert.assertNotNull(result);
1521     }
1522
1523     @Test
1524     public void testConvertToNodeTemplateArtifacts() throws Exception {
1525         Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1526         ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1527         art.setFile("test_file");
1528         art.setType("test_type");
1529         Map<String, ToscaTemplateArtifact> result;
1530         container.put("test_art", art);
1531         result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1532         Assert.assertNotNull(result);
1533         Assert.assertTrue(MapUtils.isNotEmpty(result));
1534         Assert.assertTrue(result.get("test_art").getFile().equals("test_file"));
1535         Assert.assertTrue(result.get("test_art").getType().equals("test_type"));
1536     }
1537
1538     @Test
1539     public void testGetProxyNodeTypeInterfacesNoInterfaces() {
1540         Component service = new Service();
1541         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1542                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1543         Assert.assertFalse(proxyNodeTypeInterfaces.isPresent());
1544     }
1545
1546     @Test
1547     public void testGetProxyNodeTypeInterfaces() {
1548         Component service = getTestComponent();
1549         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1550                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1551         Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1552         Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1553         Assert.assertNotNull(componentInterfaces);
1554     }
1555
1556
1557     @Test
1558     public void testGetProxyNodeTypePropertiesComponentNull() {
1559         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1560                 testSubject.getProxyNodeTypeProperties(null, DATA_TYPES);
1561         Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1562     }
1563
1564     @Test
1565     public void testGetProxyNodeTypePropertiesNoProperties() {
1566         Component service = new Service();
1567         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1568                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1569         Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1570     }
1571
1572     @Test
1573     public void testGetProxyNodeTypeProperties() {
1574         Component service = getTestComponent();
1575         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1576                 createMockProperty("componentPropInt", null)));
1577         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1578                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1579         Assert.assertTrue(proxyNodeTypeProperties.isPresent());
1580         Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
1581         Assert.assertNotNull(componentProperties);
1582         Assert.assertEquals(2, componentProperties.size());
1583     }
1584
1585     @Test
1586     public void testAddInputsToPropertiesNoInputs() {
1587         Component service = getTestComponent();
1588         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1589                 createMockProperty("componentPropInt", null)));
1590         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1591                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1592
1593         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1594         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1595         testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties);
1596         Assert.assertNotNull(proxyNodeTypeProperties);
1597         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1598         testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties);
1599         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1600     }
1601
1602     @Test
1603     public void testAddInputsToPropertiesWithInputs() {
1604         Component service = getTestComponent();
1605         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1606                 createMockProperty("componentPropInt", null)));
1607         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1608                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1609         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1610                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1611
1612         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1613         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1614         testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1615         Assert.assertNotNull(proxyNodeTypeProperties);
1616         Assert.assertEquals(4, proxyNodeTypeProperties.size());
1617     }
1618
1619     @Test
1620     public void testAddInputsToPropertiesOnlyInputs() {
1621         Component service = getTestComponent();
1622         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1623                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1624         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1625                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1626
1627         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1628         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1629         testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1630         Assert.assertNotNull(proxyNodeTypeProperties);
1631         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1632     }
1633
1634     @Test
1635     public void testOperationImplementationInProxyNodeTypeNotPresent() {
1636         Component service = getTestComponent();
1637         InterfaceDefinition interfaceDefinition =
1638                 service.getInterfaces().get("normalizedServiceComponentName-interface");
1639         interfaceDefinition.setOperations(new HashMap<>());
1640         final OperationDataDefinition operation = new OperationDataDefinition();
1641         operation.setName("start");
1642         operation.setDescription("op description");
1643         final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
1644         implementation.setArtifactName("createBPMN.bpmn");
1645         operation.setImplementation(implementation);
1646         interfaceDefinition.getOperations().put(operation.getName(), operation);
1647         service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
1648         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1649                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1650         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1651                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1652         Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1653         Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1654         Assert.assertNotNull(componentInterfaces);
1655     }
1656
1657     private Component getTestComponent() {
1658         Component component = new Service();
1659         component.setNormalizedName("normalizedServiceComponentName");
1660         InterfaceDefinition addedInterface = new InterfaceDefinition();
1661         addedInterface.setType("com.some.service.or.other.serviceName");
1662         final String interfaceType = "normalizedServiceComponentName-interface";
1663         component.setInterfaces(new HashMap<>());
1664         component.getInterfaces().put(interfaceType, addedInterface);
1665         return component;
1666     }
1667
1668     private PropertyDefinition createMockProperty(String propertyName, String defaultValue){
1669         PropertyDefinition propertyDefinition = new PropertyDefinition();
1670         propertyDefinition.setName(propertyName);
1671         propertyDefinition.setType("string");
1672         propertyDefinition.setDefaultValue(defaultValue);
1673         return propertyDefinition;
1674     }
1675
1676     private InputDefinition createMockInput(String inputName, String defaultValue){
1677         InputDefinition inputDefinition = new InputDefinition();
1678         inputDefinition.setName(inputName);
1679         inputDefinition.setType("string");
1680         inputDefinition.setDefaultValue(defaultValue);
1681         return inputDefinition;
1682     }
1683
1684 }