catalog-be/src/test/java/org/openecomp/sdc/be/tosca/ToscaExportHandlerTest.java

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