1 package org.openecomp.sdc.be.tosca;
4 import java.util.ArrayList;
5 import java.util.Arrays;
6 import java.util.Collections;
7 import java.util.HashMap;
10 import java.util.stream.Collectors;
11 import mockit.Deencapsulation;
12 import org.apache.commons.lang3.tuple.ImmutablePair;
13 import org.apache.commons.lang3.tuple.Triple;
14 import org.junit.Before;
15 import org.junit.Ignore;
16 import org.junit.Test;
17 import org.mockito.InjectMocks;
18 import org.mockito.Mock;
19 import org.mockito.Mockito;
20 import org.mockito.MockitoAnnotations;
21 import org.openecomp.sdc.be.components.BeConfDependentTest;
22 import org.openecomp.sdc.be.components.utils.PropertyDataDefinitionBuilder;
23 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
24 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
25 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
26 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
27 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
28 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
29 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
30 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
31 import org.openecomp.sdc.be.model.ArtifactDefinition;
32 import org.openecomp.sdc.be.model.CapabilityDefinition;
33 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
34 import org.openecomp.sdc.be.model.Component;
35 import org.openecomp.sdc.be.model.ComponentInstance;
36 import org.openecomp.sdc.be.model.ComponentInstanceInput;
37 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
38 import org.openecomp.sdc.be.model.ComponentMetadataDefinition;
39 import org.openecomp.sdc.be.model.ComponentParametersView;
40 import org.openecomp.sdc.be.model.DataTypeDefinition;
41 import org.openecomp.sdc.be.model.GroupDefinition;
42 import org.openecomp.sdc.be.model.GroupInstance;
43 import org.openecomp.sdc.be.model.InputDefinition;
44 import org.openecomp.sdc.be.model.PropertyDefinition;
45 import org.openecomp.sdc.be.model.RelationshipInfo;
46 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
47 import org.openecomp.sdc.be.model.RequirementDefinition;
48 import org.openecomp.sdc.be.model.Resource;
49 import org.openecomp.sdc.be.model.Service;
50 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
51 import org.openecomp.sdc.be.model.category.CategoryDefinition;
52 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
53 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
54 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
55 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
56 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
57 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
58 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
59 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
60 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
61 import org.openecomp.sdc.be.tosca.model.ToscaProperty;
62 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
63 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
64 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
65 import org.openecomp.sdc.be.tosca.utils.InputConverter;
66 import org.yaml.snakeyaml.Yaml;
68 import static org.junit.Assert.assertThat;
69 import static org.hamcrest.CoreMatchers.is;
71 public class ToscaExportHandlerTest extends BeConfDependentTest {
72 private static final String COMPONENT_PROPERTY_NAME = "prop1";
73 private static final String COMPONENT_PROPERTY_TYPE = "string";
74 private static final String COMPONENT_INPUT_NAME = "input1";
75 private static final String COMPONENT_INPUT_TYPE = "integer";
76 private static final String RESOURCE_NAME = "resource";
77 private static final String TOSCA_VERSION = "tosca_simple_yaml_1_1";
80 ToscaExportHandler testSubject;
83 ApplicationDataTypeCache dataTypeCache;
86 ToscaOperationFacade toscaOperationFacade;
89 CapabilityRequirementConverter capabiltyRequirementConvertor;
92 InputConverter inputConverter;
95 GroupExportParser groupExportParser;
98 GroupExportParserImpl groupExportParserImpl;
101 InterfaceLifecycleOperation interfaceLifecycleOperation;
104 public void setUpMock() throws Exception {
105 MockitoAnnotations.initMocks(this);
108 private Resource getNewResource() {
109 Resource resource = new Resource();
110 List<CategoryDefinition> categories = new ArrayList<>();
111 CategoryDefinition category = new CategoryDefinition();
112 List<SubCategoryDefinition> subcategories = new ArrayList<>();
113 SubCategoryDefinition subcategory = new SubCategoryDefinition();
114 List<DataTypeDefinition> dataTypes = new ArrayList<>();
115 DataTypeDefinition dataType = new DataTypeDefinition();
116 dataType.setName("dataTypeName");
117 dataType.setDerivedFromName("tosca.datatypes.Root");
118 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
122 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
123 dataType.setPropertiesData(propDataList);
124 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
125 .collect(Collectors.toList());
126 dataType.setProperties(propList);
127 dataTypes.add(dataType);
129 subcategory.setName("name");
130 subcategories.add(subcategory);
131 category.setName("name");
132 category.setSubcategories(subcategories);
133 categories.add(category);
135 resource.setCategories(categories);
136 resource.setVersion("version");
137 resource.setVendorName("vendorName");
138 resource.setVendorRelease("vendorRelease");
139 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
140 resource.setDataTypes(dataTypes);
145 private Service getNewService() {
146 Service service = new Service();
147 List<CategoryDefinition> categories = new ArrayList<>();
148 CategoryDefinition category = new CategoryDefinition();
149 List<SubCategoryDefinition> subcategories = new ArrayList<>();
150 SubCategoryDefinition subcategory = new SubCategoryDefinition();
152 subcategory.setName("name");
153 subcategories.add(subcategory);
154 category.setName("name");
155 category.setSubcategories(subcategories);
156 categories.add(category);
158 service.setCategories(categories);
159 service.setComponentType(ComponentTypeEnum.SERVICE);
160 service.setServiceType("serviceType");
161 service.setServiceRole("serviceRole");
162 service.setEnvironmentContext("environmentContext");
168 public void testExportComponent() throws Exception {
169 Component component = getNewResource();
170 Either<ToscaRepresentation, ToscaError> result;
172 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
173 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
174 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
175 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
176 .thenReturn(Either.left(Collections.emptyMap()));
178 // default test when component is Resource
179 result = testSubject.exportComponent(component);
181 component = getNewService();
182 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
183 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
184 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
186 // default test when component is Service
187 result = testSubject.exportComponent(component);
191 public void testExportComponentInterface() throws Exception {
192 Component component = getNewResource();
193 Either<ToscaRepresentation, ToscaError> result;
195 ((Resource) component).setInterfaces(new HashMap<>());
197 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
198 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
199 // default test when convertInterfaceNodeType is right
200 result = testSubject.exportComponentInterface(component, false);
202 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
203 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
204 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
206 // default test when convertInterfaceNodeType is left
207 result = testSubject.exportComponentInterface(component, false);
212 public void testConvertInterfaceNodeTypeProperties() throws Exception {
214 Resource component = getNewResource();
216 component.setInterfaces(new HashMap<>());
217 InputDefinition input = new InputDefinition();
218 input.setName(COMPONENT_INPUT_NAME);
219 input.setType(COMPONENT_INPUT_TYPE);
220 component.setInputs(Collections.singletonList(input));
221 PropertyDefinition property = new PropertyDefinition();
222 property.setName(COMPONENT_PROPERTY_NAME);
223 property.setType(COMPONENT_PROPERTY_TYPE);
224 component.setProperties(Collections.singletonList(property));
225 component.setName(RESOURCE_NAME);
226 component.setToscaResourceName(RESOURCE_NAME);
228 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
229 .thenReturn(Either.left(Collections.emptyMap()));
230 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
231 // when convertRequirements is called, make it return the same value as 3rd (index=2) argument.
233 .when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
234 Mockito.any(ToscaNodeType.class))).thenAnswer(i -> Either.left(i.getArgument(2)));
236 Either<ToscaTemplate, ToscaError> result = (Either<ToscaTemplate, ToscaError>) Deencapsulation
237 .invoke(testSubject, "convertInterfaceNodeType", new HashMap<String, Component>(), component,
238 new ToscaTemplate(TOSCA_VERSION), new HashMap<String, ToscaNodeType>(), false);
239 assertThat(result.isLeft(), is(true));
240 Map<String, ToscaNodeType> nodeTypeMap = result.left().value().getNode_types();
241 assertThat(nodeTypeMap.size(), is(1));
242 ToscaNodeType toscaNodeType = nodeTypeMap.values().iterator().next();
243 Map<String, ToscaProperty> propertyMap = toscaNodeType.getProperties();
244 // Check if inputs and properties in component are merged properly
245 assertThat(propertyMap.size(), is(2));
246 assertThat(propertyMap.containsKey(COMPONENT_INPUT_NAME), is(true));
247 assertThat(propertyMap.containsKey(COMPONENT_PROPERTY_NAME), is(true));
251 public void testCreateToscaRepresentation() throws Exception {
252 ToscaTemplate toscaTemplate = new ToscaTemplate("");
253 ToscaRepresentation result;
256 result = testSubject.createToscaRepresentation(toscaTemplate);
260 public void testGetDependencies() throws Exception {
262 Component component = new Resource();
263 Either<ToscaTemplate, ToscaError> result;
266 result = testSubject.getDependencies(component);
270 public void testConvertToscaTemplate() throws Exception {
272 Component component = getNewResource();
273 ToscaTemplate toscaNode = new ToscaTemplate("");
274 Either<ToscaTemplate, ToscaError> result;
275 List<ComponentInstance> resourceInstances = new ArrayList<>();
276 ComponentInstance instance = new ComponentInstance();
278 instance.setOriginType(OriginTypeEnum.SERVICE);
279 instance.setSourceModelUid("targetModelUid");
280 resourceInstances.add(instance);
282 component.setComponentInstances(resourceInstances);
284 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
285 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
286 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
289 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
292 @Ignore("need to solve problem with groupExportParser injection")
294 public void testConvertToscaTemplateWhenComponentContainsGroup() {
295 Component component = getNewResource();
296 ToscaTemplate toscaNode = new ToscaTemplate("");
297 Either<ToscaTemplate, ToscaError> result;
298 component.setComponentInstances(new ArrayList<>());
300 List<GroupDefinition> groups = new ArrayList<>();
301 GroupDefinition group = new GroupDefinition();
302 List<String> artifacts = new ArrayList<>();
303 artifacts.add("artifact");
304 group.setType("org.openecomp.groups.VfModule");
305 group.setArtifacts(artifacts);
307 component.setGroups(groups);
309 Map<String, String[]> substitutionMappingMap = new HashMap<>();
310 String[] array = { "value1", "value2" };
311 substitutionMappingMap.put("key", array);
313 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
314 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
316 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
317 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
318 .thenReturn(Either.left(new SubstitutionMapping()));
320 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
322 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
323 .thenReturn(new HashMap<>());
325 Mockito.when(groupExportParser.getGroups(component))
328 // test component contains group
329 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
332 @Ignore("need to solve problem with groupExportParser injection")
334 public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
335 Component component = getNewService();
336 ToscaTemplate toscaNode = new ToscaTemplate("");
337 Either<ToscaTemplate, ToscaError> result;
338 component.setComponentInstances(new ArrayList<>());
340 List<GroupDefinition> groups = new ArrayList<>();
341 GroupDefinition group = new GroupDefinition();
342 List<String> artifacts = new ArrayList<>();
343 artifacts.add("artifact");
344 group.setType("org.openecomp.groups.VfModule");
345 group.setArtifacts(artifacts);
347 component.setGroups(groups);
349 Map<String, String[]> substitutionMappingMap = new HashMap<>();
350 String[] array = { "value1", "value2" };
351 substitutionMappingMap.put("key", array);
353 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
354 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
356 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
357 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
358 .thenReturn(Either.left(new SubstitutionMapping()));
360 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
362 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
363 .thenReturn(new HashMap<>());
364 // test component contains group
365 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
369 public void testConvertMetadata_1() throws Exception {
371 Component component = getNewResource();
372 boolean isInstance = true;
373 ComponentInstance componentInstance = new ComponentInstance();
374 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
375 componentInstance.setSourceModelInvariant("targetModelInvariant");
377 ToscaMetadata result;
381 result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
385 public void testFillImports() throws Exception {
387 Component component = getNewService();
388 ToscaTemplate toscaTemplate = new ToscaTemplate("");
389 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
391 ComponentInstance instance = new ComponentInstance();
392 List<ComponentInstance> resourceInstances = new ArrayList<>();
393 instance.setComponentUid("name");
394 resourceInstances.add(instance);
395 component.setComponentInstances(resourceInstances);
396 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
397 ArtifactDefinition artifact = new ArtifactDefinition();
398 artifact.setArtifactName("name.name2");
399 toscaArtifacts.put("assettoscatemplate", artifact);
400 component.setToscaArtifacts(toscaArtifacts);
402 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.any(String.class)))
403 .thenReturn(Either.left(component));
406 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
410 public void testCreateDependency() throws Exception {
412 Map<String, Component> componentCache = new HashMap<>();
413 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
414 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
415 ComponentInstance ci = new ComponentInstance();
416 Component component = getNewResource();
418 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
419 ArtifactDefinition artifact = new ArtifactDefinition();
420 artifact.setArtifactName("name.name2");
421 toscaArtifacts.put("assettoscatemplate", artifact);
422 component.setToscaArtifacts(toscaArtifacts);
423 ci.setComponentUid("name");
424 ci.setOriginType(OriginTypeEnum.ServiceProxy);
425 ci.setSourceModelUid("modelName");
427 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("name"))).thenReturn(Either.left(component));
429 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("modelName")))
430 .thenReturn(Either.left(new Service()));
433 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
437 public void testGetInterfaceFilename() throws Exception {
438 String artifactName = "artifact.name";
442 result = ToscaExportHandler.getInterfaceFilename(artifactName);
446 public void testConvertNodeType() throws Exception {
447 Component component = new Resource();
448 ToscaTemplate toscaNode = new ToscaTemplate("");
449 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
450 Either<ToscaTemplate, ToscaError> result;
452 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.ALREADY_EXIST));
453 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
454 .thenReturn(Either.left(Collections.emptyMap()));
456 result = Deencapsulation.invoke(testSubject, "convertNodeType",new HashMap<>(), component, toscaNode, nodeTypes);
460 public void testConvertInterfaceNodeType() throws Exception {
461 Component component = getNewResource();
462 ToscaTemplate toscaNode = new ToscaTemplate("");
463 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
464 Either<ToscaTemplate, ToscaError> result;
465 List<InputDefinition> inputs = new ArrayList<>();
466 inputs.add(new InputDefinition());
467 component.setInputs(inputs);
469 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
470 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
472 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
473 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
476 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType",new HashMap<>(), component, toscaNode
479 @Ignore("need to fix change in injected class.")
481 public void testConvertReqCapAndTypeName() throws Exception {
482 Component component = new Resource();
483 ToscaTemplate toscaNode = new ToscaTemplate("");
484 Map<String, ToscaNodeType> nodeTypes = new HashMap();
485 ToscaNodeType toscaNodeType = new ToscaNodeType();
486 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
487 Either<ToscaTemplate, ToscaError> result;
490 capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class),Mockito.any(Resource.class), Mockito.any(Map.class)))
491 .thenReturn(new HashMap<>());
493 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
494 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
497 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName",new HashMap<>(), component, toscaNode, nodeTypes,
498 toscaNodeType, dataTypes);
500 component = new Service();
502 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
503 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
505 // test when component is service
506 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
507 toscaNodeType, dataTypes);
512 public void testConvertNodeTemplates() throws Exception {
513 Component component = getNewResource();
514 List<ComponentInstance> componentInstances = new ArrayList<>();
515 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
516 Map<String, Component> componentCache = new HashMap<>();
517 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
518 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
519 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
520 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
521 List<ComponentInstanceInput> inputs = new ArrayList<>();
522 inputs.add(new ComponentInstanceInput());
523 componentInstancesInputs.put("key", inputs);
524 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
525 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
526 reldef.setFromNode("node");
527 resourceInstancesRelations.add(reldef);
528 component.setComponentInstancesRelations(resourceInstancesRelations);
530 ComponentInstance instance = new ComponentInstance();
531 instance.setUniqueId("id");
532 instance.setComponentUid("uid");
533 instance.setOriginType(OriginTypeEnum.ServiceProxy);
534 List<GroupInstance> groupInstances = new ArrayList<>();
535 GroupInstance groupInst = new GroupInstance();
536 List<String> artifacts = new ArrayList<>();
537 artifacts.add("artifact");
538 groupInst.setArtifacts(artifacts);
539 groupInst.setType("type");
540 groupInstances.add(groupInst);
541 instance.setGroupInstances(groupInstances);
542 componentInstances.add(instance);
544 component.setComponentInstancesInputs(componentInstancesInputs);
545 component.setInvariantUUID("uuid");
546 component.setUUID("uuid");
547 component.setDescription("desc");
549 componentCache.put("uid", component);
551 componentInstancesProperties.put("id", new ArrayList<>());
552 componentInstancesInputs.put("id", new ArrayList<>());
554 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
555 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
557 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
558 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
559 .thenReturn(Either.left(new ToscaNodeTemplate()));
562 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
563 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
567 public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
568 Component component = getNewService();
569 List<ComponentInstance> componentInstances = new ArrayList<>();
570 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
571 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
572 Map<String, Component> componentCache = new HashMap<>();
573 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
574 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
575 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
576 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
577 List<ComponentInstanceInput> inputs = new ArrayList<>();
578 inputs.add(new ComponentInstanceInput());
579 componentInstancesInputs.put("key", inputs);
580 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
581 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
582 reldef.setFromNode("node");
583 resourceInstancesRelations.add(reldef);
584 component.setComponentInstancesRelations(resourceInstancesRelations);
586 ComponentInstance instance = new ComponentInstance();
587 instance.setUniqueId("id");
588 instance.setComponentUid("uid");
589 instance.setOriginType(OriginTypeEnum.ServiceProxy);
590 List<GroupInstance> groupInstances = new ArrayList<>();
591 GroupInstance groupInst = new GroupInstance();
592 List<String> artifacts = new ArrayList<>();
593 artifacts.add("artifact");
594 groupInst.setArtifacts(artifacts);
595 groupInst.setType("type");
596 groupInstances.add(groupInst);
597 instance.setGroupInstances(groupInstances);
598 componentInstances.add(instance);
600 component.setComponentInstancesInputs(componentInstancesInputs);
601 component.setInvariantUUID("uuid");
602 component.setUUID("uuid");
603 component.setDescription("desc");
605 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
606 ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
607 ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
608 path.setPathElements(list);
609 forwardingPaths.put("key", path);
611 ((Service) component).setForwardingPaths(forwardingPaths);
613 componentCache.put("uid", component);
615 componentInstancesProperties.put("id", new ArrayList<>());
616 componentInstancesInterfaces.put("id", new ArrayList<>());
617 componentInstancesInputs.put("id", new ArrayList<>());
619 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
620 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
622 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
623 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
624 .thenReturn(Either.left(new ToscaNodeTemplate()));
627 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
628 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
632 public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
633 Component component = getNewResource();
634 List<ComponentInstance> componentInstances = new ArrayList<>();
635 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
636 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
637 Map<String, Component> componentCache = new HashMap<>();
638 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
639 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
640 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
641 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
642 List<ComponentInstanceInput> inputs = new ArrayList<>();
643 inputs.add(new ComponentInstanceInput());
644 componentInstancesInputs.put("key", inputs);
645 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
646 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
647 reldef.setFromNode("node");
648 resourceInstancesRelations.add(reldef);
649 component.setComponentInstancesRelations(resourceInstancesRelations);
651 ComponentInstance instance = new ComponentInstance();
652 instance.setUniqueId("id");
653 instance.setComponentUid("uid");
654 instance.setOriginType(OriginTypeEnum.ServiceProxy);
655 componentInstances.add(instance);
657 component.setComponentInstancesInputs(componentInstancesInputs);
658 component.setInvariantUUID("uuid");
659 component.setUUID("uuid");
660 component.setDescription("desc");
662 componentCache.put("uid", component);
664 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
665 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
667 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
668 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
669 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
672 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
673 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
677 public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
678 Component component = getNewResource();
679 List<ComponentInstance> componentInstances = new ArrayList<>();
680 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
681 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
682 Map<String, Component> componentCache = new HashMap<>();
683 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
684 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
685 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
686 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
687 List<ComponentInstanceInput> inputs = new ArrayList<>();
688 inputs.add(new ComponentInstanceInput());
689 componentInstancesInputs.put("key", inputs);
690 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
691 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
692 reldef.setFromNode("id");
693 resourceInstancesRelations.add(reldef);
694 component.setComponentInstancesRelations(resourceInstancesRelations);
696 ComponentInstance instance = new ComponentInstance();
697 instance.setUniqueId("id");
698 instance.setComponentUid("uid");
699 instance.setOriginType(OriginTypeEnum.ServiceProxy);
700 componentInstances.add(instance);
702 component.setComponentInstancesInputs(componentInstancesInputs);
703 component.setInvariantUUID("uuid");
704 component.setUUID("uuid");
705 component.setDescription("desc");
707 componentCache.put("uid", component);
709 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
710 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
713 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
714 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
718 public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
719 Component component = new Resource();
720 List<ComponentInstance> componentInstances = new ArrayList<>();
721 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
722 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
723 Map<String, Component> componentCache = new HashMap<>();
724 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
725 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
726 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
727 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
728 List<ComponentInstanceInput> inputs = new ArrayList<>();
729 inputs.add(new ComponentInstanceInput());
730 componentInstancesInputs.put("key", inputs);
731 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
732 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
733 reldef.setFromNode("id");
734 reldef.setToNode("node");
735 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
736 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
737 relationship.setRelation(new RelationshipInfo());
738 relationships.add(relationship);
739 reldef.setRelationships(relationships);
740 resourceInstancesRelations.add(reldef);
741 component.setComponentInstancesRelations(resourceInstancesRelations);
743 ComponentInstance instance = new ComponentInstance();
744 instance.setUniqueId("id");
745 componentInstances.add(instance);
747 component.setComponentInstancesInputs(componentInstancesInputs);
748 component.setComponentInstances(componentInstances);
750 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
751 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
754 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
755 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
759 public void testAddComponentInstanceInputs() throws Exception {
761 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
762 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
763 ComponentInstance componentInstance = new ComponentInstance();
764 String instanceUniqueId = "id";
765 Map<String, Object> props = new HashMap<>();
767 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
768 componentInstanceInputs.add(new ComponentInstanceInput());
770 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
773 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
774 instanceUniqueId, props);
778 public void testAddPropertiesOfComponentInstance() throws Exception {
779 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
780 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
781 ComponentInstance componentInstance = new ComponentInstance();
782 String instanceUniqueId = "id";
783 Map<String, Object> props = new HashMap<>();
785 ComponentInstanceProperty cip = new ComponentInstanceProperty();
786 cip.setInstanceUniqueId("id");
788 List<ComponentInstanceProperty> list = new ArrayList<>();
791 componentInstancesProperties.put("id", list);
794 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
795 instanceUniqueId, props);
799 public void testAddPropertiesOfParentComponent() throws Exception {
800 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
801 ComponentInstance componentInstance = new ComponentInstance();
802 Component componentOfInstance = new Resource();
803 Map<String, Object> props = new HashMap<>();
805 List<PropertyDefinition> properties = new ArrayList<>();
806 properties.add(new PropertyDefinition());
808 ((Resource) componentOfInstance).setProperties(properties);
811 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
812 componentOfInstance, props);
817 public void testCreateNodeType() throws Exception {
819 Component component = new Resource();
820 List<String> array = new ArrayList<>();
822 ((Resource) component).setDerivedFrom(array);
823 ToscaNodeType result;
825 // test when component is resource
826 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
828 component = new Service();
829 // test when component is service
830 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
834 public void testCreateProxyNodeTypes() throws Exception {
835 Map<String, Component> componentCache = new HashMap<>();
836 Component container = new Resource();
837 Either<Map<String, ToscaNodeType>, ToscaError> result;
838 List<ComponentInstance> componentInstances = new ArrayList<>();
839 ComponentInstance instance = new ComponentInstance();
840 instance.setOriginType(OriginTypeEnum.ServiceProxy);
841 instance.setSourceModelUid("targetModelUid");
843 componentInstances.add(instance);
844 container.setComponentInstances(componentInstances);
846 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
847 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
849 // test when getLatestByName return is right
850 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
855 public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
856 Map<String, Component> componentCache = new HashMap<>();
857 Component container = new Resource();
858 Either<Map<String, ToscaNodeType>, ToscaError> result;
859 List<ComponentInstance> componentInstances = new ArrayList<>();
860 ComponentInstance instance = new ComponentInstance();
861 instance.setOriginType(OriginTypeEnum.ServiceProxy);
862 instance.setSourceModelUid("targetModelUid");
864 componentInstances.add(instance);
865 container.setComponentInstances(componentInstances);
867 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
869 ComponentParametersView parameterView = new ComponentParametersView();
870 parameterView.disableAll();
871 parameterView.setIgnoreCategories(false);
873 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
874 Mockito.any(ComponentParametersView.class)))
875 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
877 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
879 // test when getLatestByName is left
880 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
884 public void testCreateProxyNodeType() throws Exception {
885 Map<String, Component> componentCache = new HashMap<>();
886 Component origComponent = new Resource();
887 Component proxyComponent = new Resource();
888 ComponentInstance instance = new ComponentInstance();
889 ToscaNodeType result;
891 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
894 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
895 proxyComponent, instance);
899 public void testConvertComponentInstanceRequirements() throws Exception {
900 Component component = new Resource();
901 ComponentInstance componentInstance = new ComponentInstance();
902 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
903 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
904 Component originComponent = new Resource();
905 Map<String, Component> componentCache = new HashMap<>();
906 Either<ToscaNodeTemplate, ToscaError> result;
909 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
910 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
912 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
913 reldef.setFromNode("name");
914 reldef.setToNode("name1");
915 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
916 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
917 cap.setRelation(new RelationshipInfo());
918 relationships.add(cap);
919 reldef.setRelationships(relationships);
920 relations.add(reldef);
921 componentInstance.setUniqueId("name");
923 List<ComponentInstance> instances = new ArrayList<>();
924 instances.add(componentInstance);
925 component.setComponentInstances(instances);
927 // test when filteredRElations ins't empty
928 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
929 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
933 public void testAddRequirement() throws Exception {
934 ComponentInstance fromInstance = new ComponentInstance();
935 Component fromOriginComponent = new Resource();
936 List<ComponentInstance> instancesList = new ArrayList<>();
937 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
938 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
939 Map<String, Component> componentCache = new HashMap<>();
942 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
943 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
944 cap.setRequirement(new RequirementDataDefinition());
945 RelationshipInfo relation = new RelationshipInfo();
946 relation.setRequirementUid("Uid");
947 relation.setRequirement("requirment");
948 relation.setCapability("cap");
949 relation.setCapabilityOwnerId("id1");
950 cap.setRelation(relation);
951 relationships.add(cap);
952 rel.setRelationships(relationships);
953 rel.setToNode("name");
954 fromInstance.setUniqueId("name");
955 fromInstance.setComponentUid("string");
956 instancesList.add(fromInstance);
957 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
958 fromOriginComponent.setRequirements(requirements);
961 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
962 rel, toscaRequirements, componentCache);
967 public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
969 ComponentInstance fromInstance = new ComponentInstance();
970 Component fromOriginComponent = new Resource();
971 List<ComponentInstance> instancesList = new ArrayList<>();
972 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
973 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
974 Map<String, Component> componentCache = new HashMap<>();
977 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
978 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
979 cap.setRequirement(new RequirementDataDefinition());
980 RelationshipInfo relation = new RelationshipInfo();
981 relation.setRequirementUid("Uid");
982 relation.setRequirement("requirment");
983 relation.setCapability("cap");
984 relation.setCapabilityOwnerId("id1");
985 cap.setRelation(relation);
986 relationships.add(cap);
987 rel.setRelationships(relationships);
988 rel.setToNode("name");
989 fromInstance.setUniqueId("name");
990 fromInstance.setComponentUid("string");
991 instancesList.add(fromInstance);
992 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
994 List<RequirementDefinition> defs = new ArrayList<>();
995 RequirementDefinition def = new RequirementDefinition();
996 def.setName("requirment");
997 def.setCapability("cap");
999 requirements.put("key", defs);
1000 fromOriginComponent.setRequirements(requirements);
1002 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1003 Mockito.any(ComponentParametersView.class)))
1004 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
1007 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1008 rel, toscaRequirements, componentCache);
1012 public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
1013 ComponentInstance fromInstance = new ComponentInstance();
1014 Component fromOriginComponent = new Resource();
1015 List<ComponentInstance> instancesList = new ArrayList<>();
1016 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1017 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1018 Map<String, Component> componentCache = new HashMap<>();
1021 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1022 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1023 cap.setRequirement(new RequirementDataDefinition());
1024 RelationshipInfo relation = new RelationshipInfo();
1025 relation.setRequirementUid("Uid");
1026 relation.setRequirement("requirment");
1027 relation.setCapability("cap");
1028 relation.setCapabilityOwnerId("id1");
1029 cap.setRelation(relation);
1030 relationships.add(cap);
1031 rel.setRelationships(relationships);
1032 rel.setToNode("name");
1033 fromInstance.setUniqueId("name");
1034 fromInstance.setComponentUid("string");
1035 instancesList.add(fromInstance);
1036 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1038 List<RequirementDefinition> defs = new ArrayList<>();
1039 RequirementDefinition def = new RequirementDefinition();
1040 def.setName("requirment");
1041 def.setCapability("cap");
1043 requirements.put("key", defs);
1044 fromOriginComponent.setRequirements(requirements);
1046 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1047 List<CapabilityDefinition> caps = new ArrayList<>();
1048 CapabilityDefinition capdef = new CapabilityDefinition();
1049 capdef.setOwnerId("id");
1050 capdef.setName("name");
1051 capdef.setType("type");
1053 capabilities.put("cap", caps);
1055 fromOriginComponent.setCapabilities(capabilities);
1057 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1058 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1061 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1062 rel, toscaRequirements, componentCache);
1064 @Ignore("need to fix change in injected class.")
1066 public void testAddRequirmentsWithBuildAndAddRequirements() {
1067 ComponentInstance fromInstance = new ComponentInstance();
1068 Component fromOriginComponent = new Resource();
1069 List<ComponentInstance> instancesList = new ArrayList<>();
1070 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1071 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1072 Map<String, Component> componentCache = new HashMap<>();
1075 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1076 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1077 cap.setRequirement(new RequirementDataDefinition());
1078 RelationshipInfo relation = new RelationshipInfo();
1079 relation.setRequirementUid("Uid");
1080 relation.setRequirement("requirment");
1081 relation.setCapability("cap");
1082 relation.setCapabilityOwnerId("id");
1083 cap.setRelation(relation);
1084 relationships.add(cap);
1085 rel.setRelationships(relationships);
1086 rel.setToNode("name");
1087 fromInstance.setUniqueId("name");
1088 fromInstance.setComponentUid("string");
1089 instancesList.add(fromInstance);
1090 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1092 List<RequirementDefinition> defs = new ArrayList<>();
1093 RequirementDefinition def = new RequirementDefinition();
1094 def.setName("requirment");
1095 def.setCapability("cap");
1097 requirements.put("key", defs);
1098 fromOriginComponent.setRequirements(requirements);
1100 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1101 List<CapabilityDefinition> caps = new ArrayList<>();
1102 CapabilityDefinition capdef = new CapabilityDefinition();
1103 capdef.setOwnerId("id");
1104 capdef.setName("cap");
1105 capdef.setType("type");
1107 capabilities.put("cap", caps);
1108 fromOriginComponent.setCapabilities(capabilities);
1110 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1111 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1113 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
1114 Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString(),Mockito.anyString()))
1115 .thenReturn(Either.right(false));
1118 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1119 rel, toscaRequirements, componentCache);
1121 @Ignore("need to fix change in injected class.")
1123 public void testBuildAndAddRequirement() throws Exception {
1124 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1125 Component fromOriginComponent = new Resource();
1126 Component toOriginComponent = new Resource();
1127 CapabilityDefinition capability = new CapabilityDefinition();
1128 RequirementDefinition requirement = new RequirementDefinition();
1129 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1130 ComponentInstance toInstance = new ComponentInstance();
1131 Map<String, Component> componentCache = new HashMap<>();
1133 capability.setPath(new ArrayList<>());
1134 reqAndRelationshipPair.setCapability("cap");
1135 requirement.setPath(new ArrayList<>());
1136 reqAndRelationshipPair.setRequirement("req");
1138 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
1139 new ArrayList<>(),Mockito.anyString(), "cap")).thenReturn(Either.left("buildCapNameRes"));
1141 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
1142 new ArrayList<>(),Mockito.anyString(), "req")).thenReturn(Either.right(false));
1145 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1146 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1149 @Ignore("need to fix change in injected class.")
1151 public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
1152 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1153 Component fromOriginComponent = new Resource();
1154 Component toOriginComponent = new Resource();
1155 CapabilityDefinition capability = new CapabilityDefinition();
1156 RequirementDefinition requirement = new RequirementDefinition();
1157 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1158 ComponentInstance toInstance = new ComponentInstance();
1159 Map<String, Component> componentCache = new HashMap<>();
1161 capability.setPath(new ArrayList<>());
1162 reqAndRelationshipPair.setCapability("cap");
1163 requirement.setPath(new ArrayList<>());
1164 reqAndRelationshipPair.setRequirement("req");
1166 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
1167 Mockito.anyList(), Mockito.anyString(),Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
1170 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1171 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1175 public void testIsRequirementBelongToRelation() throws Exception {
1177 Component originComponent = new Resource();
1178 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1179 RequirementDefinition requirement = new RequirementDefinition();
1180 String fromInstanceId = "";
1183 requirement.setName("name");
1184 reqAndRelationshipPair.setRequirement("name1");
1186 // test return false
1187 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1188 reqAndRelationshipPair, requirement, fromInstanceId);
1192 public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1194 Component originComponent = new Service();
1195 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1196 RequirementDefinition requirement = new RequirementDefinition();
1197 String fromInstanceId = "";
1200 // default test return true
1201 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1202 reqAndRelationshipPair, requirement, fromInstanceId);
1206 public void testIsRequirementBelongToOwner() throws Exception {
1208 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1209 RequirementDefinition requirement = new RequirementDefinition();
1210 String fromInstanceId = "";
1211 Component originComponent = new Resource();
1214 requirement.setOwnerId("owner1");
1215 reqAndRelationshipPair.setRequirementOwnerId("owner");
1218 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1219 fromInstanceId, originComponent);
1223 public void testIsCvfc() throws Exception {
1225 Component component = new Resource();
1228 component = new Service();
1230 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1234 public void testConvertCapabilities() throws Exception {
1235 Component component = new Resource();
1236 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1237 Map<String, Component> componentCache = new HashMap<>();
1238 Either<SubstitutionMapping, ToscaError> result;
1240 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
1241 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1243 // default test return isRight
1244 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1247 @Ignore("need to fix change in injected class.")
1249 public void testConvertCapabilities_1() throws Exception {
1250 Component component = new Resource();
1251 ToscaNodeType nodeType = new ToscaNodeType();
1252 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1253 Either<ToscaNodeType, ToscaError> result;
1255 Map<String, ToscaCapability> capabilities = new HashMap<>();
1256 capabilities.put("key", new ToscaCapability());
1258 Mockito.when(capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class), component, dataTypes)).thenReturn(capabilities);
1261 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);