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.PropertyDataDefinition;
66 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
68 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
69 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
70 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
71 import org.openecomp.sdc.be.exception.ToscaExportException;
72 import org.openecomp.sdc.be.model.ArtifactDefinition;
73 import org.openecomp.sdc.be.model.AttributeDefinition;
74 import org.openecomp.sdc.be.model.CapabilityDefinition;
75 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
76 import org.openecomp.sdc.be.model.Component;
77 import org.openecomp.sdc.be.model.ComponentInstance;
78 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
79 import org.openecomp.sdc.be.model.ComponentInstanceInput;
80 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
81 import org.openecomp.sdc.be.model.ComponentParametersView;
82 import org.openecomp.sdc.be.model.DataTypeDefinition;
83 import org.openecomp.sdc.be.model.GroupDefinition;
84 import org.openecomp.sdc.be.model.GroupInstance;
85 import org.openecomp.sdc.be.model.InputDefinition;
86 import org.openecomp.sdc.be.model.InterfaceDefinition;
87 import org.openecomp.sdc.be.model.OutputDefinition;
88 import org.openecomp.sdc.be.model.PropertyDefinition;
89 import org.openecomp.sdc.be.model.RelationshipInfo;
90 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
91 import org.openecomp.sdc.be.model.RequirementDefinition;
92 import org.openecomp.sdc.be.model.Resource;
93 import org.openecomp.sdc.be.model.Service;
94 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
95 import org.openecomp.sdc.be.model.category.CategoryDefinition;
96 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
97 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
98 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
99 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
100 import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
101 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
102 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
103 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
104 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
105 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
106 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
107 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
108 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
109 import org.openecomp.sdc.be.tosca.utils.InputConverter;
110 import org.openecomp.sdc.be.tosca.utils.OutputConverter;
111 import org.openecomp.sdc.common.test.BaseConfDependent;
113 class ToscaExportHandlerTest extends BaseConfDependent {
115 private static final String COMPONENT_PROPERTY_NAME = "prop1";
116 private static final String COMPONENT_PROPERTY_TYPE = "string";
117 private static final String COMPONENT_INPUT_NAME = "input1";
118 private static final String COMPONENT_OUTPUT_NAME = "output1";
119 private static final String COMPONENT_INPUT_TYPE = "integer";
120 private static final String COMPONENT_OUTPUT_TYPE = "integer";
121 private static final String RESOURCE_NAME = "resource";
122 private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
123 private static final String LOCAL_INTERFACE_TYPE = "Local";
124 public static final String UNIQUE_ID = "1L";
127 private ToscaExportHandler testSubject;
130 private ApplicationDataTypeCache applicationDataTypeCache;
133 private ToscaOperationFacade toscaOperationFacade;
136 private CapabilityRequirementConverter capabilityRequirementConverter;
139 private InputConverter inputConverter;
142 private OutputConverter outputConverter;
145 private GroupExportParser groupExportParser;
148 private PropertyConvertor propertyConvertor;
151 private GroupExportParserImpl groupExportParserImpl;
154 private InterfaceLifecycleOperation interfaceLifecycleOperation;
157 private InterfacesOperationsConverter interfacesOperationsConverter;
160 private PolicyExportParser policyExportParser;
163 private AttributeConverter attributeConverter;
166 public static void setupBeforeClass() {
167 componentName = "catalog-be";
168 confPath = "src/test/resources/config";
174 MockitoAnnotations.openMocks(this);
175 doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
176 doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter).getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean());
179 private Resource getNewResource() {
180 Resource resource = new Resource();
181 resource.setUniqueId("resourceUniqueId");
182 List<CategoryDefinition> categories = new ArrayList<>();
183 CategoryDefinition category = new CategoryDefinition();
184 List<SubCategoryDefinition> subcategories = new ArrayList<>();
185 SubCategoryDefinition subcategory = new SubCategoryDefinition();
186 List<DataTypeDefinition> dataTypes = new ArrayList<>();
187 DataTypeDefinition dataType = new DataTypeDefinition();
188 dataType.setName("dataTypeName");
189 dataType.setDerivedFromName("tosca.datatypes.Root");
190 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
194 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
195 dataType.setPropertiesData(propDataList);
196 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
197 .collect(Collectors.toList());
198 dataType.setProperties(propList);
199 dataTypes.add(dataType);
201 subcategory.setName("name");
202 subcategories.add(subcategory);
203 category.setName("name");
204 category.setSubcategories(subcategories);
205 categories.add(category);
207 final List<PropertyDefinition> properties = new ArrayList<>();
208 properties.add(new PropertyDefinition());
209 resource.setProperties(properties);
210 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
211 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
212 resource.setInterfaces(proxyInterfaces);
214 resource.setCategories(categories);
215 resource.setVersion("version");
216 resource.setVendorName("vendorName");
217 resource.setVendorRelease("vendorRelease");
218 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
219 resource.setDataTypes(dataTypes);
224 private Service getNewService() {
225 Service service = new Service();
226 List<CategoryDefinition> categories = new ArrayList<>();
227 CategoryDefinition category = new CategoryDefinition();
228 List<SubCategoryDefinition> subcategories = new ArrayList<>();
229 SubCategoryDefinition subcategory = new SubCategoryDefinition();
231 subcategory.setName("name");
232 subcategories.add(subcategory);
233 category.setName("name");
234 category.setSubcategories(subcategories);
235 categories.add(category);
237 service.setCategories(categories);
238 service.setComponentType(ComponentTypeEnum.SERVICE);
239 service.setServiceType("serviceType");
240 service.setServiceRole("serviceRole");
241 service.setEnvironmentContext("environmentContext");
247 void testExportComponent() {
248 Component component = getNewResource();
249 Either<ToscaRepresentation, ToscaError> result;
251 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
252 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
253 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
254 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
255 .thenReturn(Either.left(Collections.emptyMap()));
257 // default test when component is Resource
258 result = testSubject.exportComponent(component);
259 assertNotNull(result);
261 component = getNewService();
262 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
263 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
264 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
266 // default test when component is Service
267 result = testSubject.exportComponent(component);
268 assertNotNull(result);
272 void testExportComponentInterface() {
273 Resource component = getNewResource();
274 Either<ToscaRepresentation, ToscaError> result;
276 component.setInterfaces(new HashMap<>());
278 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
279 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
280 .thenReturn(Either.left(Collections.emptyMap()));
281 // default test when convertInterfaceNodeType is right
282 result = testSubject.exportComponentInterface(component, false);
283 assertNotNull(result);
285 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
286 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
287 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
289 // default test when convertInterfaceNodeType is left
290 result = testSubject.exportComponentInterface(component, false);
291 assertNotNull(result);
295 void testExportDataType() {
296 DataTypeDefinition dataTypeDefinition = new DataTypeDefinition();
297 dataTypeDefinition.setUniqueId("uniqueId");
298 Either<ToscaRepresentation, ToscaError> result;
299 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
300 result = testSubject.exportDataType(dataTypeDefinition);
301 assertNotNull(result);
305 void testConvertInterfaceNodeTypeProperties() {
307 Resource component = getNewResource();
309 component.setInterfaces(new HashMap<>());
310 InputDefinition input = new InputDefinition();
311 input.setName(COMPONENT_INPUT_NAME);
312 input.setType(COMPONENT_INPUT_TYPE);
313 component.setInputs(Collections.singletonList(input));
314 PropertyDefinition property = new PropertyDefinition();
315 property.setName(COMPONENT_PROPERTY_NAME);
316 property.setType(COMPONENT_PROPERTY_TYPE);
317 component.setProperties(Collections.singletonList(property));
318 component.setName(RESOURCE_NAME);
319 component.setToscaResourceName(RESOURCE_NAME);
321 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
322 .thenReturn(Either.left(Collections.emptyMap()));
323 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
324 // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
325 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
326 any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
328 final var result = testSubject.convertInterfaceNodeType(new HashMap<String, Component>(), component,
329 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
330 assertNotNull(result);
331 assertTrue(result.isLeft());
332 Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
333 assertNotNull(nodeTypeMap);
334 assertEquals(1, nodeTypeMap.size());
335 ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
336 assertNotNull(toscaNodeType);
337 Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
338 // Check if inputs and properties in component are merged properly
339 assertNotNull(propertyMap);
340 assertEquals(1, propertyMap.size());
341 assertFalse(propertyMap.containsKey(COMPONENT_INPUT_NAME));
342 assertTrue(propertyMap.containsKey(COMPONENT_PROPERTY_NAME));
346 void testGetDependencies() {
348 Component component = new Resource();
349 Either<ToscaTemplate, ToscaError> result;
352 result = testSubject.getDependencies(component);
353 assertNotNull(result);
357 void testSetImports() {
358 Resource resource = new Resource();
359 resource.setResourceType(ResourceTypeEnum.PNF);
361 resource.setName("TestResourceName");
362 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
363 ArtifactDefinition artifact = new ArtifactDefinition();
364 artifact.setArtifactName("name.name2");
365 artifactList.put("assettoscatemplate", artifact);
366 resource.setArtifacts(artifactList);
367 resource.setToscaArtifacts(artifactList);
368 ToscaTemplate toscaTemplate = new ToscaTemplate("");
370 ComponentInstance ci = new ComponentInstance();
371 ci.setComponentUid("name");
372 ci.setOriginType(OriginTypeEnum.PNF);
373 ci.setSourceModelUid("modelName");
374 List<ComponentInstance> componentInstanceList = new LinkedList<>();
375 componentInstanceList.add(ci);
376 resource.setComponentInstances(componentInstanceList);
378 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(resource));
380 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
381 result = Deencapsulation.invoke(testSubject, "fillImports", resource, toscaTemplate);
383 verify(toscaOperationFacade, times(1)).getToscaFullElement("name");
384 assertTrue(result.isLeft());
385 ToscaTemplate toscaTemplateRes = result.left().value().left;
386 assertEquals(8, toscaTemplateRes.getImports().size());
387 assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface"));
388 assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName"));
389 assertEquals(1, toscaTemplateRes.getDependencies().size());
390 assertEquals("name.name2", toscaTemplateRes.getDependencies().get(0).getLeft());
394 void testConvertToscaTemplate() throws Exception {
396 final Component component = getNewResource();
397 final ToscaTemplate toscaNode = new ToscaTemplate("");
398 Either<ToscaTemplate, ToscaError> result;
399 final List<ComponentInstance> resourceInstances = new ArrayList<>();
400 final ComponentInstance instance = new ComponentInstance();
402 instance.setOriginType(OriginTypeEnum.SERVICE);
403 instance.setSourceModelUid("targetModelUid");
404 resourceInstances.add(instance);
406 component.setComponentInstances(resourceInstances);
408 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
409 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
411 final Map<String, ToscaProperty> map = new HashMap<>();
412 map.put("mock", new ToscaProperty());
413 doReturn(map).when(outputConverter).convert(any(), any());
416 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
417 assertNotNull(result);
421 void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException {
422 Component component = getNewResource();
423 ToscaTemplate toscaNode = new ToscaTemplate("");
424 component.setComponentInstances(new ArrayList<>());
426 List<GroupDefinition> groups = new ArrayList<>();
427 GroupDefinition group = new GroupDefinition();
428 List<String> artifacts = new ArrayList<>();
429 artifacts.add("artifact");
430 group.setType("org.openecomp.groups.VfModule");
431 group.setArtifacts(artifacts);
433 component.setGroups(groups);
435 final var input = new InputDefinition();
436 input.setName(COMPONENT_INPUT_NAME);
437 input.setType(COMPONENT_INPUT_TYPE);
438 component.setInputs(Collections.singletonList(input));
440 final var output = new OutputDefinition();
441 output.setName(COMPONENT_OUTPUT_NAME);
442 output.setType(COMPONENT_OUTPUT_TYPE);
443 component.setOutputs(Collections.singletonList(output));
445 Map<String, String[]> substitutionMappingMap = new HashMap<>();
446 String[] array = {"value1", "value2"};
447 substitutionMappingMap.put("key", array);
449 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(),
450 any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
452 when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
453 .thenReturn(Either.left(Collections.emptyMap()));
455 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
457 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
459 when(groupExportParser.getGroups(component)).thenReturn(null);
461 final Map<String, ToscaProperty> map = new HashMap<>();
462 map.put("mock", new ToscaProperty());
463 doReturn(map).when(outputConverter).convert(any(), any());
465 // test component contains group
466 final var result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
467 assertNotNull(result);
471 void testConvertToscaTemplateWhenComponentIsService() throws Exception {
472 Component component = getNewService();
473 ToscaTemplate toscaNode = new ToscaTemplate("");
474 Either<ToscaTemplate, ToscaError> result;
475 component.setComponentInstances(new ArrayList<>());
477 List<GroupDefinition> groups = new ArrayList<>();
478 GroupDefinition group = new GroupDefinition();
479 List<String> artifacts = new ArrayList<>();
480 artifacts.add("artifact");
481 group.setType("org.openecomp.groups.VfModule");
482 group.setArtifacts(artifacts);
484 component.setGroups(groups);
486 Map<String, String[]> substitutionMappingMap = new HashMap<>();
487 String[] array = {"value1", "value2"};
488 substitutionMappingMap.put("key", array);
490 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
491 .thenReturn(Either.left(substitutionMappingMap));
493 when(capabilityRequirementConverter
494 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
495 .thenReturn(Either.left(Collections.emptyMap()));
497 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
499 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
500 final Map<String, ToscaProperty> map = new HashMap<>();
501 map.put("mock", new ToscaProperty());
502 doReturn(map).when(outputConverter).convert(any(), any());
504 // test component contains group
505 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
506 assertNotNull(result);
510 void testConvertMetadata_1() {
512 Component component = getNewResource();
513 boolean isInstance = true;
514 ComponentInstance componentInstance = new ComponentInstance();
515 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
516 componentInstance.setSourceModelInvariant("targetModelInvariant");
519 Map<String, String> result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
520 assertNotNull(result);
524 void testFillImports() {
526 Component component = getNewService();
527 ToscaTemplate toscaTemplate = new ToscaTemplate("");
528 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
530 ComponentInstance instance = new ComponentInstance();
531 List<ComponentInstance> resourceInstances = new ArrayList<>();
532 instance.setComponentUid("name");
533 resourceInstances.add(instance);
534 component.setComponentInstances(resourceInstances);
535 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
536 ArtifactDefinition artifact = new ArtifactDefinition();
537 artifact.setArtifactName("name.name2");
538 toscaArtifacts.put("assettoscatemplate", artifact);
539 component.setToscaArtifacts(toscaArtifacts);
541 when(toscaOperationFacade.getToscaFullElement(any(String.class)))
542 .thenReturn(Either.left(component));
544 Resource baseType = getNewResource();
545 Map<String, ArtifactDefinition> baseTypeToscaArtifacts = new HashMap<>();
546 ArtifactDefinition baseTypeArtifact = new ArtifactDefinition();
547 baseTypeArtifact.setArtifactName("typeA");
548 baseTypeToscaArtifacts.put("assettoscatemplate", baseTypeArtifact);
549 baseType.setToscaArtifacts(baseTypeToscaArtifacts);
551 component.setDerivedFromGenericType("org.typeA");
552 component.setDerivedFromGenericVersion("1.0");
553 when(toscaOperationFacade.getByToscaResourceNameAndVersion("org.typeA", "1.0", null)).thenReturn(Either.left(baseType));
556 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
557 assertNotNull(result);
561 void testCreateDependency() {
563 Map<String, Component> componentCache = new HashMap<>();
564 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
565 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
566 ComponentInstance ci = new ComponentInstance();
567 Component component = getNewResource();
569 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
570 ArtifactDefinition artifact = new ArtifactDefinition();
571 artifact.setArtifactName("name.name2");
572 toscaArtifacts.put("assettoscatemplate", artifact);
573 component.setToscaArtifacts(toscaArtifacts);
574 ci.setComponentUid("name");
575 ci.setOriginType(OriginTypeEnum.ServiceProxy);
576 ci.setSourceModelUid("modelName");
578 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
580 when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service()));
583 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
584 assertFalse(componentCache.isEmpty());
588 void testGetInterfaceFilename() {
589 String artifactName = "artifact.name";
593 result = ToscaExportHandler.getInterfaceFilename(artifactName);
594 assertNotNull(result);
598 void testConvertNodeType() {
599 Component component = new Resource();
600 ToscaTemplate toscaNode = new ToscaTemplate("");
601 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
602 Either<ToscaTemplate, ToscaError> result;
604 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
605 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
606 .thenReturn(Either.left(Collections.emptyMap()));
608 result = Deencapsulation
609 .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
610 assertNotNull(result);
614 void testConvertInterfaceNodeType() {
615 Component component = getNewResource();
616 ToscaTemplate toscaNode = new ToscaTemplate("");
617 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
618 Either<ToscaTemplate, ToscaError> result;
619 List<InputDefinition> inputs = new ArrayList<>();
620 inputs.add(new InputDefinition());
621 component.setInputs(inputs);
623 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
624 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
625 .thenReturn(Either.left(Collections.emptyMap()));
627 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
628 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
631 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
633 assertNotNull(result);
637 void testConvertReqCapAndTypeName() {
638 Component component = new Resource();
639 ToscaTemplate toscaNode = new ToscaTemplate("");
640 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
641 ToscaNodeType toscaNodeType = new ToscaNodeType();
642 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
643 Either<ToscaTemplate, ToscaError> result;
646 capabilityRequirementConverter
647 .convertCapabilities(anyMap(), any(Resource.class), anyMap()))
648 .thenReturn(new HashMap<>());
650 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
651 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
654 result = Deencapsulation
655 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
656 toscaNodeType, dataTypes);
657 assertNotNull(result);
659 component = new Service();
661 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
662 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
664 // test when component is service
665 result = Deencapsulation
666 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
667 toscaNodeType, dataTypes);
668 assertNotNull(result);
672 void testConvertNodeTemplatesWhenComponentIsService() {
673 final Component component = getNewService();
674 final List<ComponentInstance> componentInstances = new ArrayList<>();
675 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
676 final Map<String, Component> componentCache = new HashMap<>();
677 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
678 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
679 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
680 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
681 final List<ComponentInstanceInput> inputs = new ArrayList<>();
682 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
683 componentInstanceInput.setUniqueId("uuid");
684 inputs.add(componentInstanceInput);
685 componentInstancesInputs.put("uuid", inputs);
686 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
687 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
688 reldef.setFromNode("node");
689 resourceInstancesRelations.add(reldef);
690 component.setComponentInstancesRelations(resourceInstancesRelations);
692 final ComponentInstance instance = new ComponentInstance();
693 instance.setUniqueId("id");
694 instance.setComponentUid("uid");
695 instance.setOriginType(OriginTypeEnum.ServiceProxy);
696 final List<GroupInstance> groupInstances = new ArrayList<>();
697 final GroupInstance groupInst = new GroupInstance();
698 final List<String> artifacts = new ArrayList<>();
699 artifacts.add("artifact");
700 groupInst.setArtifacts(artifacts);
701 groupInst.setType("type");
702 groupInstances.add(groupInst);
703 instance.setGroupInstances(groupInstances);
705 final List<PropertyDefinition> properties = new ArrayList<>();
706 properties.add(new PropertyDefinition());
707 instance.setProperties(properties);
709 instance.setUniqueId("uuid");
710 instance.setDescription("desc");
711 instance.setSourceModelUid("sourceModelUid");
713 componentInstances.add(instance);
715 component.setComponentInstances(componentInstances);
717 component.setComponentInstancesInputs(componentInstancesInputs);
718 component.setInvariantUUID("uuid");
719 component.setUUID("uuid");
720 component.setDescription("desc");
721 component.setUniqueId("uid");
723 componentCache.put("uid", component);
725 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
726 componentInstanceProperties.add(new ComponentInstanceProperty());
728 componentInstancesProperties.put("uuid", componentInstanceProperties);
729 component.setComponentInstancesProperties(componentInstancesProperties);
731 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
732 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
733 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
734 componentInstanceAttribute.setDefaultValue("def value");
735 componentInstanceAttributes.add(componentInstanceAttribute);
737 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
738 component.setComponentInstancesAttributes(componentInstancesAttributes);
740 ComponentInstanceProperty cip = new ComponentInstanceProperty();
741 cip.setInstanceUniqueId("id");
743 List<ComponentInstanceProperty> list = new ArrayList<>();
746 componentInstancesProperties.put("id", list);
747 component.setComponentInstancesProperties(componentInstancesProperties);
749 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
750 when(capabilityRequirementConverter
751 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
752 .thenReturn(Either.left(new ToscaNodeTemplate()));
753 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
754 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
755 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
756 .thenReturn(Either.left(new ToscaNodeType()));
757 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
758 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
759 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
760 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(getNewResource()));
762 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
763 final String[] array = {"value1", "value2"};
764 substitutionMappingMap.put("key", array);
765 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
766 .thenReturn(Either.left(substitutionMappingMap));
768 when(capabilityRequirementConverter
769 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
770 .thenReturn(Either.left(Collections.emptyMap()));
773 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
774 assertNotNull(toscaRepresentationToscaErrorEither);
779 void testConvertNodeTemplatesWhenComponentIsResource() {
780 final Resource component = getNewResource();
781 component.setResourceType(VF);
782 final List<ComponentInstance> componentInstances = new ArrayList<>();
783 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
784 final Map<String, Component> componentCache = new HashMap<>();
785 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
786 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
787 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
788 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
789 final List<ComponentInstanceInput> inputs = new ArrayList<>();
790 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
791 componentInstanceInput.setUniqueId("uuid");
792 inputs.add(componentInstanceInput);
793 componentInstancesInputs.put("uuid", inputs);
794 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
795 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
796 reldef.setFromNode("node");
797 resourceInstancesRelations.add(reldef);
798 component.setComponentInstancesRelations(resourceInstancesRelations);
800 final ComponentInstance instance = new ComponentInstance();
801 instance.setUniqueId("id");
802 instance.setComponentUid("uid");
803 instance.setOriginType(OriginTypeEnum.VFC);
804 final List<GroupInstance> groupInstances = new ArrayList<>();
805 final GroupInstance groupInst = new GroupInstance();
806 final List<String> artifacts = new ArrayList<>();
807 artifacts.add("artifact");
808 groupInst.setArtifacts(artifacts);
809 groupInst.setType("type");
810 groupInstances.add(groupInst);
811 instance.setGroupInstances(groupInstances);
813 final List<PropertyDefinition> properties = new ArrayList<>();
814 properties.add(new PropertyDefinition());
815 instance.setProperties(properties);
816 component.setProperties(properties);
818 instance.setUniqueId("uuid");
819 instance.setDescription("desc");
820 instance.setSourceModelUid("sourceModelUid");
821 final Map<String, ArtifactDefinition> artifactList = new HashMap<>();
822 final ArtifactDefinition artifact = new ArtifactDefinition();
823 artifact.setArtifactName("name.name2");
824 artifactList.put("assettoscatemplate", artifact);
825 instance.setArtifacts(artifactList);
827 Map<String, ToscaArtifactDataDefinition> toscaArtifactDataDefinitionMap = new HashMap<>();
828 toscaArtifactDataDefinitionMap.put("assettoscatemplate", new ToscaArtifactDataDefinition());
829 instance.setToscaArtifacts(toscaArtifactDataDefinitionMap);
831 componentInstances.add(instance);
833 component.setComponentInstances(componentInstances);
835 component.setComponentInstancesInputs(componentInstancesInputs);
836 component.setInvariantUUID("uuid");
837 component.setUUID("uuid");
838 component.setDescription("desc");
839 component.setUniqueId("uid");
841 componentCache.put("uid", component);
843 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
844 componentInstanceProperties.add(new ComponentInstanceProperty());
846 componentInstancesProperties.put("uuid", componentInstanceProperties);
847 component.setComponentInstancesProperties(componentInstancesProperties);
849 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
850 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
851 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
852 componentInstanceAttribute.setDefaultValue("def value");
853 componentInstanceAttributes.add(componentInstanceAttribute);
855 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
856 component.setComponentInstancesAttributes(componentInstancesAttributes);
858 component.setArtifacts(artifactList);
859 component.setToscaArtifacts(artifactList);
861 final List<AttributeDefinition> attributes = new ArrayList<>();
862 final var attribute = new AttributeDefinition();
863 attribute.setName("mock");
864 attributes.add(attribute);
865 component.setAttributes(attributes);
867 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
868 componentInstanceInputs.add(new ComponentInstanceInput());
870 componentInstancesInputs.put("id", componentInstanceInputs);
871 component.setComponentInstancesInputs(componentInstancesInputs);
873 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
874 when(capabilityRequirementConverter
875 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
876 .thenReturn(Either.left(new ToscaNodeTemplate()));
877 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
878 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
879 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
880 .thenReturn(Either.left(new ToscaNodeType()));
881 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
882 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
883 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
885 Resource newResource = getNewResource();
886 InputDefinition input = new InputDefinition();
887 input.setName(COMPONENT_INPUT_NAME);
888 input.setType(COMPONENT_INPUT_TYPE);
889 newResource.setInputs(Collections.singletonList(input));
891 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(newResource));
893 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
894 final String[] array = {"value1", "value2"};
895 substitutionMappingMap.put("key", array);
896 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
897 .thenReturn(Either.left(substitutionMappingMap));
899 when(capabilityRequirementConverter
900 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
901 .thenReturn(Either.left(Collections.emptyMap()));
904 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(newResource);
905 assertNotNull(toscaRepresentationToscaErrorEither);
910 void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() {
911 Component component = getNewResource();
912 List<ComponentInstance> componentInstances = new ArrayList<>();
913 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
914 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
915 Map<String, Component> componentCache = new HashMap<>();
916 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
917 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
918 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
919 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
920 List<ComponentInstanceInput> inputs = new ArrayList<>();
921 inputs.add(new ComponentInstanceInput());
922 componentInstancesInputs.put("key", inputs);
923 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
924 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
925 reldef.setFromNode("node");
926 resourceInstancesRelations.add(reldef);
927 component.setComponentInstancesRelations(resourceInstancesRelations);
929 ComponentInstance instance = new ComponentInstance();
930 instance.setUniqueId("id");
931 instance.setComponentUid("uid");
932 instance.setOriginType(OriginTypeEnum.ServiceProxy);
933 componentInstances.add(instance);
934 component.setComponentInstances(componentInstances);
936 component.setComponentInstancesInputs(componentInstancesInputs);
937 component.setInvariantUUID("uuid");
938 component.setUUID("uuid");
939 component.setDescription("desc");
941 componentCache.put("uid", component);
943 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
944 when(capabilityRequirementConverter
945 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
946 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
947 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
948 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
949 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
950 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
953 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
954 assertNotNull(toscaRepresentationToscaErrorEither);
958 void testConvetNodeTemplateWhenGetOriginComponentIsRight() {
959 Component component = getNewResource();
960 List<ComponentInstance> componentInstances = new ArrayList<>();
961 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
962 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
963 Map<String, Component> componentCache = new HashMap<>();
964 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
965 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
966 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
967 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
968 List<ComponentInstanceInput> inputs = new ArrayList<>();
969 inputs.add(new ComponentInstanceInput());
970 componentInstancesInputs.put("key", inputs);
971 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
972 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
973 reldef.setFromNode("id");
974 resourceInstancesRelations.add(reldef);
975 component.setComponentInstancesRelations(resourceInstancesRelations);
977 ComponentInstance instance = new ComponentInstance();
978 instance.setUniqueId("id");
979 instance.setComponentUid("uid");
980 instance.setOriginType(OriginTypeEnum.ServiceProxy);
981 componentInstances.add(instance);
982 component.setComponentInstances(componentInstances);
984 component.setComponentInstancesInputs(componentInstancesInputs);
985 component.setInvariantUUID("uuid");
986 component.setUUID("uuid");
987 component.setDescription("desc");
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 componentCache.put("uid", component);
997 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
998 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
999 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1000 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1001 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1004 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
1005 assertNotNull(toscaRepresentationToscaErrorEither);
1009 void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
1010 Resource component = getNewResource();
1011 component.setResourceType(VF);
1012 List<ComponentInstance> componentInstances = new ArrayList<>();
1013 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
1014 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
1015 Map<String, Component> componentCache = new HashMap<>();
1016 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1017 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
1018 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
1019 List<ComponentInstanceInput> inputs = new ArrayList<>();
1020 inputs.add(new ComponentInstanceInput());
1021 componentInstancesInputs.put("key", inputs);
1022 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
1023 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1024 reldef.setFromNode("id");
1025 reldef.setToNode("node");
1026 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1027 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1028 relationship.setRelation(new RelationshipInfo());
1029 relationships.add(relationship);
1030 reldef.setRelationships(relationships);
1031 resourceInstancesRelations.add(reldef);
1032 component.setComponentInstancesRelations(resourceInstancesRelations);
1034 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
1035 ArtifactDefinition artifact = new ArtifactDefinition();
1036 artifact.setArtifactName("name.name2");
1037 artifactList.put("assettoscatemplate", artifact);
1038 component.setArtifacts(artifactList);
1039 component.setToscaArtifacts(artifactList);
1041 ComponentInstance instance = new ComponentInstance();
1042 instance.setUniqueId("id");
1043 instance.setComponentUid("id");
1044 instance.setOriginType(OriginTypeEnum.VF);
1045 componentInstances.add(instance);
1046 component.setComponentInstances(componentInstances);
1048 component.setComponentInstancesInputs(componentInstancesInputs);
1049 component.setComponentInstances(componentInstances);
1051 doReturn(Either.left(component)).when(toscaOperationFacade).getToscaFullElement("id");
1052 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
1053 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1054 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1055 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1056 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1057 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1058 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1061 final Either<ToscaRepresentation, ToscaError> result = testSubject.exportComponent(component);
1062 assertNotNull(result);
1066 void testCreateNodeType() {
1068 Component component = new Resource();
1069 List<String> array = new ArrayList<>();
1071 ((Resource) component).setDerivedFrom(array);
1072 ToscaNodeType result;
1074 // test when component is resource
1075 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1076 assertNotNull(result);
1078 component = new Service();
1079 // test when component is service
1080 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1081 assertNotNull(result);
1085 void testCreateProxyInterfaceTypesComponentNotFound() {
1086 Component container = new Service();
1087 Either<Map<String, ToscaNodeType>, ToscaError> result;
1088 List<ComponentInstance> componentInstances = new ArrayList<>();
1089 ComponentInstance instance = new ComponentInstance();
1090 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1091 instance.setSourceModelUid("targetModelUid");
1092 instance.setToscaComponentName("toscaComponentName");
1094 componentInstances.add(instance);
1095 container.setComponentInstances(componentInstances);
1096 when(toscaOperationFacade.getToscaElement(any(String.class),
1097 any(ComponentParametersView.class)))
1098 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1099 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1100 assertTrue(result.isRight());
1104 void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
1105 Component container = new Service();
1106 Either<Map<String, ToscaNodeType>, ToscaError> result;
1107 List<ComponentInstance> componentInstances = new ArrayList<>();
1108 ComponentInstance instance = new ComponentInstance();
1109 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1110 instance.setSourceModelUid("targetModelUid");
1111 instance.setToscaComponentName("toscaComponentName");
1112 componentInstances.add(instance);
1113 container.setComponentInstances(componentInstances);
1115 when(toscaOperationFacade.getToscaElement(any(String.class),
1116 any(ComponentParametersView.class)))
1117 .thenReturn(Either.left(new Resource()));
1118 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1119 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1120 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1121 assertTrue(result.isRight());
1125 void testCreateProxyInterfaceTypesPositive() {
1126 Component container = new Service();
1127 Either<Map<String, ToscaNodeType>, ToscaError> result;
1128 List<ComponentInstance> componentInstances = new ArrayList<>();
1129 ComponentInstance instance = new ComponentInstance();
1130 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1131 instance.setSourceModelUid("targetModelUid");
1132 instance.setToscaComponentName("toscaComponentName");
1133 componentInstances.add(instance);
1134 container.setComponentInstances(componentInstances);
1136 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1138 Component proxyResource = new Resource();
1139 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1140 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1141 proxyResource.setInterfaces(proxyInterfaces);
1142 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(proxyResource));
1143 when(interfacesOperationsConverter.addInterfaceTypeElement(any(Component.class), anyList()))
1144 .thenReturn(Collections.singletonMap(LOCAL_INTERFACE_TYPE, new HashMap<>()));
1146 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1147 assertNotNull(result);
1148 assertTrue(result.isLeft());
1149 assertEquals(1, result.left().value().size());
1153 void testCreateProxyNodeTypes() {
1154 Map<String, Component> componentCache = new HashMap<>();
1155 Component container = new Resource();
1156 Either<Map<String, ToscaNodeType>, ToscaError> result;
1157 List<ComponentInstance> componentInstances = new ArrayList<>();
1158 ComponentInstance instance = new ComponentInstance();
1159 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1160 instance.setSourceModelUid("targetModelUid");
1162 componentInstances.add(instance);
1163 container.setComponentInstances(componentInstances);
1165 when(toscaOperationFacade.getLatestByName("serviceProxy", null))
1166 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1168 // test when getLatestByName return is right
1169 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1170 assertNotNull(result);
1174 void testCreateServiceSubstitutionNodeTypes() {
1175 Map<String, Component> componentCache = new HashMap<>();
1177 Component referencedService = getNewService();
1178 referencedService.setInvariantUUID("uuid");
1179 referencedService.setUUID("uuid");
1180 referencedService.setUniqueId("targetModelUid");
1181 referencedService.setDescription("desc");
1182 componentCache.put("targetModelUid", referencedService);
1184 Component containerService = new Service();
1185 List<ComponentInstance> componentInstances = new ArrayList<>();
1186 ComponentInstance instance = new ComponentInstance();
1187 instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1188 instance.setSourceModelUid("targetModelUid");
1190 componentInstances.add(instance);
1191 containerService.setComponentInstances(componentInstances);
1193 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1194 .thenReturn(Either.left(Collections.emptyMap()));
1195 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1196 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
1197 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1199 ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1201 Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1202 assertNotNull(toscaNode.getNode_types());
1206 void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1207 Map<String, Component> componentCache = new HashMap<>();
1208 Component container = new Resource();
1209 Either<Map<String, ToscaNodeType>, ToscaError> result;
1210 List<ComponentInstance> componentInstances = new ArrayList<>();
1211 ComponentInstance instance = new ComponentInstance();
1212 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1213 instance.setSourceModelUid("targetModelUid");
1215 componentInstances.add(instance);
1216 container.setComponentInstances(componentInstances);
1218 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
1220 ComponentParametersView parameterView = new ComponentParametersView();
1221 parameterView.disableAll();
1222 parameterView.setIgnoreCategories(false);
1224 when(toscaOperationFacade.getToscaElement(any(String.class),
1225 any(ComponentParametersView.class)))
1226 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1228 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1230 // test when getLatestByName is left
1231 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1232 assertNotNull(result);
1236 void testCreateProxyNodeType() {
1237 Map<String, Component> componentCache = new HashMap<>();
1238 Component origComponent = new Resource();
1239 Component proxyComponent = new Resource();
1240 ComponentInstance instance = new ComponentInstance();
1241 ToscaNodeType result;
1243 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1246 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1247 proxyComponent, instance);
1248 assertNotNull(result);
1252 void testConvertComponentInstanceRequirements() {
1253 Component component = new Resource();
1254 ComponentInstance componentInstance = new ComponentInstance();
1255 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1256 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1257 Component originComponent = new Resource();
1258 Map<String, Component> componentCache = new HashMap<>();
1259 Either<ToscaNodeTemplate, ToscaError> result;
1262 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1263 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1264 assertNotNull(result);
1266 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1267 reldef.setFromNode("name");
1268 reldef.setToNode("name1");
1269 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1270 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1271 cap.setRelation(new RelationshipInfo());
1272 relationships.add(cap);
1273 reldef.setRelationships(relationships);
1274 relations.add(reldef);
1275 componentInstance.setUniqueId("name");
1277 List<ComponentInstance> instances = new ArrayList<>();
1278 instances.add(componentInstance);
1279 component.setComponentInstances(instances);
1281 // test when filteredRElations ins't empty
1282 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1283 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1284 assertNotNull(result);
1288 void buildRequirementFailure() {
1289 final Component fromOriginComponent = new Resource();
1290 final ComponentInstance fromInstance = new ComponentInstance();
1291 final String fromInstanceUid = "fromInstanceUid";
1292 fromInstance.setUniqueId(fromInstanceUid);
1293 fromInstance.setComponentUid("componentUid");
1294 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1295 relationshipDefinition.setToNode("wrongNodeUid");
1296 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1297 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1298 relationship.setRequirement(new RequirementDataDefinition());
1299 relationshipList.add(relationship);
1300 relationshipDefinition.setRelationships(relationshipList);
1301 final List<ComponentInstance> instancesList = new ArrayList<>();
1302 instancesList.add(fromInstance);
1303 String expectedError = String
1304 .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1305 relationshipDefinition.getToNode());
1306 assertThrows(ToscaExportException.class, () ->
1307 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1308 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1311 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1312 instancesList, relationshipDefinition, new HashMap<>());
1313 } catch (Exception e) {
1314 assertTrue(e instanceof ToscaExportException);
1315 assertEquals(expectedError, e.getMessage());
1318 final RelationshipInfo relation = new RelationshipInfo();
1319 final String requirementUid = "Uid";
1320 relation.setRequirementUid(requirementUid);
1321 final String requirementName = "requirementName";
1322 relation.setRequirement(requirementName);
1323 final String capabilityName = "capabilityName";
1324 relation.setCapability(capabilityName);
1325 final String capabilityOwnerId = "capabilityOwnerId";
1326 relation.setCapabilityOwnerId(capabilityOwnerId);
1327 relationship.setRelation(relation);
1329 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1330 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1331 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1332 fromOriginComponent.setRequirements(requirementMap);
1333 relationshipDefinition.setToNode(fromInstanceUid);
1335 expectedError = String
1336 .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1337 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1339 assertThrows(ToscaExportException.class, () ->
1340 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1341 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1343 requirementDefinition.setName(requirementName);
1345 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1346 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1348 expectedError = String.format(
1349 "Failed to build substituted name for the requirement %s. "
1350 + "Failed to get an origin component with uniqueId %s",
1351 requirementName, fromInstance.getActualComponentUid());
1352 assertThrows(ToscaExportException.class, () -> Deencapsulation
1353 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1354 relationshipDefinition, new HashMap<>()), expectedError);
1356 final Component toOriginComponent = new Resource();
1357 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1358 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1360 capabilityDefinition.setName(capabilityName);
1361 capabilityDefinition.setOwnerId(capabilityOwnerId);
1362 capabilityDefinition.setType("aType");
1363 final String capabilityPreviousName = "capabilityPreviousName";
1364 capabilityDefinition.setPreviousName(capabilityPreviousName);
1365 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1366 toOriginComponent.setCapabilities(capabilityMap);
1367 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1368 .thenReturn(Either.left(toOriginComponent));
1370 requirementDefinition.setCapability(capabilityName);
1371 relation.setCapability("wrong");
1372 final String requirementPreviousName = "requirementPreviousName";
1373 requirementDefinition.setPreviousName(requirementPreviousName);
1374 requirementDefinition.setPath(new ArrayList<>());
1376 expectedError = String
1377 .format("Failed to find a capability with name %s on a component with uniqueId %s",
1378 relation.getCapability(), fromOriginComponent.getUniqueId());
1380 assertThrows(ToscaExportException.class, () -> Deencapsulation
1381 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1382 relationshipDefinition, new HashMap<>()),
1387 void testBuildRequirement() {
1388 final ComponentInstance fromInstance = new ComponentInstance();
1389 fromInstance.setUniqueId("name");
1390 fromInstance.setComponentUid("string");
1391 final List<ComponentInstance> instancesList = new ArrayList<>();
1393 final Map<String, Component> componentCache = new HashMap<>();
1394 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1395 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1396 relationship.setRequirement(new RequirementDataDefinition());
1397 final RelationshipInfo relation = new RelationshipInfo();
1398 final String requirementUid = "Uid";
1399 relation.setRequirementUid(requirementUid);
1400 final String requirementName = "requirementName";
1401 relation.setRequirement(requirementName);
1402 final String capabilityName = "capabilityName";
1403 relation.setCapability(capabilityName);
1404 final String capabilityOwnerId = "capabilityOwnerId";
1405 relation.setCapabilityOwnerId(capabilityOwnerId);
1406 relationship.setRelation(relation);
1407 relationshipList.add(relationship);
1408 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1409 relationshipDefinition.setRelationships(relationshipList);
1410 relationshipDefinition.setToNode("name");
1411 instancesList.add(fromInstance);
1412 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1413 requirementDefinition.setName(requirementName);
1414 requirementDefinition.setCapability(capabilityName);
1415 final String requirementPreviousName = "requirementPreviousName";
1416 requirementDefinition.setPreviousName(requirementPreviousName);
1417 requirementDefinition.setPath(new ArrayList<>());
1418 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1419 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1420 final Component fromOriginComponent = new Resource();
1421 fromOriginComponent.setRequirements(requirementMap);
1423 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1424 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1425 capabilityDefinition.setName(capabilityName);
1426 capabilityDefinition.setOwnerId(capabilityOwnerId);
1427 final String capabilityPreviousName = "capabilityPreviousName";
1428 capabilityDefinition.setPreviousName(capabilityPreviousName);
1429 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1430 final Component toOriginComponent = new Resource();
1431 toOriginComponent.setCapabilities(capabilityMap);
1433 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1434 .thenReturn(Either.left(toOriginComponent));
1435 final String builtCapabilityName = "builtCapabilityName";
1437 capabilityRequirementConverter
1438 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1439 capabilityPreviousName), any()))
1440 .thenReturn(Either.left(builtCapabilityName));
1442 final String builtRequirementName = "builtRequirementName";
1444 capabilityRequirementConverter
1445 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1446 requirementPreviousName), any()))
1447 .thenReturn(Either.left(builtRequirementName));
1449 final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1450 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1451 instancesList, relationshipDefinition, componentCache);
1452 assertNotNull(actualRequirementMap);
1453 assertFalse(actualRequirementMap.isEmpty());
1454 assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1455 final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1456 assertNotNull(actualToscaTemplateRequirement);
1457 assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1459 //to toOriginComponent not found
1460 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1461 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1463 assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1464 instancesList, relationshipDefinition, componentCache));
1468 void testAddRequirmentsWithBuildAndAddRequirements() {
1469 ComponentInstance fromInstance = new ComponentInstance();
1470 Component fromOriginComponent = new Resource();
1471 List<ComponentInstance> instancesList = new ArrayList<>();
1472 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1473 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1474 Map<String, Component> componentCache = new HashMap<>();
1476 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1477 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1478 cap.setRequirement(new RequirementDataDefinition());
1479 RelationshipInfo relation = new RelationshipInfo();
1480 relation.setRequirementUid("Uid");
1481 relation.setRequirement("requirment");
1482 relation.setCapability("cap");
1483 relation.setCapabilityOwnerId("id");
1484 cap.setRelation(relation);
1485 relationships.add(cap);
1486 rel.setRelationships(relationships);
1487 rel.setToNode("name");
1488 fromInstance.setUniqueId("name");
1489 fromInstance.setComponentUid("string");
1490 instancesList.add(fromInstance);
1491 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1493 List<RequirementDefinition> defs = new ArrayList<>();
1494 RequirementDefinition def = new RequirementDefinition();
1495 def.setName("requirment");
1496 def.setCapability("cap");
1498 requirements.put("key", defs);
1499 fromOriginComponent.setRequirements(requirements);
1501 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1502 List<CapabilityDefinition> caps = new ArrayList<>();
1503 CapabilityDefinition capdef = new CapabilityDefinition();
1504 capdef.setOwnerId("id");
1505 capdef.setName("cap");
1506 capdef.setPreviousName("before cap");
1507 capdef.setType("type");
1509 capabilities.put("cap", caps);
1510 fromOriginComponent.setCapabilities(capabilities);
1512 when(toscaOperationFacade.getToscaElement(any(String.class),
1513 any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1516 capabilityRequirementConverter
1517 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString(), any()))
1518 .thenReturn(Either.right(false));
1520 final String expectedErrorMsg =
1521 String.format("Failed to build a substituted capability name for the capability "
1522 + "with name %s on a component with uniqueId %s",
1523 cap.getRequirement(), fromOriginComponent.getUniqueId());
1525 assertThrows(ToscaExportException.class, () ->
1526 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1527 rel, componentCache), expectedErrorMsg);
1531 void testBuildAndAddRequirement() {
1532 Component fromOriginComponent = new Resource();
1533 Component toOriginComponent = new Resource();
1534 CapabilityDefinition capability = new CapabilityDefinition();
1535 RequirementDefinition requirement = new RequirementDefinition();
1536 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1537 ComponentInstance toInstance = new ComponentInstance();
1538 Map<String, Component> componentCache = new HashMap<>();
1539 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1540 capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1541 capability.setPath(new ArrayList<>());
1542 capability.setPreviousName("before cap");
1543 reqAndRelationshipPair.setCapability("cap");
1544 requirement.setPath(new ArrayList<>());
1545 requirement.setPreviousName("before req");
1546 reqAndRelationshipPair.setRequirement("req");
1549 capabilityRequirementConverter
1550 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString(), any()))
1551 .thenReturn(Either.left("buildCapNameRes"));
1554 capabilityRequirementConverter
1555 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString(), any()))
1556 .thenReturn(Either.left("buildReqNameRes"));
1559 final Map<String, ToscaTemplateRequirement> requirementMap =
1560 Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1561 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1562 assertNotNull(requirementMap);
1563 assertFalse(requirementMap.isEmpty());
1564 assertTrue(requirementMap.containsKey("buildReqNameRes"));
1565 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1566 assertNotNull(actualToscaTemplateRequirement);
1567 assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1571 void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1572 final Component fromOriginComponent = new Resource();
1573 final Component toOriginComponent = new Resource();
1574 final CapabilityDefinition capability = new CapabilityDefinition();
1575 final RequirementDefinition requirement = new RequirementDefinition();
1576 final RelationshipInfo relationship = new RelationshipInfo();
1577 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1578 capabilityRequirementRelationship.setRelation(relationship);
1579 ComponentInstance toInstance = new ComponentInstance();
1580 Map<String, Component> componentCache = new HashMap<>();
1581 capability.setPath(new ArrayList<>());
1582 relationship.setCapability("cap");
1583 requirement.setPath(new ArrayList<>());
1584 relationship.setRequirement("req");
1586 final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1587 when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("cap"), any(), any()))
1588 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1589 when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("req"), any(), any()))
1590 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1592 final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1593 .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1594 capabilityRequirementRelationship, toInstance, componentCache);
1595 assertNotNull(requirementMap);
1596 assertFalse(requirementMap.isEmpty());
1597 assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1598 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1599 assertNotNull(actualToscaTemplateRequirement);
1600 assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1604 void testIsRequirementBelongToRelation() {
1606 Component originComponent = new Resource();
1607 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1608 RequirementDefinition requirement = new RequirementDefinition();
1609 String fromInstanceId = "";
1612 requirement.setName("name");
1613 reqAndRelationshipPair.setRequirement("name1");
1615 // test return false
1616 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1617 reqAndRelationshipPair, requirement, fromInstanceId);
1618 assertFalse(result);
1622 void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1624 Component originComponent = new Service();
1625 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1626 RequirementDefinition requirement = new RequirementDefinition();
1627 requirement.setUniqueId(UNIQUE_ID);
1628 reqAndRelationshipPair.setRequirementUid(UNIQUE_ID);
1629 String fromInstanceId = "";
1632 // default test return true
1633 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1634 reqAndRelationshipPair, requirement, fromInstanceId);
1639 void testIsRequirementBelongToOwner() {
1641 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1642 RequirementDefinition requirement = new RequirementDefinition();
1643 String fromInstanceId = "";
1644 Component originComponent = new Resource();
1647 requirement.setOwnerId("owner1");
1648 reqAndRelationshipPair.setRequirementOwnerId("owner");
1651 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1652 fromInstanceId, originComponent);
1653 assertFalse(result);
1659 Component component = new Service();
1662 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1663 assertFalse(result);
1667 void testConvertCapabilities() {
1668 final Component component = new Resource();
1669 final Map<String, Component> componentCache = new HashMap<>();
1671 final Either<Map<String, String[]>, ToscaError> expectedResult = Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR);
1672 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1673 .thenReturn(expectedResult);
1675 // default test return isRight
1676 final Either<Map<String, String[]>, ToscaError> actualResult =
1677 Deencapsulation.invoke(testSubject, "convertSubstitutionMappingCapabilities", component, componentCache);
1678 assertNotNull(actualResult);
1679 assertEquals(expectedResult, actualResult);
1683 void testConvertCapabilities_1() {
1684 Component component = new Resource();
1685 ToscaNodeType nodeType = new ToscaNodeType();
1686 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1687 Either<ToscaNodeType, ToscaError> result;
1689 Map<String, ToscaCapability> capabilities = new HashMap<>();
1690 capabilities.put("key", new ToscaCapability());
1693 result = Deencapsulation
1694 .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1695 assertNotNull(result);
1699 void testConvertToNodeTemplateArtifacts() {
1700 Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1701 ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1702 art.setFile("test_file");
1703 art.setType("test_type");
1704 Map<String, ToscaTemplateArtifact> result;
1705 container.put("test_art", art);
1706 result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1707 assertNotNull(result);
1708 assertTrue(MapUtils.isNotEmpty(result));
1709 assertEquals("test_file", result.get("test_art").getFile());
1710 assertEquals("test_type", result.get("test_art").getType());
1713 private Component getTestComponent() {
1714 Component component = new Service();
1715 component.setUniqueId("serviceUniqueId");
1716 component.setNormalizedName("normalizedServiceComponentName");
1717 InterfaceDefinition addedInterface = new InterfaceDefinition();
1718 addedInterface.setType("com.some.service.or.other.serviceName");
1719 final String interfaceType = "normalizedServiceComponentName-interface";
1720 component.setInterfaces(new HashMap<>());
1721 component.getInterfaces().put(interfaceType, addedInterface);
1725 private PropertyDefinition createMockProperty(String propertyName, String defaultValue) {
1726 PropertyDefinition propertyDefinition = new PropertyDefinition();
1727 propertyDefinition.setName(propertyName);
1728 propertyDefinition.setType("string");
1729 propertyDefinition.setDefaultValue(defaultValue);
1730 return propertyDefinition;
1733 private InputDefinition createMockInput(String inputName, String defaultValue) {
1734 InputDefinition inputDefinition = new InputDefinition();
1735 inputDefinition.setName(inputName);
1736 inputDefinition.setType("string");
1737 inputDefinition.setDefaultValue(defaultValue);
1738 return inputDefinition;