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=========================================================
21 package org.openecomp.sdc.be.tosca;
23 import fj.data.Either;
24 import mockit.Deencapsulation;
25 import org.apache.commons.collections.MapUtils;
26 import org.apache.commons.lang3.tuple.ImmutablePair;
27 import org.apache.commons.lang3.tuple.Triple;
28 import org.junit.Assert;
29 import org.junit.Before;
30 import org.junit.Ignore;
31 import org.junit.Test;
32 import org.mockito.InjectMocks;
33 import org.mockito.Mock;
34 import org.mockito.Mockito;
35 import org.mockito.MockitoAnnotations;
36 import org.openecomp.sdc.be.components.BeConfDependentTest;
37 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
38 import org.openecomp.sdc.be.dao.janusgraph.JanusGraphOperationStatus;
39 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
40 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
41 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
42 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
43 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
44 import org.openecomp.sdc.be.datatypes.elements.ToscaArtifactDataDefinition;
45 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
46 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
47 import org.openecomp.sdc.be.model.ArtifactDefinition;
48 import org.openecomp.sdc.be.model.CapabilityDefinition;
49 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
50 import org.openecomp.sdc.be.model.Component;
51 import org.openecomp.sdc.be.model.ComponentInstance;
52 import org.openecomp.sdc.be.model.ComponentInstanceInput;
53 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
54 import org.openecomp.sdc.be.model.ComponentParametersView;
55 import org.openecomp.sdc.be.model.DataTypeDefinition;
56 import org.openecomp.sdc.be.model.GroupDefinition;
57 import org.openecomp.sdc.be.model.GroupInstance;
58 import org.openecomp.sdc.be.model.InputDefinition;
59 import org.openecomp.sdc.be.model.InterfaceDefinition;
60 import org.openecomp.sdc.be.model.PropertyDefinition;
61 import org.openecomp.sdc.be.model.RelationshipInfo;
62 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
63 import org.openecomp.sdc.be.model.RequirementDefinition;
64 import org.openecomp.sdc.be.model.Resource;
65 import org.openecomp.sdc.be.model.Service;
66 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
67 import org.openecomp.sdc.be.model.category.CategoryDefinition;
68 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
69 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
70 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
71 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
72 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
73 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
74 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
75 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
76 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
77 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
78 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
79 import org.openecomp.sdc.be.tosca.model.ToscaTemplateArtifact;
80 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
81 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
82 import org.openecomp.sdc.be.tosca.utils.InputConverter;
84 import java.util.ArrayList;
85 import java.util.Arrays;
86 import java.util.Collections;
87 import java.util.HashMap;
88 import java.util.List;
90 import java.util.stream.Collectors;
92 import static org.hamcrest.CoreMatchers.is;
93 import static org.junit.Assert.assertThat;
95 public class ToscaExportHandlerTest extends BeConfDependentTest {
96 private static final String COMPONENT_PROPERTY_NAME = "prop1";
97 private static final String COMPONENT_PROPERTY_TYPE = "string";
98 private static final String COMPONENT_INPUT_NAME = "input1";
99 private static final String COMPONENT_INPUT_TYPE = "integer";
100 private static final String RESOURCE_NAME = "resource";
101 private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
104 ToscaExportHandler testSubject;
107 ApplicationDataTypeCache dataTypeCache;
110 ToscaOperationFacade toscaOperationFacade;
113 CapabilityRequirementConverter capabiltyRequirementConvertor;
116 InputConverter inputConverter;
119 GroupExportParser groupExportParser;
122 GroupExportParserImpl groupExportParserImpl;
125 InterfaceLifecycleOperation interfaceLifecycleOperation;
128 public void setUpMock() throws Exception {
129 MockitoAnnotations.initMocks(this);
132 private Resource getNewResource() {
133 Resource resource = new Resource();
134 List<CategoryDefinition> categories = new ArrayList<>();
135 CategoryDefinition category = new CategoryDefinition();
136 List<SubCategoryDefinition> subcategories = new ArrayList<>();
137 SubCategoryDefinition subcategory = new SubCategoryDefinition();
138 List<DataTypeDefinition> dataTypes = new ArrayList<>();
139 DataTypeDefinition dataType = new DataTypeDefinition();
140 dataType.setName("dataTypeName");
141 dataType.setDerivedFromName("tosca.datatypes.Root");
142 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
146 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
147 dataType.setPropertiesData(propDataList);
148 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
149 .collect(Collectors.toList());
150 dataType.setProperties(propList);
151 dataTypes.add(dataType);
153 subcategory.setName("name");
154 subcategories.add(subcategory);
155 category.setName("name");
156 category.setSubcategories(subcategories);
157 categories.add(category);
159 resource.setCategories(categories);
160 resource.setVersion("version");
161 resource.setVendorName("vendorName");
162 resource.setVendorRelease("vendorRelease");
163 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
164 resource.setDataTypes(dataTypes);
169 private Service getNewService() {
170 Service service = new Service();
171 List<CategoryDefinition> categories = new ArrayList<>();
172 CategoryDefinition category = new CategoryDefinition();
173 List<SubCategoryDefinition> subcategories = new ArrayList<>();
174 SubCategoryDefinition subcategory = new SubCategoryDefinition();
176 subcategory.setName("name");
177 subcategories.add(subcategory);
178 category.setName("name");
179 category.setSubcategories(subcategories);
180 categories.add(category);
182 service.setCategories(categories);
183 service.setComponentType(ComponentTypeEnum.SERVICE);
184 service.setServiceType("serviceType");
185 service.setServiceRole("serviceRole");
186 service.setEnvironmentContext("environmentContext");
192 public void testExportComponent() throws Exception {
193 Component component = getNewResource();
194 Either<ToscaRepresentation, ToscaError> result;
196 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
197 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
198 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
199 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
200 .thenReturn(Either.left(Collections.emptyMap()));
202 // default test when component is Resource
203 result = testSubject.exportComponent(component);
205 component = getNewService();
206 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
207 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
208 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
210 // default test when component is Service
211 result = testSubject.exportComponent(component);
215 public void testExportComponentInterface() throws Exception {
216 Component component = getNewResource();
217 Either<ToscaRepresentation, ToscaError> result;
219 ((Resource) component).setInterfaces(new HashMap<>());
221 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.NOT_FOUND));
222 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
223 // default test when convertInterfaceNodeType is right
224 result = testSubject.exportComponentInterface(component, false);
226 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
227 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
228 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
230 // default test when convertInterfaceNodeType is left
231 result = testSubject.exportComponentInterface(component, false);
236 public void testConvertInterfaceNodeTypeProperties() throws Exception {
238 Resource component = getNewResource();
240 component.setInterfaces(new HashMap<>());
241 InputDefinition input = new InputDefinition();
242 input.setName(COMPONENT_INPUT_NAME);
243 input.setType(COMPONENT_INPUT_TYPE);
244 component.setInputs(Collections.singletonList(input));
245 PropertyDefinition property = new PropertyDefinition();
246 property.setName(COMPONENT_PROPERTY_NAME);
247 property.setType(COMPONENT_PROPERTY_TYPE);
248 component.setProperties(Collections.singletonList(property));
249 component.setName(RESOURCE_NAME);
250 component.setToscaResourceName(RESOURCE_NAME);
252 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
253 .thenReturn(Either.left(Collections.emptyMap()));
254 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
255 // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
257 .when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
258 Mockito.any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
260 Either<ToscaTemplate, ToscaError> result = (Either<ToscaTemplate, ToscaError>) Deencapsulation
261 .invoke(testSubject, "convertInterfaceNodeType", new HashMap<String, Component>(), component,
262 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
263 assertThat(result.isLeft(), is(true));
264 Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
265 assertThat(nodeTypeMap.size(), is(1));
266 ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
267 Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
268 // Check if inputs and properties in component are merged properly
269 assertThat(propertyMap.size(), is(2));
270 assertThat(propertyMap.containsKey(COMPONENT_INPUT_NAME), is(true));
271 assertThat(propertyMap.containsKey(COMPONENT_PROPERTY_NAME), is(true));
275 public void testCreateToscaRepresentation() throws Exception {
276 ToscaTemplate toscaTemplate = new ToscaTemplate("");
277 ToscaRepresentation result;
280 result = testSubject.createToscaRepresentation(toscaTemplate);
284 public void testGetDependencies() throws Exception {
286 Component component = new Resource();
287 Either<ToscaTemplate, ToscaError> result;
290 result = testSubject.getDependencies(component);
294 public void testConvertToscaTemplate() throws Exception {
296 Component component = getNewResource();
297 ToscaTemplate toscaNode = new ToscaTemplate("");
298 Either<ToscaTemplate, ToscaError> result;
299 List<ComponentInstance> resourceInstances = new ArrayList<>();
300 ComponentInstance instance = new ComponentInstance();
302 instance.setOriginType(OriginTypeEnum.SERVICE);
303 instance.setSourceModelUid("targetModelUid");
304 resourceInstances.add(instance);
306 component.setComponentInstances(resourceInstances);
308 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
309 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
310 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
313 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
316 @Ignore("need to solve problem with groupExportParser injection")
318 public void testConvertToscaTemplateWhenComponentContainsGroup() {
319 Component component = getNewResource();
320 ToscaTemplate toscaNode = new ToscaTemplate("");
321 Either<ToscaTemplate, ToscaError> result;
322 component.setComponentInstances(new ArrayList<>());
324 List<GroupDefinition> groups = new ArrayList<>();
325 GroupDefinition group = new GroupDefinition();
326 List<String> artifacts = new ArrayList<>();
327 artifacts.add("artifact");
328 group.setType("org.openecomp.groups.VfModule");
329 group.setArtifacts(artifacts);
331 component.setGroups(groups);
333 Map<String, String[]> substitutionMappingMap = new HashMap<>();
334 String[] array = { "value1", "value2" };
335 substitutionMappingMap.put("key", array);
337 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
338 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
340 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
341 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
342 .thenReturn(Either.left(new SubstitutionMapping()));
344 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
346 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
347 .thenReturn(new HashMap<>());
349 Mockito.when(groupExportParser.getGroups(component))
352 // test component contains group
353 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
356 @Ignore("need to solve problem with groupExportParser injection")
358 public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
359 Component component = getNewService();
360 ToscaTemplate toscaNode = new ToscaTemplate("");
361 Either<ToscaTemplate, ToscaError> result;
362 component.setComponentInstances(new ArrayList<>());
364 List<GroupDefinition> groups = new ArrayList<>();
365 GroupDefinition group = new GroupDefinition();
366 List<String> artifacts = new ArrayList<>();
367 artifacts.add("artifact");
368 group.setType("org.openecomp.groups.VfModule");
369 group.setArtifacts(artifacts);
371 component.setGroups(groups);
373 Map<String, String[]> substitutionMappingMap = new HashMap<>();
374 String[] array = { "value1", "value2" };
375 substitutionMappingMap.put("key", array);
377 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
378 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
380 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
381 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
382 .thenReturn(Either.left(new SubstitutionMapping()));
384 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
386 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
387 .thenReturn(new HashMap<>());
388 // test component contains group
389 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
393 public void testConvertMetadata_1() throws Exception {
395 Component component = getNewResource();
396 boolean isInstance = true;
397 ComponentInstance componentInstance = new ComponentInstance();
398 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
399 componentInstance.setSourceModelInvariant("targetModelInvariant");
401 ToscaMetadata result;
405 result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
409 public void testFillImports() throws Exception {
411 Component component = getNewService();
412 ToscaTemplate toscaTemplate = new ToscaTemplate("");
413 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
415 ComponentInstance instance = new ComponentInstance();
416 List<ComponentInstance> resourceInstances = new ArrayList<>();
417 instance.setComponentUid("name");
418 resourceInstances.add(instance);
419 component.setComponentInstances(resourceInstances);
420 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
421 ArtifactDefinition artifact = new ArtifactDefinition();
422 artifact.setArtifactName("name.name2");
423 toscaArtifacts.put("assettoscatemplate", artifact);
424 component.setToscaArtifacts(toscaArtifacts);
426 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.any(String.class)))
427 .thenReturn(Either.left(component));
430 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
434 public void testCreateDependency() throws Exception {
436 Map<String, Component> componentCache = new HashMap<>();
437 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
438 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
439 ComponentInstance ci = new ComponentInstance();
440 Component component = getNewResource();
442 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
443 ArtifactDefinition artifact = new ArtifactDefinition();
444 artifact.setArtifactName("name.name2");
445 toscaArtifacts.put("assettoscatemplate", artifact);
446 component.setToscaArtifacts(toscaArtifacts);
447 ci.setComponentUid("name");
448 ci.setOriginType(OriginTypeEnum.ServiceProxy);
449 ci.setSourceModelUid("modelName");
451 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("name"))).thenReturn(Either.left(component));
453 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("modelName")))
454 .thenReturn(Either.left(new Service()));
457 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
461 public void testGetInterfaceFilename() throws Exception {
462 String artifactName = "artifact.name";
466 result = ToscaExportHandler.getInterfaceFilename(artifactName);
470 public void testConvertNodeType() throws Exception {
471 Component component = new Resource();
472 ToscaTemplate toscaNode = new ToscaTemplate("");
473 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
474 Either<ToscaTemplate, ToscaError> result;
476 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(JanusGraphOperationStatus.ALREADY_EXIST));
477 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
478 .thenReturn(Either.left(Collections.emptyMap()));
480 result = Deencapsulation.invoke(testSubject, "convertNodeType",new HashMap<>(), component, toscaNode, nodeTypes);
484 public void testConvertInterfaceNodeType() throws Exception {
485 Component component = getNewResource();
486 ToscaTemplate toscaNode = new ToscaTemplate("");
487 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
488 Either<ToscaTemplate, ToscaError> result;
489 List<InputDefinition> inputs = new ArrayList<>();
490 inputs.add(new InputDefinition());
491 component.setInputs(inputs);
493 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
494 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
496 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
497 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
500 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType",new HashMap<>(), component, toscaNode
503 @Ignore("need to fix change in injected class.")
505 public void testConvertReqCapAndTypeName() throws Exception {
506 Component component = new Resource();
507 ToscaTemplate toscaNode = new ToscaTemplate("");
508 Map<String, ToscaNodeType> nodeTypes = new HashMap();
509 ToscaNodeType toscaNodeType = new ToscaNodeType();
510 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
511 Either<ToscaTemplate, ToscaError> result;
514 capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class),Mockito.any(Resource.class), Mockito.any(Map.class)))
515 .thenReturn(new HashMap<>());
517 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
518 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
521 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName",new HashMap<>(), component, toscaNode, nodeTypes,
522 toscaNodeType, dataTypes);
524 component = new Service();
526 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
527 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
529 // test when component is service
530 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
531 toscaNodeType, dataTypes);
536 public void testConvertNodeTemplates() throws Exception {
537 Component component = getNewResource();
538 List<ComponentInstance> componentInstances = new ArrayList<>();
539 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
540 Map<String, Component> componentCache = new HashMap<>();
541 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
542 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
543 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
544 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
545 List<ComponentInstanceInput> inputs = new ArrayList<>();
546 inputs.add(new ComponentInstanceInput());
547 componentInstancesInputs.put("key", inputs);
548 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
549 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
550 reldef.setFromNode("node");
551 resourceInstancesRelations.add(reldef);
552 component.setComponentInstancesRelations(resourceInstancesRelations);
554 ComponentInstance instance = new ComponentInstance();
555 instance.setUniqueId("id");
556 instance.setComponentUid("uid");
557 instance.setOriginType(OriginTypeEnum.ServiceProxy);
558 List<GroupInstance> groupInstances = new ArrayList<>();
559 GroupInstance groupInst = new GroupInstance();
560 List<String> artifacts = new ArrayList<>();
561 artifacts.add("artifact");
562 groupInst.setArtifacts(artifacts);
563 groupInst.setType("type");
564 groupInstances.add(groupInst);
565 instance.setGroupInstances(groupInstances);
566 componentInstances.add(instance);
568 component.setComponentInstancesInputs(componentInstancesInputs);
569 component.setInvariantUUID("uuid");
570 component.setUUID("uuid");
571 component.setDescription("desc");
573 componentCache.put("uid", component);
575 componentInstancesProperties.put("id", new ArrayList<>());
576 componentInstancesInputs.put("id", new ArrayList<>());
578 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
579 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
581 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
582 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
583 .thenReturn(Either.left(new ToscaNodeTemplate()));
586 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
587 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
591 public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
592 Component component = getNewService();
593 List<ComponentInstance> componentInstances = new ArrayList<>();
594 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
595 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
596 Map<String, Component> componentCache = new HashMap<>();
597 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
598 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
599 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
600 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
601 List<ComponentInstanceInput> inputs = new ArrayList<>();
602 inputs.add(new ComponentInstanceInput());
603 componentInstancesInputs.put("key", inputs);
604 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
605 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
606 reldef.setFromNode("node");
607 resourceInstancesRelations.add(reldef);
608 component.setComponentInstancesRelations(resourceInstancesRelations);
610 ComponentInstance instance = new ComponentInstance();
611 instance.setUniqueId("id");
612 instance.setComponentUid("uid");
613 instance.setOriginType(OriginTypeEnum.ServiceProxy);
614 List<GroupInstance> groupInstances = new ArrayList<>();
615 GroupInstance groupInst = new GroupInstance();
616 List<String> artifacts = new ArrayList<>();
617 artifacts.add("artifact");
618 groupInst.setArtifacts(artifacts);
619 groupInst.setType("type");
620 groupInstances.add(groupInst);
621 instance.setGroupInstances(groupInstances);
622 componentInstances.add(instance);
624 component.setComponentInstancesInputs(componentInstancesInputs);
625 component.setInvariantUUID("uuid");
626 component.setUUID("uuid");
627 component.setDescription("desc");
629 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
630 ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
631 ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
632 path.setPathElements(list);
633 forwardingPaths.put("key", path);
635 ((Service) component).setForwardingPaths(forwardingPaths);
637 componentCache.put("uid", component);
639 componentInstancesProperties.put("id", new ArrayList<>());
640 componentInstancesInterfaces.put("id", new ArrayList<>());
641 componentInstancesInputs.put("id", new ArrayList<>());
643 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
644 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
646 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
647 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
648 .thenReturn(Either.left(new ToscaNodeTemplate()));
651 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
652 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
656 public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
657 Component component = getNewResource();
658 List<ComponentInstance> componentInstances = new ArrayList<>();
659 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
660 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
661 Map<String, Component> componentCache = new HashMap<>();
662 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
663 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
664 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
665 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
666 List<ComponentInstanceInput> inputs = new ArrayList<>();
667 inputs.add(new ComponentInstanceInput());
668 componentInstancesInputs.put("key", inputs);
669 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
670 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
671 reldef.setFromNode("node");
672 resourceInstancesRelations.add(reldef);
673 component.setComponentInstancesRelations(resourceInstancesRelations);
675 ComponentInstance instance = new ComponentInstance();
676 instance.setUniqueId("id");
677 instance.setComponentUid("uid");
678 instance.setOriginType(OriginTypeEnum.ServiceProxy);
679 componentInstances.add(instance);
681 component.setComponentInstancesInputs(componentInstancesInputs);
682 component.setInvariantUUID("uuid");
683 component.setUUID("uuid");
684 component.setDescription("desc");
686 componentCache.put("uid", component);
688 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
689 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
691 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
692 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
693 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
696 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
697 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
701 public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
702 Component component = getNewResource();
703 List<ComponentInstance> componentInstances = new ArrayList<>();
704 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
705 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
706 Map<String, Component> componentCache = new HashMap<>();
707 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
708 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
709 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
710 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
711 List<ComponentInstanceInput> inputs = new ArrayList<>();
712 inputs.add(new ComponentInstanceInput());
713 componentInstancesInputs.put("key", inputs);
714 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
715 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
716 reldef.setFromNode("id");
717 resourceInstancesRelations.add(reldef);
718 component.setComponentInstancesRelations(resourceInstancesRelations);
720 ComponentInstance instance = new ComponentInstance();
721 instance.setUniqueId("id");
722 instance.setComponentUid("uid");
723 instance.setOriginType(OriginTypeEnum.ServiceProxy);
724 componentInstances.add(instance);
726 component.setComponentInstancesInputs(componentInstancesInputs);
727 component.setInvariantUUID("uuid");
728 component.setUUID("uuid");
729 component.setDescription("desc");
731 componentCache.put("uid", component);
733 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
734 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
737 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
738 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
742 public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
743 Component component = new Resource();
744 List<ComponentInstance> componentInstances = new ArrayList<>();
745 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
746 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
747 Map<String, Component> componentCache = new HashMap<>();
748 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
749 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
750 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
751 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
752 List<ComponentInstanceInput> inputs = new ArrayList<>();
753 inputs.add(new ComponentInstanceInput());
754 componentInstancesInputs.put("key", inputs);
755 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
756 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
757 reldef.setFromNode("id");
758 reldef.setToNode("node");
759 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
760 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
761 relationship.setRelation(new RelationshipInfo());
762 relationships.add(relationship);
763 reldef.setRelationships(relationships);
764 resourceInstancesRelations.add(reldef);
765 component.setComponentInstancesRelations(resourceInstancesRelations);
767 ComponentInstance instance = new ComponentInstance();
768 instance.setUniqueId("id");
769 componentInstances.add(instance);
771 component.setComponentInstancesInputs(componentInstancesInputs);
772 component.setComponentInstances(componentInstances);
774 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
775 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
778 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
779 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
783 public void testAddComponentInstanceInputs() throws Exception {
785 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
786 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
787 ComponentInstance componentInstance = new ComponentInstance();
788 String instanceUniqueId = "id";
789 Map<String, Object> props = new HashMap<>();
791 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
792 componentInstanceInputs.add(new ComponentInstanceInput());
794 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
797 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
798 instanceUniqueId, props);
802 public void testAddPropertiesOfComponentInstance() throws Exception {
803 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
804 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
805 ComponentInstance componentInstance = new ComponentInstance();
806 String instanceUniqueId = "id";
807 Map<String, Object> props = new HashMap<>();
809 ComponentInstanceProperty cip = new ComponentInstanceProperty();
810 cip.setInstanceUniqueId("id");
812 List<ComponentInstanceProperty> list = new ArrayList<>();
815 componentInstancesProperties.put("id", list);
818 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
819 instanceUniqueId, props);
823 public void testAddPropertiesOfParentComponent() throws Exception {
824 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
825 ComponentInstance componentInstance = new ComponentInstance();
826 Component componentOfInstance = new Resource();
827 Map<String, Object> props = new HashMap<>();
829 List<PropertyDefinition> properties = new ArrayList<>();
830 properties.add(new PropertyDefinition());
832 ((Resource) componentOfInstance).setProperties(properties);
835 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
836 componentOfInstance, props);
841 public void testCreateNodeType() throws Exception {
843 Component component = new Resource();
844 List<String> array = new ArrayList<>();
846 ((Resource) component).setDerivedFrom(array);
847 ToscaNodeType result;
849 // test when component is resource
850 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
852 component = new Service();
853 // test when component is service
854 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
858 public void testCreateProxyInterfaceTypesComponentNotFound() throws Exception {
859 Component container = new Service();
860 Either<Map<String, ToscaNodeType>, ToscaError> result;
861 List<ComponentInstance> componentInstances = new ArrayList<>();
862 ComponentInstance instance = new ComponentInstance();
863 instance.setOriginType(OriginTypeEnum.ServiceProxy);
864 instance.setSourceModelUid("targetModelUid");
865 instance.setToscaComponentName("toscaComponentName");
867 componentInstances.add(instance);
868 container.setComponentInstances(componentInstances);
869 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
870 Mockito.any(ComponentParametersView.class)))
871 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
872 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
873 Assert.assertTrue(result.isRight());
878 public void testCreateProxyInterfaceTypesWhenInterfaceLifecycleFetchFailed() {
879 Component container = new Service();
880 Either<Map<String, ToscaNodeType>, ToscaError> result;
881 List<ComponentInstance> componentInstances = new ArrayList<>();
882 ComponentInstance instance = new ComponentInstance();
883 instance.setOriginType(OriginTypeEnum.ServiceProxy);
884 instance.setSourceModelUid("targetModelUid");
885 instance.setToscaComponentName("toscaComponentName");
886 componentInstances.add(instance);
887 container.setComponentInstances(componentInstances);
889 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
890 Mockito.any(ComponentParametersView.class)))
891 .thenReturn(Either.left(new Resource()));
892 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
893 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
894 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
895 Assert.assertTrue(result.isRight());
899 public void testCreateProxyInterfaceTypesPositive() {
900 Component container = new Service();
901 Either<Map<String, ToscaNodeType>, ToscaError> result;
902 List<ComponentInstance> componentInstances = new ArrayList<>();
903 ComponentInstance instance = new ComponentInstance();
904 instance.setOriginType(OriginTypeEnum.ServiceProxy);
905 instance.setSourceModelUid("targetModelUid");
906 instance.setToscaComponentName("toscaComponentName");
907 componentInstances.add(instance);
908 container.setComponentInstances(componentInstances);
910 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
911 .thenReturn(Either.left(Collections.emptyMap()));
913 Component proxyResource = new Resource();
914 Map<String, InterfaceDefinition> proxyInterfaces = new HashMap<>();
915 proxyInterfaces.put("Local", new InterfaceDefinition("Local", "desc", new HashMap<>()));
916 proxyResource.setInterfaces(proxyInterfaces);
917 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
918 Mockito.any(ComponentParametersView.class)))
919 .thenReturn(Either.left(proxyResource));
921 result = Deencapsulation.invoke(testSubject, "createProxyInterfaceTypes", container);
922 Assert.assertTrue(result.isLeft());
923 Assert.assertEquals(1, result.left().value().size());
927 public void testCreateProxyNodeTypes() throws Exception {
928 Map<String, Component> componentCache = new HashMap<>();
929 Component container = new Resource();
930 Either<Map<String, ToscaNodeType>, ToscaError> result;
931 List<ComponentInstance> componentInstances = new ArrayList<>();
932 ComponentInstance instance = new ComponentInstance();
933 instance.setOriginType(OriginTypeEnum.ServiceProxy);
934 instance.setSourceModelUid("targetModelUid");
936 componentInstances.add(instance);
937 container.setComponentInstances(componentInstances);
939 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
940 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
942 // test when getLatestByName return is right
943 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
948 public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
949 Map<String, Component> componentCache = new HashMap<>();
950 Component container = new Resource();
951 Either<Map<String, ToscaNodeType>, ToscaError> result;
952 List<ComponentInstance> componentInstances = new ArrayList<>();
953 ComponentInstance instance = new ComponentInstance();
954 instance.setOriginType(OriginTypeEnum.ServiceProxy);
955 instance.setSourceModelUid("targetModelUid");
957 componentInstances.add(instance);
958 container.setComponentInstances(componentInstances);
960 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
962 ComponentParametersView parameterView = new ComponentParametersView();
963 parameterView.disableAll();
964 parameterView.setIgnoreCategories(false);
966 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
967 Mockito.any(ComponentParametersView.class)))
968 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
970 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
972 // test when getLatestByName is left
973 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
977 public void testCreateProxyNodeType() throws Exception {
978 Map<String, Component> componentCache = new HashMap<>();
979 Component origComponent = new Resource();
980 Component proxyComponent = new Resource();
981 ComponentInstance instance = new ComponentInstance();
982 ToscaNodeType result;
984 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
987 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
988 proxyComponent, instance);
992 public void testConvertComponentInstanceRequirements() throws Exception {
993 Component component = new Resource();
994 ComponentInstance componentInstance = new ComponentInstance();
995 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
996 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
997 Component originComponent = new Resource();
998 Map<String, Component> componentCache = new HashMap<>();
999 Either<ToscaNodeTemplate, ToscaError> result;
1002 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1003 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1005 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
1006 reldef.setFromNode("name");
1007 reldef.setToNode("name1");
1008 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1009 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1010 cap.setRelation(new RelationshipInfo());
1011 relationships.add(cap);
1012 reldef.setRelationships(relationships);
1013 relations.add(reldef);
1014 componentInstance.setUniqueId("name");
1016 List<ComponentInstance> instances = new ArrayList<>();
1017 instances.add(componentInstance);
1018 component.setComponentInstances(instances);
1020 // test when filteredRElations ins't empty
1021 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
1022 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
1026 public void testAddRequirement() throws Exception {
1027 ComponentInstance fromInstance = new ComponentInstance();
1028 Component fromOriginComponent = new Resource();
1029 List<ComponentInstance> instancesList = new ArrayList<>();
1030 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1031 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1032 Map<String, Component> componentCache = new HashMap<>();
1035 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1036 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1037 cap.setRequirement(new RequirementDataDefinition());
1038 RelationshipInfo relation = new RelationshipInfo();
1039 relation.setRequirementUid("Uid");
1040 relation.setRequirement("requirment");
1041 relation.setCapability("cap");
1042 relation.setCapabilityOwnerId("id1");
1043 cap.setRelation(relation);
1044 relationships.add(cap);
1045 rel.setRelationships(relationships);
1046 rel.setToNode("name");
1047 fromInstance.setUniqueId("name");
1048 fromInstance.setComponentUid("string");
1049 instancesList.add(fromInstance);
1050 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1051 fromOriginComponent.setRequirements(requirements);
1054 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1055 rel, toscaRequirements, componentCache);
1060 public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
1062 ComponentInstance fromInstance = new ComponentInstance();
1063 Component fromOriginComponent = new Resource();
1064 List<ComponentInstance> instancesList = new ArrayList<>();
1065 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1066 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1067 Map<String, Component> componentCache = new HashMap<>();
1070 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1071 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1072 cap.setRequirement(new RequirementDataDefinition());
1073 RelationshipInfo relation = new RelationshipInfo();
1074 relation.setRequirementUid("Uid");
1075 relation.setRequirement("requirment");
1076 relation.setCapability("cap");
1077 relation.setCapabilityOwnerId("id1");
1078 cap.setRelation(relation);
1079 relationships.add(cap);
1080 rel.setRelationships(relationships);
1081 rel.setToNode("name");
1082 fromInstance.setUniqueId("name");
1083 fromInstance.setComponentUid("string");
1084 instancesList.add(fromInstance);
1085 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1087 List<RequirementDefinition> defs = new ArrayList<>();
1088 RequirementDefinition def = new RequirementDefinition();
1089 def.setName("requirment");
1090 def.setCapability("cap");
1092 requirements.put("key", defs);
1093 fromOriginComponent.setRequirements(requirements);
1095 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1096 Mockito.any(ComponentParametersView.class)))
1097 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1100 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1101 rel, toscaRequirements, componentCache);
1105 public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
1106 ComponentInstance fromInstance = new ComponentInstance();
1107 Component fromOriginComponent = new Resource();
1108 List<ComponentInstance> instancesList = new ArrayList<>();
1109 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1110 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1111 Map<String, Component> componentCache = new HashMap<>();
1114 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1115 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1116 cap.setRequirement(new RequirementDataDefinition());
1117 RelationshipInfo relation = new RelationshipInfo();
1118 relation.setRequirementUid("Uid");
1119 relation.setRequirement("requirment");
1120 relation.setCapability("cap");
1121 relation.setCapabilityOwnerId("id1");
1122 cap.setRelation(relation);
1123 relationships.add(cap);
1124 rel.setRelationships(relationships);
1125 rel.setToNode("name");
1126 fromInstance.setUniqueId("name");
1127 fromInstance.setComponentUid("string");
1128 instancesList.add(fromInstance);
1129 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1131 List<RequirementDefinition> defs = new ArrayList<>();
1132 RequirementDefinition def = new RequirementDefinition();
1133 def.setName("requirment");
1134 def.setCapability("cap");
1136 requirements.put("key", defs);
1137 fromOriginComponent.setRequirements(requirements);
1139 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1140 List<CapabilityDefinition> caps = new ArrayList<>();
1141 CapabilityDefinition capdef = new CapabilityDefinition();
1142 capdef.setOwnerId("id");
1143 capdef.setName("name");
1144 capdef.setType("type");
1146 capabilities.put("cap", caps);
1148 fromOriginComponent.setCapabilities(capabilities);
1150 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1151 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1154 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1155 rel, toscaRequirements, componentCache);
1157 @Ignore("need to fix change in injected class.")
1159 public void testAddRequirmentsWithBuildAndAddRequirements() {
1160 ComponentInstance fromInstance = new ComponentInstance();
1161 Component fromOriginComponent = new Resource();
1162 List<ComponentInstance> instancesList = new ArrayList<>();
1163 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1164 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1165 Map<String, Component> componentCache = new HashMap<>();
1168 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1169 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1170 cap.setRequirement(new RequirementDataDefinition());
1171 RelationshipInfo relation = new RelationshipInfo();
1172 relation.setRequirementUid("Uid");
1173 relation.setRequirement("requirment");
1174 relation.setCapability("cap");
1175 relation.setCapabilityOwnerId("id");
1176 cap.setRelation(relation);
1177 relationships.add(cap);
1178 rel.setRelationships(relationships);
1179 rel.setToNode("name");
1180 fromInstance.setUniqueId("name");
1181 fromInstance.setComponentUid("string");
1182 instancesList.add(fromInstance);
1183 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1185 List<RequirementDefinition> defs = new ArrayList<>();
1186 RequirementDefinition def = new RequirementDefinition();
1187 def.setName("requirment");
1188 def.setCapability("cap");
1190 requirements.put("key", defs);
1191 fromOriginComponent.setRequirements(requirements);
1193 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1194 List<CapabilityDefinition> caps = new ArrayList<>();
1195 CapabilityDefinition capdef = new CapabilityDefinition();
1196 capdef.setOwnerId("id");
1197 capdef.setName("cap");
1198 capdef.setType("type");
1200 capabilities.put("cap", caps);
1201 fromOriginComponent.setCapabilities(capabilities);
1203 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1204 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1206 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
1207 Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString(),Mockito.anyString()))
1208 .thenReturn(Either.right(false));
1211 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1212 rel, toscaRequirements, componentCache);
1214 @Ignore("need to fix change in injected class.")
1216 public void testBuildAndAddRequirement() throws Exception {
1217 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1218 Component fromOriginComponent = new Resource();
1219 Component toOriginComponent = new Resource();
1220 CapabilityDefinition capability = new CapabilityDefinition();
1221 RequirementDefinition requirement = new RequirementDefinition();
1222 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1223 ComponentInstance toInstance = new ComponentInstance();
1224 Map<String, Component> componentCache = new HashMap<>();
1226 capability.setPath(new ArrayList<>());
1227 reqAndRelationshipPair.setCapability("cap");
1228 requirement.setPath(new ArrayList<>());
1229 reqAndRelationshipPair.setRequirement("req");
1231 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
1232 new ArrayList<>(),Mockito.anyString(), "cap")).thenReturn(Either.left("buildCapNameRes"));
1234 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
1235 new ArrayList<>(),Mockito.anyString(), "req")).thenReturn(Either.right(false));
1238 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1239 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1242 @Ignore("need to fix change in injected class.")
1244 public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
1245 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1246 Component fromOriginComponent = new Resource();
1247 Component toOriginComponent = new Resource();
1248 CapabilityDefinition capability = new CapabilityDefinition();
1249 RequirementDefinition requirement = new RequirementDefinition();
1250 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1251 ComponentInstance toInstance = new ComponentInstance();
1252 Map<String, Component> componentCache = new HashMap<>();
1254 capability.setPath(new ArrayList<>());
1255 reqAndRelationshipPair.setCapability("cap");
1256 requirement.setPath(new ArrayList<>());
1257 reqAndRelationshipPair.setRequirement("req");
1259 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
1260 Mockito.anyList(), Mockito.anyString(),Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
1263 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1264 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1268 public void testIsRequirementBelongToRelation() throws Exception {
1270 Component originComponent = new Resource();
1271 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1272 RequirementDefinition requirement = new RequirementDefinition();
1273 String fromInstanceId = "";
1276 requirement.setName("name");
1277 reqAndRelationshipPair.setRequirement("name1");
1279 // test return false
1280 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1281 reqAndRelationshipPair, requirement, fromInstanceId);
1285 public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1287 Component originComponent = new Service();
1288 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1289 RequirementDefinition requirement = new RequirementDefinition();
1290 String fromInstanceId = "";
1293 // default test return true
1294 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1295 reqAndRelationshipPair, requirement, fromInstanceId);
1299 public void testIsRequirementBelongToOwner() throws Exception {
1301 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1302 RequirementDefinition requirement = new RequirementDefinition();
1303 String fromInstanceId = "";
1304 Component originComponent = new Resource();
1307 requirement.setOwnerId("owner1");
1308 reqAndRelationshipPair.setRequirementOwnerId("owner");
1311 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1312 fromInstanceId, originComponent);
1316 public void testIsCvfc() throws Exception {
1318 Component component = new Resource();
1321 component = new Service();
1323 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1327 public void testConvertCapabilities() throws Exception {
1328 Component component = new Resource();
1329 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1330 Map<String, Component> componentCache = new HashMap<>();
1331 Either<SubstitutionMapping, ToscaError> result;
1333 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
1334 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1336 // default test return isRight
1337 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1340 @Ignore("need to fix change in injected class.")
1342 public void testConvertCapabilities_1() throws Exception {
1343 Component component = new Resource();
1344 ToscaNodeType nodeType = new ToscaNodeType();
1345 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1346 Either<ToscaNodeType, ToscaError> result;
1348 Map<String, ToscaCapability> capabilities = new HashMap<>();
1349 capabilities.put("key", new ToscaCapability());
1351 Mockito.when(capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class), component, dataTypes)).thenReturn(capabilities);
1354 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);
1358 public void testConvertToNodeTemplateArtifacts() throws Exception {
1359 Map<String, ToscaArtifactDataDefinition> container = new HashMap<>();
1360 ToscaArtifactDataDefinition art = new ToscaArtifactDataDefinition();
1361 art.setFile("test_file");
1362 art.setType("test_type");
1363 Map<String, ToscaTemplateArtifact> result;
1364 container.put("test_art", art);
1365 result = Deencapsulation.invoke(testSubject, "convertToNodeTemplateArtifacts", container);
1366 Assert.assertTrue(MapUtils.isNotEmpty(result));
1367 Assert.assertTrue(result.get("test_art").getFile().equals("test_file"));
1368 Assert.assertTrue(result.get("test_art").getType().equals("test_type"));