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.ComponentParametersView;
39 import org.openecomp.sdc.be.model.DataTypeDefinition;
40 import org.openecomp.sdc.be.model.GroupDefinition;
41 import org.openecomp.sdc.be.model.GroupInstance;
42 import org.openecomp.sdc.be.model.InputDefinition;
43 import org.openecomp.sdc.be.model.PropertyDefinition;
44 import org.openecomp.sdc.be.model.RelationshipInfo;
45 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
46 import org.openecomp.sdc.be.model.RequirementDefinition;
47 import org.openecomp.sdc.be.model.Resource;
48 import org.openecomp.sdc.be.model.Service;
49 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
50 import org.openecomp.sdc.be.model.category.CategoryDefinition;
51 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
52 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
53 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
54 import org.openecomp.sdc.be.model.operations.impl.InterfaceLifecycleOperation;
55 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
56 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
57 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
58 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
59 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
60 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
61 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
62 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
63 import org.openecomp.sdc.be.tosca.utils.InputConverter;
65 public class ToscaExportHandlerTest extends BeConfDependentTest {
68 ToscaExportHandler testSubject;
71 ApplicationDataTypeCache dataTypeCache;
74 ToscaOperationFacade toscaOperationFacade;
77 CapabilityRequirementConverter capabiltyRequirementConvertor;
80 InputConverter inputConverter;
83 GroupExportParser groupExportParser;
86 GroupExportParserImpl groupExportParserImpl;
89 InterfaceLifecycleOperation interfaceLifecycleOperation;
92 public void setUpMock() throws Exception {
93 MockitoAnnotations.initMocks(this);
96 private Resource getNewResource() {
97 Resource resource = new Resource();
98 List<CategoryDefinition> categories = new ArrayList<>();
99 CategoryDefinition category = new CategoryDefinition();
100 List<SubCategoryDefinition> subcategories = new ArrayList<>();
101 SubCategoryDefinition subcategory = new SubCategoryDefinition();
102 List<DataTypeDefinition> dataTypes = new ArrayList<>();
103 DataTypeDefinition dataType = new DataTypeDefinition();
104 dataType.setName("dataTypeName");
105 dataType.setDerivedFromName("tosca.datatypes.Root");
106 PropertyDataDefinition propData = new PropertyDataDefinitionBuilder()
110 List<PropertyDataDefinition> propDataList = Arrays.asList(propData);
111 dataType.setPropertiesData(propDataList);
112 List<PropertyDefinition> propList = propDataList.stream().map(PropertyDefinition::new)
113 .collect(Collectors.toList());
114 dataType.setProperties(propList);
115 dataTypes.add(dataType);
117 subcategory.setName("name");
118 subcategories.add(subcategory);
119 category.setName("name");
120 category.setSubcategories(subcategories);
121 categories.add(category);
123 resource.setCategories(categories);
124 resource.setVersion("version");
125 resource.setVendorName("vendorName");
126 resource.setVendorRelease("vendorRelease");
127 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
128 resource.setDataTypes(dataTypes);
133 private Service getNewService() {
134 Service service = new Service();
135 List<CategoryDefinition> categories = new ArrayList<>();
136 CategoryDefinition category = new CategoryDefinition();
137 List<SubCategoryDefinition> subcategories = new ArrayList<>();
138 SubCategoryDefinition subcategory = new SubCategoryDefinition();
140 subcategory.setName("name");
141 subcategories.add(subcategory);
142 category.setName("name");
143 category.setSubcategories(subcategories);
144 categories.add(category);
146 service.setCategories(categories);
147 service.setComponentType(ComponentTypeEnum.SERVICE);
148 service.setServiceType("serviceType");
149 service.setServiceRole("serviceRole");
150 service.setEnvironmentContext("environmentContext");
156 public void testExportComponent() throws Exception {
157 Component component = getNewResource();
158 Either<ToscaRepresentation, ToscaError> result;
160 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
161 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
162 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
163 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
164 .thenReturn(Either.left(Collections.emptyMap()));
166 // default test when component is Resource
167 result = testSubject.exportComponent(component);
169 component = getNewService();
170 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
171 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
172 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
174 // default test when component is Service
175 result = testSubject.exportComponent(component);
179 public void testExportComponentInterface() throws Exception {
180 Component component = getNewResource();
181 Either<ToscaRepresentation, ToscaError> result;
183 ((Resource) component).setInterfaces(new HashMap<>());
185 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
186 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
187 // default test when convertInterfaceNodeType is right
188 result = testSubject.exportComponentInterface(component, false);
190 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
191 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
192 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
194 // default test when convertInterfaceNodeType is left
195 result = testSubject.exportComponentInterface(component, false);
200 public void testCreateToscaRepresentation() throws Exception {
201 ToscaTemplate toscaTemplate = new ToscaTemplate("");
202 ToscaRepresentation result;
205 result = testSubject.createToscaRepresentation(toscaTemplate);
209 public void testGetDependencies() throws Exception {
211 Component component = new Resource();
212 Either<ToscaTemplate, ToscaError> result;
215 result = testSubject.getDependencies(component);
219 public void testConvertToscaTemplate() throws Exception {
221 Component component = getNewResource();
222 ToscaTemplate toscaNode = new ToscaTemplate("");
223 Either<ToscaTemplate, ToscaError> result;
224 List<ComponentInstance> resourceInstances = new ArrayList<>();
225 ComponentInstance instance = new ComponentInstance();
227 instance.setOriginType(OriginTypeEnum.SERVICE);
228 instance.setSourceModelUid("targetModelUid");
229 resourceInstances.add(instance);
231 component.setComponentInstances(resourceInstances);
233 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
234 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
235 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
238 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
241 @Ignore("need to solve problem with groupExportParser injection")
243 public void testConvertToscaTemplateWhenComponentContainsGroup() {
244 Component component = getNewResource();
245 ToscaTemplate toscaNode = new ToscaTemplate("");
246 Either<ToscaTemplate, ToscaError> result;
247 component.setComponentInstances(new ArrayList<>());
249 List<GroupDefinition> groups = new ArrayList<>();
250 GroupDefinition group = new GroupDefinition();
251 List<String> artifacts = new ArrayList<>();
252 artifacts.add("artifact");
253 group.setType("org.openecomp.groups.VfModule");
254 group.setArtifacts(artifacts);
256 component.setGroups(groups);
258 Map<String, String[]> substitutionMappingMap = new HashMap<>();
259 String[] array = { "value1", "value2" };
260 substitutionMappingMap.put("key", array);
262 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
263 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
265 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
266 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
267 .thenReturn(Either.left(new SubstitutionMapping()));
269 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
271 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
272 .thenReturn(new HashMap<>());
274 Mockito.when(groupExportParser.getGroups(component))
277 // test component contains group
278 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
281 @Ignore("need to solve problem with groupExportParser injection")
283 public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
284 Component component = getNewService();
285 ToscaTemplate toscaNode = new ToscaTemplate("");
286 Either<ToscaTemplate, ToscaError> result;
287 component.setComponentInstances(new ArrayList<>());
289 List<GroupDefinition> groups = new ArrayList<>();
290 GroupDefinition group = new GroupDefinition();
291 List<String> artifacts = new ArrayList<>();
292 artifacts.add("artifact");
293 group.setType("org.openecomp.groups.VfModule");
294 group.setArtifacts(artifacts);
296 component.setGroups(groups);
298 Map<String, String[]> substitutionMappingMap = new HashMap<>();
299 String[] array = { "value1", "value2" };
300 substitutionMappingMap.put("key", array);
302 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
303 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
305 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
306 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
307 .thenReturn(Either.left(new SubstitutionMapping()));
309 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
311 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
312 .thenReturn(new HashMap<>());
313 // test component contains group
314 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
318 public void testConvertMetadata_1() throws Exception {
320 Component component = getNewResource();
321 boolean isInstance = true;
322 ComponentInstance componentInstance = new ComponentInstance();
323 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
324 componentInstance.setSourceModelInvariant("targetModelInvariant");
326 ToscaMetadata result;
330 result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
334 public void testFillImports() throws Exception {
336 Component component = getNewService();
337 ToscaTemplate toscaTemplate = new ToscaTemplate("");
338 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
340 ComponentInstance instance = new ComponentInstance();
341 List<ComponentInstance> resourceInstances = new ArrayList<>();
342 instance.setComponentUid("name");
343 resourceInstances.add(instance);
344 component.setComponentInstances(resourceInstances);
345 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
346 ArtifactDefinition artifact = new ArtifactDefinition();
347 artifact.setArtifactName("name.name2");
348 toscaArtifacts.put("assettoscatemplate", artifact);
349 component.setToscaArtifacts(toscaArtifacts);
351 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.any(String.class)))
352 .thenReturn(Either.left(component));
355 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
359 public void testCreateDependency() throws Exception {
361 Map<String, Component> componentCache = new HashMap<>();
362 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
363 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
364 ComponentInstance ci = new ComponentInstance();
365 Component component = getNewResource();
367 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
368 ArtifactDefinition artifact = new ArtifactDefinition();
369 artifact.setArtifactName("name.name2");
370 toscaArtifacts.put("assettoscatemplate", artifact);
371 component.setToscaArtifacts(toscaArtifacts);
372 ci.setComponentUid("name");
373 ci.setOriginType(OriginTypeEnum.ServiceProxy);
374 ci.setSourceModelUid("modelName");
376 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("name"))).thenReturn(Either.left(component));
378 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("modelName")))
379 .thenReturn(Either.left(new Service()));
382 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
386 public void testGetInterfaceFilename() throws Exception {
387 String artifactName = "artifact.name";
391 result = ToscaExportHandler.getInterfaceFilename(artifactName);
395 public void testConvertNodeType() throws Exception {
396 Component component = new Resource();
397 ToscaTemplate toscaNode = new ToscaTemplate("");
398 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
399 Either<ToscaTemplate, ToscaError> result;
401 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.ALREADY_EXIST));
402 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes())
403 .thenReturn(Either.left(Collections.emptyMap()));
405 result = Deencapsulation.invoke(testSubject, "convertNodeType",new HashMap<>(), component, toscaNode, nodeTypes);
409 public void testConvertInterfaceNodeType() throws Exception {
410 Component component = getNewResource();
411 ToscaTemplate toscaNode = new ToscaTemplate("");
412 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
413 Either<ToscaTemplate, ToscaError> result;
414 List<InputDefinition> inputs = new ArrayList<>();
415 inputs.add(new InputDefinition());
416 component.setInputs(inputs);
418 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
419 Mockito.when(interfaceLifecycleOperation.getAllInterfaceLifecycleTypes()).thenReturn(Either.left(Collections.emptyMap()));
421 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
422 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
425 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType",new HashMap<>(), component, toscaNode
428 @Ignore("need to fix change in injected class.")
430 public void testConvertReqCapAndTypeName() throws Exception {
431 Component component = new Resource();
432 ToscaTemplate toscaNode = new ToscaTemplate("");
433 Map<String, ToscaNodeType> nodeTypes = new HashMap();
434 ToscaNodeType toscaNodeType = new ToscaNodeType();
435 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
436 Either<ToscaTemplate, ToscaError> result;
439 capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class),Mockito.any(Resource.class), Mockito.any(Map.class)))
440 .thenReturn(new HashMap<>());
442 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
443 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
446 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName",new HashMap<>(), component, toscaNode, nodeTypes,
447 toscaNodeType, dataTypes);
449 component = new Service();
451 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
452 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
454 // test when component is service
455 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
456 toscaNodeType, dataTypes);
461 public void testConvertNodeTemplates() throws Exception {
462 Component component = getNewResource();
463 List<ComponentInstance> componentInstances = new ArrayList<>();
464 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
465 Map<String, Component> componentCache = new HashMap<>();
466 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
467 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
468 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
469 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
470 List<ComponentInstanceInput> inputs = new ArrayList<>();
471 inputs.add(new ComponentInstanceInput());
472 componentInstancesInputs.put("key", inputs);
473 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
474 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
475 reldef.setFromNode("node");
476 resourceInstancesRelations.add(reldef);
477 component.setComponentInstancesRelations(resourceInstancesRelations);
479 ComponentInstance instance = new ComponentInstance();
480 instance.setUniqueId("id");
481 instance.setComponentUid("uid");
482 instance.setOriginType(OriginTypeEnum.ServiceProxy);
483 List<GroupInstance> groupInstances = new ArrayList<>();
484 GroupInstance groupInst = new GroupInstance();
485 List<String> artifacts = new ArrayList<>();
486 artifacts.add("artifact");
487 groupInst.setArtifacts(artifacts);
488 groupInst.setType("type");
489 groupInstances.add(groupInst);
490 instance.setGroupInstances(groupInstances);
491 componentInstances.add(instance);
493 component.setComponentInstancesInputs(componentInstancesInputs);
494 component.setInvariantUUID("uuid");
495 component.setUUID("uuid");
496 component.setDescription("desc");
498 componentCache.put("uid", component);
500 componentInstancesProperties.put("id", new ArrayList<>());
501 componentInstancesInputs.put("id", new ArrayList<>());
503 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
504 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
506 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
507 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
508 .thenReturn(Either.left(new ToscaNodeTemplate()));
511 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
512 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
516 public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
517 Component component = getNewService();
518 List<ComponentInstance> componentInstances = new ArrayList<>();
519 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
520 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
521 Map<String, Component> componentCache = new HashMap<>();
522 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
523 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
524 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
525 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
526 List<ComponentInstanceInput> inputs = new ArrayList<>();
527 inputs.add(new ComponentInstanceInput());
528 componentInstancesInputs.put("key", inputs);
529 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
530 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
531 reldef.setFromNode("node");
532 resourceInstancesRelations.add(reldef);
533 component.setComponentInstancesRelations(resourceInstancesRelations);
535 ComponentInstance instance = new ComponentInstance();
536 instance.setUniqueId("id");
537 instance.setComponentUid("uid");
538 instance.setOriginType(OriginTypeEnum.ServiceProxy);
539 List<GroupInstance> groupInstances = new ArrayList<>();
540 GroupInstance groupInst = new GroupInstance();
541 List<String> artifacts = new ArrayList<>();
542 artifacts.add("artifact");
543 groupInst.setArtifacts(artifacts);
544 groupInst.setType("type");
545 groupInstances.add(groupInst);
546 instance.setGroupInstances(groupInstances);
547 componentInstances.add(instance);
549 component.setComponentInstancesInputs(componentInstancesInputs);
550 component.setInvariantUUID("uuid");
551 component.setUUID("uuid");
552 component.setDescription("desc");
554 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
555 ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
556 ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
557 path.setPathElements(list);
558 forwardingPaths.put("key", path);
560 ((Service) component).setForwardingPaths(forwardingPaths);
562 componentCache.put("uid", component);
564 componentInstancesProperties.put("id", new ArrayList<>());
565 componentInstancesInterfaces.put("id", new ArrayList<>());
566 componentInstancesInputs.put("id", new ArrayList<>());
568 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
569 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
571 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
572 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
573 .thenReturn(Either.left(new ToscaNodeTemplate()));
576 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
577 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
581 public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
582 Component component = getNewResource();
583 List<ComponentInstance> componentInstances = new ArrayList<>();
584 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
585 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
586 Map<String, Component> componentCache = new HashMap<>();
587 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
588 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
589 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
590 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
591 List<ComponentInstanceInput> inputs = new ArrayList<>();
592 inputs.add(new ComponentInstanceInput());
593 componentInstancesInputs.put("key", inputs);
594 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
595 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
596 reldef.setFromNode("node");
597 resourceInstancesRelations.add(reldef);
598 component.setComponentInstancesRelations(resourceInstancesRelations);
600 ComponentInstance instance = new ComponentInstance();
601 instance.setUniqueId("id");
602 instance.setComponentUid("uid");
603 instance.setOriginType(OriginTypeEnum.ServiceProxy);
604 componentInstances.add(instance);
606 component.setComponentInstancesInputs(componentInstancesInputs);
607 component.setInvariantUUID("uuid");
608 component.setUUID("uuid");
609 component.setDescription("desc");
611 componentCache.put("uid", component);
613 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
614 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
616 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
617 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
618 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
621 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
622 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
626 public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
627 Component component = getNewResource();
628 List<ComponentInstance> componentInstances = new ArrayList<>();
629 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
630 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
631 Map<String, Component> componentCache = new HashMap<>();
632 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
633 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
634 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
635 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
636 List<ComponentInstanceInput> inputs = new ArrayList<>();
637 inputs.add(new ComponentInstanceInput());
638 componentInstancesInputs.put("key", inputs);
639 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
640 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
641 reldef.setFromNode("id");
642 resourceInstancesRelations.add(reldef);
643 component.setComponentInstancesRelations(resourceInstancesRelations);
645 ComponentInstance instance = new ComponentInstance();
646 instance.setUniqueId("id");
647 instance.setComponentUid("uid");
648 instance.setOriginType(OriginTypeEnum.ServiceProxy);
649 componentInstances.add(instance);
651 component.setComponentInstancesInputs(componentInstancesInputs);
652 component.setInvariantUUID("uuid");
653 component.setUUID("uuid");
654 component.setDescription("desc");
656 componentCache.put("uid", component);
658 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
659 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
662 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
663 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
667 public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
668 Component component = new Resource();
669 List<ComponentInstance> componentInstances = new ArrayList<>();
670 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
671 Map<String, List<ComponentInstanceProperty>> componentInstancesInterfaces = new HashMap<>();
672 Map<String, Component> componentCache = new HashMap<>();
673 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
674 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
675 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
676 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
677 List<ComponentInstanceInput> inputs = new ArrayList<>();
678 inputs.add(new ComponentInstanceInput());
679 componentInstancesInputs.put("key", inputs);
680 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
681 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
682 reldef.setFromNode("id");
683 reldef.setToNode("node");
684 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
685 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
686 relationship.setRelation(new RelationshipInfo());
687 relationships.add(relationship);
688 reldef.setRelationships(relationships);
689 resourceInstancesRelations.add(reldef);
690 component.setComponentInstancesRelations(resourceInstancesRelations);
692 ComponentInstance instance = new ComponentInstance();
693 instance.setUniqueId("id");
694 componentInstances.add(instance);
696 component.setComponentInstancesInputs(componentInstancesInputs);
697 component.setComponentInstances(componentInstances);
699 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
700 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
703 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
704 componentInstancesProperties, componentInstancesInterfaces, componentCache, dataTypes, topologyTemplate);
708 public void testAddComponentInstanceInputs() throws Exception {
710 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
711 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
712 ComponentInstance componentInstance = new ComponentInstance();
713 String instanceUniqueId = "id";
714 Map<String, Object> props = new HashMap<>();
716 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
717 componentInstanceInputs.add(new ComponentInstanceInput());
719 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
722 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
723 instanceUniqueId, props);
727 public void testAddPropertiesOfComponentInstance() throws Exception {
728 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
729 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
730 ComponentInstance componentInstance = new ComponentInstance();
731 String instanceUniqueId = "id";
732 Map<String, Object> props = new HashMap<>();
734 ComponentInstanceProperty cip = new ComponentInstanceProperty();
735 cip.setInstanceUniqueId("id");
737 List<ComponentInstanceProperty> list = new ArrayList<>();
740 componentInstancesProperties.put("id", list);
743 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
744 instanceUniqueId, props);
748 public void testAddPropertiesOfParentComponent() throws Exception {
749 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
750 ComponentInstance componentInstance = new ComponentInstance();
751 Component componentOfInstance = new Resource();
752 Map<String, Object> props = new HashMap<>();
754 List<PropertyDefinition> properties = new ArrayList<>();
755 properties.add(new PropertyDefinition());
757 ((Resource) componentOfInstance).setProperties(properties);
760 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
761 componentOfInstance, props);
766 public void testCreateNodeType() throws Exception {
768 Component component = new Resource();
769 List<String> array = new ArrayList<>();
771 ((Resource) component).setDerivedFrom(array);
772 ToscaNodeType result;
774 // test when component is resource
775 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
777 component = new Service();
778 // test when component is service
779 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
783 public void testCreateProxyNodeTypes() throws Exception {
784 Map<String, Component> componentCache = new HashMap<>();
785 Component container = new Resource();
786 Either<Map<String, ToscaNodeType>, ToscaError> result;
787 List<ComponentInstance> componentInstances = new ArrayList<>();
788 ComponentInstance instance = new ComponentInstance();
789 instance.setOriginType(OriginTypeEnum.ServiceProxy);
790 instance.setSourceModelUid("targetModelUid");
792 componentInstances.add(instance);
793 container.setComponentInstances(componentInstances);
795 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
796 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
798 // test when getLatestByName return is right
799 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
804 public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
805 Map<String, Component> componentCache = new HashMap<>();
806 Component container = new Resource();
807 Either<Map<String, ToscaNodeType>, ToscaError> result;
808 List<ComponentInstance> componentInstances = new ArrayList<>();
809 ComponentInstance instance = new ComponentInstance();
810 instance.setOriginType(OriginTypeEnum.ServiceProxy);
811 instance.setSourceModelUid("targetModelUid");
813 componentInstances.add(instance);
814 container.setComponentInstances(componentInstances);
816 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
818 ComponentParametersView parameterView = new ComponentParametersView();
819 parameterView.disableAll();
820 parameterView.setIgnoreCategories(false);
822 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
823 Mockito.any(ComponentParametersView.class)))
824 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
826 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
828 // test when getLatestByName is left
829 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
833 public void testCreateProxyNodeType() throws Exception {
834 Map<String, Component> componentCache = new HashMap<>();
835 Component origComponent = new Resource();
836 Component proxyComponent = new Resource();
837 ComponentInstance instance = new ComponentInstance();
838 ToscaNodeType result;
840 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
843 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
844 proxyComponent, instance);
848 public void testConvertComponentInstanceRequirements() throws Exception {
849 Component component = new Resource();
850 ComponentInstance componentInstance = new ComponentInstance();
851 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
852 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
853 Component originComponent = new Resource();
854 Map<String, Component> componentCache = new HashMap<>();
855 Either<ToscaNodeTemplate, ToscaError> result;
858 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
859 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
861 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
862 reldef.setFromNode("name");
863 reldef.setToNode("name1");
864 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
865 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
866 cap.setRelation(new RelationshipInfo());
867 relationships.add(cap);
868 reldef.setRelationships(relationships);
869 relations.add(reldef);
870 componentInstance.setUniqueId("name");
872 List<ComponentInstance> instances = new ArrayList<>();
873 instances.add(componentInstance);
874 component.setComponentInstances(instances);
876 // test when filteredRElations ins't empty
877 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
878 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
882 public void testAddRequirement() throws Exception {
883 ComponentInstance fromInstance = new ComponentInstance();
884 Component fromOriginComponent = new Resource();
885 List<ComponentInstance> instancesList = new ArrayList<>();
886 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
887 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
888 Map<String, Component> componentCache = new HashMap<>();
891 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
892 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
893 cap.setRequirement(new RequirementDataDefinition());
894 RelationshipInfo relation = new RelationshipInfo();
895 relation.setRequirementUid("Uid");
896 relation.setRequirement("requirment");
897 relation.setCapability("cap");
898 relation.setCapabilityOwnerId("id1");
899 cap.setRelation(relation);
900 relationships.add(cap);
901 rel.setRelationships(relationships);
902 rel.setToNode("name");
903 fromInstance.setUniqueId("name");
904 fromInstance.setComponentUid("string");
905 instancesList.add(fromInstance);
906 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
907 fromOriginComponent.setRequirements(requirements);
910 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
911 rel, toscaRequirements, componentCache);
916 public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
918 ComponentInstance fromInstance = new ComponentInstance();
919 Component fromOriginComponent = new Resource();
920 List<ComponentInstance> instancesList = new ArrayList<>();
921 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
922 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
923 Map<String, Component> componentCache = new HashMap<>();
926 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
927 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
928 cap.setRequirement(new RequirementDataDefinition());
929 RelationshipInfo relation = new RelationshipInfo();
930 relation.setRequirementUid("Uid");
931 relation.setRequirement("requirment");
932 relation.setCapability("cap");
933 relation.setCapabilityOwnerId("id1");
934 cap.setRelation(relation);
935 relationships.add(cap);
936 rel.setRelationships(relationships);
937 rel.setToNode("name");
938 fromInstance.setUniqueId("name");
939 fromInstance.setComponentUid("string");
940 instancesList.add(fromInstance);
941 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
943 List<RequirementDefinition> defs = new ArrayList<>();
944 RequirementDefinition def = new RequirementDefinition();
945 def.setName("requirment");
946 def.setCapability("cap");
948 requirements.put("key", defs);
949 fromOriginComponent.setRequirements(requirements);
951 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
952 Mockito.any(ComponentParametersView.class)))
953 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
956 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
957 rel, toscaRequirements, componentCache);
961 public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
962 ComponentInstance fromInstance = new ComponentInstance();
963 Component fromOriginComponent = new Resource();
964 List<ComponentInstance> instancesList = new ArrayList<>();
965 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
966 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
967 Map<String, Component> componentCache = new HashMap<>();
970 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
971 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
972 cap.setRequirement(new RequirementDataDefinition());
973 RelationshipInfo relation = new RelationshipInfo();
974 relation.setRequirementUid("Uid");
975 relation.setRequirement("requirment");
976 relation.setCapability("cap");
977 relation.setCapabilityOwnerId("id1");
978 cap.setRelation(relation);
979 relationships.add(cap);
980 rel.setRelationships(relationships);
981 rel.setToNode("name");
982 fromInstance.setUniqueId("name");
983 fromInstance.setComponentUid("string");
984 instancesList.add(fromInstance);
985 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
987 List<RequirementDefinition> defs = new ArrayList<>();
988 RequirementDefinition def = new RequirementDefinition();
989 def.setName("requirment");
990 def.setCapability("cap");
992 requirements.put("key", defs);
993 fromOriginComponent.setRequirements(requirements);
995 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
996 List<CapabilityDefinition> caps = new ArrayList<>();
997 CapabilityDefinition capdef = new CapabilityDefinition();
998 capdef.setOwnerId("id");
999 capdef.setName("name");
1000 capdef.setType("type");
1002 capabilities.put("cap", caps);
1004 fromOriginComponent.setCapabilities(capabilities);
1006 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1007 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1010 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1011 rel, toscaRequirements, componentCache);
1013 @Ignore("need to fix change in injected class.")
1015 public void testAddRequirmentsWithBuildAndAddRequirements() {
1016 ComponentInstance fromInstance = new ComponentInstance();
1017 Component fromOriginComponent = new Resource();
1018 List<ComponentInstance> instancesList = new ArrayList<>();
1019 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
1020 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1021 Map<String, Component> componentCache = new HashMap<>();
1024 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
1025 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
1026 cap.setRequirement(new RequirementDataDefinition());
1027 RelationshipInfo relation = new RelationshipInfo();
1028 relation.setRequirementUid("Uid");
1029 relation.setRequirement("requirment");
1030 relation.setCapability("cap");
1031 relation.setCapabilityOwnerId("id");
1032 cap.setRelation(relation);
1033 relationships.add(cap);
1034 rel.setRelationships(relationships);
1035 rel.setToNode("name");
1036 fromInstance.setUniqueId("name");
1037 fromInstance.setComponentUid("string");
1038 instancesList.add(fromInstance);
1039 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1041 List<RequirementDefinition> defs = new ArrayList<>();
1042 RequirementDefinition def = new RequirementDefinition();
1043 def.setName("requirment");
1044 def.setCapability("cap");
1046 requirements.put("key", defs);
1047 fromOriginComponent.setRequirements(requirements);
1049 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1050 List<CapabilityDefinition> caps = new ArrayList<>();
1051 CapabilityDefinition capdef = new CapabilityDefinition();
1052 capdef.setOwnerId("id");
1053 capdef.setName("cap");
1054 capdef.setType("type");
1056 capabilities.put("cap", caps);
1057 fromOriginComponent.setCapabilities(capabilities);
1059 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1060 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1062 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
1063 Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString(),Mockito.anyString()))
1064 .thenReturn(Either.right(false));
1067 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1068 rel, toscaRequirements, componentCache);
1070 @Ignore("need to fix change in injected class.")
1072 public void testBuildAndAddRequirement() throws Exception {
1073 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1074 Component fromOriginComponent = new Resource();
1075 Component toOriginComponent = new Resource();
1076 CapabilityDefinition capability = new CapabilityDefinition();
1077 RequirementDefinition requirement = new RequirementDefinition();
1078 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1079 ComponentInstance toInstance = new ComponentInstance();
1080 Map<String, Component> componentCache = new HashMap<>();
1082 capability.setPath(new ArrayList<>());
1083 reqAndRelationshipPair.setCapability("cap");
1084 requirement.setPath(new ArrayList<>());
1085 reqAndRelationshipPair.setRequirement("req");
1087 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
1088 new ArrayList<>(),Mockito.anyString(), "cap")).thenReturn(Either.left("buildCapNameRes"));
1090 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
1091 new ArrayList<>(),Mockito.anyString(), "req")).thenReturn(Either.right(false));
1094 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1095 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1098 @Ignore("need to fix change in injected class.")
1100 public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
1101 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1102 Component fromOriginComponent = new Resource();
1103 Component toOriginComponent = new Resource();
1104 CapabilityDefinition capability = new CapabilityDefinition();
1105 RequirementDefinition requirement = new RequirementDefinition();
1106 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1107 ComponentInstance toInstance = new ComponentInstance();
1108 Map<String, Component> componentCache = new HashMap<>();
1110 capability.setPath(new ArrayList<>());
1111 reqAndRelationshipPair.setCapability("cap");
1112 requirement.setPath(new ArrayList<>());
1113 reqAndRelationshipPair.setRequirement("req");
1115 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
1116 Mockito.anyList(), Mockito.anyString(),Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
1119 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1120 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1124 public void testIsRequirementBelongToRelation() throws Exception {
1126 Component originComponent = new Resource();
1127 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1128 RequirementDefinition requirement = new RequirementDefinition();
1129 String fromInstanceId = "";
1132 requirement.setName("name");
1133 reqAndRelationshipPair.setRequirement("name1");
1135 // test return false
1136 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1137 reqAndRelationshipPair, requirement, fromInstanceId);
1141 public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1143 Component originComponent = new Service();
1144 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1145 RequirementDefinition requirement = new RequirementDefinition();
1146 String fromInstanceId = "";
1149 // default test return true
1150 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1151 reqAndRelationshipPair, requirement, fromInstanceId);
1155 public void testIsRequirementBelongToOwner() throws Exception {
1157 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1158 RequirementDefinition requirement = new RequirementDefinition();
1159 String fromInstanceId = "";
1160 Component originComponent = new Resource();
1163 requirement.setOwnerId("owner1");
1164 reqAndRelationshipPair.setRequirementOwnerId("owner");
1167 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1168 fromInstanceId, originComponent);
1172 public void testIsCvfc() throws Exception {
1174 Component component = new Resource();
1177 component = new Service();
1179 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1183 public void testConvertCapabilities() throws Exception {
1184 Component component = new Resource();
1185 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1186 Map<String, Component> componentCache = new HashMap<>();
1187 Either<SubstitutionMapping, ToscaError> result;
1189 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
1190 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1192 // default test return isRight
1193 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1196 @Ignore("need to fix change in injected class.")
1198 public void testConvertCapabilities_1() throws Exception {
1199 Component component = new Resource();
1200 ToscaNodeType nodeType = new ToscaNodeType();
1201 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1202 Either<ToscaNodeType, ToscaError> result;
1204 Map<String, ToscaCapability> capabilities = new HashMap<>();
1205 capabilities.put("key", new ToscaCapability());
1207 Mockito.when(capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class), component, dataTypes)).thenReturn(capabilities);
1210 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);