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