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