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(eq("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.assertTrue(toscaTemplateRes.getImports().size() == 8);
 372         Assert.assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface"));
 373         Assert.assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName"));
 374         Assert.assertTrue(toscaTemplateRes.getDependencies().size() == 1);
 375         Assert.assertNotNull(toscaTemplateRes.getDependencies().get(0).getLeft().equals("name.name2"));
 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(eq("name"))).thenReturn(Either.left(component));
 534
 535         when(toscaOperationFacade.getToscaFullElement(eq("modelName")))
 536             .thenReturn(Either.left(new Service()));
 537
 538         // default test
 539         Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
 540     }
 541
 542     @Test
 543     public void testGetInterfaceFilename() throws Exception {
 544         String artifactName = "artifact.name";
 545         String result;
 546
 547         // default test
 548         result = ToscaExportHandler.getInterfaceFilename(artifactName);
 549         Assert.assertNotNull(result);
 550     }
 551
 552     @Test
 553     public void testConvertNodeType() throws Exception {
 554         Component component = new Resource();
 555         ToscaTemplate toscaNode = new ToscaTemplate("");
 556         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 557         Either<ToscaTemplate, ToscaError> result;
 558
 559         when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
 560         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 561             .thenReturn(Either.left(Collections.emptyMap()));
 562         // default test
 563         result = Deencapsulation
 564             .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
 565         Assert.assertNotNull(result);
 566     }
 567
 568     @Test
 569     public void testConvertInterfaceNodeType() throws Exception {
 570         Component component = getNewResource();
 571         ToscaTemplate toscaNode = new ToscaTemplate("");
 572         Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
 573         Either<ToscaTemplate, ToscaError> result;
 574         List<InputDefinition> inputs = new ArrayList<>();
 575         inputs.add(new InputDefinition());
 576         component.setInputs(inputs);
 577
 578         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
 579         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 580             .thenReturn(Either.left(Collections.emptyMap()));
 581
 582         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 583                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 584
 585         // default test
 586         result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
 587             , nodeTypes, false);
 588         Assert.assertNotNull(result);
 589     }
 590
 591     @Test
 592     public void testConvertReqCapAndTypeName() throws Exception {
 593         Component component = new Resource();
 594         ToscaTemplate toscaNode = new ToscaTemplate("");
 595         Map<String, ToscaNodeType> nodeTypes = new HashMap();
 596         ToscaNodeType toscaNodeType = new ToscaNodeType();
 597         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 598         Either<ToscaTemplate, ToscaError> result;
 599
 600         when(
 601             capabilityRequirementConverter
 602                 .convertCapabilities(any(Map.class), any(Resource.class), any(Map.class)))
 603             .thenReturn(new HashMap<>());
 604
 605         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
 606                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 607
 608         // default test
 609         result = Deencapsulation
 610             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 611                 toscaNodeType, dataTypes);
 612         Assert.assertNotNull(result);
 613
 614         component = new Service();
 615
 616         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
 617                 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
 618
 619         // test when component is service
 620         result = Deencapsulation
 621             .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
 622                 toscaNodeType, dataTypes);
 623         Assert.assertNotNull(result);
 624     }
 625
 626     @Test
 627     public void testConvertNodeTemplates() throws Exception {
 628         Component component = getNewResource();
 629         List<ComponentInstance> componentInstances = new ArrayList<>();
 630         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 631         Map<String, Component> componentCache = new HashMap<>();
 632         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 633         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 634         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 635         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 636         List<ComponentInstanceInput> inputs = new ArrayList<>();
 637         inputs.add(new ComponentInstanceInput());
 638         componentInstancesInputs.put("key", inputs);
 639         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 640         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 641         reldef.setFromNode("node");
 642         resourceInstancesRelations.add(reldef);
 643         component.setComponentInstancesRelations(resourceInstancesRelations);
 644
 645         ComponentInstance instance = new ComponentInstance();
 646         instance.setUniqueId("id");
 647         instance.setComponentUid("uid");
 648         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 649         List<GroupInstance> groupInstances = new ArrayList<>();
 650         GroupInstance groupInst = new GroupInstance();
 651         List<String> artifacts = new ArrayList<>();
 652         artifacts.add("artifact");
 653         groupInst.setArtifacts(artifacts);
 654         groupInst.setType("type");
 655         groupInstances.add(groupInst);
 656         instance.setGroupInstances(groupInstances);
 657         componentInstances.add(instance);
 658
 659         component.setComponentInstancesInputs(componentInstancesInputs);
 660         component.setInvariantUUID("uuid");
 661         component.setUUID("uuid");
 662         component.setDescription("desc");
 663
 664         componentCache.put("uid", component);
 665
 666         componentInstancesProperties.put("id", new ArrayList<>());
 667         componentInstancesInputs.put("id", new ArrayList<>());
 668
 669         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 670             any(ComponentInstance.class))).thenReturn(Either.left(component));
 671
 672         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 673             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 674             .thenReturn(Either.left(new ToscaNodeTemplate()));
 675
 676         // default test
 677         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 678             componentInstancesProperties, new HashMap<>(), componentCache, dataTypes, topologyTemplate);
 679         Assert.assertNotNull(result);
 680     }
 681
 682     @Test
 683     public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
 684         Component component = getNewService();
 685         List<ComponentInstance> componentInstances = new ArrayList<>();
 686         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 687         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 688         Map<String, Component> componentCache = new HashMap<>();
 689         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 690         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 691         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 692         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 693         List<ComponentInstanceInput> inputs = new ArrayList<>();
 694         inputs.add(new ComponentInstanceInput());
 695         componentInstancesInputs.put("key", inputs);
 696         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 697         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 698         reldef.setFromNode("node");
 699         resourceInstancesRelations.add(reldef);
 700         component.setComponentInstancesRelations(resourceInstancesRelations);
 701
 702         ComponentInstance instance = new ComponentInstance();
 703         instance.setUniqueId("id");
 704         instance.setComponentUid("uid");
 705         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 706         List<GroupInstance> groupInstances = new ArrayList<>();
 707         GroupInstance groupInst = new GroupInstance();
 708         List<String> artifacts = new ArrayList<>();
 709         artifacts.add("artifact");
 710         groupInst.setArtifacts(artifacts);
 711         groupInst.setType("type");
 712         groupInstances.add(groupInst);
 713         instance.setGroupInstances(groupInstances);
 714         componentInstances.add(instance);
 715
 716         component.setComponentInstancesInputs(componentInstancesInputs);
 717         component.setInvariantUUID("uuid");
 718         component.setUUID("uuid");
 719         component.setDescription("desc");
 720
 721         Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
 722         ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
 723         ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
 724         path.setPathElements(list);
 725         forwardingPaths.put("key", path);
 726
 727         ((Service) component).setForwardingPaths(forwardingPaths);
 728
 729         componentCache.put("uid", component);
 730
 731         componentInstancesProperties.put("id", new ArrayList<>());
 732         componentInstancesInterfaces.put("id", new ArrayList<>());
 733         componentInstancesInputs.put("id", new ArrayList<>());
 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.left(new ToscaNodeTemplate()));
 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 testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() 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("node");
 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.left(component));
 783
 784         when(capabilityRequirementConverter.convertComponentInstanceCapabilities(
 785             any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
 786             .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
 787
 788         // default test
 789         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 790             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 791         Assert.assertNotNull(result);
 792     }
 793
 794     @Test
 795     public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
 796         Component component = getNewResource();
 797         List<ComponentInstance> componentInstances = new ArrayList<>();
 798         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 799         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 800         Map<String, Component> componentCache = new HashMap<>();
 801         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 802         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 803         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 804         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 805         List<ComponentInstanceInput> inputs = new ArrayList<>();
 806         inputs.add(new ComponentInstanceInput());
 807         componentInstancesInputs.put("key", inputs);
 808         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 809         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 810         reldef.setFromNode("id");
 811         resourceInstancesRelations.add(reldef);
 812         component.setComponentInstancesRelations(resourceInstancesRelations);
 813
 814         ComponentInstance instance = new ComponentInstance();
 815         instance.setUniqueId("id");
 816         instance.setComponentUid("uid");
 817         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 818         componentInstances.add(instance);
 819
 820         component.setComponentInstancesInputs(componentInstancesInputs);
 821         component.setInvariantUUID("uuid");
 822         component.setUUID("uuid");
 823         component.setDescription("desc");
 824
 825         componentCache.put("uid", component);
 826
 827         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 828             any(ComponentInstance.class))).thenReturn(Either.right(false));
 829
 830         // default test
 831         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 832             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 833         Assert.assertNotNull(result);
 834     }
 835
 836     @Test
 837     public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
 838         Component component = new Resource();
 839         List<ComponentInstance> componentInstances = new ArrayList<>();
 840         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 841         Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
 842         Map<String, Component> componentCache = new HashMap<>();
 843         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 844         ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
 845         Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
 846         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 847         List<ComponentInstanceInput> inputs = new ArrayList<>();
 848         inputs.add(new ComponentInstanceInput());
 849         componentInstancesInputs.put("key", inputs);
 850         List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
 851         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
 852         reldef.setFromNode("id");
 853         reldef.setToNode("node");
 854         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
 855         CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
 856         relationship.setRelation(new RelationshipInfo());
 857         relationships.add(relationship);
 858         reldef.setRelationships(relationships);
 859         resourceInstancesRelations.add(reldef);
 860         component.setComponentInstancesRelations(resourceInstancesRelations);
 861
 862         ComponentInstance instance = new ComponentInstance();
 863         instance.setUniqueId("id");
 864         componentInstances.add(instance);
 865
 866         component.setComponentInstancesInputs(componentInstancesInputs);
 867         component.setComponentInstances(componentInstances);
 868
 869         when(capabilityRequirementConverter.getOriginComponent(any(Map.class),
 870             any(ComponentInstance.class))).thenReturn(Either.left(component));
 871
 872         // default test
 873         result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
 874             componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
 875         Assert.assertNotNull(result);
 876     }
 877
 878     @Test
 879     public void testAddComponentInstanceInputs() throws Exception {
 880
 881         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 882         Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
 883         ComponentInstance componentInstance = new ComponentInstance();
 884         String instanceUniqueId = "id";
 885         Map<String, Object> props = new HashMap<>();
 886
 887         List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
 888         componentInstanceInputs.add(new ComponentInstanceInput());
 889
 890         componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
 891
 892         // default test
 893         Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
 894             instanceUniqueId, props);
 895     }
 896
 897     @Test
 898     public void testAddPropertiesOfComponentInstance() throws Exception {
 899         Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
 900         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 901         ComponentInstance componentInstance = new ComponentInstance();
 902         String instanceUniqueId = "id";
 903         Map<String, Object> props = new HashMap<>();
 904
 905         ComponentInstanceProperty cip = new ComponentInstanceProperty();
 906         cip.setInstanceUniqueId("id");
 907
 908         List<ComponentInstanceProperty> list = new ArrayList<>();
 909         list.add(cip);
 910
 911         componentInstancesProperties.put("id", list);
 912
 913         // default test
 914         Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
 915             instanceUniqueId, props);
 916     }
 917
 918     @Test
 919     public void testAddPropertiesOfParentComponent() throws Exception {
 920         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
 921         ComponentInstance componentInstance = new ComponentInstance();
 922         Component componentOfInstance = new Resource();
 923         Map<String, Object> props = new HashMap<>();
 924
 925         List<PropertyDefinition> properties = new ArrayList<>();
 926         properties.add(new PropertyDefinition());
 927
 928         ((Resource) componentOfInstance).setProperties(properties);
 929
 930         // default test
 931         Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
 932             componentOfInstance, props);
 933     }
 934
 935     @Test
 936     public void testCreateNodeType() throws Exception {
 937
 938         Component component = new Resource();
 939         List<String> array = new ArrayList<>();
 940         array.add("value");
 941         ((Resource) component).setDerivedFrom(array);
 942         ToscaNodeType result;
 943
 944         // test when component is resource
 945         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 946         Assert.assertNotNull(result);
 947
 948         component = new Service();
 949         // test when component is service
 950         result = Deencapsulation.invoke(testSubject, "createNodeType", component);
 951         Assert.assertNotNull(result);
 952     }
 953
 954     @Test
 955     public void testCreateProxyInterfaceTypesComponentNotFound() throws Exception {
 956         Component container = new Service();
 957         Either<Map<String, ToscaNodeType>, ToscaError> result;
 958         List<ComponentInstance> componentInstances = new ArrayList<>();
 959         ComponentInstance instance = new ComponentInstance();
 960         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 961         instance.setSourceModelUid("targetModelUid");
 962         instance.setToscaComponentName("toscaComponentName");
 963
 964         componentInstances.add(instance);
 965         container.setComponentInstances(componentInstances);
 966         when(toscaOperationFacade.getToscaElement(any(String.class),
 967             any(ComponentParametersView.class)))
 968             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 969         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
 970         Assert.assertTrue(result.isRight());
 971     }
 972
 973     @Test
 974     public void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
 975         Component container = new Service();
 976         Either<Map<String, ToscaNodeType>, ToscaError> result;
 977         List<ComponentInstance> componentInstances = new ArrayList<>();
 978         ComponentInstance instance = new ComponentInstance();
 979         instance.setOriginType(OriginTypeEnum.ServiceProxy);
 980         instance.setSourceModelUid("targetModelUid");
 981         instance.setToscaComponentName("toscaComponentName");
 982         componentInstances.add(instance);
 983         container.setComponentInstances(componentInstances);
 984
 985         when(toscaOperationFacade.getToscaElement(any(String.class),
 986             any(ComponentParametersView.class)))
 987             .thenReturn(Either.left(new Resource()));
 988         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
 989             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
 990         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
 991         Assert.assertTrue(result.isRight());
 992     }
 993
 994     @Test
 995     public void testCreateProxyInterfaceTypesPositive() {
 996         Component container = new Service();
 997         Either<Map<String, ToscaNodeType>, ToscaError> result;
 998         List<ComponentInstance> componentInstances = new ArrayList<>();
 999         ComponentInstance instance = new ComponentInstance();
1000         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1001         instance.setSourceModelUid("targetModelUid");
1002         instance.setToscaComponentName("toscaComponentName");
1003         componentInstances.add(instance);
1004         container.setComponentInstances(componentInstances);
1005
1006         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1007             .thenReturn(Either.left(Collections.emptyMap()));
1008
1009         Component proxyResource = new Resource();
1010         Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1011         proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1012         proxyResource.setInterfaces(proxyInterfaces);
1013         when(toscaOperationFacade.getToscaElement(any(String.class),
1014             any(ComponentParametersView.class)))
1015             .thenReturn(Either.left(proxyResource));
1016
1017         result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1018         Assert.assertNotNull(result);
1019         Assert.assertTrue(result.isLeft());
1020         Assert.assertEquals(1, result.left().value().size());
1021     }
1022
1023     @Test
1024     public void testCreateProxyNodeTypes() throws Exception {
1025         Map<String, Component> componentCache = new HashMap<>();
1026         Component container = new Resource();
1027         Either<Map<String, ToscaNodeType>, ToscaError> result;
1028         List<ComponentInstance> componentInstances = new ArrayList<>();
1029         ComponentInstance instance = new ComponentInstance();
1030         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1031         instance.setSourceModelUid("targetModelUid");
1032
1033         componentInstances.add(instance);
1034         container.setComponentInstances(componentInstances);
1035
1036         when(toscaOperationFacade.getLatestByName("serviceProxy"))
1037             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1038
1039         // test when getLatestByName return is right
1040         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1041         Assert.assertNotNull(result);
1042     }
1043
1044     @Test
1045     public void testCreateServiceSubstitutionNodeTypes() throws Exception {
1046         Map<String, Component> componentCache = new HashMap<>();
1047
1048         Component referencedService = getNewService();
1049         referencedService.setInvariantUUID("uuid");
1050         referencedService.setUUID("uuid");
1051         referencedService.setUniqueId("targetModelUid");
1052         referencedService.setDescription("desc");
1053         componentCache.put("targetModelUid", referencedService);
1054
1055         Component containerService = new Service();
1056         List<ComponentInstance> componentInstances = new ArrayList<>();
1057         ComponentInstance instance = new ComponentInstance();
1058         instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1059         instance.setSourceModelUid("targetModelUid");
1060
1061         componentInstances.add(instance);
1062         containerService.setComponentInstances(componentInstances);
1063
1064         when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1065             .thenReturn(Either.left(Collections.emptyMap()));
1066         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1067         when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
1068             any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1069
1070         ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1071
1072         Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1073         Assert.assertNotNull(toscaNode.getNode_types());
1074     }
1075
1076     @Test
1077     public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1078         Map<String, Component> componentCache = new HashMap<>();
1079         Component container = new Resource();
1080         Either<Map<String, ToscaNodeType>, ToscaError> result;
1081         List<ComponentInstance> componentInstances = new ArrayList<>();
1082         ComponentInstance instance = new ComponentInstance();
1083         instance.setOriginType(OriginTypeEnum.ServiceProxy);
1084         instance.setSourceModelUid("targetModelUid");
1085
1086         componentInstances.add(instance);
1087         container.setComponentInstances(componentInstances);
1088
1089         when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
1090
1091         ComponentParametersView parameterView = new ComponentParametersView();
1092         parameterView.disableAll();
1093         parameterView.setIgnoreCategories(false);
1094
1095         when(toscaOperationFacade.getToscaElement(any(String.class),
1096             any(ComponentParametersView.class)))
1097             .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1098
1099         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1100
1101         // test when getLatestByName is left
1102         result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1103         Assert.assertNotNull(result);
1104     }
1105
1106     @Test
1107     public void testCreateProxyNodeType() throws Exception {
1108         Map<String, Component> componentCache = new HashMap<>();
1109         Component origComponent = new Resource();
1110         Component proxyComponent = new Resource();
1111         ComponentInstance instance = new ComponentInstance();
1112         ToscaNodeType result;
1113
1114         when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1115
1116         // default test
1117         result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1118             proxyComponent, instance);
1119         Assert.assertNotNull(result);
1120     }
1121
1122     @Test
1123     public void testConvertComponentInstanceRequirements() throws Exception {
1124         Component component = new Resource();
1125         ComponentInstance componentInstance = new ComponentInstance();
1126         List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1127         ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1128         Component originComponent = new Resource();
1129         Map<String, Component> componentCache = new HashMap<>();
1130         Either<ToscaNodeTemplate, ToscaError> result;
1131
1132         // default test
1133         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1134             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1135         Assert.assertNotNull(result);
1136
1137         RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1138         reldef.setFromNode("name");
1139         reldef.setToNode("name1");
1140         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1141         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1142         cap.setRelation(new RelationshipInfo());
1143         relationships.add(cap);
1144         reldef.setRelationships(relationships);
1145         relations.add(reldef);
1146         componentInstance.setUniqueId("name");
1147
1148         List<ComponentInstance> instances = new ArrayList<>();
1149         instances.add(componentInstance);
1150         component.setComponentInstances(instances);
1151
1152         // test when filteredRElations ins't empty
1153         result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1154             componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1155         Assert.assertNotNull(result);
1156     }
1157
1158     @Test
1159     public void buildRequirementFailure() {
1160         final Component fromOriginComponent = new Resource();
1161         final ComponentInstance fromInstance = new ComponentInstance();
1162         final String fromInstanceUid = "fromInstanceUid";
1163         fromInstance.setUniqueId(fromInstanceUid);
1164         fromInstance.setComponentUid("componentUid");
1165         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1166         relationshipDefinition.setToNode("wrongNodeUid");
1167         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1168         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1169         relationship.setRequirement(new RequirementDataDefinition());
1170         relationshipList.add(relationship);
1171         relationshipDefinition.setRelationships(relationshipList);
1172         final List<ComponentInstance> instancesList = new ArrayList<>();
1173         instancesList.add(fromInstance);
1174         String expectedError = String
1175             .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1176                 relationshipDefinition.getToNode());
1177         assertThrows(ToscaExportException.class, () ->
1178             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1179                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1180
1181         try {
1182             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1183                 instancesList, relationshipDefinition, new HashMap<>());
1184         } catch (Exception e) {
1185             assertTrue(e instanceof ToscaExportException);
1186             assertEquals(expectedError, e.getMessage());
1187         }
1188
1189         final RelationshipInfo relation = new RelationshipInfo();
1190         final String requirementUid = "Uid";
1191         relation.setRequirementUid(requirementUid);
1192         final String requirementName = "requirementName";
1193         relation.setRequirement(requirementName);
1194         final String capabilityName = "capabilityName";
1195         relation.setCapability(capabilityName);
1196         final String capabilityOwnerId = "capabilityOwnerId";
1197         relation.setCapabilityOwnerId(capabilityOwnerId);
1198         relationship.setRelation(relation);
1199
1200         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1201         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1202         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1203         fromOriginComponent.setRequirements(requirementMap);
1204         relationshipDefinition.setToNode(fromInstanceUid);
1205
1206         expectedError = String
1207             .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1208                 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1209
1210
1211         assertThrows(ToscaExportException.class, () ->
1212             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1213                 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1214
1215         requirementDefinition.setName(requirementName);
1216
1217         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1218             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1219
1220         expectedError = String.format(
1221             "Failed to build substituted name for the requirement %s. "
1222                 + "Failed to get an origin component with uniqueId %s",
1223             requirementName, fromInstance.getActualComponentUid());
1224         assertThrows(ToscaExportException.class, () -> Deencapsulation
1225             .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1226                 relationshipDefinition, new HashMap<>()), expectedError);
1227
1228         final Component toOriginComponent = new Resource();
1229         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1230         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1231
1232         capabilityDefinition.setName(capabilityName);
1233         capabilityDefinition.setOwnerId(capabilityOwnerId);
1234         capabilityDefinition.setType("aType");
1235         final String capabilityPreviousName = "capabilityPreviousName";
1236         capabilityDefinition.setPreviousName(capabilityPreviousName);
1237         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1238         toOriginComponent.setCapabilities(capabilityMap);
1239         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1240             .thenReturn(Either.left(toOriginComponent));
1241
1242
1243         requirementDefinition.setCapability(capabilityName);
1244         relation.setCapability("wrong");
1245         final String requirementPreviousName = "requirementPreviousName";
1246         requirementDefinition.setPreviousName(requirementPreviousName);
1247         requirementDefinition.setPath(new ArrayList<>());
1248
1249         expectedError = String
1250             .format("Failed to find a capability with name %s on a component with uniqueId %s",
1251                 relation.getCapability(), fromOriginComponent.getUniqueId());
1252
1253         assertThrows(ToscaExportException.class, () -> Deencapsulation
1254                 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1255                     relationshipDefinition, new HashMap<>()),
1256             expectedError);
1257     }
1258
1259     @Test
1260     public void testBuildRequirement() {
1261         final ComponentInstance fromInstance = new ComponentInstance();
1262         fromInstance.setUniqueId("name");
1263         fromInstance.setComponentUid("string");
1264         final List<ComponentInstance> instancesList = new ArrayList<>();
1265
1266         final Map<String, Component> componentCache = new HashMap<>();
1267         final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1268         final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1269         relationship.setRequirement(new RequirementDataDefinition());
1270         final RelationshipInfo relation = new RelationshipInfo();
1271         final String requirementUid = "Uid";
1272         relation.setRequirementUid(requirementUid);
1273         final String requirementName = "requirementName";
1274         relation.setRequirement(requirementName);
1275         final String capabilityName = "capabilityName";
1276         relation.setCapability(capabilityName);
1277         final String capabilityOwnerId = "capabilityOwnerId";
1278         relation.setCapabilityOwnerId(capabilityOwnerId);
1279         relationship.setRelation(relation);
1280         relationshipList.add(relationship);
1281         final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1282         relationshipDefinition.setRelationships(relationshipList);
1283         relationshipDefinition.setToNode("name");
1284         instancesList.add(fromInstance);
1285         final RequirementDefinition requirementDefinition = new RequirementDefinition();
1286         requirementDefinition.setName(requirementName);
1287         requirementDefinition.setCapability(capabilityName);
1288         final String requirementPreviousName = "requirementPreviousName";
1289         requirementDefinition.setPreviousName(requirementPreviousName);
1290         requirementDefinition.setPath(new ArrayList<>());
1291         final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1292         requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1293         final Component fromOriginComponent = new Resource();
1294         fromOriginComponent.setRequirements(requirementMap);
1295
1296         final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1297         final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1298         capabilityDefinition.setName(capabilityName);
1299         capabilityDefinition.setOwnerId(capabilityOwnerId);
1300         final String capabilityPreviousName = "capabilityPreviousName";
1301         capabilityDefinition.setPreviousName(capabilityPreviousName);
1302         capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1303         final Component toOriginComponent = new Resource();
1304         toOriginComponent.setCapabilities(capabilityMap);
1305
1306         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1307             .thenReturn(Either.left(toOriginComponent));
1308         final String builtCapabilityName = "builtCapabilityName";
1309         when(
1310             capabilityRequirementConverter
1311                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1312                     capabilityPreviousName)))
1313             .thenReturn(Either.left(builtCapabilityName));
1314
1315         final String builtRequirementName = "builtRequirementName";
1316         when(
1317             capabilityRequirementConverter
1318                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1319                     requirementPreviousName)))
1320             .thenReturn(Either.left(builtRequirementName));
1321
1322         final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1323             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1324                 instancesList, relationshipDefinition, componentCache);
1325         assertNotNull(actualRequirementMap);
1326         assertFalse(actualRequirementMap.isEmpty());
1327         assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1328         final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1329         assertNotNull(actualToscaTemplateRequirement);
1330         assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1331
1332         //to toOriginComponent not found
1333         when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1334             .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1335
1336         assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1337             instancesList, relationshipDefinition, componentCache));
1338     }
1339
1340     @Test
1341     public void testAddRequirmentsWithBuildAndAddRequirements() {
1342         ComponentInstance fromInstance = new ComponentInstance();
1343         Component fromOriginComponent = new Resource();
1344         List<ComponentInstance> instancesList = new ArrayList<>();
1345         RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1346         List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1347         Map<String, Component> componentCache = new HashMap<>();
1348
1349         List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1350         CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1351         cap.setRequirement(new RequirementDataDefinition());
1352         RelationshipInfo relation = new RelationshipInfo();
1353         relation.setRequirementUid("Uid");
1354         relation.setRequirement("requirment");
1355         relation.setCapability("cap");
1356         relation.setCapabilityOwnerId("id");
1357         cap.setRelation(relation);
1358         relationships.add(cap);
1359         rel.setRelationships(relationships);
1360         rel.setToNode("name");
1361         fromInstance.setUniqueId("name");
1362         fromInstance.setComponentUid("string");
1363         instancesList.add(fromInstance);
1364         Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1365
1366         List<RequirementDefinition> defs = new ArrayList<>();
1367         RequirementDefinition def = new RequirementDefinition();
1368         def.setName("requirment");
1369         def.setCapability("cap");
1370         defs.add(def);
1371         requirements.put("key", defs);
1372         fromOriginComponent.setRequirements(requirements);
1373
1374         Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1375         List<CapabilityDefinition> caps = new ArrayList<>();
1376         CapabilityDefinition capdef = new CapabilityDefinition();
1377         capdef.setOwnerId("id");
1378         capdef.setName("cap");
1379         capdef.setPreviousName("before cap");
1380         capdef.setType("type");
1381         caps.add(capdef);
1382         capabilities.put("cap", caps);
1383         fromOriginComponent.setCapabilities(capabilities);
1384
1385         when(toscaOperationFacade.getToscaElement(any(String.class),
1386             any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1387
1388         when(
1389             capabilityRequirementConverter
1390                 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString()))
1391             .thenReturn(Either.right(false));
1392
1393         final String expectedErrorMsg =
1394             String.format("Failed to build a substituted capability name for the capability "
1395                     + "with name %s on a component with uniqueId %s",
1396                 cap.getRequirement(), fromOriginComponent.getUniqueId());
1397
1398         assertThrows(ToscaExportException.class, () ->
1399             Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1400                 rel, componentCache), expectedErrorMsg);
1401     }
1402
1403     @Test
1404     public void testBuildAndAddRequirement() {
1405         Component fromOriginComponent = new Resource();
1406         Component toOriginComponent = new Resource();
1407         CapabilityDefinition capability = new CapabilityDefinition();
1408         RequirementDefinition requirement = new RequirementDefinition();
1409         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1410         ComponentInstance toInstance = new ComponentInstance();
1411         Map<String, Component> componentCache = new HashMap<>();
1412         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1413         capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1414         capability.setPath(new ArrayList<>());
1415         capability.setPreviousName("before cap");
1416         reqAndRelationshipPair.setCapability("cap");
1417         requirement.setPath(new ArrayList<>());
1418         requirement.setPreviousName("before req");
1419         reqAndRelationshipPair.setRequirement("req");
1420
1421         when(
1422             capabilityRequirementConverter
1423                 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString()))
1424             .thenReturn(Either.left("buildCapNameRes"));
1425
1426         when(
1427             capabilityRequirementConverter
1428                 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString()))
1429             .thenReturn(Either.left("buildReqNameRes"));
1430
1431         // default test
1432         final Map<String, ToscaTemplateRequirement> requirementMap =
1433             Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1434                 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1435         assertNotNull(requirementMap);
1436         assertFalse(requirementMap.isEmpty());
1437         assertTrue(requirementMap.containsKey("buildReqNameRes"));
1438         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1439         assertNotNull(actualToscaTemplateRequirement);
1440         assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1441     }
1442
1443     @Test
1444     public void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1445         final Component fromOriginComponent = new Resource();
1446         final Component toOriginComponent = new Resource();
1447         final CapabilityDefinition capability = new CapabilityDefinition();
1448         final RequirementDefinition requirement = new RequirementDefinition();
1449         final RelationshipInfo relationship = new RelationshipInfo();
1450         final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1451         capabilityRequirementRelationship.setRelation(relationship);
1452         ComponentInstance toInstance = new ComponentInstance();
1453         Map<String, Component> componentCache = new HashMap<>();
1454         capability.setPath(new ArrayList<>());
1455         relationship.setCapability("cap");
1456         requirement.setPath(new ArrayList<>());
1457         relationship.setRequirement("req");
1458
1459         final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1460         when(capabilityRequirementConverter.buildSubstitutedName(any(), any(), any(), any(), any()))
1461             .thenReturn(Either.left(builtCapabilityOrRequirementName));
1462
1463         final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1464             .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1465                 capabilityRequirementRelationship, toInstance, componentCache);
1466         assertNotNull(requirementMap);
1467         assertFalse(requirementMap.isEmpty());
1468         assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1469         final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1470         assertNotNull(actualToscaTemplateRequirement);
1471         assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1472     }
1473
1474     @Test
1475     public void testIsRequirementBelongToRelation() throws Exception {
1476
1477         Component originComponent = new Resource();
1478         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1479         RequirementDefinition requirement = new RequirementDefinition();
1480         String fromInstanceId = "";
1481         boolean result;
1482
1483         requirement.setName("name");
1484         reqAndRelationshipPair.setRequirement("name1");
1485
1486         // test return false
1487         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1488             reqAndRelationshipPair, requirement, fromInstanceId);
1489         Assert.assertNotNull(result);
1490     }
1491
1492     @Test
1493     public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1494
1495         Component originComponent = new Service();
1496         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1497         RequirementDefinition requirement = new RequirementDefinition();
1498         String fromInstanceId = "";
1499         boolean result;
1500
1501         // default test return true
1502         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1503             reqAndRelationshipPair, requirement, fromInstanceId);
1504         Assert.assertNotNull(result);
1505     }
1506
1507     @Test
1508     public void testIsRequirementBelongToOwner() throws Exception {
1509
1510         RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1511         RequirementDefinition requirement = new RequirementDefinition();
1512         String fromInstanceId = "";
1513         Component originComponent = new Resource();
1514         boolean result;
1515
1516         requirement.setOwnerId("owner1");
1517         reqAndRelationshipPair.setRequirementOwnerId("owner");
1518
1519         // default test
1520         result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1521             fromInstanceId, originComponent);
1522         Assert.assertNotNull(result);
1523     }
1524
1525     @Test
1526     public void testIsCvfc() throws Exception {
1527
1528         Component component = new Resource();
1529         boolean result;
1530
1531         component = new Service();
1532
1533         result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1534         Assert.assertNotNull(result);
1535     }
1536
1537     @Test
1538     public void testConvertCapabilities() throws Exception {
1539         Component component = new Resource();
1540         SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1541         Map<String, Component> componentCache = new HashMap<>();
1542         Either<SubstitutionMapping, ToscaError> result;
1543
1544         when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1545             .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1546
1547         // default test return isRight
1548         result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1549             componentCache);
1550         Assert.assertNotNull(result);
1551     }
1552
1553     @Test
1554     public void testConvertCapabilities_1() throws Exception {
1555         Component component = new Resource();
1556         ToscaNodeType nodeType = new ToscaNodeType();
1557         Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1558         Either<ToscaNodeType, ToscaError> result;
1559
1560         Map<String, ToscaCapability> capabilities = new HashMap<>();
1561         capabilities.put("key", new ToscaCapability());
1562
1563         // default test
1564         result = Deencapsulation
1565             .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1566         Assert.assertNotNull(result);
1567     }
1568
1569     @Test
1570     public void testConvertToNodeTemplateArtifacts() throws Exception {
1571         Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1572         ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1573         art.setFile("test_file");
1574         art.setType("test_type");
1575         Map<String, ToscaTemplateArtifact> result;
1576         container.put("test_art", art);
1577         result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1578         Assert.assertNotNull(result);
1579         Assert.assertTrue(MapUtils.isNotEmpty(result));
1580         Assert.assertTrue(result.get("test_art").getFile().equals("test_file"));
1581         Assert.assertTrue(result.get("test_art").getType().equals("test_type"));
1582     }
1583
1584     @Test
1585     public void testGetProxyNodeTypeInterfacesNoInterfaces() {
1586         Component service = new Service();
1587         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1588                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1589         Assert.assertFalse(proxyNodeTypeInterfaces.isPresent());
1590     }
1591
1592     @Test
1593     public void testGetProxyNodeTypeInterfaces() {
1594         Component service = getTestComponent();
1595         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1596                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1597         Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1598         Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1599         Assert.assertNotNull(componentInterfaces);
1600     }
1601
1602
1603     @Test
1604     public void testGetProxyNodeTypePropertiesComponentNull() {
1605         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1606                 testSubject.getProxyNodeTypeProperties(null, DATA_TYPES);
1607         Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1608     }
1609
1610     @Test
1611     public void testGetProxyNodeTypePropertiesNoProperties() {
1612         Component service = new Service();
1613         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1614                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1615         Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1616     }
1617
1618     @Test
1619     public void testGetProxyNodeTypeProperties() {
1620         Component service = getTestComponent();
1621         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1622                 createMockProperty("componentPropInt", null)));
1623         Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1624                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1625         Assert.assertTrue(proxyNodeTypeProperties.isPresent());
1626         Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
1627         Assert.assertNotNull(componentProperties);
1628         Assert.assertEquals(2, componentProperties.size());
1629     }
1630
1631     @Test
1632     public void testAddInputsToPropertiesNoInputs() {
1633         Component service = getTestComponent();
1634         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1635                 createMockProperty("componentPropInt", null)));
1636         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1637                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1638
1639         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1640         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1641         testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties);
1642         Assert.assertNotNull(proxyNodeTypeProperties);
1643         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1644         testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties);
1645         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1646     }
1647
1648     @Test
1649     public void testAddInputsToPropertiesWithInputs() {
1650         Component service = getTestComponent();
1651         service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1652                 createMockProperty("componentPropInt", null)));
1653         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1654                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1655         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1656                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1657
1658         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1659         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1660         testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1661         Assert.assertNotNull(proxyNodeTypeProperties);
1662         Assert.assertEquals(4, proxyNodeTypeProperties.size());
1663     }
1664
1665     @Test
1666     public void testAddInputsToPropertiesOnlyInputs() {
1667         Component service = getTestComponent();
1668         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1669                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1670         Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1671                 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1672
1673         Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1674         Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1675         testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1676         Assert.assertNotNull(proxyNodeTypeProperties);
1677         Assert.assertEquals(2, proxyNodeTypeProperties.size());
1678     }
1679
1680     @Test
1681     public void testOperationImplementationInProxyNodeTypeNotPresent() {
1682         Component service = getTestComponent();
1683         InterfaceDefinition interfaceDefinition =
1684                 service.getInterfaces().get("normalizedServiceComponentName-interface");
1685         interfaceDefinition.setOperations(new HashMap<>());
1686         final OperationDataDefinition operation = new OperationDataDefinition();
1687         operation.setName("start");
1688         operation.setDescription("op description");
1689         final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
1690         implementation.setArtifactName("createBPMN.bpmn");
1691         operation.setImplementation(implementation);
1692         interfaceDefinition.getOperations().put(operation.getName(), operation);
1693         service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
1694         service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1695                 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1696         Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1697                 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1698         Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1699         Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1700         Assert.assertNotNull(componentInterfaces);
1701     }
1702
1703     private Component getTestComponent() {
1704         Component component = new Service();
1705         component.setNormalizedName("normalizedServiceComponentName");
1706         InterfaceDefinition addedInterface = new InterfaceDefinition();
1707         addedInterface.setType("com.some.service.or.other.serviceName");
1708         final String interfaceType = "normalizedServiceComponentName-interface";
1709         component.setInterfaces(new HashMap<>());
1710         component.getInterfaces().put(interfaceType, addedInterface);
1711         return component;
1712     }
1713
1714     private PropertyDefinition createMockProperty(String propertyName, String defaultValue){
1715         PropertyDefinition propertyDefinition = new PropertyDefinition();
1716         propertyDefinition.setName(propertyName);
1717         propertyDefinition.setType("string");
1718         propertyDefinition.setDefaultValue(defaultValue);
1719         return propertyDefinition;
1720     }
1721
1722     private InputDefinition createMockInput(String inputName, String defaultValue){
1723         InputDefinition inputDefinition = new InputDefinition();
1724         inputDefinition.setName(inputName);
1725         inputDefinition.setType("string");
1726         inputDefinition.setDefaultValue(defaultValue);
1727         return inputDefinition;
1728     }
1729
1730 }