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