2 * ============LICENSE_START=======================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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 * ================================================================================
23 package org.openecomp.sdc.be.tosca;
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;
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;
52 import java.util.stream.Collectors;
53 import mockit.Deencapsulation;
54 import org.apache.commons.collections.MapUtils;
55 import org.apache.commons.lang3.tuple.ImmutablePair;
56 import org.apache.commons.lang3.tuple.Triple;
57 import org.junit.jupiter.api.BeforeAll;
58 import org.junit.jupiter.api.BeforeEach;
59 import org.junit.jupiter.api.Test;
60 import org.mockito.InjectMocks;
61 import org.mockito.Mock;
62 import org.mockito.MockitoAnnotations;
63 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
64 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
65 import org.openecomp.sdc.be.datatypes.elements.CINodeFilterDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.PropertyFilterConstraintDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.PropertyFilterDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
72 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
73 import org.openecomp.sdc.be.datatypes.enums.ConstraintType;
74 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
75 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
76 import org.openecomp.sdc.be.exception.ToscaExportException;
77 import org.openecomp.sdc.be.model.ArtifactDefinition;
78 import org.openecomp.sdc.be.model.AttributeDefinition;
79 import org.openecomp.sdc.be.model.CapabilityDefinition;
80 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
81 import org.openecomp.sdc.be.model.Component;
82 import org.openecomp.sdc.be.model.ComponentInstance;
83 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
84 import org.openecomp.sdc.be.model.ComponentInstanceInput;
85 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
86 import org.openecomp.sdc.be.model.ComponentParametersView;
87 import org.openecomp.sdc.be.model.DataTypeDefinition;
88 import org.openecomp.sdc.be.model.GroupDefinition;
89 import org.openecomp.sdc.be.model.GroupInstance;
90 import org.openecomp.sdc.be.model.InputDefinition;
91 import org.openecomp.sdc.be.model.InterfaceDefinition;
92 import org.openecomp.sdc.be.model.OutputDefinition;
93 import org.openecomp.sdc.be.model.PropertyDefinition;
94 import org.openecomp.sdc.be.model.RelationshipInfo;
95 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
96 import org.openecomp.sdc.be.model.RequirementDefinition;
97 import org.openecomp.sdc.be.model.Resource;
98 import org.openecomp.sdc.be.model.Service;
99 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
100 import org.openecomp.sdc.be.model.category.CategoryDefinition;
101 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
102 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
103 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
104 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
105 import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
106 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
107 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
108 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
109 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
110 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
111 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
112 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
113 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
114 import org.openecomp.sdc.be.tosca.utils.InputConverter;
115 import org.openecomp.sdc.be.tosca.utils.OutputConverter;
116 import org.openecomp.sdc.common.test.BaseConfDependent;
118 class ToscaExportHandlerTest extends BaseConfDependent {
120 private static final String COMPONENT_PROPERTY_NAME = "prop1";
121 private static final String COMPONENT_PROPERTY_TYPE = "string";
122 private static final String COMPONENT_INPUT_NAME = "input1";
123 private static final String COMPONENT_OUTPUT_NAME = "output1";
124 private static final String COMPONENT_INPUT_TYPE = "integer";
125 private static final String COMPONENT_OUTPUT_TYPE = "integer";
126 private static final String RESOURCE_NAME = "resource";
127 private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
128 private static final String LOCAL_INTERFACE_TYPE = "Local";
129 public static final String UNIQUE_ID = "1L";
132 private ToscaExportHandler testSubject;
135 private ApplicationDataTypeCache applicationDataTypeCache;
138 private ToscaOperationFacade toscaOperationFacade;
141 private CapabilityRequirementConverter capabilityRequirementConverter;
144 private InputConverter inputConverter;
147 private OutputConverter outputConverter;
150 private GroupExportParser groupExportParser;
153 private PropertyConvertor propertyConvertor;
156 private GroupExportParserImpl groupExportParserImpl;
159 private InterfaceLifecycleOperation interfaceLifecycleOperation;
162 private InterfacesOperationsConverter interfacesOperationsConverter;
165 private PolicyExportParser policyExportParser;
168 private AttributeConverter attributeConverter;
171 public static void setupBeforeClass() {
172 componentName = "catalog-be";
173 confPath = "src/test/resources/config";
179 MockitoAnnotations.openMocks(this);
180 doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
181 doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter).getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean());
184 private Resource getNewResource() {
185 Resource resource = new Resource();
186 resource.setUniqueId("resourceUniqueId");
187 List<CategoryDefinition> categories = new ArrayList<>();
188 CategoryDefinition category = new CategoryDefinition();
189 List<SubCategoryDefinition> subcategories = new ArrayList<>();
190 SubCategoryDefinition subcategory = new SubCategoryDefinition();
191 List<DataTypeDefinition> dataTypes = new ArrayList<>();
192 DataTypeDefinition dataType = new DataTypeDefinition();
193 dataType.setName("dataTypeName");
194 dataType.setDerivedFromName("tosca.datatypes.Root");
195 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
199 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
200 dataType.setPropertiesData(propDataList);
201 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
202 .collect(Collectors.toList());
203 dataType.setProperties(propList);
204 dataTypes.add(dataType);
206 subcategory.setName("name");
207 subcategories.add(subcategory);
208 category.setName("name");
209 category.setSubcategories(subcategories);
210 categories.add(category);
212 final List<PropertyDefinition> properties = new ArrayList<>();
213 properties.add(new PropertyDefinition());
214 resource.setProperties(properties);
215 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
216 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
217 resource.setInterfaces(proxyInterfaces);
219 resource.setCategories(categories);
220 resource.setVersion("version");
221 resource.setVendorName("vendorName");
222 resource.setVendorRelease("vendorRelease");
223 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
224 resource.setDataTypes(dataTypes);
229 private Service getNewService() {
230 Service service = new Service();
231 List<CategoryDefinition> categories = new ArrayList<>();
232 CategoryDefinition category = new CategoryDefinition();
233 List<SubCategoryDefinition> subcategories = new ArrayList<>();
234 SubCategoryDefinition subcategory = new SubCategoryDefinition();
236 subcategory.setName("name");
237 subcategories.add(subcategory);
238 category.setName("name");
239 category.setSubcategories(subcategories);
240 categories.add(category);
242 service.setCategories(categories);
243 service.setComponentType(ComponentTypeEnum.SERVICE);
244 service.setServiceType("serviceType");
245 service.setServiceRole("serviceRole");
246 service.setEnvironmentContext("environmentContext");
252 void testExportComponent() {
253 Component component = getNewResource();
254 Either<ToscaRepresentation, ToscaError> result;
256 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
257 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
258 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
259 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
260 .thenReturn(Either.left(Collections.emptyMap()));
262 // default test when component is Resource
263 result = testSubject.exportComponent(component);
264 assertNotNull(result);
266 component = getNewService();
267 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
268 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
269 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
271 // default test when component is Service
272 result = testSubject.exportComponent(component);
273 assertNotNull(result);
277 void testExportComponentInterface() {
278 Resource component = getNewResource();
279 Either<ToscaRepresentation, ToscaError> result;
281 component.setInterfaces(new HashMap<>());
283 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
284 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
285 .thenReturn(Either.left(Collections.emptyMap()));
286 // default test when convertInterfaceNodeType is right
287 result = testSubject.exportComponentInterface(component, false);
288 assertNotNull(result);
290 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
291 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
292 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
294 // default test when convertInterfaceNodeType is left
295 result = testSubject.exportComponentInterface(component, false);
296 assertNotNull(result);
300 void testExportDataType() {
301 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
302 dataTypeDefinition.setUniqueId("uniqueId");
303 Either<ToscaRepresentation, ToscaError> result;
304 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
305 result = testSubject.exportDataType(dataTypeDefinition);
306 assertNotNull(result);
310 void testConvertInterfaceNodeTypeProperties() {
312 Resource component = getNewResource();
314 component.setInterfaces(new HashMap<>());
315 InputDefinition input = new InputDefinition();
316 input.setName(COMPONENT_INPUT_NAME);
317 input.setType(COMPONENT_INPUT_TYPE);
318 component.setInputs(Collections.singletonList(input));
319 PropertyDefinition property = new PropertyDefinition();
320 property.setName(COMPONENT_PROPERTY_NAME);
321 property.setType(COMPONENT_PROPERTY_TYPE);
322 component.setProperties(Collections.singletonList(property));
323 component.setName(RESOURCE_NAME);
324 component.setToscaResourceName(RESOURCE_NAME);
326 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
327 .thenReturn(Either.left(Collections.emptyMap()));
328 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
329 // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
330 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
331 any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
333 final var result = testSubject.convertInterfaceNodeType(new HashMap<String, Component>(), component,
334 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
335 assertNotNull(result);
336 assertTrue(result.isLeft());
337 Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
338 assertNotNull(nodeTypeMap);
339 assertEquals(1, nodeTypeMap.size());
340 ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
341 assertNotNull(toscaNodeType);
342 Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
343 // Check if inputs and properties in component are merged properly
344 assertNotNull(propertyMap);
345 assertEquals(1, propertyMap.size());
346 assertFalse(propertyMap.containsKey(COMPONENT_INPUT_NAME));
347 assertTrue(propertyMap.containsKey(COMPONENT_PROPERTY_NAME));
351 void testGetDependencies() {
353 Component component = new Resource();
354 Either<ToscaTemplate, ToscaError> result;
357 result = testSubject.getDependencies(component);
358 assertNotNull(result);
362 void testSetImports() {
363 Resource resource = new Resource();
364 resource.setResourceType(ResourceTypeEnum.PNF);
366 resource.setName("TestResourceName");
367 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
368 ArtifactDefinition artifact = new ArtifactDefinition();
369 artifact.setArtifactName("name.name2");
370 artifactList.put("assettoscatemplate", artifact);
371 resource.setArtifacts(artifactList);
372 resource.setToscaArtifacts(artifactList);
373 ToscaTemplate toscaTemplate = new ToscaTemplate("");
375 ComponentInstance ci = new ComponentInstance();
376 ci.setComponentUid("name");
377 ci.setOriginType(OriginTypeEnum.PNF);
378 ci.setSourceModelUid("modelName");
379 List<ComponentInstance> componentInstanceList = new LinkedList<>();
380 componentInstanceList.add(ci);
381 resource.setComponentInstances(componentInstanceList);
383 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(resource));
385 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
386 result = Deencapsulation.invoke(testSubject, "fillImports", resource, toscaTemplate);
388 verify(toscaOperationFacade, times(1)).getToscaFullElement("name");
389 assertTrue(result.isLeft());
390 ToscaTemplate toscaTemplateRes = result.left().value().left;
391 assertEquals(8, toscaTemplateRes.getImports().size());
392 assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface"));
393 assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName"));
394 assertEquals(1, toscaTemplateRes.getDependencies().size());
395 assertEquals("name.name2", toscaTemplateRes.getDependencies().get(0).getLeft());
399 void testConvertToscaTemplate() throws Exception {
401 final Component component = getNewResource();
402 final ToscaTemplate toscaNode = new ToscaTemplate("");
403 Either<ToscaTemplate, ToscaError> result;
404 final List<ComponentInstance> resourceInstances = new ArrayList<>();
405 final ComponentInstance instance = new ComponentInstance();
407 instance.setOriginType(OriginTypeEnum.SERVICE);
408 instance.setSourceModelUid("targetModelUid");
409 resourceInstances.add(instance);
411 component.setComponentInstances(resourceInstances);
413 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
414 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
416 final Map<String, ToscaProperty> map = new HashMap<>();
417 map.put("mock", new ToscaProperty());
418 doReturn(map).when(outputConverter).convert(any(), any());
421 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
422 assertNotNull(result);
426 void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException {
427 Component component = getNewResource();
428 ToscaTemplate toscaNode = new ToscaTemplate("");
429 component.setComponentInstances(new ArrayList<>());
431 List<GroupDefinition> groups = new ArrayList<>();
432 GroupDefinition group = new GroupDefinition();
433 List<String> artifacts = new ArrayList<>();
434 artifacts.add("artifact");
435 group.setType("org.openecomp.groups.VfModule");
436 group.setArtifacts(artifacts);
438 component.setGroups(groups);
440 final var input = new InputDefinition();
441 input.setName(COMPONENT_INPUT_NAME);
442 input.setType(COMPONENT_INPUT_TYPE);
443 component.setInputs(Collections.singletonList(input));
445 final var output = new OutputDefinition();
446 output.setName(COMPONENT_OUTPUT_NAME);
447 output.setType(COMPONENT_OUTPUT_TYPE);
448 component.setOutputs(Collections.singletonList(output));
450 Map<String, String[]> substitutionMappingMap = new HashMap<>();
451 String[] array = {"value1", "value2"};
452 substitutionMappingMap.put("key", array);
454 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(),
455 any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
457 when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
458 .thenReturn(Either.left(Collections.emptyMap()));
460 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
462 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
464 when(groupExportParser.getGroups(component)).thenReturn(null);
466 final Map<String, ToscaProperty> map = new HashMap<>();
467 map.put("mock", new ToscaProperty());
468 doReturn(map).when(outputConverter).convert(any(), any());
470 // test component contains group
471 final var result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
472 assertNotNull(result);
476 void testConvertToscaTemplateWhenComponentIsService() throws Exception {
477 Component component = getNewService();
478 ToscaTemplate toscaNode = new ToscaTemplate("");
479 Either<ToscaTemplate, ToscaError> result;
480 component.setComponentInstances(new ArrayList<>());
482 List<GroupDefinition> groups = new ArrayList<>();
483 GroupDefinition group = new GroupDefinition();
484 List<String> artifacts = new ArrayList<>();
485 artifacts.add("artifact");
486 group.setType("org.openecomp.groups.VfModule");
487 group.setArtifacts(artifacts);
489 component.setGroups(groups);
491 Map<String, String[]> substitutionMappingMap = new HashMap<>();
492 String[] array = {"value1", "value2"};
493 substitutionMappingMap.put("key", array);
495 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
496 .thenReturn(Either.left(substitutionMappingMap));
498 when(capabilityRequirementConverter
499 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
500 .thenReturn(Either.left(Collections.emptyMap()));
502 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
504 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
505 final Map<String, ToscaProperty> map = new HashMap<>();
506 map.put("mock", new ToscaProperty());
507 doReturn(map).when(outputConverter).convert(any(), any());
509 // test component contains group
510 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
511 assertNotNull(result);
515 void testConvertMetadata_1() {
517 Component component = getNewResource();
518 boolean isInstance = true;
519 ComponentInstance componentInstance = new ComponentInstance();
520 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
521 componentInstance.setSourceModelInvariant("targetModelInvariant");
524 Map<String, String> result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
525 assertNotNull(result);
529 void testFillImports() {
531 Component component = getNewService();
532 ToscaTemplate toscaTemplate = new ToscaTemplate("");
533 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
535 ComponentInstance instance = new ComponentInstance();
536 List<ComponentInstance> resourceInstances = new ArrayList<>();
537 instance.setComponentUid("name");
538 resourceInstances.add(instance);
539 component.setComponentInstances(resourceInstances);
540 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
541 ArtifactDefinition artifact = new ArtifactDefinition();
542 artifact.setArtifactName("name.name2");
543 toscaArtifacts.put("assettoscatemplate", artifact);
544 component.setToscaArtifacts(toscaArtifacts);
546 when(toscaOperationFacade.getToscaFullElement(any(String.class)))
547 .thenReturn(Either.left(component));
549 Resource baseType = getNewResource();
550 Map<String, ArtifactDefinition> baseTypeToscaArtifacts = new HashMap<>();
551 ArtifactDefinition baseTypeArtifact = new ArtifactDefinition();
552 baseTypeArtifact.setArtifactName("typeA");
553 baseTypeToscaArtifacts.put("assettoscatemplate", baseTypeArtifact);
554 baseType.setToscaArtifacts(baseTypeToscaArtifacts);
556 component.setDerivedFromGenericType("org.typeA");
557 component.setDerivedFromGenericVersion("1.0");
558 when(toscaOperationFacade.getByToscaResourceNameAndVersion("org.typeA", "1.0", null)).thenReturn(Either.left(baseType));
561 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
562 assertNotNull(result);
566 void testCreateDependency() {
568 Map<String, Component> componentCache = new HashMap<>();
569 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
570 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
571 ComponentInstance ci = new ComponentInstance();
572 Component component = getNewResource();
574 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
575 ArtifactDefinition artifact = new ArtifactDefinition();
576 artifact.setArtifactName("name.name2");
577 toscaArtifacts.put("assettoscatemplate", artifact);
578 component.setToscaArtifacts(toscaArtifacts);
579 ci.setComponentUid("name");
580 ci.setOriginType(OriginTypeEnum.ServiceProxy);
581 ci.setSourceModelUid("modelName");
583 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
585 when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service()));
588 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
589 assertFalse(componentCache.isEmpty());
593 void testGetInterfaceFilename() {
594 String artifactName = "artifact.name";
598 result = ToscaExportHandler.getInterfaceFilename(artifactName);
599 assertNotNull(result);
603 void testConvertNodeType() {
604 Component component = new Resource();
605 ToscaTemplate toscaNode = new ToscaTemplate("");
606 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
607 Either<ToscaTemplate, ToscaError> result;
609 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
610 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
611 .thenReturn(Either.left(Collections.emptyMap()));
613 result = Deencapsulation
614 .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
615 assertNotNull(result);
619 void testConvertInterfaceNodeType() {
620 Component component = getNewResource();
621 ToscaTemplate toscaNode = new ToscaTemplate("");
622 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
623 Either<ToscaTemplate, ToscaError> result;
624 List<InputDefinition> inputs = new ArrayList<>();
625 inputs.add(new InputDefinition());
626 component.setInputs(inputs);
628 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
629 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
630 .thenReturn(Either.left(Collections.emptyMap()));
632 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
633 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
636 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
638 assertNotNull(result);
642 void testConvertReqCapAndTypeName() {
643 Component component = new Resource();
644 ToscaTemplate toscaNode = new ToscaTemplate("");
645 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
646 ToscaNodeType toscaNodeType = new ToscaNodeType();
647 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
648 Either<ToscaTemplate, ToscaError> result;
651 capabilityRequirementConverter
652 .convertCapabilities(anyMap(), any(Resource.class), anyMap()))
653 .thenReturn(new HashMap<>());
655 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
656 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
659 result = Deencapsulation
660 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
661 toscaNodeType, dataTypes);
662 assertNotNull(result);
664 component = new Service();
666 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
667 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
669 // test when component is service
670 result = Deencapsulation
671 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
672 toscaNodeType, dataTypes);
673 assertNotNull(result);
677 void testConvertNodeTemplatesWhenComponentIsService() {
678 final Component component = getNewService();
679 final List<ComponentInstance> componentInstances = new ArrayList<>();
680 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
681 final Map<String, Component> componentCache = new HashMap<>();
682 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
683 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
684 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
685 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
686 final List<ComponentInstanceInput> inputs = new ArrayList<>();
687 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
688 componentInstanceInput.setUniqueId("uuid");
689 inputs.add(componentInstanceInput);
690 componentInstancesInputs.put("uuid", inputs);
691 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
692 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
693 reldef.setFromNode("node");
694 resourceInstancesRelations.add(reldef);
695 component.setComponentInstancesRelations(resourceInstancesRelations);
697 final ComponentInstance instance = new ComponentInstance();
698 instance.setUniqueId("id");
699 instance.setComponentUid("uid");
700 instance.setOriginType(OriginTypeEnum.ServiceProxy);
701 final List<GroupInstance> groupInstances = new ArrayList<>();
702 final GroupInstance groupInst = new GroupInstance();
703 final List<String> artifacts = new ArrayList<>();
704 artifacts.add("artifact");
705 groupInst.setArtifacts(artifacts);
706 groupInst.setType("type");
707 groupInstances.add(groupInst);
708 instance.setGroupInstances(groupInstances);
710 final List<PropertyDefinition> properties = new ArrayList<>();
711 properties.add(new PropertyDefinition());
712 instance.setProperties(properties);
714 instance.setUniqueId("uuid");
715 instance.setDescription("desc");
716 instance.setSourceModelUid("sourceModelUid");
718 componentInstances.add(instance);
720 component.setComponentInstances(componentInstances);
722 component.setComponentInstancesInputs(componentInstancesInputs);
723 component.setInvariantUUID("uuid");
724 component.setUUID("uuid");
725 component.setDescription("desc");
726 component.setUniqueId("uid");
728 componentCache.put("uid", component);
730 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
731 componentInstanceProperties.add(new ComponentInstanceProperty());
733 componentInstancesProperties.put("uuid", componentInstanceProperties);
734 component.setComponentInstancesProperties(componentInstancesProperties);
736 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
737 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
738 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
739 componentInstanceAttribute.setDefaultValue("def value");
740 componentInstanceAttributes.add(componentInstanceAttribute);
742 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
743 component.setComponentInstancesAttributes(componentInstancesAttributes);
745 ComponentInstanceProperty cip = new ComponentInstanceProperty();
746 cip.setInstanceUniqueId("id");
748 List<ComponentInstanceProperty> list = new ArrayList<>();
751 componentInstancesProperties.put("id", list);
752 component.setComponentInstancesProperties(componentInstancesProperties);
754 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
755 when(capabilityRequirementConverter
756 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
757 .thenReturn(Either.left(new ToscaNodeTemplate()));
758 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
759 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
760 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
761 .thenReturn(Either.left(new ToscaNodeType()));
762 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
763 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
764 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
765 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(getNewResource()));
767 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
768 final String[] array = {"value1", "value2"};
769 substitutionMappingMap.put("key", array);
770 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
771 .thenReturn(Either.left(substitutionMappingMap));
773 when(capabilityRequirementConverter
774 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
775 .thenReturn(Either.left(Collections.emptyMap()));
778 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
779 assertNotNull(toscaRepresentationToscaErrorEither);
784 void testConvertWithBooleanNodeFilterWhenComponentIsService() {
785 final Component component = getNewService();
786 final List<ComponentInstance> componentInstances = new ArrayList<>();
787 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
788 final Map<String, Component> componentCache = new HashMap<>();
789 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
790 final Map<String, CINodeFilterDataDefinition> componentInstanceNodeFilters = new HashMap<>();
791 CINodeFilterDataDefinition nodeFilter = new CINodeFilterDataDefinition();
792 PropertyFilterDataDefinition prop = new PropertyFilterDataDefinition();
793 prop.setName("nodeFilterPropBoolean");
794 prop.setType("boolean");
795 PropertyFilterConstraintDataDefinition constr = new PropertyFilterConstraintDataDefinition();
796 constr.setPropertyName(prop.getName());
797 constr.setOperator(ConstraintType.EQUAL);
798 constr.setValue("true");
799 constr.setOriginalType("boolean");
800 prop.setConstraints(List.of(constr));
801 ListDataDefinition<PropertyFilterDataDefinition> lstDataDef = new ListDataDefinition<>();
802 lstDataDef.add(prop);
803 nodeFilter.setProperties(lstDataDef);
804 final List<ComponentInstanceInput> inputs = new ArrayList<>();
805 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
806 componentInstanceInput.setUniqueId("uuid");
807 inputs.add(componentInstanceInput);
808 componentInstancesInputs.put("uuid", inputs);
809 componentInstanceNodeFilters.put("uuid", nodeFilter);
810 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
811 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
812 reldef.setFromNode("node");
813 resourceInstancesRelations.add(reldef);
814 component.setComponentInstancesRelations(resourceInstancesRelations);
816 final ComponentInstance instance = new ComponentInstance();
817 instance.setNodeFilter(nodeFilter);
818 instance.setUniqueId("id");
819 instance.setComponentUid("uid");
820 instance.setOriginType(OriginTypeEnum.ServiceProxy);
821 final List<GroupInstance> groupInstances = new ArrayList<>();
822 final GroupInstance groupInst = new GroupInstance();
823 final List<String> artifacts = new ArrayList<>();
824 artifacts.add("artifact");
825 groupInst.setArtifacts(artifacts);
826 groupInst.setType("type");
827 groupInstances.add(groupInst);
828 instance.setGroupInstances(groupInstances);
830 final List<PropertyDefinition> properties = new ArrayList<>();
831 properties.add(new PropertyDefinition());
832 instance.setProperties(properties);
834 instance.setUniqueId("uuid");
835 instance.setDescription("desc");
836 instance.setSourceModelUid("sourceModelUid");
838 componentInstances.add(instance);
840 component.setComponentInstances(componentInstances);
841 component.setNodeFilterComponents(componentInstanceNodeFilters);
842 component.setComponentInstancesInputs(componentInstancesInputs);
844 component.setInvariantUUID("uuid");
845 component.setUUID("uuid");
846 component.setDescription("desc");
847 component.setUniqueId("uid");
849 componentCache.put("uid", component);
851 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
852 componentInstanceProperties.add(new ComponentInstanceProperty());
854 componentInstancesProperties.put("uuid", componentInstanceProperties);
855 component.setComponentInstancesProperties(componentInstancesProperties);
857 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
858 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
859 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
860 componentInstanceAttribute.setDefaultValue("def value");
861 componentInstanceAttributes.add(componentInstanceAttribute);
863 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
864 component.setComponentInstancesAttributes(componentInstancesAttributes);
866 ComponentInstanceProperty cip = new ComponentInstanceProperty();
867 cip.setInstanceUniqueId("id");
869 List<ComponentInstanceProperty> list = new ArrayList<>();
872 componentInstancesProperties.put("id", list);
873 component.setComponentInstancesProperties(componentInstancesProperties);
875 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
876 when(capabilityRequirementConverter
877 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
878 .thenReturn(Either.left(new ToscaNodeTemplate()));
879 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
880 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
881 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
882 .thenReturn(Either.left(new ToscaNodeType()));
883 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
884 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
885 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
886 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(getNewResource()));
888 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
889 final String[] array = {"value1", "value2"};
890 substitutionMappingMap.put("key", array);
891 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
892 .thenReturn(Either.left(substitutionMappingMap));
894 when(capabilityRequirementConverter
895 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
896 .thenReturn(Either.left(Collections.emptyMap()));
899 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
900 assertNotNull(toscaRepresentationToscaErrorEither);
904 void testConvertNodeTemplatesWhenComponentIsResource() {
905 final Resource component = getNewResource();
906 component.setResourceType(VF);
907 final List<ComponentInstance> componentInstances = new ArrayList<>();
908 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
909 final Map<String, Component> componentCache = new HashMap<>();
910 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
911 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
912 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
913 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
914 final List<ComponentInstanceInput> inputs = new ArrayList<>();
915 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
916 componentInstanceInput.setUniqueId("uuid");
917 inputs.add(componentInstanceInput);
918 componentInstancesInputs.put("uuid", inputs);
919 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
920 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
921 reldef.setFromNode("node");
922 resourceInstancesRelations.add(reldef);
923 component.setComponentInstancesRelations(resourceInstancesRelations);
925 final ComponentInstance instance = new ComponentInstance();
926 instance.setUniqueId("id");
927 instance.setComponentUid("uid");
928 instance.setOriginType(OriginTypeEnum.VFC);
929 final List<GroupInstance> groupInstances = new ArrayList<>();
930 final GroupInstance groupInst = new GroupInstance();
931 final List<String> artifacts = new ArrayList<>();
932 artifacts.add("artifact");
933 groupInst.setArtifacts(artifacts);
934 groupInst.setType("type");
935 groupInstances.add(groupInst);
936 instance.setGroupInstances(groupInstances);
938 final List<PropertyDefinition> properties = new ArrayList<>();
939 properties.add(new PropertyDefinition());
940 instance.setProperties(properties);
941 component.setProperties(properties);
943 instance.setUniqueId("uuid");
944 instance.setDescription("desc");
945 instance.setSourceModelUid("sourceModelUid");
946 final Map<String, ArtifactDefinition> artifactList = new HashMap<>();
947 final ArtifactDefinition artifact = new ArtifactDefinition();
948 artifact.setArtifactName("name.name2");
949 artifactList.put("assettoscatemplate", artifact);
950 instance.setArtifacts(artifactList);
952 Map<String, ToscaArtifactDataDefinition> toscaArtifactDataDefinitionMap = new HashMap<>();
953 toscaArtifactDataDefinitionMap.put("assettoscatemplate", new ToscaArtifactDataDefinition());
954 instance.setToscaArtifacts(toscaArtifactDataDefinitionMap);
956 componentInstances.add(instance);
958 component.setComponentInstances(componentInstances);
960 component.setComponentInstancesInputs(componentInstancesInputs);
961 component.setInvariantUUID("uuid");
962 component.setUUID("uuid");
963 component.setDescription("desc");
964 component.setUniqueId("uid");
966 componentCache.put("uid", component);
968 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
969 componentInstanceProperties.add(new ComponentInstanceProperty());
971 componentInstancesProperties.put("uuid", componentInstanceProperties);
972 component.setComponentInstancesProperties(componentInstancesProperties);
974 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
975 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
976 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
977 componentInstanceAttribute.setDefaultValue("def value");
978 componentInstanceAttributes.add(componentInstanceAttribute);
980 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
981 component.setComponentInstancesAttributes(componentInstancesAttributes);
983 component.setArtifacts(artifactList);
984 component.setToscaArtifacts(artifactList);
986 final List<AttributeDefinition> attributes = new ArrayList<>();
987 final var attribute = new AttributeDefinition();
988 attribute.setName("mock");
989 attributes.add(attribute);
990 component.setAttributes(attributes);
992 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
993 componentInstanceInputs.add(new ComponentInstanceInput());
995 componentInstancesInputs.put("id", componentInstanceInputs);
996 component.setComponentInstancesInputs(componentInstancesInputs);
998 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
999 when(capabilityRequirementConverter
1000 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
1001 .thenReturn(Either.left(new ToscaNodeTemplate()));
1002 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1003 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1004 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
1005 .thenReturn(Either.left(new ToscaNodeType()));
1006 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
1007 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
1008 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
1010 Resource newResource = getNewResource();
1011 InputDefinition input = new InputDefinition();
1012 input.setName(COMPONENT_INPUT_NAME);
1013 input.setType(COMPONENT_INPUT_TYPE);
1014 newResource.setInputs(Collections.singletonList(input));
1016 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(newResource));
1018 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
1019 final String[] array = {"value1", "value2"};
1020 substitutionMappingMap.put("key", array);
1021 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
1022 .thenReturn(Either.left(substitutionMappingMap));
1024 when(capabilityRequirementConverter
1025 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
1026 .thenReturn(Either.left(Collections.emptyMap()));
1029 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(newResource);
1030 assertNotNull(toscaRepresentationToscaErrorEither);
1035 void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() {
1036 Component component = getNewResource();
1037 List<ComponentInstance> componentInstances = new ArrayList<>();
1038 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
1039 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
1040 Map<String, Component> componentCache = new HashMap<>();
1041 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1042 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
1043 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
1044 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
1045 List<ComponentInstanceInput> inputs = new ArrayList<>();
1046 inputs.add(new ComponentInstanceInput());
1047 componentInstancesInputs.put("key", inputs);
1048 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
1049 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1050 reldef.setFromNode("node");
1051 resourceInstancesRelations.add(reldef);
1052 component.setComponentInstancesRelations(resourceInstancesRelations);
1054 ComponentInstance instance = new ComponentInstance();
1055 instance.setUniqueId("id");
1056 instance.setComponentUid("uid");
1057 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1058 componentInstances.add(instance);
1059 component.setComponentInstances(componentInstances);
1061 component.setComponentInstancesInputs(componentInstancesInputs);
1062 component.setInvariantUUID("uuid");
1063 component.setUUID("uuid");
1064 component.setDescription("desc");
1066 componentCache.put("uid", component);
1068 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
1069 when(capabilityRequirementConverter
1070 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
1071 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
1072 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1073 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1074 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1075 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1078 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
1079 assertNotNull(toscaRepresentationToscaErrorEither);
1083 void testConvetNodeTemplateWhenGetOriginComponentIsRight() {
1084 Component component = getNewResource();
1085 List<ComponentInstance> componentInstances = new ArrayList<>();
1086 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
1087 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
1088 Map<String, Component> componentCache = new HashMap<>();
1089 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1090 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
1091 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
1092 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
1093 List<ComponentInstanceInput> inputs = new ArrayList<>();
1094 inputs.add(new ComponentInstanceInput());
1095 componentInstancesInputs.put("key", inputs);
1096 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
1097 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1098 reldef.setFromNode("id");
1099 resourceInstancesRelations.add(reldef);
1100 component.setComponentInstancesRelations(resourceInstancesRelations);
1102 ComponentInstance instance = new ComponentInstance();
1103 instance.setUniqueId("id");
1104 instance.setComponentUid("uid");
1105 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1106 componentInstances.add(instance);
1107 component.setComponentInstances(componentInstances);
1109 component.setComponentInstancesInputs(componentInstancesInputs);
1110 component.setInvariantUUID("uuid");
1111 component.setUUID("uuid");
1112 component.setDescription("desc");
1114 final List<AttributeDefinition> attributes = new ArrayList<>();
1115 final var attribute = new AttributeDefinition();
1116 attribute.setName("mock");
1117 attributes.add(attribute);
1118 component.setAttributes(attributes);
1120 componentCache.put("uid", component);
1122 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
1123 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1124 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1125 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1126 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1129 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
1130 assertNotNull(toscaRepresentationToscaErrorEither);
1134 void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
1135 Resource component = getNewResource();
1136 component.setResourceType(VF);
1137 List<ComponentInstance> componentInstances = new ArrayList<>();
1138 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
1139 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
1140 Map<String, Component> componentCache = new HashMap<>();
1141 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1142 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
1143 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
1144 List<ComponentInstanceInput> inputs = new ArrayList<>();
1145 inputs.add(new ComponentInstanceInput());
1146 componentInstancesInputs.put("key", inputs);
1147 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
1148 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1149 reldef.setFromNode("id");
1150 reldef.setToNode("node");
1151 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1152 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1153 relationship.setRelation(new RelationshipInfo());
1154 relationships.add(relationship);
1155 reldef.setRelationships(relationships);
1156 resourceInstancesRelations.add(reldef);
1157 component.setComponentInstancesRelations(resourceInstancesRelations);
1159 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
1160 ArtifactDefinition artifact = new ArtifactDefinition();
1161 artifact.setArtifactName("name.name2");
1162 artifactList.put("assettoscatemplate", artifact);
1163 component.setArtifacts(artifactList);
1164 component.setToscaArtifacts(artifactList);
1166 ComponentInstance instance = new ComponentInstance();
1167 instance.setUniqueId("id");
1168 instance.setComponentUid("id");
1169 instance.setOriginType(OriginTypeEnum.VF);
1170 componentInstances.add(instance);
1171 component.setComponentInstances(componentInstances);
1173 component.setComponentInstancesInputs(componentInstancesInputs);
1174 component.setComponentInstances(componentInstances);
1176 doReturn(Either.left(component)).when(toscaOperationFacade).getToscaFullElement("id");
1177 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
1178 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1179 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1180 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1181 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1182 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1183 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1186 final Either<ToscaRepresentation, ToscaError> result = testSubject.exportComponent(component);
1187 assertNotNull(result);
1191 void testCreateNodeType() {
1193 Component component = new Resource();
1194 List<String> array = new ArrayList<>();
1196 ((Resource) component).setDerivedFrom(array);
1197 ToscaNodeType result;
1199 // test when component is resource
1200 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1201 assertNotNull(result);
1203 component = new Service();
1204 // test when component is service
1205 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1206 assertNotNull(result);
1210 void testCreateProxyInterfaceTypesComponentNotFound() {
1211 Component container = new Service();
1212 Either<Map<String, ToscaNodeType>, ToscaError> result;
1213 List<ComponentInstance> componentInstances = new ArrayList<>();
1214 ComponentInstance instance = new ComponentInstance();
1215 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1216 instance.setSourceModelUid("targetModelUid");
1217 instance.setToscaComponentName("toscaComponentName");
1219 componentInstances.add(instance);
1220 container.setComponentInstances(componentInstances);
1221 when(toscaOperationFacade.getToscaElement(any(String.class),
1222 any(ComponentParametersView.class)))
1223 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1224 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1225 assertTrue(result.isRight());
1229 void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
1230 Component container = new Service();
1231 Either<Map<String, ToscaNodeType>, ToscaError> result;
1232 List<ComponentInstance> componentInstances = new ArrayList<>();
1233 ComponentInstance instance = new ComponentInstance();
1234 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1235 instance.setSourceModelUid("targetModelUid");
1236 instance.setToscaComponentName("toscaComponentName");
1237 componentInstances.add(instance);
1238 container.setComponentInstances(componentInstances);
1240 when(toscaOperationFacade.getToscaElement(any(String.class),
1241 any(ComponentParametersView.class)))
1242 .thenReturn(Either.left(new Resource()));
1243 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1244 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1245 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1246 assertTrue(result.isRight());
1250 void testCreateProxyInterfaceTypesPositive() {
1251 Component container = new Service();
1252 Either<Map<String, ToscaNodeType>, ToscaError> result;
1253 List<ComponentInstance> componentInstances = new ArrayList<>();
1254 ComponentInstance instance = new ComponentInstance();
1255 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1256 instance.setSourceModelUid("targetModelUid");
1257 instance.setToscaComponentName("toscaComponentName");
1258 componentInstances.add(instance);
1259 container.setComponentInstances(componentInstances);
1261 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1263 Component proxyResource = new Resource();
1264 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1265 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1266 proxyResource.setInterfaces(proxyInterfaces);
1267 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(proxyResource));
1268 when(interfacesOperationsConverter.addInterfaceTypeElement(any(Component.class), anyList()))
1269 .thenReturn(Collections.singletonMap(LOCAL_INTERFACE_TYPE, new HashMap<>()));
1271 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1272 assertNotNull(result);
1273 assertTrue(result.isLeft());
1274 assertEquals(1, result.left().value().size());
1278 void testCreateProxyNodeTypes() {
1279 Map<String, Component> componentCache = new HashMap<>();
1280 Component container = new Resource();
1281 Either<Map<String, ToscaNodeType>, ToscaError> result;
1282 List<ComponentInstance> componentInstances = new ArrayList<>();
1283 ComponentInstance instance = new ComponentInstance();
1284 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1285 instance.setSourceModelUid("targetModelUid");
1287 componentInstances.add(instance);
1288 container.setComponentInstances(componentInstances);
1290 when(toscaOperationFacade.getLatestByName("serviceProxy", null))
1291 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1293 // test when getLatestByName return is right
1294 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1295 assertNotNull(result);
1299 void testCreateServiceSubstitutionNodeTypes() {
1300 Map<String, Component> componentCache = new HashMap<>();
1302 Component referencedService = getNewService();
1303 referencedService.setInvariantUUID("uuid");
1304 referencedService.setUUID("uuid");
1305 referencedService.setUniqueId("targetModelUid");
1306 referencedService.setDescription("desc");
1307 componentCache.put("targetModelUid", referencedService);
1309 Component containerService = new Service();
1310 List<ComponentInstance> componentInstances = new ArrayList<>();
1311 ComponentInstance instance = new ComponentInstance();
1312 instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1313 instance.setSourceModelUid("targetModelUid");
1315 componentInstances.add(instance);
1316 containerService.setComponentInstances(componentInstances);
1318 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1319 .thenReturn(Either.left(Collections.emptyMap()));
1320 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1321 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
1322 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1324 ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1326 Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1327 assertNotNull(toscaNode.getNode_types());
1331 void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1332 Map<String, Component> componentCache = new HashMap<>();
1333 Component container = new Resource();
1334 Either<Map<String, ToscaNodeType>, ToscaError> result;
1335 List<ComponentInstance> componentInstances = new ArrayList<>();
1336 ComponentInstance instance = new ComponentInstance();
1337 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1338 instance.setSourceModelUid("targetModelUid");
1340 componentInstances.add(instance);
1341 container.setComponentInstances(componentInstances);
1343 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
1345 ComponentParametersView parameterView = new ComponentParametersView();
1346 parameterView.disableAll();
1347 parameterView.setIgnoreCategories(false);
1349 when(toscaOperationFacade.getToscaElement(any(String.class),
1350 any(ComponentParametersView.class)))
1351 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1353 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1355 // test when getLatestByName is left
1356 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1357 assertNotNull(result);
1361 void testCreateProxyNodeType() {
1362 Map<String, Component> componentCache = new HashMap<>();
1363 Component origComponent = new Resource();
1364 Component proxyComponent = new Resource();
1365 ComponentInstance instance = new ComponentInstance();
1366 ToscaNodeType result;
1368 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1371 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1372 proxyComponent, instance);
1373 assertNotNull(result);
1377 void testConvertComponentInstanceRequirements() {
1378 Component component = new Resource();
1379 ComponentInstance componentInstance = new ComponentInstance();
1380 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1381 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1382 Component originComponent = new Resource();
1383 Map<String, Component> componentCache = new HashMap<>();
1384 Either<ToscaNodeTemplate, ToscaError> result;
1387 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1388 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1389 assertNotNull(result);
1391 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1392 reldef.setFromNode("name");
1393 reldef.setToNode("name1");
1394 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1395 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1396 cap.setRelation(new RelationshipInfo());
1397 relationships.add(cap);
1398 reldef.setRelationships(relationships);
1399 relations.add(reldef);
1400 componentInstance.setUniqueId("name");
1402 List<ComponentInstance> instances = new ArrayList<>();
1403 instances.add(componentInstance);
1404 component.setComponentInstances(instances);
1406 // test when filteredRElations ins't empty
1407 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1408 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1409 assertNotNull(result);
1413 void buildRequirementFailure() {
1414 final Component fromOriginComponent = new Resource();
1415 final ComponentInstance fromInstance = new ComponentInstance();
1416 final String fromInstanceUid = "fromInstanceUid";
1417 fromInstance.setUniqueId(fromInstanceUid);
1418 fromInstance.setComponentUid("componentUid");
1419 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1420 relationshipDefinition.setToNode("wrongNodeUid");
1421 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1422 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1423 relationship.setRequirement(new RequirementDataDefinition());
1424 relationshipList.add(relationship);
1425 relationshipDefinition.setRelationships(relationshipList);
1426 final List<ComponentInstance> instancesList = new ArrayList<>();
1427 instancesList.add(fromInstance);
1428 String expectedError = String
1429 .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1430 relationshipDefinition.getToNode());
1431 assertThrows(ToscaExportException.class, () ->
1432 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1433 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1436 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1437 instancesList, relationshipDefinition, new HashMap<>());
1438 } catch (Exception e) {
1439 assertTrue(e instanceof ToscaExportException);
1440 assertEquals(expectedError, e.getMessage());
1443 final RelationshipInfo relation = new RelationshipInfo();
1444 final String requirementUid = "Uid";
1445 relation.setRequirementUid(requirementUid);
1446 final String requirementName = "requirementName";
1447 relation.setRequirement(requirementName);
1448 final String capabilityName = "capabilityName";
1449 relation.setCapability(capabilityName);
1450 final String capabilityOwnerId = "capabilityOwnerId";
1451 relation.setCapabilityOwnerId(capabilityOwnerId);
1452 relationship.setRelation(relation);
1454 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1455 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1456 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1457 fromOriginComponent.setRequirements(requirementMap);
1458 relationshipDefinition.setToNode(fromInstanceUid);
1460 expectedError = String
1461 .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1462 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1464 assertThrows(ToscaExportException.class, () ->
1465 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1466 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1468 requirementDefinition.setName(requirementName);
1470 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1471 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1473 expectedError = String.format(
1474 "Failed to build substituted name for the requirement %s. "
1475 + "Failed to get an origin component with uniqueId %s",
1476 requirementName, fromInstance.getActualComponentUid());
1477 assertThrows(ToscaExportException.class, () -> Deencapsulation
1478 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1479 relationshipDefinition, new HashMap<>()), expectedError);
1481 final Component toOriginComponent = new Resource();
1482 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1483 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1485 capabilityDefinition.setName(capabilityName);
1486 capabilityDefinition.setOwnerId(capabilityOwnerId);
1487 capabilityDefinition.setType("aType");
1488 final String capabilityPreviousName = "capabilityPreviousName";
1489 capabilityDefinition.setPreviousName(capabilityPreviousName);
1490 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1491 toOriginComponent.setCapabilities(capabilityMap);
1492 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1493 .thenReturn(Either.left(toOriginComponent));
1495 requirementDefinition.setCapability(capabilityName);
1496 relation.setCapability("wrong");
1497 final String requirementPreviousName = "requirementPreviousName";
1498 requirementDefinition.setPreviousName(requirementPreviousName);
1499 requirementDefinition.setPath(new ArrayList<>());
1501 expectedError = String
1502 .format("Failed to find a capability with name %s on a component with uniqueId %s",
1503 relation.getCapability(), fromOriginComponent.getUniqueId());
1505 assertThrows(ToscaExportException.class, () -> Deencapsulation
1506 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1507 relationshipDefinition, new HashMap<>()),
1512 void testBuildRequirement() {
1513 final ComponentInstance fromInstance = new ComponentInstance();
1514 fromInstance.setUniqueId("name");
1515 fromInstance.setComponentUid("string");
1516 final List<ComponentInstance> instancesList = new ArrayList<>();
1518 final Map<String, Component> componentCache = new HashMap<>();
1519 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1520 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1521 relationship.setRequirement(new RequirementDataDefinition());
1522 final RelationshipInfo relation = new RelationshipInfo();
1523 final String requirementUid = "Uid";
1524 relation.setRequirementUid(requirementUid);
1525 final String requirementName = "requirementName";
1526 relation.setRequirement(requirementName);
1527 final String capabilityName = "capabilityName";
1528 relation.setCapability(capabilityName);
1529 final String capabilityOwnerId = "capabilityOwnerId";
1530 relation.setCapabilityOwnerId(capabilityOwnerId);
1531 relationship.setRelation(relation);
1532 relationshipList.add(relationship);
1533 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1534 relationshipDefinition.setRelationships(relationshipList);
1535 relationshipDefinition.setToNode("name");
1536 instancesList.add(fromInstance);
1537 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1538 requirementDefinition.setName(requirementName);
1539 requirementDefinition.setCapability(capabilityName);
1540 final String requirementPreviousName = "requirementPreviousName";
1541 requirementDefinition.setPreviousName(requirementPreviousName);
1542 requirementDefinition.setPath(new ArrayList<>());
1543 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1544 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1545 final Component fromOriginComponent = new Resource();
1546 fromOriginComponent.setRequirements(requirementMap);
1548 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1549 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1550 capabilityDefinition.setName(capabilityName);
1551 capabilityDefinition.setOwnerId(capabilityOwnerId);
1552 final String capabilityPreviousName = "capabilityPreviousName";
1553 capabilityDefinition.setPreviousName(capabilityPreviousName);
1554 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1555 final Component toOriginComponent = new Resource();
1556 toOriginComponent.setCapabilities(capabilityMap);
1558 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1559 .thenReturn(Either.left(toOriginComponent));
1560 final String builtCapabilityName = "builtCapabilityName";
1562 capabilityRequirementConverter
1563 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1564 capabilityPreviousName), any()))
1565 .thenReturn(Either.left(builtCapabilityName));
1567 final String builtRequirementName = "builtRequirementName";
1569 capabilityRequirementConverter
1570 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1571 requirementPreviousName), any()))
1572 .thenReturn(Either.left(builtRequirementName));
1574 final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1575 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1576 instancesList, relationshipDefinition, componentCache);
1577 assertNotNull(actualRequirementMap);
1578 assertFalse(actualRequirementMap.isEmpty());
1579 assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1580 final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1581 assertNotNull(actualToscaTemplateRequirement);
1582 assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1584 //to toOriginComponent not found
1585 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1586 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1588 assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1589 instancesList, relationshipDefinition, componentCache));
1593 void testAddRequirmentsWithBuildAndAddRequirements() {
1594 ComponentInstance fromInstance = new ComponentInstance();
1595 Component fromOriginComponent = new Resource();
1596 List<ComponentInstance> instancesList = new ArrayList<>();
1597 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1598 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1599 Map<String, Component> componentCache = new HashMap<>();
1601 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1602 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1603 cap.setRequirement(new RequirementDataDefinition());
1604 RelationshipInfo relation = new RelationshipInfo();
1605 relation.setRequirementUid("Uid");
1606 relation.setRequirement("requirment");
1607 relation.setCapability("cap");
1608 relation.setCapabilityOwnerId("id");
1609 cap.setRelation(relation);
1610 relationships.add(cap);
1611 rel.setRelationships(relationships);
1612 rel.setToNode("name");
1613 fromInstance.setUniqueId("name");
1614 fromInstance.setComponentUid("string");
1615 instancesList.add(fromInstance);
1616 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1618 List<RequirementDefinition> defs = new ArrayList<>();
1619 RequirementDefinition def = new RequirementDefinition();
1620 def.setName("requirment");
1621 def.setCapability("cap");
1623 requirements.put("key", defs);
1624 fromOriginComponent.setRequirements(requirements);
1626 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1627 List<CapabilityDefinition> caps = new ArrayList<>();
1628 CapabilityDefinition capdef = new CapabilityDefinition();
1629 capdef.setOwnerId("id");
1630 capdef.setName("cap");
1631 capdef.setPreviousName("before cap");
1632 capdef.setType("type");
1634 capabilities.put("cap", caps);
1635 fromOriginComponent.setCapabilities(capabilities);
1637 when(toscaOperationFacade.getToscaElement(any(String.class),
1638 any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1641 capabilityRequirementConverter
1642 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString(), any()))
1643 .thenReturn(Either.right(false));
1645 final String expectedErrorMsg =
1646 String.format("Failed to build a substituted capability name for the capability "
1647 + "with name %s on a component with uniqueId %s",
1648 cap.getRequirement(), fromOriginComponent.getUniqueId());
1650 assertThrows(ToscaExportException.class, () ->
1651 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1652 rel, componentCache), expectedErrorMsg);
1656 void testBuildAndAddRequirement() {
1657 Component fromOriginComponent = new Resource();
1658 Component toOriginComponent = new Resource();
1659 CapabilityDefinition capability = new CapabilityDefinition();
1660 RequirementDefinition requirement = new RequirementDefinition();
1661 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1662 ComponentInstance toInstance = new ComponentInstance();
1663 Map<String, Component> componentCache = new HashMap<>();
1664 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1665 capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1666 capability.setPath(new ArrayList<>());
1667 capability.setPreviousName("before cap");
1668 reqAndRelationshipPair.setCapability("cap");
1669 requirement.setPath(new ArrayList<>());
1670 requirement.setPreviousName("before req");
1671 reqAndRelationshipPair.setRequirement("req");
1674 capabilityRequirementConverter
1675 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString(), any()))
1676 .thenReturn(Either.left("buildCapNameRes"));
1679 capabilityRequirementConverter
1680 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString(), any()))
1681 .thenReturn(Either.left("buildReqNameRes"));
1684 final Map<String, ToscaTemplateRequirement> requirementMap =
1685 Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1686 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1687 assertNotNull(requirementMap);
1688 assertFalse(requirementMap.isEmpty());
1689 assertTrue(requirementMap.containsKey("buildReqNameRes"));
1690 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1691 assertNotNull(actualToscaTemplateRequirement);
1692 assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1696 void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1697 final Component fromOriginComponent = new Resource();
1698 final Component toOriginComponent = new Resource();
1699 final CapabilityDefinition capability = new CapabilityDefinition();
1700 final RequirementDefinition requirement = new RequirementDefinition();
1701 final RelationshipInfo relationship = new RelationshipInfo();
1702 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1703 capabilityRequirementRelationship.setRelation(relationship);
1704 ComponentInstance toInstance = new ComponentInstance();
1705 Map<String, Component> componentCache = new HashMap<>();
1706 capability.setPath(new ArrayList<>());
1707 relationship.setCapability("cap");
1708 requirement.setPath(new ArrayList<>());
1709 relationship.setRequirement("req");
1711 final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1712 when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("cap"), any(), any()))
1713 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1714 when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("req"), any(), any()))
1715 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1717 final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1718 .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1719 capabilityRequirementRelationship, toInstance, componentCache);
1720 assertNotNull(requirementMap);
1721 assertFalse(requirementMap.isEmpty());
1722 assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1723 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1724 assertNotNull(actualToscaTemplateRequirement);
1725 assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1729 void testIsRequirementBelongToRelation() {
1731 Component originComponent = new Resource();
1732 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1733 RequirementDefinition requirement = new RequirementDefinition();
1734 String fromInstanceId = "";
1737 requirement.setName("name");
1738 reqAndRelationshipPair.setRequirement("name1");
1740 // test return false
1741 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1742 reqAndRelationshipPair, requirement, fromInstanceId);
1743 assertFalse(result);
1747 void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1749 Component originComponent = new Service();
1750 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1751 RequirementDefinition requirement = new RequirementDefinition();
1752 requirement.setUniqueId(UNIQUE_ID);
1753 reqAndRelationshipPair.setRequirementUid(UNIQUE_ID);
1754 String fromInstanceId = "";
1757 // default test return true
1758 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1759 reqAndRelationshipPair, requirement, fromInstanceId);
1764 void testIsRequirementBelongToOwner() {
1766 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1767 RequirementDefinition requirement = new RequirementDefinition();
1768 String fromInstanceId = "";
1769 Component originComponent = new Resource();
1772 requirement.setOwnerId("owner1");
1773 reqAndRelationshipPair.setRequirementOwnerId("owner");
1776 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1777 fromInstanceId, originComponent);
1778 assertFalse(result);
1784 Component component = new Service();
1787 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1788 assertFalse(result);
1792 void testConvertCapabilities() {
1793 final Component component = new Resource();
1794 final Map<String, Component> componentCache = new HashMap<>();
1796 final Either<Map<String, String[]>, ToscaError> expectedResult = Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR);
1797 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1798 .thenReturn(expectedResult);
1800 // default test return isRight
1801 final Either<Map<String, String[]>, ToscaError> actualResult =
1802 Deencapsulation.invoke(testSubject, "convertSubstitutionMappingCapabilities", component, componentCache);
1803 assertNotNull(actualResult);
1804 assertEquals(expectedResult, actualResult);
1808 void testConvertCapabilities_1() {
1809 Component component = new Resource();
1810 ToscaNodeType nodeType = new ToscaNodeType();
1811 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1812 Either<ToscaNodeType, ToscaError> result;
1814 Map<String, ToscaCapability> capabilities = new HashMap<>();
1815 capabilities.put("key", new ToscaCapability());
1818 result = Deencapsulation
1819 .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1820 assertNotNull(result);
1824 void testConvertToNodeTemplateArtifacts() {
1825 Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1826 ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1827 art.setFile("test_file");
1828 art.setType("test_type");
1829 Map<String, ToscaTemplateArtifact> result;
1830 container.put("test_art", art);
1831 result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1832 assertNotNull(result);
1833 assertTrue(MapUtils.isNotEmpty(result));
1834 assertEquals("test_file", result.get("test_art").getFile());
1835 assertEquals("test_type", result.get("test_art").getType());
1838 private Component getTestComponent() {
1839 Component component = new Service();
1840 component.setUniqueId("serviceUniqueId");
1841 component.setNormalizedName("normalizedServiceComponentName");
1842 InterfaceDefinition addedInterface = new InterfaceDefinition();
1843 addedInterface.setType("com.some.service.or.other.serviceName");
1844 final String interfaceType = "normalizedServiceComponentName-interface";
1845 component.setInterfaces(new HashMap<>());
1846 component.getInterfaces().put(interfaceType, addedInterface);
1850 private PropertyDefinition createMockProperty(String propertyName, String defaultValue) {
1851 PropertyDefinition propertyDefinition = new PropertyDefinition();
1852 propertyDefinition.setName(propertyName);
1853 propertyDefinition.setType("string");
1854 propertyDefinition.setDefaultValue(defaultValue);
1855 return propertyDefinition;
1858 private InputDefinition createMockInput(String inputName, String defaultValue) {
1859 InputDefinition inputDefinition = new InputDefinition();
1860 inputDefinition.setName(inputName);
1861 inputDefinition.setType("string");
1862 inputDefinition.setDefaultValue(defaultValue);
1863 return inputDefinition;