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