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