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.hamcrest.CoreMatchers.is;
26 import static org.junit.Assert.assertEquals;
27 import static org.junit.Assert.assertFalse;
28 import static org.junit.Assert.assertThat;
29 import static org.junit.Assert.assertTrue;
30 import static org.junit.jupiter.api.Assertions.assertNotNull;
31 import static org.junit.jupiter.api.Assertions.assertThrows;
32 import static org.mockito.ArgumentMatchers.any;
33 import static org.mockito.ArgumentMatchers.anyBoolean;
34 import static org.mockito.ArgumentMatchers.anyList;
35 import static org.mockito.ArgumentMatchers.anyMap;
36 import static org.mockito.ArgumentMatchers.anyString;
37 import static org.mockito.ArgumentMatchers.eq;
38 import static org.mockito.ArgumentMatchers.isNull;
39 import static org.mockito.Mockito.doReturn;
40 import static org.mockito.Mockito.times;
41 import static org.mockito.Mockito.verify;
42 import static org.mockito.Mockito.when;
43 import static org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum.VF;
44 import static org.openecomp.sdc.be.tosca.PropertyConvertor.PropertyType.PROPERTY;
46 import fj.data.Either;
47 import java.util.ArrayList;
48 import java.util.Arrays;
49 import java.util.Collections;
50 import java.util.HashMap;
51 import java.util.LinkedList;
52 import java.util.List;
54 import java.util.Optional;
55 import java.util.stream.Collectors;
56 import mockit.Deencapsulation;
57 import org.apache.commons.collections.MapUtils;
58 import org.apache.commons.lang3.tuple.ImmutablePair;
59 import org.apache.commons.lang3.tuple.Triple;
60 import org.junit.Assert;
61 import org.junit.Before;
62 import org.junit.Test;
63 import org.mockito.InjectMocks;
64 import org.mockito.Mock;
65 import org.mockito.MockitoAnnotations;
66 import org.openecomp.sdc.be.components.BeConfDependentTest;
67 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
68 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
69 import org.openecomp.sdc.be.datatypes.elements.ArtifactDataDefinition;
70 import org.openecomp.sdc.be.datatypes.elements.OperationDataDefinition;
71 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
72 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
73 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
74 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
75 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
76 import org.openecomp.sdc.be.datatypes.enums.ResourceTypeEnum;
77 import org.openecomp.sdc.be.exception.ToscaExportException;
78 import org.openecomp.sdc.be.model.ArtifactDefinition;
79 import org.openecomp.sdc.be.model.CapabilityDefinition;
80 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
81 import org.openecomp.sdc.be.model.Component;
82 import org.openecomp.sdc.be.model.ComponentInstance;
83 import org.openecomp.sdc.be.model.ComponentInstanceAttribute;
84 import org.openecomp.sdc.be.model.ComponentInstanceInput;
85 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
86 import org.openecomp.sdc.be.model.ComponentParametersView;
87 import org.openecomp.sdc.be.model.DataTypeDefinition;
88 import org.openecomp.sdc.be.model.GroupDefinition;
89 import org.openecomp.sdc.be.model.GroupInstance;
90 import org.openecomp.sdc.be.model.InputDefinition;
91 import org.openecomp.sdc.be.model.InterfaceDefinition;
92 import org.openecomp.sdc.be.model.PropertyDefinition;
93 import org.openecomp.sdc.be.model.RelationshipInfo;
94 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
95 import org.openecomp.sdc.be.model.RequirementDefinition;
96 import org.openecomp.sdc.be.model.Resource;
97 import org.openecomp.sdc.be.model.Service;
98 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
99 import org.openecomp.sdc.be.model.category.CategoryDefinition;
100 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
101 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
102 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
103 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
104 import org.openecomp.sdc.be.tosca.exception.ToscaConversionException;
105 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
106 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
107 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
108 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
109 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
110 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
111 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
112 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
113 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
114 import org.openecomp.sdc.be.tosca.utils.InputConverter;
115 import org.openecomp.sdc.be.tosca.utils.OutputConverter;
117 public class ToscaExportHandlerTest extends BeConfDependentTest {
119 private static final String COMPONENT_PROPERTY_NAME = "prop1";
120 private static final String COMPONENT_PROPERTY_TYPE = "string";
121 private static final String COMPONENT_INPUT_NAME = "input1";
122 private static final String COMPONENT_INPUT_TYPE = "integer";
123 private static final String RESOURCE_NAME = "resource";
124 private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
125 private static final Map<String, DataTypeDefinition> DATA_TYPES = new HashMap<>();
128 private ToscaExportHandler testSubject;
131 private ApplicationDataTypeCache dataTypeCache;
134 private ToscaOperationFacade toscaOperationFacade;
137 private CapabilityRequirementConverter capabilityRequirementConverter;
140 private InputConverter inputConverter;
143 private OutputConverter outputConverter;
146 private GroupExportParser groupExportParser;
149 private PropertyConvertor propertyConvertor;
152 private GroupExportParserImpl groupExportParserImpl;
155 private InterfaceLifecycleOperation interfaceLifecycleOperation;
158 private InterfacesOperationsConverter interfacesOperationsConverter;
161 private PolicyExportParser policyExportParser;
164 private AttributeConverter attributeConverter;
167 public void setUpMock() {
168 MockitoAnnotations.initMocks(this);
169 doReturn(new ToscaProperty()).when(propertyConvertor).convertProperty(any(), any(), eq(PROPERTY));
170 doReturn(new HashMap<String, Object>()).when(interfacesOperationsConverter)
171 .getInterfacesMap(any(), isNull(), anyMap(), anyMap(), anyBoolean(), anyBoolean());
174 private Resource getNewResource() {
175 Resource resource = new Resource();
176 List<CategoryDefinition> categories = new ArrayList<>();
177 CategoryDefinition category = new CategoryDefinition();
178 List<SubCategoryDefinition> subcategories = new ArrayList<>();
179 SubCategoryDefinition subcategory = new SubCategoryDefinition();
180 List<DataTypeDefinition> dataTypes = new ArrayList<>();
181 DataTypeDefinition dataType = new DataTypeDefinition();
182 dataType.setName("dataTypeName");
183 dataType.setDerivedFromName("tosca.datatypes.Root");
184 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
188 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
189 dataType.setPropertiesData(propDataList);
190 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
191 .collect(Collectors.toList());
192 dataType.setProperties(propList);
193 dataTypes.add(dataType);
195 subcategory.setName("name");
196 subcategories.add(subcategory);
197 category.setName("name");
198 category.setSubcategories(subcategories);
199 categories.add(category);
201 resource.setCategories(categories);
202 resource.setVersion("version");
203 resource.setVendorName("vendorName");
204 resource.setVendorRelease("vendorRelease");
205 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
206 resource.setDataTypes(dataTypes);
211 private Service getNewService() {
212 Service service = new Service();
213 List<CategoryDefinition> categories = new ArrayList<>();
214 CategoryDefinition category = new CategoryDefinition();
215 List<SubCategoryDefinition> subcategories = new ArrayList<>();
216 SubCategoryDefinition subcategory = new SubCategoryDefinition();
218 subcategory.setName("name");
219 subcategories.add(subcategory);
220 category.setName("name");
221 category.setSubcategories(subcategories);
222 categories.add(category);
224 service.setCategories(categories);
225 service.setComponentType(ComponentTypeEnum.SERVICE);
226 service.setServiceType("serviceType");
227 service.setServiceRole("serviceRole");
228 service.setEnvironmentContext("environmentContext");
234 public void testExportComponent() throws Exception {
235 Component component = getNewResource();
236 Either<ToscaRepresentation, ToscaError> result;
238 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
239 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
240 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
241 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
242 .thenReturn(Either.left(Collections.emptyMap()));
244 // default test when component is Resource
245 result = testSubject.exportComponent(component);
246 Assert.assertNotNull(result);
248 component = getNewService();
249 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
250 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
251 when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
253 // default test when component is Service
254 result = testSubject.exportComponent(component);
255 Assert.assertNotNull(result);
259 public void testExportComponentInterface() throws Exception {
260 Component component = getNewResource();
261 Either<ToscaRepresentation, ToscaError> result;
263 ((Resource) component).setInterfaces(new HashMap<>());
265 when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
266 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
267 .thenReturn(Either.left(Collections.emptyMap()));
268 // default test when convertInterfaceNodeType is right
269 result = testSubject.exportComponentInterface(component, false);
270 Assert.assertNotNull(result);
272 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
273 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
274 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
276 // default test when convertInterfaceNodeType is left
277 result = testSubject.exportComponentInterface(component, false);
278 Assert.assertNotNull(result);
282 public void testConvertInterfaceNodeTypeProperties() throws Exception {
284 Resource component = getNewResource();
286 component.setInterfaces(new HashMap<>());
287 InputDefinition input = new InputDefinition();
288 input.setName(COMPONENT_INPUT_NAME);
289 input.setType(COMPONENT_INPUT_TYPE);
290 component.setInputs(Collections.singletonList(input));
291 PropertyDefinition property = new PropertyDefinition();
292 property.setName(COMPONENT_PROPERTY_NAME);
293 property.setType(COMPONENT_PROPERTY_TYPE);
294 component.setProperties(Collections.singletonList(property));
295 component.setName(RESOURCE_NAME);
296 component.setToscaResourceName(RESOURCE_NAME);
298 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
299 .thenReturn(Either.left(Collections.emptyMap()));
300 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
301 // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
302 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
303 any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
305 Either<ToscaTemplate, ToscaError> result = (Either<ToscaTemplate, ToscaError>) Deencapsulation
306 .invoke(testSubject, "convertInterfaceNodeType", new HashMap<String, Component>(), component,
307 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
308 Assert.assertNotNull(result);
309 assertThat(result.isLeft(), is(true));
310 Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
311 assertThat(nodeTypeMap.size(), is(1));
312 ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
313 Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
314 // Check if inputs and properties in component are merged properly
315 assertThat(propertyMap.size(), is(2));
316 assertThat(propertyMap.containsKey(COMPONENT_INPUT_NAME), is(true));
317 assertThat(propertyMap.containsKey(COMPONENT_PROPERTY_NAME), is(true));
321 public void testCreateToscaRepresentation() throws Exception {
322 ToscaTemplate toscaTemplate = new ToscaTemplate("");
323 ToscaRepresentation result;
326 result = testSubject.createToscaRepresentation(toscaTemplate);
327 Assert.assertNotNull(result);
331 public void testGetDependencies() throws Exception {
333 Component component = new Resource();
334 Either<ToscaTemplate, ToscaError> result;
337 result = testSubject.getDependencies(component);
338 Assert.assertNotNull(result);
342 public void testSetImports() throws Exception {
343 Resource resource = new Resource();
344 resource.setResourceType(ResourceTypeEnum.PNF);
346 Component component = resource;
347 component.setName("TestResourceName");
348 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
349 ArtifactDefinition artifact = new ArtifactDefinition();
350 artifact.setArtifactName("name.name2");
351 artifactList.put("assettoscatemplate", artifact);
352 component.setArtifacts(artifactList);
353 component.setToscaArtifacts(artifactList);
354 ToscaTemplate toscaTemplate = new ToscaTemplate("");
356 ComponentInstance ci = new ComponentInstance();
357 ci.setComponentUid("name");
358 ci.setOriginType(OriginTypeEnum.PNF);
359 ci.setSourceModelUid("modelName");
360 List<ComponentInstance> componentInstanceList = new LinkedList<>();
361 componentInstanceList.add(ci);
362 component.setComponentInstances(componentInstanceList);
364 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
366 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
367 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
369 verify(toscaOperationFacade, times(1)).getToscaFullElement("name");
370 Assert.assertTrue(result.isLeft());
371 ToscaTemplate toscaTemplateRes = result.left().value().left;
372 Assert.assertEquals(8, toscaTemplateRes.getImports().size());
373 Assert.assertNotNull(toscaTemplateRes.getImports().get(6).get("resource-TestResourceName-interface"));
374 Assert.assertNotNull(toscaTemplateRes.getImports().get(7).get("resource-TestResourceName"));
375 Assert.assertEquals(1, toscaTemplateRes.getDependencies().size());
376 Assert.assertEquals("name.name2", toscaTemplateRes.getDependencies().get(0).getLeft());
380 public void testConvertToscaTemplate() throws Exception {
382 final Component component = getNewResource();
383 final ToscaTemplate toscaNode = new ToscaTemplate("");
384 Either<ToscaTemplate, ToscaError> result;
385 final List<ComponentInstance> resourceInstances = new ArrayList<>();
386 final ComponentInstance instance = new ComponentInstance();
388 instance.setOriginType(OriginTypeEnum.SERVICE);
389 instance.setSourceModelUid("targetModelUid");
390 resourceInstances.add(instance);
392 component.setComponentInstances(resourceInstances);
394 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
395 when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.right(false));
397 final Map<String, ToscaProperty> map = new HashMap<>();
398 map.put("mock", new ToscaProperty());
399 doReturn(map).when(outputConverter).convert(any(), any());
402 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
403 Assert.assertNotNull(result);
407 public void testConvertToscaTemplateWhenComponentContainsGroup() throws ToscaConversionException {
408 Component component = getNewResource();
409 ToscaTemplate toscaNode = new ToscaTemplate("");
410 Either<ToscaTemplate, ToscaError> result;
411 component.setComponentInstances(new ArrayList<>());
413 List<GroupDefinition> groups = new ArrayList<>();
414 GroupDefinition group = new GroupDefinition();
415 List<String> artifacts = new ArrayList<>();
416 artifacts.add("artifact");
417 group.setType("org.openecomp.groups.VfModule");
418 group.setArtifacts(artifacts);
420 component.setGroups(groups);
422 Map<String, String[]> substitutionMappingMap = new HashMap<>();
423 String[] array = {"value1", "value2"};
424 substitutionMappingMap.put("key", array);
426 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(any(Map.class),
427 any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
429 when(capabilityRequirementConverter.convertSubstitutionMappingRequirements(any(Map.class),
430 any(Component.class), any(SubstitutionMapping.class)))
431 .thenReturn(Either.left(new SubstitutionMapping()));
433 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
435 when(inputConverter.convertInputs(any(List.class), any(Map.class))).thenReturn(new HashMap<>());
437 when(groupExportParser.getGroups(component)).thenReturn(null);
439 final Map<String, ToscaProperty> map = new HashMap<>();
440 map.put("mock", new ToscaProperty());
441 doReturn(map).when(outputConverter).convert(any(), any());
443 // test component contains group
444 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
445 Assert.assertNotNull(result);
449 public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
450 Component component = getNewService();
451 ToscaTemplate toscaNode = new ToscaTemplate("");
452 Either<ToscaTemplate, ToscaError> result;
453 component.setComponentInstances(new ArrayList<>());
455 List<GroupDefinition> groups = new ArrayList<>();
456 GroupDefinition group = new GroupDefinition();
457 List<String> artifacts = new ArrayList<>();
458 artifacts.add("artifact");
459 group.setType("org.openecomp.groups.VfModule");
460 group.setArtifacts(artifacts);
462 component.setGroups(groups);
464 Map<String, String[]> substitutionMappingMap = new HashMap<>();
465 String[] array = {"value1", "value2"};
466 substitutionMappingMap.put("key", array);
468 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
469 .thenReturn(Either.left(substitutionMappingMap));
471 when(capabilityRequirementConverter
472 .convertSubstitutionMappingRequirements(anyMap(), any(Component.class), any(SubstitutionMapping.class)))
473 .thenReturn(Either.left(new SubstitutionMapping()));
475 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
477 when(inputConverter.convertInputs(anyList(), anyMap())).thenReturn(new HashMap<>());
478 final Map<String, ToscaProperty> map = new HashMap<>();
479 map.put("mock", new ToscaProperty());
480 doReturn(map).when(outputConverter).convert(any(), any());
482 // test component contains group
483 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
484 Assert.assertNotNull(result);
488 public void testConvertMetadata_1() throws Exception {
490 Component component = getNewResource();
491 boolean isInstance = true;
492 ComponentInstance componentInstance = new ComponentInstance();
493 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
494 componentInstance.setSourceModelInvariant("targetModelInvariant");
497 Map<String, String> result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
498 Assert.assertNotNull(result);
502 public void testFillImports() throws Exception {
504 Component component = getNewService();
505 ToscaTemplate toscaTemplate = new ToscaTemplate("");
506 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
508 ComponentInstance instance = new ComponentInstance();
509 List<ComponentInstance> resourceInstances = new ArrayList<>();
510 instance.setComponentUid("name");
511 resourceInstances.add(instance);
512 component.setComponentInstances(resourceInstances);
513 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
514 ArtifactDefinition artifact = new ArtifactDefinition();
515 artifact.setArtifactName("name.name2");
516 toscaArtifacts.put("assettoscatemplate", artifact);
517 component.setToscaArtifacts(toscaArtifacts);
519 when(toscaOperationFacade.getToscaFullElement(any(String.class)))
520 .thenReturn(Either.left(component));
522 Resource baseType = getNewResource();
523 Map<String, ArtifactDefinition> baseTypeToscaArtifacts = new HashMap<>();
524 ArtifactDefinition baseTypeArtifact = new ArtifactDefinition();
525 baseTypeArtifact.setArtifactName("typeA");
526 baseTypeToscaArtifacts.put("assettoscatemplate", baseTypeArtifact);
527 baseType.setToscaArtifacts(baseTypeToscaArtifacts);
529 component.setDerivedFromGenericType("org.typeA");
530 component.setDerivedFromGenericVersion("1.0");
531 when(toscaOperationFacade.getByToscaResourceNameAndVersion("org.typeA", "1.0")).thenReturn(Either.left(baseType));
534 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
535 Assert.assertNotNull(result);
539 public void testCreateDependency() throws Exception {
541 Map<String, Component> componentCache = new HashMap<>();
542 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
543 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
544 ComponentInstance ci = new ComponentInstance();
545 Component component = getNewResource();
547 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
548 ArtifactDefinition artifact = new ArtifactDefinition();
549 artifact.setArtifactName("name.name2");
550 toscaArtifacts.put("assettoscatemplate", artifact);
551 component.setToscaArtifacts(toscaArtifacts);
552 ci.setComponentUid("name");
553 ci.setOriginType(OriginTypeEnum.ServiceProxy);
554 ci.setSourceModelUid("modelName");
556 when(toscaOperationFacade.getToscaFullElement("name")).thenReturn(Either.left(component));
558 when(toscaOperationFacade.getToscaFullElement("modelName")).thenReturn(Either.left(new Service()));
561 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
562 Assert.assertFalse(componentCache.isEmpty());
566 public void testGetInterfaceFilename() throws Exception {
567 String artifactName = "artifact.name";
571 result = ToscaExportHandler.getInterfaceFilename(artifactName);
572 Assert.assertNotNull(result);
576 public void testConvertNodeType() throws Exception {
577 Component component = new Resource();
578 ToscaTemplate toscaNode = new ToscaTemplate("");
579 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
580 Either<ToscaTemplate, ToscaError> result;
582 when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
583 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
584 .thenReturn(Either.left(Collections.emptyMap()));
586 result = Deencapsulation
587 .invoke(testSubject, "convertNodeType", new HashMap<>(), component, toscaNode, nodeTypes);
588 Assert.assertNotNull(result);
592 public void testConvertInterfaceNodeType() throws Exception {
593 Component component = getNewResource();
594 ToscaTemplate toscaNode = new ToscaTemplate("");
595 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
596 Either<ToscaTemplate, ToscaError> result;
597 List<InputDefinition> inputs = new ArrayList<>();
598 inputs.add(new InputDefinition());
599 component.setInputs(inputs);
601 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
602 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
603 .thenReturn(Either.left(Collections.emptyMap()));
605 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
606 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
609 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType", new HashMap<>(), component, toscaNode
611 Assert.assertNotNull(result);
615 public void testConvertReqCapAndTypeName() throws Exception {
616 Component component = new Resource();
617 ToscaTemplate toscaNode = new ToscaTemplate("");
618 Map<String, ToscaNodeType> nodeTypes = new HashMap();
619 ToscaNodeType toscaNodeType = new ToscaNodeType();
620 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
621 Either<ToscaTemplate, ToscaError> result;
624 capabilityRequirementConverter
625 .convertCapabilities(any(Map.class), any(Resource.class), any(Map.class)))
626 .thenReturn(new HashMap<>());
628 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
629 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
632 result = Deencapsulation
633 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
634 toscaNodeType, dataTypes);
635 Assert.assertNotNull(result);
637 component = new Service();
639 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
640 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
642 // test when component is service
643 result = Deencapsulation
644 .invoke(testSubject, "convertReqCapAndTypeName", new HashMap<>(), component, toscaNode, nodeTypes,
645 toscaNodeType, dataTypes);
646 Assert.assertNotNull(result);
650 public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
651 final Component component = getNewService();
652 final List<ComponentInstance> componentInstances = new ArrayList<>();
653 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
654 final Map<String, Component> componentCache = new HashMap<>();
655 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
656 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
657 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
658 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
659 final List<ComponentInstanceInput> inputs = new ArrayList<>();
660 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
661 componentInstanceInput.setUniqueId("uuid");
662 inputs.add(componentInstanceInput);
663 componentInstancesInputs.put("uuid", inputs);
664 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
665 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
666 reldef.setFromNode("node");
667 resourceInstancesRelations.add(reldef);
668 component.setComponentInstancesRelations(resourceInstancesRelations);
670 final ComponentInstance instance = new ComponentInstance();
671 instance.setUniqueId("id");
672 instance.setComponentUid("uid");
673 instance.setOriginType(OriginTypeEnum.ServiceProxy);
674 final List<GroupInstance> groupInstances = new ArrayList<>();
675 final GroupInstance groupInst = new GroupInstance();
676 final List<String> artifacts = new ArrayList<>();
677 artifacts.add("artifact");
678 groupInst.setArtifacts(artifacts);
679 groupInst.setType("type");
680 groupInstances.add(groupInst);
681 instance.setGroupInstances(groupInstances);
683 final List<PropertyDefinition> properties = new ArrayList<>();
684 properties.add(new PropertyDefinition());
685 instance.setProperties(properties);
687 instance.setUniqueId("uuid");
688 instance.setDescription("desc");
689 instance.setSourceModelUid("sourceModelUid");
691 componentInstances.add(instance);
693 component.setComponentInstances(componentInstances);
695 component.setComponentInstancesInputs(componentInstancesInputs);
696 component.setInvariantUUID("uuid");
697 component.setUUID("uuid");
698 component.setDescription("desc");
699 component.setUniqueId("uid");
701 componentCache.put("uid", component);
703 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
704 componentInstanceProperties.add(new ComponentInstanceProperty());
706 componentInstancesProperties.put("uuid", componentInstanceProperties);
707 component.setComponentInstancesProperties(componentInstancesProperties);
709 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
710 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
711 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
712 componentInstanceAttribute.setDefaultValue("def value");
713 componentInstanceAttributes.add(componentInstanceAttribute);
715 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
716 component.setComponentInstancesAttributes(componentInstancesAttributes);
718 when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.left(component));
719 when(capabilityRequirementConverter
720 .convertComponentInstanceCapabilities(any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
721 .thenReturn(Either.left(new ToscaNodeTemplate()));
722 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
723 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
724 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class), any(ToscaNodeType.class)))
725 .thenReturn(Either.left(new ToscaNodeType()));
726 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
727 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
728 when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
729 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(new Resource()));
731 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
732 final String[] array = {"value1", "value2"};
733 substitutionMappingMap.put("key", array);
734 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
735 .thenReturn(Either.left(substitutionMappingMap));
737 when(capabilityRequirementConverter
738 .convertSubstitutionMappingRequirements(any(Map.class), any(Component.class), any(SubstitutionMapping.class)))
739 .thenReturn(Either.left(new SubstitutionMapping()));
742 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
743 assertNotNull(toscaRepresentationToscaErrorEither);
748 public void testConvertNodeTemplatesWhenComponentIsResource() throws Exception {
749 final Resource component = getNewResource();
750 component.setResourceType(VF);
751 final List<ComponentInstance> componentInstances = new ArrayList<>();
752 final Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
753 final Map<String, Component> componentCache = new HashMap<>();
754 final Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
755 final ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
756 final Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
757 final Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
758 final List<ComponentInstanceInput> inputs = new ArrayList<>();
759 final ComponentInstanceInput componentInstanceInput = new ComponentInstanceInput();
760 componentInstanceInput.setUniqueId("uuid");
761 inputs.add(componentInstanceInput);
762 componentInstancesInputs.put("uuid", inputs);
763 final List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
764 final RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
765 reldef.setFromNode("node");
766 resourceInstancesRelations.add(reldef);
767 component.setComponentInstancesRelations(resourceInstancesRelations);
769 final ComponentInstance instance = new ComponentInstance();
770 instance.setUniqueId("id");
771 instance.setComponentUid("uid");
772 instance.setOriginType(OriginTypeEnum.ServiceProxy);
773 final List<GroupInstance> groupInstances = new ArrayList<>();
774 final GroupInstance groupInst = new GroupInstance();
775 final List<String> artifacts = new ArrayList<>();
776 artifacts.add("artifact");
777 groupInst.setArtifacts(artifacts);
778 groupInst.setType("type");
779 groupInstances.add(groupInst);
780 instance.setGroupInstances(groupInstances);
782 final List<PropertyDefinition> properties = new ArrayList<>();
783 properties.add(new PropertyDefinition());
784 instance.setProperties(properties);
786 instance.setUniqueId("uuid");
787 instance.setDescription("desc");
788 instance.setSourceModelUid("sourceModelUid");
789 final Map<String, ArtifactDefinition> artifactList = new HashMap<>();
790 final ArtifactDefinition artifact = new ArtifactDefinition();
791 artifact.setArtifactName("name.name2");
792 artifactList.put("assettoscatemplate", artifact);
793 instance.setArtifacts(artifactList);
795 Map<String, ToscaArtifactDataDefinition> toscaArtifactDataDefinitionMap = new HashMap<>();
796 toscaArtifactDataDefinitionMap.put("assettoscatemplate", new ToscaArtifactDataDefinition());
797 instance.setToscaArtifacts(toscaArtifactDataDefinitionMap);
799 componentInstances.add(instance);
801 component.setComponentInstances(componentInstances);
803 component.setComponentInstancesInputs(componentInstancesInputs);
804 component.setInvariantUUID("uuid");
805 component.setUUID("uuid");
806 component.setDescription("desc");
807 component.setUniqueId("uid");
809 componentCache.put("uid", component);
811 final List<ComponentInstanceProperty> componentInstanceProperties = new ArrayList<>();
812 componentInstanceProperties.add(new ComponentInstanceProperty());
814 componentInstancesProperties.put("uuid", componentInstanceProperties);
815 component.setComponentInstancesProperties(componentInstancesProperties);
817 final Map<String, List<ComponentInstanceAttribute>> componentInstancesAttributes = new HashMap<>();
818 final List<ComponentInstanceAttribute> componentInstanceAttributes = new ArrayList<>();
819 final ComponentInstanceAttribute componentInstanceAttribute = new ComponentInstanceAttribute();
820 componentInstanceAttribute.setDefaultValue("def value");
821 componentInstanceAttributes.add(componentInstanceAttribute);
823 componentInstancesAttributes.put("uuid", componentInstanceAttributes);
824 component.setComponentInstancesAttributes(componentInstancesAttributes);
826 component.setArtifacts(artifactList);
827 component.setToscaArtifacts(artifactList);
829 when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.left(component));
830 when(capabilityRequirementConverter
831 .convertComponentInstanceCapabilities(any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
832 .thenReturn(Either.left(new ToscaNodeTemplate()));
833 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
834 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
835 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class), any(ToscaNodeType.class)))
836 .thenReturn(Either.left(new ToscaNodeType()));
837 when(toscaOperationFacade.getToscaFullElement("uid")).thenReturn(Either.left(component));
838 when(toscaOperationFacade.getToscaFullElement("sourceModelUid")).thenReturn(Either.left(component));
839 when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
840 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class))).thenReturn(Either.left(new Resource()));
842 final Map<String, String[]> substitutionMappingMap = new HashMap<>();
843 final String[] array = {"value1", "value2"};
844 substitutionMappingMap.put("key", array);
845 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(anyMap(), any(Component.class)))
846 .thenReturn(Either.left(substitutionMappingMap));
848 when(capabilityRequirementConverter
849 .convertSubstitutionMappingRequirements(any(Map.class), any(Component.class), any(SubstitutionMapping.class)))
850 .thenReturn(Either.left(new SubstitutionMapping()));
853 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
854 assertNotNull(toscaRepresentationToscaErrorEither);
859 public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
860 Component component = getNewResource();
861 List<ComponentInstance> componentInstances = new ArrayList<>();
862 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
863 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
864 Map<String, Component> componentCache = new HashMap<>();
865 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
866 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
867 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
868 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
869 List<ComponentInstanceInput> inputs = new ArrayList<>();
870 inputs.add(new ComponentInstanceInput());
871 componentInstancesInputs.put("key", inputs);
872 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
873 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
874 reldef.setFromNode("node");
875 resourceInstancesRelations.add(reldef);
876 component.setComponentInstancesRelations(resourceInstancesRelations);
878 ComponentInstance instance = new ComponentInstance();
879 instance.setUniqueId("id");
880 instance.setComponentUid("uid");
881 instance.setOriginType(OriginTypeEnum.ServiceProxy);
882 componentInstances.add(instance);
883 component.setComponentInstances(componentInstances);
885 component.setComponentInstancesInputs(componentInstancesInputs);
886 component.setInvariantUUID("uuid");
887 component.setUUID("uuid");
888 component.setDescription("desc");
890 componentCache.put("uid", component);
892 when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.left(component));
893 when(capabilityRequirementConverter
894 .convertComponentInstanceCapabilities(any(ComponentInstance.class), any(Map.class), any(ToscaNodeTemplate.class)))
895 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
896 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
897 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
898 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
899 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
902 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
903 assertNotNull(toscaRepresentationToscaErrorEither);
907 public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
908 Component component = getNewResource();
909 List<ComponentInstance> componentInstances = new ArrayList<>();
910 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
911 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
912 Map<String, Component> componentCache = new HashMap<>();
913 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
914 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
915 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
916 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
917 List<ComponentInstanceInput> inputs = new ArrayList<>();
918 inputs.add(new ComponentInstanceInput());
919 componentInstancesInputs.put("key", inputs);
920 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
921 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
922 reldef.setFromNode("id");
923 resourceInstancesRelations.add(reldef);
924 component.setComponentInstancesRelations(resourceInstancesRelations);
926 ComponentInstance instance = new ComponentInstance();
927 instance.setUniqueId("id");
928 instance.setComponentUid("uid");
929 instance.setOriginType(OriginTypeEnum.ServiceProxy);
930 componentInstances.add(instance);
931 component.setComponentInstances(componentInstances);
933 component.setComponentInstancesInputs(componentInstancesInputs);
934 component.setInvariantUUID("uuid");
935 component.setUUID("uuid");
936 component.setDescription("desc");
938 componentCache.put("uid", component);
940 when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.right(false));
941 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
942 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
943 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
944 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
947 final Either<ToscaRepresentation, ToscaError> toscaRepresentationToscaErrorEither = testSubject.exportComponent(component);
948 assertNotNull(toscaRepresentationToscaErrorEither);
952 public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
953 Resource component = getNewResource();
954 component.setResourceType(VF);
955 List<ComponentInstance> componentInstances = new ArrayList<>();
956 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
957 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
958 Map<String, Component> componentCache = new HashMap<>();
959 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
960 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
961 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
962 List<ComponentInstanceInput> inputs = new ArrayList<>();
963 inputs.add(new ComponentInstanceInput());
964 componentInstancesInputs.put("key", inputs);
965 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
966 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
967 reldef.setFromNode("id");
968 reldef.setToNode("node");
969 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
970 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
971 relationship.setRelation(new RelationshipInfo());
972 relationships.add(relationship);
973 reldef.setRelationships(relationships);
974 resourceInstancesRelations.add(reldef);
975 component.setComponentInstancesRelations(resourceInstancesRelations);
977 Map<String, ArtifactDefinition> artifactList = new HashMap<>();
978 ArtifactDefinition artifact = new ArtifactDefinition();
979 artifact.setArtifactName("name.name2");
980 artifactList.put("assettoscatemplate", artifact);
981 component.setArtifacts(artifactList);
982 component.setToscaArtifacts(artifactList);
984 ComponentInstance instance = new ComponentInstance();
985 instance.setUniqueId("id");
986 instance.setComponentUid("id");
987 instance.setOriginType(OriginTypeEnum.VF);
988 componentInstances.add(instance);
989 component.setComponentInstances(componentInstances);
991 component.setComponentInstancesInputs(componentInstancesInputs);
992 component.setComponentInstances(componentInstances);
994 doReturn(Either.left(component)).when(toscaOperationFacade).getToscaFullElement("id");
995 when(capabilityRequirementConverter.getOriginComponent(any(Map.class), any(ComponentInstance.class))).thenReturn(Either.left(component));
996 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
997 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
998 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Resource.class),
999 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1000 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1001 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1004 final Either<ToscaRepresentation, ToscaError> result = testSubject.exportComponent(component);
1005 assertNotNull(result);
1009 public void testAddComponentInstanceInputs() throws Exception {
1011 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1012 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
1013 ComponentInstance componentInstance = new ComponentInstance();
1014 String instanceUniqueId = "id";
1015 Map<String, Object> props = new HashMap<>();
1017 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
1018 componentInstanceInputs.add(new ComponentInstanceInput());
1020 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
1023 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
1024 instanceUniqueId, props);
1028 public void testAddPropertiesOfComponentInstance() throws Exception {
1029 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
1030 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1031 ComponentInstance componentInstance = new ComponentInstance();
1032 String instanceUniqueId = "id";
1033 Map<String, Object> props = new HashMap<>();
1035 ComponentInstanceProperty cip = new ComponentInstanceProperty();
1036 cip.setInstanceUniqueId("id");
1038 List<ComponentInstanceProperty> list = new ArrayList<>();
1041 componentInstancesProperties.put("id", list);
1044 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
1045 instanceUniqueId, props);
1049 public void testAddPropertiesOfParentComponent() throws Exception {
1050 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1051 ComponentInstance componentInstance = new ComponentInstance();
1052 Component componentOfInstance = new Resource();
1053 Map<String, Object> props = new HashMap<>();
1055 List<PropertyDefinition> properties = new ArrayList<>();
1056 properties.add(new PropertyDefinition());
1058 ((Resource) componentOfInstance).setProperties(properties);
1061 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
1062 componentOfInstance, props);
1066 public void testCreateNodeType() throws Exception {
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 Assert.assertNotNull(result);
1078 component = new Service();
1079 // test when component is service
1080 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
1081 Assert.assertNotNull(result);
1085 public void testCreateProxyInterfaceTypesComponentNotFound() throws Exception {
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 Assert.assertTrue(result.isRight());
1104 public 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())
1119 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1120 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1121 Assert.assertTrue(result.isRight());
1125 public 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())
1137 .thenReturn(Either.left(Collections.emptyMap()));
1139 Component proxyResource = new Resource();
1140 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
1141 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
1142 proxyResource.setInterfaces(proxyInterfaces);
1143 when(toscaOperationFacade.getToscaElement(any(String.class),
1144 any(ComponentParametersView.class)))
1145 .thenReturn(Either.left(proxyResource));
1147 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
1148 Assert.assertNotNull(result);
1149 Assert.assertTrue(result.isLeft());
1150 Assert.assertEquals(1, result.left().value().size());
1154 public void testCreateProxyNodeTypes() throws Exception {
1155 Map<String, Component> componentCache = new HashMap<>();
1156 Component container = new Resource();
1157 Either<Map<String, ToscaNodeType>, ToscaError> result;
1158 List<ComponentInstance> componentInstances = new ArrayList<>();
1159 ComponentInstance instance = new ComponentInstance();
1160 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1161 instance.setSourceModelUid("targetModelUid");
1163 componentInstances.add(instance);
1164 container.setComponentInstances(componentInstances);
1166 when(toscaOperationFacade.getLatestByName("serviceProxy"))
1167 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1169 // test when getLatestByName return is right
1170 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1171 Assert.assertNotNull(result);
1175 public void testCreateServiceSubstitutionNodeTypes() throws Exception {
1176 Map<String, Component> componentCache = new HashMap<>();
1178 Component referencedService = getNewService();
1179 referencedService.setInvariantUUID("uuid");
1180 referencedService.setUUID("uuid");
1181 referencedService.setUniqueId("targetModelUid");
1182 referencedService.setDescription("desc");
1183 componentCache.put("targetModelUid", referencedService);
1185 Component containerService = new Service();
1186 List<ComponentInstance> componentInstances = new ArrayList<>();
1187 ComponentInstance instance = new ComponentInstance();
1188 instance.setOriginType(OriginTypeEnum.ServiceSubstitution);
1189 instance.setSourceModelUid("targetModelUid");
1191 componentInstances.add(instance);
1192 containerService.setComponentInstances(componentInstances);
1194 when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
1195 .thenReturn(Either.left(Collections.emptyMap()));
1196 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1197 when(capabilityRequirementConverter.convertRequirements(any(Map.class), any(Service.class),
1198 any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
1200 ToscaTemplate toscaNode = new ToscaTemplate("1_1");
1202 Deencapsulation.invoke(testSubject, "createServiceSubstitutionNodeTypes", componentCache, containerService, toscaNode);
1203 Assert.assertNotNull(toscaNode.getNode_types());
1207 public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
1208 Map<String, Component> componentCache = new HashMap<>();
1209 Component container = new Resource();
1210 Either<Map<String, ToscaNodeType>, ToscaError> result;
1211 List<ComponentInstance> componentInstances = new ArrayList<>();
1212 ComponentInstance instance = new ComponentInstance();
1213 instance.setOriginType(OriginTypeEnum.ServiceProxy);
1214 instance.setSourceModelUid("targetModelUid");
1216 componentInstances.add(instance);
1217 container.setComponentInstances(componentInstances);
1219 when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
1221 ComponentParametersView parameterView = new ComponentParametersView();
1222 parameterView.disableAll();
1223 parameterView.setIgnoreCategories(false);
1225 when(toscaOperationFacade.getToscaElement(any(String.class),
1226 any(ComponentParametersView.class)))
1227 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1229 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1231 // test when getLatestByName is left
1232 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
1233 Assert.assertNotNull(result);
1237 public void testCreateProxyNodeType() throws Exception {
1238 Map<String, Component> componentCache = new HashMap<>();
1239 Component origComponent = new Resource();
1240 Component proxyComponent = new Resource();
1241 ComponentInstance instance = new ComponentInstance();
1242 ToscaNodeType result;
1244 when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
1247 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
1248 proxyComponent, instance);
1249 Assert.assertNotNull(result);
1253 public void testConvertComponentInstanceRequirements() throws Exception {
1254 Component component = new Resource();
1255 ComponentInstance componentInstance = new ComponentInstance();
1256 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
1257 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
1258 Component originComponent = new Resource();
1259 Map<String, Component> componentCache = new HashMap<>();
1260 Either<ToscaNodeTemplate, ToscaError> result;
1263 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1264 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1265 Assert.assertNotNull(result);
1267 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1268 reldef.setFromNode("name");
1269 reldef.setToNode("name1");
1270 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1271 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1272 cap.setRelation(new RelationshipInfo());
1273 relationships.add(cap);
1274 reldef.setRelationships(relationships);
1275 relations.add(reldef);
1276 componentInstance.setUniqueId("name");
1278 List<ComponentInstance> instances = new ArrayList<>();
1279 instances.add(componentInstance);
1280 component.setComponentInstances(instances);
1282 // test when filteredRElations ins't empty
1283 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1284 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1285 Assert.assertNotNull(result);
1289 public void buildRequirementFailure() {
1290 final Component fromOriginComponent = new Resource();
1291 final ComponentInstance fromInstance = new ComponentInstance();
1292 final String fromInstanceUid = "fromInstanceUid";
1293 fromInstance.setUniqueId(fromInstanceUid);
1294 fromInstance.setComponentUid("componentUid");
1295 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1296 relationshipDefinition.setToNode("wrongNodeUid");
1297 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1298 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1299 relationship.setRequirement(new RequirementDataDefinition());
1300 relationshipList.add(relationship);
1301 relationshipDefinition.setRelationships(relationshipList);
1302 final List<ComponentInstance> instancesList = new ArrayList<>();
1303 instancesList.add(fromInstance);
1304 String expectedError = String
1305 .format("Failed to find a relation from the node %s to the node %s", fromInstance.getName(),
1306 relationshipDefinition.getToNode());
1307 assertThrows(ToscaExportException.class, () ->
1308 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1309 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1312 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1313 instancesList, relationshipDefinition, new HashMap<>());
1314 } catch (Exception e) {
1315 assertTrue(e instanceof ToscaExportException);
1316 assertEquals(expectedError, e.getMessage());
1319 final RelationshipInfo relation = new RelationshipInfo();
1320 final String requirementUid = "Uid";
1321 relation.setRequirementUid(requirementUid);
1322 final String requirementName = "requirementName";
1323 relation.setRequirement(requirementName);
1324 final String capabilityName = "capabilityName";
1325 relation.setCapability(capabilityName);
1326 final String capabilityOwnerId = "capabilityOwnerId";
1327 relation.setCapabilityOwnerId(capabilityOwnerId);
1328 relationship.setRelation(relation);
1330 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1331 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1332 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1333 fromOriginComponent.setRequirements(requirementMap);
1334 relationshipDefinition.setToNode(fromInstanceUid);
1336 expectedError = String
1337 .format("Failed to find a requirement with uniqueId %s on a component with uniqueId %s",
1338 relation.getRequirementUid(), fromOriginComponent.getUniqueId());
1340 assertThrows(ToscaExportException.class, () ->
1341 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1342 instancesList, relationshipDefinition, new HashMap<>()), expectedError);
1344 requirementDefinition.setName(requirementName);
1346 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1347 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1349 expectedError = String.format(
1350 "Failed to build substituted name for the requirement %s. "
1351 + "Failed to get an origin component with uniqueId %s",
1352 requirementName, fromInstance.getActualComponentUid());
1353 assertThrows(ToscaExportException.class, () -> Deencapsulation
1354 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1355 relationshipDefinition, new HashMap<>()), expectedError);
1357 final Component toOriginComponent = new Resource();
1358 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1359 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1361 capabilityDefinition.setName(capabilityName);
1362 capabilityDefinition.setOwnerId(capabilityOwnerId);
1363 capabilityDefinition.setType("aType");
1364 final String capabilityPreviousName = "capabilityPreviousName";
1365 capabilityDefinition.setPreviousName(capabilityPreviousName);
1366 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1367 toOriginComponent.setCapabilities(capabilityMap);
1368 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1369 .thenReturn(Either.left(toOriginComponent));
1371 requirementDefinition.setCapability(capabilityName);
1372 relation.setCapability("wrong");
1373 final String requirementPreviousName = "requirementPreviousName";
1374 requirementDefinition.setPreviousName(requirementPreviousName);
1375 requirementDefinition.setPath(new ArrayList<>());
1377 expectedError = String
1378 .format("Failed to find a capability with name %s on a component with uniqueId %s",
1379 relation.getCapability(), fromOriginComponent.getUniqueId());
1381 assertThrows(ToscaExportException.class, () -> Deencapsulation
1382 .invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1383 relationshipDefinition, new HashMap<>()),
1388 public void testBuildRequirement() {
1389 final ComponentInstance fromInstance = new ComponentInstance();
1390 fromInstance.setUniqueId("name");
1391 fromInstance.setComponentUid("string");
1392 final List<ComponentInstance> instancesList = new ArrayList<>();
1394 final Map<String, Component> componentCache = new HashMap<>();
1395 final List<CapabilityRequirementRelationship> relationshipList = new ArrayList<>();
1396 final CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
1397 relationship.setRequirement(new RequirementDataDefinition());
1398 final RelationshipInfo relation = new RelationshipInfo();
1399 final String requirementUid = "Uid";
1400 relation.setRequirementUid(requirementUid);
1401 final String requirementName = "requirementName";
1402 relation.setRequirement(requirementName);
1403 final String capabilityName = "capabilityName";
1404 relation.setCapability(capabilityName);
1405 final String capabilityOwnerId = "capabilityOwnerId";
1406 relation.setCapabilityOwnerId(capabilityOwnerId);
1407 relationship.setRelation(relation);
1408 relationshipList.add(relationship);
1409 final RequirementCapabilityRelDef relationshipDefinition = new RequirementCapabilityRelDef();
1410 relationshipDefinition.setRelationships(relationshipList);
1411 relationshipDefinition.setToNode("name");
1412 instancesList.add(fromInstance);
1413 final RequirementDefinition requirementDefinition = new RequirementDefinition();
1414 requirementDefinition.setName(requirementName);
1415 requirementDefinition.setCapability(capabilityName);
1416 final String requirementPreviousName = "requirementPreviousName";
1417 requirementDefinition.setPreviousName(requirementPreviousName);
1418 requirementDefinition.setPath(new ArrayList<>());
1419 final Map<String, List<RequirementDefinition>> requirementMap = new HashMap<>();
1420 requirementMap.put(requirementUid, Collections.singletonList(requirementDefinition));
1421 final Component fromOriginComponent = new Resource();
1422 fromOriginComponent.setRequirements(requirementMap);
1424 final Map<String, List<CapabilityDefinition>> capabilityMap = new HashMap<>();
1425 final CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
1426 capabilityDefinition.setName(capabilityName);
1427 capabilityDefinition.setOwnerId(capabilityOwnerId);
1428 final String capabilityPreviousName = "capabilityPreviousName";
1429 capabilityDefinition.setPreviousName(capabilityPreviousName);
1430 capabilityMap.put(capabilityName, Collections.singletonList(capabilityDefinition));
1431 final Component toOriginComponent = new Resource();
1432 toOriginComponent.setCapabilities(capabilityMap);
1434 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1435 .thenReturn(Either.left(toOriginComponent));
1436 final String builtCapabilityName = "builtCapabilityName";
1438 capabilityRequirementConverter
1439 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq(capabilityName), eq(
1440 capabilityPreviousName)))
1441 .thenReturn(Either.left(builtCapabilityName));
1443 final String builtRequirementName = "builtRequirementName";
1445 capabilityRequirementConverter
1446 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq(requirementName), eq(
1447 requirementPreviousName)))
1448 .thenReturn(Either.left(builtRequirementName));
1450 final Map<String, ToscaTemplateRequirement> actualRequirementMap =
1451 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1452 instancesList, relationshipDefinition, componentCache);
1453 assertNotNull(actualRequirementMap);
1454 assertFalse(actualRequirementMap.isEmpty());
1455 assertTrue(actualRequirementMap.containsKey(builtRequirementName));
1456 final ToscaTemplateRequirement actualToscaTemplateRequirement = actualRequirementMap.get(builtRequirementName);
1457 assertNotNull(actualToscaTemplateRequirement);
1458 assertEquals(builtCapabilityName, actualToscaTemplateRequirement.getCapability());
1460 //to toOriginComponent not found
1461 when(toscaOperationFacade.getToscaElement(any(String.class), any(ComponentParametersView.class)))
1462 .thenReturn(Either.right(StorageOperationStatus.NOT_FOUND));
1464 assertThrows(ToscaExportException.class, () -> Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent,
1465 instancesList, relationshipDefinition, componentCache));
1469 public void testAddRequirmentsWithBuildAndAddRequirements() {
1470 ComponentInstance fromInstance = new ComponentInstance();
1471 Component fromOriginComponent = new Resource();
1472 List<ComponentInstance> instancesList = new ArrayList<>();
1473 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1474 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1475 Map<String, Component> componentCache = new HashMap<>();
1477 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1478 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1479 cap.setRequirement(new RequirementDataDefinition());
1480 RelationshipInfo relation = new RelationshipInfo();
1481 relation.setRequirementUid("Uid");
1482 relation.setRequirement("requirment");
1483 relation.setCapability("cap");
1484 relation.setCapabilityOwnerId("id");
1485 cap.setRelation(relation);
1486 relationships.add(cap);
1487 rel.setRelationships(relationships);
1488 rel.setToNode("name");
1489 fromInstance.setUniqueId("name");
1490 fromInstance.setComponentUid("string");
1491 instancesList.add(fromInstance);
1492 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1494 List<RequirementDefinition> defs = new ArrayList<>();
1495 RequirementDefinition def = new RequirementDefinition();
1496 def.setName("requirment");
1497 def.setCapability("cap");
1499 requirements.put("key", defs);
1500 fromOriginComponent.setRequirements(requirements);
1502 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1503 List<CapabilityDefinition> caps = new ArrayList<>();
1504 CapabilityDefinition capdef = new CapabilityDefinition();
1505 capdef.setOwnerId("id");
1506 capdef.setName("cap");
1507 capdef.setPreviousName("before cap");
1508 capdef.setType("type");
1510 capabilities.put("cap", caps);
1511 fromOriginComponent.setCapabilities(capabilities);
1513 when(toscaOperationFacade.getToscaElement(any(String.class),
1514 any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1517 capabilityRequirementConverter
1518 .buildSubstitutedName(anyMap(), any(Component.class), anyList(), anyString(), anyString()))
1519 .thenReturn(Either.right(false));
1521 final String expectedErrorMsg =
1522 String.format("Failed to build a substituted capability name for the capability "
1523 + "with name %s on a component with uniqueId %s",
1524 cap.getRequirement(), fromOriginComponent.getUniqueId());
1526 assertThrows(ToscaExportException.class, () ->
1527 Deencapsulation.invoke(testSubject, "buildRequirement", fromInstance, fromOriginComponent, instancesList,
1528 rel, componentCache), expectedErrorMsg);
1532 public void testBuildAndAddRequirement() {
1533 Component fromOriginComponent = new Resource();
1534 Component toOriginComponent = new Resource();
1535 CapabilityDefinition capability = new CapabilityDefinition();
1536 RequirementDefinition requirement = new RequirementDefinition();
1537 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1538 ComponentInstance toInstance = new ComponentInstance();
1539 Map<String, Component> componentCache = new HashMap<>();
1540 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1541 capabilityRequirementRelationship.setRelation(reqAndRelationshipPair);
1542 capability.setPath(new ArrayList<>());
1543 capability.setPreviousName("before cap");
1544 reqAndRelationshipPair.setCapability("cap");
1545 requirement.setPath(new ArrayList<>());
1546 requirement.setPreviousName("before req");
1547 reqAndRelationshipPair.setRequirement("req");
1550 capabilityRequirementConverter
1551 .buildSubstitutedName(anyMap(), eq(toOriginComponent), anyList(), eq("cap"), anyString()))
1552 .thenReturn(Either.left("buildCapNameRes"));
1555 capabilityRequirementConverter
1556 .buildSubstitutedName(anyMap(), eq(fromOriginComponent), anyList(), eq("req"), anyString()))
1557 .thenReturn(Either.left("buildReqNameRes"));
1560 final Map<String, ToscaTemplateRequirement> requirementMap =
1561 Deencapsulation.invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent,
1562 capability, requirement, capabilityRequirementRelationship, toInstance, componentCache);
1563 assertNotNull(requirementMap);
1564 assertFalse(requirementMap.isEmpty());
1565 assertTrue(requirementMap.containsKey("buildReqNameRes"));
1566 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get("buildReqNameRes");
1567 assertNotNull(actualToscaTemplateRequirement);
1568 assertEquals("buildCapNameRes", actualToscaTemplateRequirement.getCapability());
1572 public void testBuildRequirementBuildSubstitutedNameReturnsValueTwice() {
1573 final Component fromOriginComponent = new Resource();
1574 final Component toOriginComponent = new Resource();
1575 final CapabilityDefinition capability = new CapabilityDefinition();
1576 final RequirementDefinition requirement = new RequirementDefinition();
1577 final RelationshipInfo relationship = new RelationshipInfo();
1578 final CapabilityRequirementRelationship capabilityRequirementRelationship = new CapabilityRequirementRelationship();
1579 capabilityRequirementRelationship.setRelation(relationship);
1580 ComponentInstance toInstance = new ComponentInstance();
1581 Map<String, Component> componentCache = new HashMap<>();
1582 capability.setPath(new ArrayList<>());
1583 relationship.setCapability("cap");
1584 requirement.setPath(new ArrayList<>());
1585 relationship.setRequirement("req");
1587 final String builtCapabilityOrRequirementName = "builtCapabilityOrRequirementName";
1588 when(capabilityRequirementConverter.buildSubstitutedName(any(), any(), any(), any(), any()))
1589 .thenReturn(Either.left(builtCapabilityOrRequirementName));
1591 final Map<String, ToscaTemplateRequirement> requirementMap = Deencapsulation
1592 .invoke(testSubject, "buildRequirement", fromOriginComponent, toOriginComponent, capability, requirement,
1593 capabilityRequirementRelationship, toInstance, componentCache);
1594 assertNotNull(requirementMap);
1595 assertFalse(requirementMap.isEmpty());
1596 assertTrue(requirementMap.containsKey(builtCapabilityOrRequirementName));
1597 final ToscaTemplateRequirement actualToscaTemplateRequirement = requirementMap.get(builtCapabilityOrRequirementName);
1598 assertNotNull(actualToscaTemplateRequirement);
1599 assertEquals(builtCapabilityOrRequirementName, actualToscaTemplateRequirement.getCapability());
1603 public void testIsRequirementBelongToRelation() throws Exception {
1605 Component originComponent = new Resource();
1606 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1607 RequirementDefinition requirement = new RequirementDefinition();
1608 String fromInstanceId = "";
1611 requirement.setName("name");
1612 reqAndRelationshipPair.setRequirement("name1");
1614 // test return false
1615 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1616 reqAndRelationshipPair, requirement, fromInstanceId);
1617 Assert.assertFalse(result);
1621 public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1623 Component originComponent = new Service();
1624 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1625 RequirementDefinition requirement = new RequirementDefinition();
1626 String fromInstanceId = "";
1629 // default test return true
1630 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1631 reqAndRelationshipPair, requirement, fromInstanceId);
1632 Assert.assertTrue(result);
1636 public void testIsRequirementBelongToOwner() throws Exception {
1638 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1639 RequirementDefinition requirement = new RequirementDefinition();
1640 String fromInstanceId = "";
1641 Component originComponent = new Resource();
1644 requirement.setOwnerId("owner1");
1645 reqAndRelationshipPair.setRequirementOwnerId("owner");
1648 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1649 fromInstanceId, originComponent);
1650 Assert.assertFalse(result);
1654 public void testIsCvfc() throws Exception {
1656 Component component = new Service();
1659 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1660 Assert.assertFalse(result);
1664 public void testConvertCapabilities() throws Exception {
1665 Component component = new Resource();
1666 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1667 Map<String, Component> componentCache = new HashMap<>();
1668 Either<SubstitutionMapping, ToscaError> result;
1670 when(capabilityRequirementConverter.convertSubstitutionMappingCapabilities(componentCache, component))
1671 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1673 // default test return isRight
1674 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1676 Assert.assertNotNull(result);
1680 public void testConvertCapabilities_1() throws Exception {
1681 Component component = new Resource();
1682 ToscaNodeType nodeType = new ToscaNodeType();
1683 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1684 Either<ToscaNodeType, ToscaError> result;
1686 Map<String, ToscaCapability> capabilities = new HashMap<>();
1687 capabilities.put("key", new ToscaCapability());
1690 result = Deencapsulation
1691 .invoke(testSubject, "convertCapabilities", new HashMap<>(), component, nodeType, dataTypes);
1692 Assert.assertNotNull(result);
1696 public void testConvertToNodeTemplateArtifacts() throws Exception {
1697 Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1698 ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1699 art.setFile("test_file");
1700 art.setType("test_type");
1701 Map<String, ToscaTemplateArtifact> result;
1702 container.put("test_art", art);
1703 result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1704 Assert.assertNotNull(result);
1705 Assert.assertTrue(MapUtils.isNotEmpty(result));
1706 Assert.assertEquals("test_file", result.get("test_art").getFile());
1707 Assert.assertEquals("test_type", result.get("test_art").getType());
1711 public void testGetProxyNodeTypeInterfacesNoInterfaces() {
1712 Component service = new Service();
1713 Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1714 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1715 Assert.assertFalse(proxyNodeTypeInterfaces.isPresent());
1719 public void testGetProxyNodeTypeInterfaces() {
1720 Component service = getTestComponent();
1721 Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1722 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1723 Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1724 Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1725 Assert.assertNotNull(componentInterfaces);
1730 public void testGetProxyNodeTypePropertiesComponentNull() {
1731 Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1732 testSubject.getProxyNodeTypeProperties(null, DATA_TYPES);
1733 Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1737 public void testGetProxyNodeTypePropertiesNoProperties() {
1738 Component service = new Service();
1739 Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1740 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1741 Assert.assertFalse(proxyNodeTypeProperties.isPresent());
1745 public void testGetProxyNodeTypeProperties() {
1746 Component service = getTestComponent();
1747 service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1748 createMockProperty("componentPropInt", null)));
1749 Optional<Map<String, ToscaProperty>> proxyNodeTypeProperties =
1750 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1751 Assert.assertTrue(proxyNodeTypeProperties.isPresent());
1752 Map<String, ToscaProperty> componentProperties = proxyNodeTypeProperties.get();
1753 Assert.assertNotNull(componentProperties);
1754 Assert.assertEquals(2, componentProperties.size());
1758 public void testAddInputsToPropertiesNoInputs() {
1759 Component service = getTestComponent();
1760 service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1761 createMockProperty("componentPropInt", null)));
1762 Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1763 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1765 Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1766 Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1767 testSubject.addInputsToProperties(DATA_TYPES, null, proxyNodeTypeProperties);
1768 Assert.assertNotNull(proxyNodeTypeProperties);
1769 Assert.assertEquals(2, proxyNodeTypeProperties.size());
1770 testSubject.addInputsToProperties(DATA_TYPES, new ArrayList<>(), proxyNodeTypeProperties);
1771 Assert.assertEquals(2, proxyNodeTypeProperties.size());
1775 public void testAddInputsToPropertiesWithInputs() {
1776 Component service = getTestComponent();
1777 service.setProperties(Arrays.asList(createMockProperty("componentPropStr", "Default String Prop"),
1778 createMockProperty("componentPropInt", null)));
1779 service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1780 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1781 Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1782 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1784 Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1785 Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1786 testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1787 Assert.assertNotNull(proxyNodeTypeProperties);
1788 Assert.assertEquals(4, proxyNodeTypeProperties.size());
1792 public void testAddInputsToPropertiesOnlyInputs() {
1793 Component service = getTestComponent();
1794 service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1795 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1796 Optional<Map<String, ToscaProperty>> proxyNodeTypePropertiesResult =
1797 testSubject.getProxyNodeTypeProperties(service, DATA_TYPES);
1799 Assert.assertTrue(proxyNodeTypePropertiesResult.isPresent());
1800 Map<String, ToscaProperty> proxyNodeTypeProperties = proxyNodeTypePropertiesResult.get();
1801 testSubject.addInputsToProperties(DATA_TYPES, service.getInputs(), proxyNodeTypeProperties);
1802 Assert.assertNotNull(proxyNodeTypeProperties);
1803 Assert.assertEquals(2, proxyNodeTypeProperties.size());
1807 public void testOperationImplementationInProxyNodeTypeNotPresent() {
1808 Component service = getTestComponent();
1809 InterfaceDefinition interfaceDefinition =
1810 service.getInterfaces().get("normalizedServiceComponentName-interface");
1811 interfaceDefinition.setOperations(new HashMap<>());
1812 final OperationDataDefinition operation = new OperationDataDefinition();
1813 operation.setName("start");
1814 operation.setDescription("op description");
1815 final ArtifactDataDefinition implementation = new ArtifactDataDefinition();
1816 implementation.setArtifactName("createBPMN.bpmn");
1817 operation.setImplementation(implementation);
1818 interfaceDefinition.getOperations().put(operation.getName(), operation);
1819 service.getInterfaces().put("normalizedServiceComponentName-interface", interfaceDefinition);
1820 service.setInputs(Arrays.asList(createMockInput("componentInputStr1",
1821 "Default String Input1"), createMockInput("componentInputStr2", "Default String Input2")));
1822 Optional<Map<String, Object>> proxyNodeTypeInterfaces =
1823 testSubject.getProxyNodeTypeInterfaces(service, DATA_TYPES);
1824 Assert.assertTrue(proxyNodeTypeInterfaces.isPresent());
1825 Map<String, Object> componentInterfaces = proxyNodeTypeInterfaces.get();
1826 Assert.assertNotNull(componentInterfaces);
1829 private Component getTestComponent() {
1830 Component component = new Service();
1831 component.setNormalizedName("normalizedServiceComponentName");
1832 InterfaceDefinition addedInterface = new InterfaceDefinition();
1833 addedInterface.setType("com.some.service.or.other.serviceName");
1834 final String interfaceType = "normalizedServiceComponentName-interface";
1835 component.setInterfaces(new HashMap<>());
1836 component.getInterfaces().put(interfaceType, addedInterface);
1840 private PropertyDefinition createMockProperty(String propertyName, String defaultValue) {
1841 PropertyDefinition propertyDefinition = new PropertyDefinition();
1842 propertyDefinition.setName(propertyName);
1843 propertyDefinition.setType("string");
1844 propertyDefinition.setDefaultValue(defaultValue);
1845 return propertyDefinition;
1848 private InputDefinition createMockInput(String inputName, String defaultValue) {
1849 InputDefinition inputDefinition = new InputDefinition();
1850 inputDefinition.setName(inputName);
1851 inputDefinition.setType("string");
1852 inputDefinition.setDefaultValue(defaultValue);
1853 return inputDefinition;