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