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.Optional;
53 import java.util.stream.Collectors;
54 import mockit.Deencapsulation;
55 import org.apache.commons.collections.MapUtils;
56 import org.apache.commons.lang3.tuple.ImmutablePair;
57 import org.apache.commons.lang3.tuple.Triple;
58 import org.junit.jupiter.api.BeforeAll;
59 import org.junit.jupiter.api.BeforeEach;
60 import org.junit.jupiter.api.Test;
61 import org.mockito.InjectMocks;
62 import org.mockito.Mock;
63 import org.mockito.MockitoAnnotations;
64 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
65 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
66 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
67 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
68 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
69 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
71 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
72 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
73 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
74 import org.openecomp.sdc.be.exception.ToscaExportException;
75 import org.openecomp.sdc.be.model.ArtifactDefinition;
76 import org.openecomp.sdc.be.model.AttributeDefinition;
77 import org.openecomp.sdc.be.model.CapabilityDefinition;
78 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
79 import org.openecomp.sdc.be.model.Component;
80 import org.openecomp.sdc.be.model.ComponentInstance;
81 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
82 import org.openecomp.sdc.be.model.ComponentInstanceInput;
83 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
84 import org.openecomp.sdc.be.model.ComponentParametersView;
85 import org.openecomp.sdc.be.model.DataTypeDefinition;
86 import org.openecomp.sdc.be.model.GroupDefinition;
87 import org.openecomp.sdc.be.model.GroupInstance;
88 import org.openecomp.sdc.be.model.InputDefinition;
89 import org.openecomp.sdc.be.model.InterfaceDefinition;
90 import org.openecomp.sdc.be.model.PropertyDefinition;
91 import org.openecomp.sdc.be.model.RelationshipInfo;
92 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
93 import org.openecomp.sdc.be.model.RequirementDefinition;
94 import org.openecomp.sdc.be.model.Resource;
95 import org.openecomp.sdc.be.model.Service;
96 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
97 import org.openecomp.sdc.be.model.category.CategoryDefinition;
98 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
99 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
100 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
101 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
102 import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
103 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
104 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
105 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
106 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
107 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
108 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
109 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
110 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
111 import org.openecomp.sdc.be.tosca.utils.InputConverter;
112 import org.openecomp.sdc.be.tosca.utils.OutputConverter;
113 import org.openecomp.sdc.common.test.BaseConfDependent;
115 class ToscaExportHandlerTest extends BaseConfDependent {
117 private static final String COMPONENT_PROPERTY_NAME = "prop1";
118 private static final String COMPONENT_PROPERTY_TYPE = "string";
119 private static final String COMPONENT_INPUT_NAME = "input1";
120 private static final String COMPONENT_INPUT_TYPE = "integer";
121 private static final String RESOURCE_NAME = "resource";
122 private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
123 private static final Map<String, DataTypeDefinition> DATA_TYPES = new HashMap<>();
126 private ToscaExportHandler testSubject;
129 private ApplicationDataTypeCache applicationDataTypeCache;
132 private ToscaOperationFacade toscaOperationFacade;
135 private CapabilityRequirementConverter capabilityRequirementConverter;
138 private InputConverter inputConverter;
141 private OutputConverter outputConverter;
144 private GroupExportParser groupExportParser;
147 private PropertyConvertor propertyConvertor;
150 private GroupExportParserImpl groupExportParserImpl;
153 private InterfaceLifecycleOperation interfaceLifecycleOperation;
156 private InterfacesOperationsConverter interfacesOperationsConverter;
159 private PolicyExportParser policyExportParser;
162 private AttributeConverter attributeConverter;
165 public static void setupBeforeClass() {
166 componentName = "catalog-be";
167 confPath = "src/test/resources/config";
173 MockitoAnnotations.openMocks(this);
174 doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
175 doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter)
176 .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean(), anyBoolean());
179 private Resource getNewResource() {
180 Resource resource = new Resource();
181 List<CategoryDefinition> categories = new ArrayList<>();
182 CategoryDefinition category = new CategoryDefinition();
183 List<SubCategoryDefinition> subcategories = new ArrayList<>();
184 SubCategoryDefinition subcategory = new SubCategoryDefinition();
185 List<DataTypeDefinition> dataTypes = new ArrayList<>();
186 DataTypeDefinition dataType = new DataTypeDefinition();
187 dataType.setName("dataTypeName");
188 dataType.setDerivedFromName("tosca.datatypes.Root");
189 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
193 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
194 dataType.setPropertiesData(propDataList);
195 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
196 .collect(Collectors.toList());
197 dataType.setProperties(propList);
198 dataTypes.add(dataType);
200 subcategory.setName("name");
201 subcategories.add(subcategory);
202 category.setName("name");
203 category.setSubcategories(subcategories);
204 categories.add(category);
206 resource.setCategories(categories);
207 resource.setVersion("version");
208 resource.setVendorName("vendorName");
209 resource.setVendorRelease("vendorRelease");
210 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
211 resource.setDataTypes(dataTypes);
216 private Service getNewService() {
217 Service service = new Service();
218 List<CategoryDefinition> categories = new ArrayList<>();
219 CategoryDefinition category = new CategoryDefinition();
220 List<SubCategoryDefinition> subcategories = new ArrayList<>();
221 SubCategoryDefinition subcategory = new SubCategoryDefinition();
223 subcategory.setName("name");
224 subcategories.add(subcategory);
225 category.setName("name");
226 category.setSubcategories(subcategories);
227 categories.add(category);
229 service.setCategories(categories);
230 service.setComponentType(ComponentTypeEnum.SERVICE);
231 service.setServiceType("serviceType");
232 service.setServiceRole("serviceRole");
233 service.setEnvironmentContext("environmentContext");
239 void testExportComponent() {
240 Component component = getNewResource();
241 Either<ToscaRepresentation, ToscaError> result;
243 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
244 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
245 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
246 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
247 .thenReturn(Either.left(Collections.emptyMap()));
249 // default test when component is Resource
250 result = testSubject.exportComponent(component);
251 assertNotNull(result);
253 component = getNewService();
254 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
255 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
256 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
258 // default test when component is Service
259 result = testSubject.exportComponent(component);
260 assertNotNull(result);
264 void testExportComponentInterface() {
265 Resource component = getNewResource();
266 Either<ToscaRepresentation, ToscaError> result;
268 component.setInterfaces(new HashMap<>());
270 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
271 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
272 .thenReturn(Either.left(Collections.emptyMap()));
273 // default test when convertInterfaceNodeType is right
274 result = testSubject.exportComponentInterface(component, false);
275 assertNotNull(result);
277 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
278 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
279 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
281 // default test when convertInterfaceNodeType is left
282 result = testSubject.exportComponentInterface(component, false);
283 assertNotNull(result);
287 void testConvertInterfaceNodeTypeProperties() {
289 Resource component = getNewResource();
291 component.setInterfaces(new HashMap<>());
292 InputDefinition input = new InputDefinition();
293 input.setName(COMPONENT_INPUT_NAME);
294 input.setType(COMPONENT_INPUT_TYPE);
295 component.setInputs(Collections.singletonList(input));
296 PropertyDefinition property = new PropertyDefinition();
297 property.setName(COMPONENT_PROPERTY_NAME);
298 property.setType(COMPONENT_PROPERTY_TYPE);
299 component.setProperties(Collections.singletonList(property));
300 component.setName(RESOURCE_NAME);
301 component.setToscaResourceName(RESOURCE_NAME);
303 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
304 .thenReturn(Either.left(Collections.emptyMap()));
305 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
306 // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
307 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
308 any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
310 Either<ToscaTemplate, ToscaError> result = (Either<ToscaTemplate, ToscaError>) Deencapsulation
311 .invoke(testSubject, "convertInterfaceNodeType", new HashMap<String, Component>(), component,
312 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
313 assertNotNull(result);
314 assertTrue(result.isLeft());
315 Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
316 assertEquals(1,nodeTypeMap.size());
317 ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
318 Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
319 // Check if inputs and properties in component are merged properly
320 assertEquals(2, propertyMap.size());
321 assertTrue(propertyMap.containsKey(COMPONENT_INPUT_NAME));
322 assertTrue(propertyMap.containsKey(COMPONENT_PROPERTY_NAME));
326 void testCreateToscaRepresentation() {
327 ToscaTemplate toscaTemplate = new ToscaTemplate("");
328 ToscaRepresentation result;
331 result = testSubject.createToscaRepresentation(toscaTemplate);
332 assertNotNull(result);
336 void testGetDependencies() {
338 Component component = new Resource();
339 Either<ToscaTemplate, ToscaError> result;
342 result = testSubject.getDependencies(component);
343 assertNotNull(result);
347 void testSetImports() {
348 Resource resource = new Resource();
349 resource.setResourceType(ResourceTypeEnum.PNF);
351 resource.setName("TestResourceName");
352 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
353 ArtifactDefinition artifact = new ArtifactDefinition();
354 artifact.setArtifactName("name.name2");
355 artifactList.put("assettoscatemplate", artifact);
356 resource.setArtifacts(artifactList);
357 resource.setToscaArtifacts(artifactList);
358 ToscaTemplate toscaTemplate = new ToscaTemplate("");
360 ComponentInstance ci = new ComponentInstance();
361 ci.setComponentUid("name");
362 ci.setOriginType(OriginTypeEnum.PNF);
363 ci.setSourceModelUid("modelName");
364 List<ComponentInstance> componentInstanceList = new LinkedList<>();
365 componentInstanceList.add(ci);
366 resource.setComponentInstances(componentInstanceList);
368 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(resource));
370 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
371 result = Deencapsulation.invoke(testSubject, "fillImports", resource, toscaTemplate);
373 verify(toscaOperationFacade, times(1)).getToscaFullElement("name");
374 assertTrue(result.isLeft());
375 ToscaTemplate toscaTemplateRes = result.left().value().left;
376 assertEquals(8, toscaTemplateRes.getImports().size());
377 assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface"));
378 assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName"));
379 assertEquals(1, toscaTemplateRes.getDependencies().size());
380 assertEquals("name.name2", toscaTemplateRes.getDependencies().get(0).getLeft());
384 void testConvertToscaTemplate() throws Exception {
386 final Component component = getNewResource();
387 final ToscaTemplate toscaNode = new ToscaTemplate("");
388 Either<ToscaTemplate, ToscaError> result;
389 final List<ComponentInstance> resourceInstances = new ArrayList<>();
390 final ComponentInstance instance = new ComponentInstance();
392 instance.setOriginType(OriginTypeEnum.SERVICE);
393 instance.setSourceModelUid("targetModelUid");
394 resourceInstances.add(instance);
396 component.setComponentInstances(resourceInstances);
398 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
399 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
401 final Map<String, ToscaProperty> map = new HashMap<>();
402 map.put("mock", new ToscaProperty());
403 doReturn(map).when(outputConverter).convert(any(), any());
406 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
407 assertNotNull(result);
411 void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException {
412 Component component = getNewResource();
413 ToscaTemplate toscaNode = new ToscaTemplate("");
414 Either<ToscaTemplate, ToscaError> result;
415 component.setComponentInstances(new ArrayList<>());
417 List<GroupDefinition> groups = new ArrayList<>();
418 GroupDefinition group = new GroupDefinition();
419 List<String> artifacts = new ArrayList<>();
420 artifacts.add("artifact");
421 group.setType("org.openecomp.groups.VfModule");
422 group.setArtifacts(artifacts);
424 component.setGroups(groups);
426 Map<String, String[]> substitutionMappingMap = new HashMap<>();
427 String[] array = {"value1", "value2"};
428 substitutionMappingMap.put("key", array);
430 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(),
431 any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
433 when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
434 .thenReturn(Either.left(Collections.emptyMap()));
436 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
438 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
440 when(groupExportParser.getGroups(component)).thenReturn(null);
442 final Map<String, ToscaProperty> map = new HashMap<>();
443 map.put("mock", new ToscaProperty());
444 doReturn(map).when(outputConverter).convert(any(), any());
446 // test component contains group
447 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
448 assertNotNull(result);
452 void testConvertToscaTemplateWhenComponentIsService() throws Exception {
453 Component component = getNewService();
454 ToscaTemplate toscaNode = new ToscaTemplate("");
455 Either<ToscaTemplate, ToscaError> result;
456 component.setComponentInstances(new ArrayList<>());
458 List<GroupDefinition> groups = new ArrayList<>();
459 GroupDefinition group = new GroupDefinition();
460 List<String> artifacts = new ArrayList<>();
461 artifacts.add("artifact");
462 group.setType("org.openecomp.groups.VfModule");
463 group.setArtifacts(artifacts);
465 component.setGroups(groups);
467 Map<String, String[]> substitutionMappingMap = new HashMap<>();
468 String[] array = {"value1", "value2"};
469 substitutionMappingMap.put("key", array);
471 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
472 .thenReturn(Either.left(substitutionMappingMap));
474 when(capabilityRequirementConverter
475 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
476 .thenReturn(Either.left(Collections.emptyMap()));
478 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
480 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
481 final Map<String, ToscaProperty> map = new HashMap<>();
482 map.put("mock", new ToscaProperty());
483 doReturn(map).when(outputConverter).convert(any(), any());
485 // test component contains group
486 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
487 assertNotNull(result);
491 void testConvertMetadata_1() {
493 Component component = getNewResource();
494 boolean isInstance = true;
495 ComponentInstance componentInstance = new ComponentInstance();
496 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
497 componentInstance.setSourceModelInvariant("targetModelInvariant");
500 Map<String, String> result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
501 assertNotNull(result);
505 void testFillImports() {
507 Component component = getNewService();
508 ToscaTemplate toscaTemplate = new ToscaTemplate("");
509 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
511 ComponentInstance instance = new ComponentInstance();
512 List<ComponentInstance> resourceInstances = new ArrayList<>();
513 instance.setComponentUid("name");
514 resourceInstances.add(instance);
515 component.setComponentInstances(resourceInstances);
516 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
517 ArtifactDefinition artifact = new ArtifactDefinition();
518 artifact.setArtifactName("name.name2");
519 toscaArtifacts.put("assettoscatemplate", artifact);
520 component.setToscaArtifacts(toscaArtifacts);
522 when(toscaOperationFacade.getToscaFullElement(any(String.class)))
523 .thenReturn(Either.left(component));
525 Resource baseType = getNewResource();
526 Map<String, ArtifactDefinition> baseTypeToscaArtifacts = new HashMap<>();
527 ArtifactDefinition baseTypeArtifact = new ArtifactDefinition();
528 baseTypeArtifact.setArtifactName("typeA");
529 baseTypeToscaArtifacts.put("assettoscatemplate", baseTypeArtifact);
530 baseType.setToscaArtifacts(baseTypeToscaArtifacts);
532 component.setDerivedFromGenericType("org.typeA");
533 component.setDerivedFromGenericVersion("1.0");
534 when(toscaOperationFacade.getByToscaResourceNameAndVersion("org.typeA", "1.0", null)).thenReturn(Either.left(baseType));
537 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
538 assertNotNull(result);
542 void testCreateDependency() {
544 Map<String, Component> componentCache = new HashMap<>();
545 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
546 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
547 ComponentInstance ci = new ComponentInstance();
548 Component component = getNewResource();
550 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
551 ArtifactDefinition artifact = new ArtifactDefinition();
552 artifact.setArtifactName("name.name2");
553 toscaArtifacts.put("assettoscatemplate", artifact);
554 component.setToscaArtifacts(toscaArtifacts);
555 ci.setComponentUid("name");
556 ci.setOriginType(OriginTypeEnum.ServiceProxy);
557 ci.setSourceModelUid("modelName");
559 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
561 when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service()));
564 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
565 assertFalse(componentCache.isEmpty());
569 void testGetInterfaceFilename() {
570 String artifactName = "artifact.name";
574 result = ToscaExportHandler.getInterfaceFilename(artifactName);
575 assertNotNull(result);
579 void testConvertNodeType() {
580 Component component = new Resource();
581 ToscaTemplate toscaNode = new ToscaTemplate("");
582 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
583 Either<ToscaTemplate, ToscaError> result;
585 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
586 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
587 .thenReturn(Either.left(Collections.emptyMap()));
589 result = Deencapsulation
590 .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
591 assertNotNull(result);
595 void testConvertInterfaceNodeType() {
596 Component component = getNewResource();
597 ToscaTemplate toscaNode = new ToscaTemplate("");
598 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
599 Either<ToscaTemplate, ToscaError> result;
600 List<InputDefinition> inputs = new ArrayList<>();
601 inputs.add(new InputDefinition());
602 component.setInputs(inputs);
604 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
605 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
606 .thenReturn(Either.left(Collections.emptyMap()));
608 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
609 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
612 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
614 assertNotNull(result);
618 void testConvertReqCapAndTypeName() {
619 Component component = new Resource();
620 ToscaTemplate toscaNode = new ToscaTemplate("");
621 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
622 ToscaNodeType toscaNodeType = new ToscaNodeType();
623 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
624 Either<ToscaTemplate, ToscaError> result;
627 capabilityRequirementConverter
628 .convertCapabilities(anyMap(), any(Resource.class), anyMap()))
629 .thenReturn(new HashMap<>());
631 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
632 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
635 result = Deencapsulation
636 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
637 toscaNodeType, dataTypes);
638 assertNotNull(result);
640 component = new Service();
642 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
643 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
645 // test when component is service
646 result = Deencapsulation
647 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
648 toscaNodeType, dataTypes);
649 assertNotNull(result);
653 void testConvertNodeTemplatesWhenComponentIsService() {
654 final Component component = getNewService();
655 final List<ComponentInstance> componentInstances = new ArrayList<>();
656 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
657 final Map<String, Component> componentCache = new HashMap<>();
658 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
659 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
660 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
661 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
662 final List<ComponentInstanceInput> inputs = new ArrayList<>();
663 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
664 componentInstanceInput.setUniqueId("uuid");
665 inputs.add(componentInstanceInput);
666 componentInstancesInputs.put("uuid", inputs);
667 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
668 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
669 reldef.setFromNode("node");
670 resourceInstancesRelations.add(reldef);
671 component.setComponentInstancesRelations(resourceInstancesRelations);
673 final ComponentInstance instance = new ComponentInstance();
674 instance.setUniqueId("id");
675 instance.setComponentUid("uid");
676 instance.setOriginType(OriginTypeEnum.ServiceProxy);
677 final List<GroupInstance> groupInstances = new ArrayList<>();
678 final GroupInstance groupInst = new GroupInstance();
679 final List<String> artifacts = new ArrayList<>();
680 artifacts.add("artifact");
681 groupInst.setArtifacts(artifacts);
682 groupInst.setType("type");
683 groupInstances.add(groupInst);
684 instance.setGroupInstances(groupInstances);
686 final List<PropertyDefinition> properties = new ArrayList<>();
687 properties.add(new PropertyDefinition());
688 instance.setProperties(properties);
690 instance.setUniqueId("uuid");
691 instance.setDescription("desc");
692 instance.setSourceModelUid("sourceModelUid");
694 componentInstances.add(instance);
696 component.setComponentInstances(componentInstances);
698 component.setComponentInstancesInputs(componentInstancesInputs);
699 component.setInvariantUUID("uuid");
700 component.setUUID("uuid");
701 component.setDescription("desc");
702 component.setUniqueId("uid");
704 componentCache.put("uid", component);
706 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
707 componentInstanceProperties.add(new ComponentInstanceProperty());
709 componentInstancesProperties.put("uuid", componentInstanceProperties);
710 component.setComponentInstancesProperties(componentInstancesProperties);
712 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
713 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
714 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
715 componentInstanceAttribute.setDefaultValue("def value");
716 componentInstanceAttributes.add(componentInstanceAttribute);
718 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
719 component.setComponentInstancesAttributes(componentInstancesAttributes);
721 ComponentInstanceProperty cip = new ComponentInstanceProperty();
722 cip.setInstanceUniqueId("id");
724 List<ComponentInstanceProperty> list = new ArrayList<>();
727 componentInstancesProperties.put("id", list);
728 component.setComponentInstancesProperties(componentInstancesProperties);
730 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
731 when(capabilityRequirementConverter
732 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
733 .thenReturn(Either.left(new ToscaNodeTemplate()));
734 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
735 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
736 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
737 .thenReturn(Either.left(new ToscaNodeType()));
738 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
739 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
740 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
741 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(new Resource()));
743 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
744 final String[] array = {"value1", "value2"};
745 substitutionMappingMap.put("key", array);
746 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
747 .thenReturn(Either.left(substitutionMappingMap));
749 when(capabilityRequirementConverter
750 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
751 .thenReturn(Either.left(Collections.emptyMap()));
754 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
755 assertNotNull(toscaRepresentationToscaErrorEither);
760 void testConvertNodeTemplatesWhenComponentIsResource() {
761 final Resource component = getNewResource();
762 component.setResourceType(VF);
763 final List<ComponentInstance> componentInstances = new ArrayList<>();
764 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
765 final Map<String, Component> componentCache = new HashMap<>();
766 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
767 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
768 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
769 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
770 final List<ComponentInstanceInput> inputs = new ArrayList<>();
771 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
772 componentInstanceInput.setUniqueId("uuid");
773 inputs.add(componentInstanceInput);
774 componentInstancesInputs.put("uuid", inputs);
775 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
776 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
777 reldef.setFromNode("node");
778 resourceInstancesRelations.add(reldef);
779 component.setComponentInstancesRelations(resourceInstancesRelations);
781 final ComponentInstance instance = new ComponentInstance();
782 instance.setUniqueId("id");
783 instance.setComponentUid("uid");
784 instance.setOriginType(OriginTypeEnum.VFC);
785 final List<GroupInstance> groupInstances = new ArrayList<>();
786 final GroupInstance groupInst = new GroupInstance();
787 final List<String> artifacts = new ArrayList<>();
788 artifacts.add("artifact");
789 groupInst.setArtifacts(artifacts);
790 groupInst.setType("type");
791 groupInstances.add(groupInst);
792 instance.setGroupInstances(groupInstances);
794 final List<PropertyDefinition> properties = new ArrayList<>();
795 properties.add(new PropertyDefinition());
796 instance.setProperties(properties);
797 component.setProperties(properties);
799 instance.setUniqueId("uuid");
800 instance.setDescription("desc");
801 instance.setSourceModelUid("sourceModelUid");
802 final Map<String, ArtifactDefinition> artifactList = new HashMap<>();
803 final ArtifactDefinition artifact = new ArtifactDefinition();
804 artifact.setArtifactName("name.name2");
805 artifactList.put("assettoscatemplate", artifact);
806 instance.setArtifacts(artifactList);
808 Map<String, ToscaArtifactDataDefinition> toscaArtifactDataDefinitionMap = new HashMap<>();
809 toscaArtifactDataDefinitionMap.put("assettoscatemplate", new ToscaArtifactDataDefinition());
810 instance.setToscaArtifacts(toscaArtifactDataDefinitionMap);
812 componentInstances.add(instance);
814 component.setComponentInstances(componentInstances);
816 component.setComponentInstancesInputs(componentInstancesInputs);
817 component.setInvariantUUID("uuid");
818 component.setUUID("uuid");
819 component.setDescription("desc");
820 component.setUniqueId("uid");
822 componentCache.put("uid", component);
824 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
825 componentInstanceProperties.add(new ComponentInstanceProperty());
827 componentInstancesProperties.put("uuid", componentInstanceProperties);
828 component.setComponentInstancesProperties(componentInstancesProperties);
830 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
831 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
832 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
833 componentInstanceAttribute.setDefaultValue("def value");
834 componentInstanceAttributes.add(componentInstanceAttribute);
836 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
837 component.setComponentInstancesAttributes(componentInstancesAttributes);
839 component.setArtifacts(artifactList);
840 component.setToscaArtifacts(artifactList);
842 final List<AttributeDefinition> attributes = new ArrayList<>();
843 final var attribute = new AttributeDefinition();
844 attribute.setName("mock");
845 attributes.add(attribute);
846 component.setAttributes(attributes);
848 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
849 componentInstanceInputs.add(new ComponentInstanceInput());
851 componentInstancesInputs.put("id", componentInstanceInputs);
852 component.setComponentInstancesInputs(componentInstancesInputs);
854 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
855 when(capabilityRequirementConverter
856 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
857 .thenReturn(Either.left(new ToscaNodeTemplate()));
858 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
859 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
860 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class), any(ToscaNodeType.class)))
861 .thenReturn(Either.left(new ToscaNodeType()));
862 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
863 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
864 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
865 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(new Resource()));
867 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
868 final String[] array = {"value1", "value2"};
869 substitutionMappingMap.put("key", array);
870 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
871 .thenReturn(Either.left(substitutionMappingMap));
873 when(capabilityRequirementConverter
874 .convertSubstitutionMappingRequirements(any(Component.class), anyMap()))
875 .thenReturn(Either.left(Collections.emptyMap()));
878 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
879 assertNotNull(toscaRepresentationToscaErrorEither);
884 void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() {
885 Component component = getNewResource();
886 List<ComponentInstance> componentInstances = new ArrayList<>();
887 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
888 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
889 Map<String, Component> componentCache = new HashMap<>();
890 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
891 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
892 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
893 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
894 List<ComponentInstanceInput> inputs = new ArrayList<>();
895 inputs.add(new ComponentInstanceInput());
896 componentInstancesInputs.put("key", inputs);
897 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
898 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
899 reldef.setFromNode("node");
900 resourceInstancesRelations.add(reldef);
901 component.setComponentInstancesRelations(resourceInstancesRelations);
903 ComponentInstance instance = new ComponentInstance();
904 instance.setUniqueId("id");
905 instance.setComponentUid("uid");
906 instance.setOriginType(OriginTypeEnum.ServiceProxy);
907 componentInstances.add(instance);
908 component.setComponentInstances(componentInstances);
910 component.setComponentInstancesInputs(componentInstancesInputs);
911 component.setInvariantUUID("uuid");
912 component.setUUID("uuid");
913 component.setDescription("desc");
915 componentCache.put("uid", component);
917 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
918 when(capabilityRequirementConverter
919 .convertComponentInstanceCapabilities(any(ComponentInstance.class), anyMap(), any(ToscaNodeTemplate.class)))
920 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
921 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
922 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
923 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
924 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
927 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
928 assertNotNull(toscaRepresentationToscaErrorEither);
932 void testConvetNodeTemplateWhenGetOriginComponentIsRight() {
933 Component component = getNewResource();
934 List<ComponentInstance> componentInstances = new ArrayList<>();
935 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
936 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
937 Map<String, Component> componentCache = new HashMap<>();
938 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
939 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
940 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
941 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
942 List<ComponentInstanceInput> inputs = new ArrayList<>();
943 inputs.add(new ComponentInstanceInput());
944 componentInstancesInputs.put("key", inputs);
945 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
946 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
947 reldef.setFromNode("id");
948 resourceInstancesRelations.add(reldef);
949 component.setComponentInstancesRelations(resourceInstancesRelations);
951 ComponentInstance instance = new ComponentInstance();
952 instance.setUniqueId("id");
953 instance.setComponentUid("uid");
954 instance.setOriginType(OriginTypeEnum.ServiceProxy);
955 componentInstances.add(instance);
956 component.setComponentInstances(componentInstances);
958 component.setComponentInstancesInputs(componentInstancesInputs);
959 component.setInvariantUUID("uuid");
960 component.setUUID("uuid");
961 component.setDescription("desc");
963 final List<AttributeDefinition> attributes = new ArrayList<>();
964 final var attribute = new AttributeDefinition();
965 attribute.setName("mock");
966 attributes.add(attribute);
967 component.setAttributes(attributes);
969 componentCache.put("uid", component);
971 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.right(false));
972 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
973 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
974 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
975 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
978 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
979 assertNotNull(toscaRepresentationToscaErrorEither);
983 void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
984 Resource component = getNewResource();
985 component.setResourceType(VF);
986 List<ComponentInstance> componentInstances = new ArrayList<>();
987 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
988 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
989 Map<String, Component> componentCache = new HashMap<>();
990 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
991 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
992 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
993 List<ComponentInstanceInput> inputs = new ArrayList<>();
994 inputs.add(new ComponentInstanceInput());
995 componentInstancesInputs.put("key", inputs);
996 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
997 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
998 reldef.setFromNode("id");
999 reldef.setToNode("node");
1000 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1001 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1002 relationship.setRelation(new RelationshipInfo());
1003 relationships.add(relationship);
1004 reldef.setRelationships(relationships);
1005 resourceInstancesRelations.add(reldef);
1006 component.setComponentInstancesRelations(resourceInstancesRelations);
1008 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
1009 ArtifactDefinition artifact = new ArtifactDefinition();
1010 artifact.setArtifactName("name.name2");
1011 artifactList.put("assettoscatemplate", artifact);
1012 component.setArtifacts(artifactList);
1013 component.setToscaArtifacts(artifactList);
1015 ComponentInstance instance = new ComponentInstance();
1016 instance.setUniqueId("id");
1017 instance.setComponentUid("id");
1018 instance.setOriginType(OriginTypeEnum.VF);
1019 componentInstances.add(instance);
1020 component.setComponentInstances(componentInstances);
1022 component.setComponentInstancesInputs(componentInstancesInputs);
1023 component.setComponentInstances(componentInstances);
1025 doReturn(Either.left(component)).when(toscaOperationFacade).getToscaFullElement("id");
1026 when(capabilityRequirementConverter.getOriginComponent(anyMap(), any(ComponentInstance.class))).thenReturn(Either.left(component));
1027 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any())).thenReturn(Either.left(Collections.emptyMap()));
1028 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1029 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Resource.class),
1030 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1031 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1032 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1035 final Either<ToscaRepresentation, ToscaError> result = testSubject.exportComponent(component);
1036 assertNotNull(result);
1040 void testCreateNodeType() {
1042 Component component = new Resource();
1043 List<String> array = new ArrayList<>();
1045 ((Resource) component).setDerivedFrom(array);
1046 ToscaNodeType result;
1048 // test when component is resource
1049 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1050 assertNotNull(result);
1052 component = new Service();
1053 // test when component is service
1054 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1055 assertNotNull(result);
1059 void testCreateProxyInterfaceTypesComponentNotFound() {
1060 Component container = new Service();
1061 Either<Map<String, ToscaNodeType>, ToscaError> result;
1062 List<ComponentInstance> componentInstances = new ArrayList<>();
1063 ComponentInstance instance = new ComponentInstance();
1064 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1065 instance.setSourceModelUid("targetModelUid");
1066 instance.setToscaComponentName("toscaComponentName");
1068 componentInstances.add(instance);
1069 container.setComponentInstances(componentInstances);
1070 when(toscaOperationFacade.getToscaElement(any(String.class),
1071 any(ComponentParametersView.class)))
1072 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1073 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1074 assertTrue(result.isRight());
1078 void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
1079 Component container = new Service();
1080 Either<Map<String, ToscaNodeType>, ToscaError> result;
1081 List<ComponentInstance> componentInstances = new ArrayList<>();
1082 ComponentInstance instance = new ComponentInstance();
1083 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1084 instance.setSourceModelUid("targetModelUid");
1085 instance.setToscaComponentName("toscaComponentName");
1086 componentInstances.add(instance);
1087 container.setComponentInstances(componentInstances);
1089 when(toscaOperationFacade.getToscaElement(any(String.class),
1090 any(ComponentParametersView.class)))
1091 .thenReturn(Either.left(new Resource()));
1092 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1093 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1094 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1095 assertTrue(result.isRight());
1099 void testCreateProxyInterfaceTypesPositive() {
1100 Component container = new Service();
1101 Either<Map<String, ToscaNodeType>, ToscaError> result;
1102 List<ComponentInstance> componentInstances = new ArrayList<>();
1103 ComponentInstance instance = new ComponentInstance();
1104 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1105 instance.setSourceModelUid("targetModelUid");
1106 instance.setToscaComponentName("toscaComponentName");
1107 componentInstances.add(instance);
1108 container.setComponentInstances(componentInstances);
1110 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1111 .thenReturn(Either.left(Collections.emptyMap()));
1113 Component proxyResource = new Resource();
1114 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1115 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1116 proxyResource.setInterfaces(proxyInterfaces);
1117 when(toscaOperationFacade.getToscaElement(any(String.class),
1118 any(ComponentParametersView.class)))
1119 .thenReturn(Either.left(proxyResource));
1121 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1122 assertNotNull(result);
1123 assertTrue(result.isLeft());
1124 assertEquals(1, result.left().value().size());
1128 void testCreateProxyNodeTypes() {
1129 Map<String, Component> componentCache = new HashMap<>();
1130 Component container = new Resource();
1131 Either<Map<String, ToscaNodeType>, ToscaError> result;
1132 List<ComponentInstance> componentInstances = new ArrayList<>();
1133 ComponentInstance instance = new ComponentInstance();
1134 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1135 instance.setSourceModelUid("targetModelUid");
1137 componentInstances.add(instance);
1138 container.setComponentInstances(componentInstances);
1140 when(toscaOperationFacade.getLatestByName("serviceProxy", null))
1141 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1143 // test when getLatestByName return is right
1144 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1145 assertNotNull(result);
1149 void testCreateServiceSubstitutionNodeTypes() {
1150 Map<String, Component> componentCache = new HashMap<>();
1152 Component referencedService = getNewService();
1153 referencedService.setInvariantUUID("uuid");
1154 referencedService.setUUID("uuid");
1155 referencedService.setUniqueId("targetModelUid");
1156 referencedService.setDescription("desc");
1157 componentCache.put("targetModelUid", referencedService);
1159 Component containerService = new Service();
1160 List<ComponentInstance> componentInstances = new ArrayList<>();
1161 ComponentInstance instance = new ComponentInstance();
1162 instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1163 instance.setSourceModelUid("targetModelUid");
1165 componentInstances.add(instance);
1166 containerService.setComponentInstances(componentInstances);
1168 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes(any()))
1169 .thenReturn(Either.left(Collections.emptyMap()));
1170 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1171 when(capabilityRequirementConverter.convertRequirements(anyMap(), any(Service.class),
1172 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1174 ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1176 Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1177 assertNotNull(toscaNode.getNode_types());
1181 void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1182 Map<String, Component> componentCache = new HashMap<>();
1183 Component container = new Resource();
1184 Either<Map<String, ToscaNodeType>, ToscaError> result;
1185 List<ComponentInstance> componentInstances = new ArrayList<>();
1186 ComponentInstance instance = new ComponentInstance();
1187 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1188 instance.setSourceModelUid("targetModelUid");
1190 componentInstances.add(instance);
1191 container.setComponentInstances(componentInstances);
1193 when(toscaOperationFacade.getLatestByName("serviceProxy", null)).thenReturn(Either.left(new Resource()));
1195 ComponentParametersView parameterView = new ComponentParametersView();
1196 parameterView.disableAll();
1197 parameterView.setIgnoreCategories(false);
1199 when(toscaOperationFacade.getToscaElement(any(String.class),
1200 any(ComponentParametersView.class)))
1201 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1203 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1205 // test when getLatestByName is left
1206 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1207 assertNotNull(result);
1211 void testCreateProxyNodeType() {
1212 Map<String, Component> componentCache = new HashMap<>();
1213 Component origComponent = new Resource();
1214 Component proxyComponent = new Resource();
1215 ComponentInstance instance = new ComponentInstance();
1216 ToscaNodeType result;
1218 when(applicationDataTypeCache.getAll(null)).thenReturn(Either.left(new HashMap<>()));
1221 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1222 proxyComponent, instance);
1223 assertNotNull(result);
1227 void testConvertComponentInstanceRequirements() {
1228 Component component = new Resource();
1229 ComponentInstance componentInstance = new ComponentInstance();
1230 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1231 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1232 Component originComponent = new Resource();
1233 Map<String, Component> componentCache = new HashMap<>();
1234 Either<ToscaNodeTemplate, ToscaError> result;
1237 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1238 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1239 assertNotNull(result);
1241 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1242 reldef.setFromNode("name");
1243 reldef.setToNode("name1");
1244 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1245 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1246 cap.setRelation(new RelationshipInfo());
1247 relationships.add(cap);
1248 reldef.setRelationships(relationships);
1249 relations.add(reldef);
1250 componentInstance.setUniqueId("name");
1252 List<ComponentInstance> instances = new ArrayList<>();
1253 instances.add(componentInstance);
1254 component.setComponentInstances(instances);
1256 // test when filteredRElations ins't empty
1257 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1258 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1259 assertNotNull(result);
1263 void buildRequirementFailure() {
1264 final Component fromOriginComponent = new Resource();
1265 final ComponentInstance fromInstance = new ComponentInstance();
1266 final String fromInstanceUid = "fromInstanceUid";
1267 fromInstance.setUniqueId(fromInstanceUid);
1268 fromInstance.setComponentUid("componentUid");
1269 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1270 relationshipDefinition.setToNode("wrongNodeUid");
1271 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1272 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1273 relationship.setRequirement(new RequirementDataDefinition());
1274 relationshipList.add(relationship);
1275 relationshipDefinition.setRelationships(relationshipList);
1276 final List<ComponentInstance> instancesList = new ArrayList<>();
1277 instancesList.add(fromInstance);
1278 String expectedError = String
1279 .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1280 relationshipDefinition.getToNode());
1281 assertThrows(ToscaExportException.class, () ->
1282 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1283 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1286 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1287 instancesList, relationshipDefinition, new HashMap<>());
1288 } catch (Exception e) {
1289 assertTrue(e instanceof ToscaExportException);
1290 assertEquals(expectedError, e.getMessage());
1293 final RelationshipInfo relation = new RelationshipInfo();
1294 final String requirementUid = "Uid";
1295 relation.setRequirementUid(requirementUid);
1296 final String requirementName = "requirementName";
1297 relation.setRequirement(requirementName);
1298 final String capabilityName = "capabilityName";
1299 relation.setCapability(capabilityName);
1300 final String capabilityOwnerId = "capabilityOwnerId";
1301 relation.setCapabilityOwnerId(capabilityOwnerId);
1302 relationship.setRelation(relation);
1304 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1305 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1306 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1307 fromOriginComponent.setRequirements(requirementMap);
1308 relationshipDefinition.setToNode(fromInstanceUid);
1310 expectedError = String
1311 .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1312 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1314 assertThrows(ToscaExportException.class, () ->
1315 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1316 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1318 requirementDefinition.setName(requirementName);
1320 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1321 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1323 expectedError = String.format(
1324 "Failed to build substituted name for the requirement %s. "
1325 + "Failed to get an origin component with uniqueId %s",
1326 requirementName, fromInstance.getActualComponentUid());
1327 assertThrows(ToscaExportException.class, () -> Deencapsulation
1328 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1329 relationshipDefinition, new HashMap<>()), expectedError);
1331 final Component toOriginComponent = new Resource();
1332 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1333 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1335 capabilityDefinition.setName(capabilityName);
1336 capabilityDefinition.setOwnerId(capabilityOwnerId);
1337 capabilityDefinition.setType("aType");
1338 final String capabilityPreviousName = "capabilityPreviousName";
1339 capabilityDefinition.setPreviousName(capabilityPreviousName);
1340 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1341 toOriginComponent.setCapabilities(capabilityMap);
1342 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1343 .thenReturn(Either.left(toOriginComponent));
1345 requirementDefinition.setCapability(capabilityName);
1346 relation.setCapability("wrong");
1347 final String requirementPreviousName = "requirementPreviousName";
1348 requirementDefinition.setPreviousName(requirementPreviousName);
1349 requirementDefinition.setPath(new ArrayList<>());
1351 expectedError = String
1352 .format("Failed to find a capability with name %s on a component with uniqueId %s",
1353 relation.getCapability(), fromOriginComponent.getUniqueId());
1355 assertThrows(ToscaExportException.class, () -> Deencapsulation
1356 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1357 relationshipDefinition, new HashMap<>()),
1362 void testBuildRequirement() {
1363 final ComponentInstance fromInstance = new ComponentInstance();
1364 fromInstance.setUniqueId("name");
1365 fromInstance.setComponentUid("string");
1366 final List<ComponentInstance> instancesList = new ArrayList<>();
1368 final Map<String, Component> componentCache = new HashMap<>();
1369 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1370 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1371 relationship.setRequirement(new RequirementDataDefinition());
1372 final RelationshipInfo relation = new RelationshipInfo();
1373 final String requirementUid = "Uid";
1374 relation.setRequirementUid(requirementUid);
1375 final String requirementName = "requirementName";
1376 relation.setRequirement(requirementName);
1377 final String capabilityName = "capabilityName";
1378 relation.setCapability(capabilityName);
1379 final String capabilityOwnerId = "capabilityOwnerId";
1380 relation.setCapabilityOwnerId(capabilityOwnerId);
1381 relationship.setRelation(relation);
1382 relationshipList.add(relationship);
1383 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1384 relationshipDefinition.setRelationships(relationshipList);
1385 relationshipDefinition.setToNode("name");
1386 instancesList.add(fromInstance);
1387 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1388 requirementDefinition.setName(requirementName);
1389 requirementDefinition.setCapability(capabilityName);
1390 final String requirementPreviousName = "requirementPreviousName";
1391 requirementDefinition.setPreviousName(requirementPreviousName);
1392 requirementDefinition.setPath(new ArrayList<>());
1393 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1394 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1395 final Component fromOriginComponent = new Resource();
1396 fromOriginComponent.setRequirements(requirementMap);
1398 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1399 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1400 capabilityDefinition.setName(capabilityName);
1401 capabilityDefinition.setOwnerId(capabilityOwnerId);
1402 final String capabilityPreviousName = "capabilityPreviousName";
1403 capabilityDefinition.setPreviousName(capabilityPreviousName);
1404 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1405 final Component toOriginComponent = new Resource();
1406 toOriginComponent.setCapabilities(capabilityMap);
1408 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1409 .thenReturn(Either.left(toOriginComponent));
1410 final String builtCapabilityName = "builtCapabilityName";
1412 capabilityRequirementConverter
1413 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1414 capabilityPreviousName), any()))
1415 .thenReturn(Either.left(builtCapabilityName));
1417 final String builtRequirementName = "builtRequirementName";
1419 capabilityRequirementConverter
1420 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1421 requirementPreviousName), any()))
1422 .thenReturn(Either.left(builtRequirementName));
1424 final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1425 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1426 instancesList, relationshipDefinition, componentCache);
1427 assertNotNull(actualRequirementMap);
1428 assertFalse(actualRequirementMap.isEmpty());
1429 assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1430 final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1431 assertNotNull(actualToscaTemplateRequirement);
1432 assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1434 //to toOriginComponent not found
1435 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1436 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1438 assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1439 instancesList, relationshipDefinition, componentCache));
1443 void testAddRequirmentsWithBuildAndAddRequirements() {
1444 ComponentInstance fromInstance = new ComponentInstance();
1445 Component fromOriginComponent = new Resource();
1446 List<ComponentInstance> instancesList = new ArrayList<>();
1447 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1448 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1449 Map<String, Component> componentCache = new HashMap<>();
1451 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1452 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1453 cap.setRequirement(new RequirementDataDefinition());
1454 RelationshipInfo relation = new RelationshipInfo();
1455 relation.setRequirementUid("Uid");
1456 relation.setRequirement("requirment");
1457 relation.setCapability("cap");
1458 relation.setCapabilityOwnerId("id");
1459 cap.setRelation(relation);
1460 relationships.add(cap);
1461 rel.setRelationships(relationships);
1462 rel.setToNode("name");
1463 fromInstance.setUniqueId("name");
1464 fromInstance.setComponentUid("string");
1465 instancesList.add(fromInstance);
1466 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1468 List<RequirementDefinition> defs = new ArrayList<>();
1469 RequirementDefinition def = new RequirementDefinition();
1470 def.setName("requirment");
1471 def.setCapability("cap");
1473 requirements.put("key", defs);
1474 fromOriginComponent.setRequirements(requirements);
1476 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1477 List<CapabilityDefinition> caps = new ArrayList<>();
1478 CapabilityDefinition capdef = new CapabilityDefinition();
1479 capdef.setOwnerId("id");
1480 capdef.setName("cap");
1481 capdef.setPreviousName("before cap");
1482 capdef.setType("type");
1484 capabilities.put("cap", caps);
1485 fromOriginComponent.setCapabilities(capabilities);
1487 when(toscaOperationFacade.getToscaElement(any(String.class),
1488 any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1491 capabilityRequirementConverter
1492 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString(), any()))
1493 .thenReturn(Either.right(false));
1495 final String expectedErrorMsg =
1496 String.format("Failed to build a substituted capability name for the capability "
1497 + "with name %s on a component with uniqueId %s",
1498 cap.getRequirement(), fromOriginComponent.getUniqueId());
1500 assertThrows(ToscaExportException.class, () ->
1501 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1502 rel, componentCache), expectedErrorMsg);
1506 void testBuildAndAddRequirement() {
1507 Component fromOriginComponent = new Resource();
1508 Component toOriginComponent = new Resource();
1509 CapabilityDefinition capability = new CapabilityDefinition();
1510 RequirementDefinition requirement = new RequirementDefinition();
1511 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1512 ComponentInstance toInstance = new ComponentInstance();
1513 Map<String, Component> componentCache = new HashMap<>();
1514 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1515 capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1516 capability.setPath(new ArrayList<>());
1517 capability.setPreviousName("before cap");
1518 reqAndRelationshipPair.setCapability("cap");
1519 requirement.setPath(new ArrayList<>());
1520 requirement.setPreviousName("before req");
1521 reqAndRelationshipPair.setRequirement("req");
1524 capabilityRequirementConverter
1525 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString(), any()))
1526 .thenReturn(Either.left("buildCapNameRes"));
1529 capabilityRequirementConverter
1530 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString(), any()))
1531 .thenReturn(Either.left("buildReqNameRes"));
1534 final Map<String, ToscaTemplateRequirement> requirementMap =
1535 Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1536 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1537 assertNotNull(requirementMap);
1538 assertFalse(requirementMap.isEmpty());
1539 assertTrue(requirementMap.containsKey("buildReqNameRes"));
1540 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1541 assertNotNull(actualToscaTemplateRequirement);
1542 assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1546 void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1547 final Component fromOriginComponent = new Resource();
1548 final Component toOriginComponent = new Resource();
1549 final CapabilityDefinition capability = new CapabilityDefinition();
1550 final RequirementDefinition requirement = new RequirementDefinition();
1551 final RelationshipInfo relationship = new RelationshipInfo();
1552 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1553 capabilityRequirementRelationship.setRelation(relationship);
1554 ComponentInstance toInstance = new ComponentInstance();
1555 Map<String, Component> componentCache = new HashMap<>();
1556 capability.setPath(new ArrayList<>());
1557 relationship.setCapability("cap");
1558 requirement.setPath(new ArrayList<>());
1559 relationship.setRequirement("req");
1561 final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1562 when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("cap"), any(), any()))
1563 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1564 when(capabilityRequirementConverter.buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("req"), any(), any()))
1565 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1567 final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1568 .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1569 capabilityRequirementRelationship, toInstance, componentCache);
1570 assertNotNull(requirementMap);
1571 assertFalse(requirementMap.isEmpty());
1572 assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1573 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1574 assertNotNull(actualToscaTemplateRequirement);
1575 assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1579 void testIsRequirementBelongToRelation() {
1581 Component originComponent = new Resource();
1582 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1583 RequirementDefinition requirement = new RequirementDefinition();
1584 String fromInstanceId = "";
1587 requirement.setName("name");
1588 reqAndRelationshipPair.setRequirement("name1");
1590 // test return false
1591 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1592 reqAndRelationshipPair, requirement, fromInstanceId);
1593 assertFalse(result);
1597 void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1599 Component originComponent = new Service();
1600 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1601 RequirementDefinition requirement = new RequirementDefinition();
1602 String fromInstanceId = "";
1605 // default test return true
1606 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1607 reqAndRelationshipPair, requirement, fromInstanceId);
1612 void testIsRequirementBelongToOwner() {
1614 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1615 RequirementDefinition requirement = new RequirementDefinition();
1616 String fromInstanceId = "";
1617 Component originComponent = new Resource();
1620 requirement.setOwnerId("owner1");
1621 reqAndRelationshipPair.setRequirementOwnerId("owner");
1624 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1625 fromInstanceId, originComponent);
1626 assertFalse(result);
1632 Component component = new Service();
1635 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1636 assertFalse(result);
1640 void testConvertCapabilities() {
1641 final Component component = new Resource();
1642 final Map<String, Component> componentCache = new HashMap<>();
1644 final Either<Map<String, String[]>, ToscaError> expectedResult = Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR);
1645 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1646 .thenReturn(expectedResult);
1648 // default test return isRight
1649 final Either<Map<String, String[]>, ToscaError> actualResult =
1650 Deencapsulation.invoke(testSubject, "convertSubstitutionMappingCapabilities", component, componentCache);
1651 assertNotNull(actualResult);
1652 assertEquals(expectedResult, actualResult);
1656 void testConvertCapabilities_1() {
1657 Component component = new Resource();
1658 ToscaNodeType nodeType = new ToscaNodeType();
1659 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1660 Either<ToscaNodeType, ToscaError> result;
1662 Map<String, ToscaCapability> capabilities = new HashMap<>();
1663 capabilities.put("key", new ToscaCapability());
1666 result = Deencapsulation
1667 .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1668 assertNotNull(result);
1672 void testConvertToNodeTemplateArtifacts() {
1673 Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1674 ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1675 art.setFile("test_file");
1676 art.setType("test_type");
1677 Map<String, ToscaTemplateArtifact> result;
1678 container.put("test_art", art);
1679 result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1680 assertNotNull(result);
1681 assertTrue(MapUtils.isNotEmpty(result));
1682 assertEquals("test_file", result.get("test_art").getFile());
1683 assertEquals("test_type", result.get("test_art").getType());
1687 void testGetProxyNodeTypeInterfacesNoInterfaces() {
1688 Component service = new Service();
1689 Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1690 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1691 assertFalse(proxyNodeTypeInterfaces.isPresent());
1695 void testGetProxyNodeTypeInterfaces() {
1696 Component service = getTestComponent();
1697 Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1698 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1699 assertTrue(proxyNodeTypeInterfaces.isPresent());
1700 Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1701 assertNotNull(componentInterfaces);
1706 void testGetProxyNodeTypePropertiesComponentNull() {
1707 Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1708 testSubject.getProxyNodeTypeProperties(null, DATA_TYPES);
1709 assertFalse(proxyNodeTypeProperties.isPresent());
1713 void testGetProxyNodeTypePropertiesNoProperties() {
1714 Component service = new Service();
1715 Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1716 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1717 assertFalse(proxyNodeTypeProperties.isPresent());
1721 void testGetProxyNodeTypeProperties() {
1722 Component service = getTestComponent();
1723 service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1724 createMockProperty("componentPropInt", null)));
1725 Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1726 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1727 assertTrue(proxyNodeTypeProperties.isPresent());
1728 Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
1729 assertNotNull(componentProperties);
1730 assertEquals(2, componentProperties.size());
1734 void testAddInputsToPropertiesNoInputs() {
1735 Component service = getTestComponent();
1736 service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1737 createMockProperty("componentPropInt", null)));
1738 Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1739 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1741 assertTrue(proxyNodeTypePropertiesResult.isPresent());
1742 Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1743 testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties);
1744 assertNotNull(proxyNodeTypeProperties);
1745 assertEquals(2, proxyNodeTypeProperties.size());
1746 testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties);
1747 assertEquals(2, proxyNodeTypeProperties.size());
1751 void testAddInputsToPropertiesWithInputs() {
1752 Component service = getTestComponent();
1753 service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1754 createMockProperty("componentPropInt", null)));
1755 service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1756 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1757 Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1758 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1760 assertTrue(proxyNodeTypePropertiesResult.isPresent());
1761 Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1762 testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1763 assertNotNull(proxyNodeTypeProperties);
1764 assertEquals(4, proxyNodeTypeProperties.size());
1768 void testAddInputsToPropertiesOnlyInputs() {
1769 Component service = getTestComponent();
1770 service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1771 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1772 Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1773 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1775 assertTrue(proxyNodeTypePropertiesResult.isPresent());
1776 Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1777 testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1778 assertNotNull(proxyNodeTypeProperties);
1779 assertEquals(2, proxyNodeTypeProperties.size());
1783 void testOperationImplementationInProxyNodeTypeNotPresent() {
1784 Component service = getTestComponent();
1785 InterfaceDefinition interfaceDefinition =
1786 service.getInterfaces().get("normalizedServiceComponentName-interface");
1787 interfaceDefinition.setOperations(new HashMap<>());
1788 final OperationDataDefinition operation = new OperationDataDefinition();
1789 operation.setName("start");
1790 operation.setDescription("op description");
1791 final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
1792 implementation.setArtifactName("createBPMN.bpmn");
1793 operation.setImplementation(implementation);
1794 interfaceDefinition.getOperations().put(operation.getName(), operation);
1795 service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
1796 service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1797 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1798 Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1799 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1800 assertTrue(proxyNodeTypeInterfaces.isPresent());
1801 Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1802 assertNotNull(componentInterfaces);
1805 private Component getTestComponent() {
1806 Component component = new Service();
1807 component.setNormalizedName("normalizedServiceComponentName");
1808 InterfaceDefinition addedInterface = new InterfaceDefinition();
1809 addedInterface.setType("com.some.service.or.other.serviceName");
1810 final String interfaceType = "normalizedServiceComponentName-interface";
1811 component.setInterfaces(new HashMap<>());
1812 component.getInterfaces().put(interfaceType, addedInterface);
1816 private PropertyDefinition createMockProperty(String propertyName, String defaultValue) {
1817 PropertyDefinition propertyDefinition = new PropertyDefinition();
1818 propertyDefinition.setName(propertyName);
1819 propertyDefinition.setType("string");
1820 propertyDefinition.setDefaultValue(defaultValue);
1821 return propertyDefinition;
1824 private InputDefinition createMockInput(String inputName, String defaultValue) {
1825 InputDefinition inputDefinition = new InputDefinition();
1826 inputDefinition.setName(inputName);
1827 inputDefinition.setType("string");
1828 inputDefinition.setDefaultValue(defaultValue);
1829 return inputDefinition;