1 package org.openecomp.sdc.be.tosca;
3 import java.util.ArrayList;
4 import java.util.HashMap;
7 import java.util.function.Supplier;
9 import org.apache.commons.lang3.tuple.ImmutablePair;
10 import org.apache.commons.lang3.tuple.Triple;
11 import org.junit.Before;
12 import org.junit.Ignore;
13 import org.junit.Test;
14 import org.mockito.InjectMocks;
15 import org.mockito.Mock;
16 import org.mockito.Mockito;
17 import org.mockito.MockitoAnnotations;
18 import org.openecomp.sdc.be.components.BeConfDependentTest;
19 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
20 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathDataDefinition;
21 import org.openecomp.sdc.be.datatypes.elements.ForwardingPathElementDataDefinition;
22 import org.openecomp.sdc.be.datatypes.elements.ListDataDefinition;
23 import org.openecomp.sdc.be.datatypes.elements.RequirementDataDefinition;
24 import org.openecomp.sdc.be.datatypes.enums.ComponentTypeEnum;
25 import org.openecomp.sdc.be.datatypes.enums.OriginTypeEnum;
26 import org.openecomp.sdc.be.model.ArtifactDefinition;
27 import org.openecomp.sdc.be.model.CapabilityDefinition;
28 import org.openecomp.sdc.be.model.CapabilityRequirementRelationship;
29 import org.openecomp.sdc.be.model.Component;
30 import org.openecomp.sdc.be.model.ComponentInstance;
31 import org.openecomp.sdc.be.model.ComponentInstanceInput;
32 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
33 import org.openecomp.sdc.be.model.ComponentParametersView;
34 import org.openecomp.sdc.be.model.DataTypeDefinition;
35 import org.openecomp.sdc.be.model.GroupDefinition;
36 import org.openecomp.sdc.be.model.GroupInstance;
37 import org.openecomp.sdc.be.model.InputDefinition;
38 import org.openecomp.sdc.be.model.PropertyDefinition;
39 import org.openecomp.sdc.be.model.RelationshipInfo;
40 import org.openecomp.sdc.be.model.RequirementCapabilityRelDef;
41 import org.openecomp.sdc.be.model.RequirementDefinition;
42 import org.openecomp.sdc.be.model.Resource;
43 import org.openecomp.sdc.be.model.Service;
44 import org.openecomp.sdc.be.model.cache.ApplicationDataTypeCache;
45 import org.openecomp.sdc.be.model.category.CategoryDefinition;
46 import org.openecomp.sdc.be.model.category.SubCategoryDefinition;
47 import org.openecomp.sdc.be.model.jsontitan.operations.ToscaOperationFacade;
48 import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
49 import org.openecomp.sdc.be.tosca.model.SubstitutionMapping;
50 import org.openecomp.sdc.be.tosca.model.ToscaCapability;
51 import org.openecomp.sdc.be.tosca.model.ToscaMetadata;
52 import org.openecomp.sdc.be.tosca.model.ToscaNodeTemplate;
53 import org.openecomp.sdc.be.tosca.model.ToscaNodeType;
54 import org.openecomp.sdc.be.tosca.model.ToscaTemplate;
55 import org.openecomp.sdc.be.tosca.model.ToscaTemplateRequirement;
56 import org.openecomp.sdc.be.tosca.model.ToscaTopolgyTemplate;
58 import fj.data.Either;
59 import mockit.Deencapsulation;
60 import org.openecomp.sdc.be.tosca.utils.InputConverter;
62 public class ToscaExportHandlerTest extends BeConfDependentTest {
65 ToscaExportHandler testSubject;
68 ApplicationDataTypeCache dataTypeCache;
71 ToscaOperationFacade toscaOperationFacade;
74 CapabilityRequirementConverter capabiltyRequirementConvertor;
77 InputConverter inputConverter;
80 GroupExportParser groupExportParser;
83 GroupExportParserImpl groupExportParserImpl;
86 public void setUpMock() throws Exception {
87 MockitoAnnotations.initMocks(this);
90 private Resource getNewResource() {
91 Resource resource = new Resource();
92 List<CategoryDefinition> categories = new ArrayList<>();
93 CategoryDefinition category = new CategoryDefinition();
94 List<SubCategoryDefinition> subcategories = new ArrayList<>();
95 SubCategoryDefinition subcategory = new SubCategoryDefinition();
97 subcategory.setName("name");
98 subcategories.add(subcategory);
99 category.setName("name");
100 category.setSubcategories(subcategories);
101 categories.add(category);
103 resource.setCategories(categories);
104 resource.setVersion("version");
105 resource.setVendorName("vendorName");
106 resource.setVendorRelease("vendorRelease");
107 resource.setResourceVendorModelNumber("resourceVendorModelNumber");
112 private Service getNewService() {
113 Service service = new Service();
114 List<CategoryDefinition> categories = new ArrayList<>();
115 CategoryDefinition category = new CategoryDefinition();
116 List<SubCategoryDefinition> subcategories = new ArrayList<>();
117 SubCategoryDefinition subcategory = new SubCategoryDefinition();
119 subcategory.setName("name");
120 subcategories.add(subcategory);
121 category.setName("name");
122 category.setSubcategories(subcategories);
123 categories.add(category);
125 service.setCategories(categories);
126 service.setComponentType(ComponentTypeEnum.SERVICE);
127 service.setServiceType("serviceType");
128 service.setServiceRole("serviceRole");
129 service.setEnvironmentContext("environmentContext");
135 public void testExportComponent() throws Exception {
136 Component component = getNewResource();
137 Either<ToscaRepresentation, ToscaError> result;
139 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
140 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
141 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
143 // default test when component is Resource
144 result = testSubject.exportComponent(component);
146 component = getNewService();
147 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
148 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
149 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
151 // default test when component is Service
152 result = testSubject.exportComponent(component);
156 public void testExportComponentInterface() throws Exception {
157 Component component = getNewResource();
158 Either<ToscaRepresentation, ToscaError> result;
160 ((Resource) component).setInterfaces(new HashMap<>());
162 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.NOT_FOUND));
164 // default test when convertInterfaceNodeType is right
165 result = testSubject.exportComponentInterface(component);
167 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
168 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
169 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
171 // default test when convertInterfaceNodeType is left
172 result = testSubject.exportComponentInterface(component);
177 public void testCreateToscaRepresentation() throws Exception {
178 ToscaTemplate toscaTemplate = new ToscaTemplate("");
179 ToscaRepresentation result;
182 result = testSubject.createToscaRepresentation(toscaTemplate);
186 public void testGetDependencies() throws Exception {
188 Component component = new Resource();
189 Either<ToscaTemplate, ToscaError> result;
192 result = testSubject.getDependencies(component);
196 public void testConvertToscaTemplate() throws Exception {
198 Component component = getNewResource();
199 ToscaTemplate toscaNode = new ToscaTemplate("");
200 Either<ToscaTemplate, ToscaError> result;
201 List<ComponentInstance> resourceInstances = new ArrayList<>();
202 ComponentInstance instance = new ComponentInstance();
204 instance.setOriginType(OriginTypeEnum.SERVICE);
205 instance.setSourceModelUid("targetModelUid");
206 resourceInstances.add(instance);
208 component.setComponentInstances(resourceInstances);
210 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
211 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
212 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
215 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
218 @Ignore("need to solve problem with groupExportParser injection")
220 public void testConvertToscaTemplateWhenComponentContainsGroup() {
221 Component component = getNewResource();
222 ToscaTemplate toscaNode = new ToscaTemplate("");
223 Either<ToscaTemplate, ToscaError> result;
224 component.setComponentInstances(new ArrayList<>());
226 List<GroupDefinition> groups = new ArrayList<>();
227 GroupDefinition group = new GroupDefinition();
228 List<String> artifacts = new ArrayList<>();
229 artifacts.add("artifact");
230 group.setType("org.openecomp.groups.VfModule");
231 group.setArtifacts(artifacts);
233 component.setGroups(groups);
235 Map<String, String[]> substitutionMappingMap = new HashMap<>();
236 String[] array = { "value1", "value2" };
237 substitutionMappingMap.put("key", array);
239 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
240 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
242 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
243 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
244 .thenReturn(Either.left(new SubstitutionMapping()));
246 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
248 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
249 .thenReturn(new HashMap<>());
251 Mockito.when(groupExportParser.getGroups(component))
254 // test component contains group
255 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
258 @Ignore("need to solve problem with groupExportParser injection")
260 public void testConvertToscaTemplateWhenComponentIsService() throws Exception {
261 Component component = getNewService();
262 ToscaTemplate toscaNode = new ToscaTemplate("");
263 Either<ToscaTemplate, ToscaError> result;
264 component.setComponentInstances(new ArrayList<>());
266 List<GroupDefinition> groups = new ArrayList<>();
267 GroupDefinition group = new GroupDefinition();
268 List<String> artifacts = new ArrayList<>();
269 artifacts.add("artifact");
270 group.setType("org.openecomp.groups.VfModule");
271 group.setArtifacts(artifacts);
273 component.setGroups(groups);
275 Map<String, String[]> substitutionMappingMap = new HashMap<>();
276 String[] array = { "value1", "value2" };
277 substitutionMappingMap.put("key", array);
279 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(Mockito.any(Map.class),
280 Mockito.any(Component.class))).thenReturn(Either.left(substitutionMappingMap));
282 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingRequirements(Mockito.any(Map.class),
283 Mockito.any(Component.class), Mockito.any(SubstitutionMapping.class)))
284 .thenReturn(Either.left(new SubstitutionMapping()));
286 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
288 Mockito.when(inputConverter.convertInputs(Mockito.any(List.class),Mockito.any(Map.class)))
289 .thenReturn(new HashMap<>());
290 // test component contains group
291 result = Deencapsulation.invoke(testSubject, "convertToscaTemplate", component, toscaNode);
295 public void testConvertMetadata_1() throws Exception {
297 Component component = getNewResource();
298 boolean isInstance = true;
299 ComponentInstance componentInstance = new ComponentInstance();
300 componentInstance.setOriginType(OriginTypeEnum.ServiceProxy);
301 componentInstance.setSourceModelInvariant("targetModelInvariant");
303 ToscaMetadata result;
307 result = Deencapsulation.invoke(testSubject, "convertMetadata", component, isInstance, componentInstance);
311 public void testFillImports() throws Exception {
313 Component component = getNewService();
314 ToscaTemplate toscaTemplate = new ToscaTemplate("");
315 Either<ImmutablePair<ToscaTemplate, Map<String, Component>>, ToscaError> result;
317 ComponentInstance instance = new ComponentInstance();
318 List<ComponentInstance> resourceInstances = new ArrayList<>();
319 instance.setComponentUid("name");
320 resourceInstances.add(instance);
321 component.setComponentInstances(resourceInstances);
322 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
323 ArtifactDefinition artifact = new ArtifactDefinition();
324 artifact.setArtifactName("name.name2");
325 toscaArtifacts.put("assettoscatemplate", artifact);
326 component.setToscaArtifacts(toscaArtifacts);
328 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.any(String.class)))
329 .thenReturn(Either.left(component));
332 result = Deencapsulation.invoke(testSubject, "fillImports", component, toscaTemplate);
336 public void testCreateDependency() throws Exception {
338 Map<String, Component> componentCache = new HashMap<>();
339 List<Map<String, Map<String, String>>> imports = new ArrayList<>();
340 List<Triple<String, String, Component>> dependecies = new ArrayList<>();
341 ComponentInstance ci = new ComponentInstance();
342 Component component = getNewResource();
344 Map<String, ArtifactDefinition> toscaArtifacts = new HashMap<>();
345 ArtifactDefinition artifact = new ArtifactDefinition();
346 artifact.setArtifactName("name.name2");
347 toscaArtifacts.put("assettoscatemplate", artifact);
348 component.setToscaArtifacts(toscaArtifacts);
349 ci.setComponentUid("name");
350 ci.setOriginType(OriginTypeEnum.ServiceProxy);
351 ci.setSourceModelUid("modelName");
353 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("name"))).thenReturn(Either.left(component));
355 Mockito.when(toscaOperationFacade.getToscaFullElement(Mockito.eq("modelName")))
356 .thenReturn(Either.left(new Service()));
359 Deencapsulation.invoke(testSubject, "createDependency", componentCache, imports, dependecies, ci);
363 public void testGetInterfaceFilename() throws Exception {
364 String artifactName = "artifact.name";
368 result = ToscaExportHandler.getInterfaceFilename(artifactName);
372 public void testConvertNodeType() throws Exception {
373 Component component = new Resource();
374 ToscaTemplate toscaNode = new ToscaTemplate("");
375 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
376 Either<ToscaTemplate, ToscaError> result;
378 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.right(TitanOperationStatus.ALREADY_EXIST));
381 result = Deencapsulation.invoke(testSubject, "convertNodeType",new HashMap<>(), component, toscaNode, nodeTypes);
385 public void testConvertInterfaceNodeType() throws Exception {
386 Component component = getNewResource();
387 ToscaTemplate toscaNode = new ToscaTemplate("");
388 Map<String, ToscaNodeType> nodeTypes = new HashMap<>();
389 Either<ToscaTemplate, ToscaError> result;
390 List<InputDefinition> inputs = new ArrayList<>();
391 inputs.add(new InputDefinition());
392 component.setInputs(inputs);
394 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
396 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class), Mockito.any(Resource.class),
397 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
400 result = Deencapsulation.invoke(testSubject, "convertInterfaceNodeType",new HashMap<>(), component, toscaNode, nodeTypes);
402 @Ignore("need to fix change in injected class.")
404 public void testConvertReqCapAndTypeName() throws Exception {
405 Component component = new Resource();
406 ToscaTemplate toscaNode = new ToscaTemplate("");
407 Map<String, ToscaNodeType> nodeTypes = new HashMap();
408 ToscaNodeType toscaNodeType = new ToscaNodeType();
409 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
410 Either<ToscaTemplate, ToscaError> result;
413 capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class),Mockito.any(Resource.class), Mockito.any(Map.class)))
414 .thenReturn(new HashMap<>());
416 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
417 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
420 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName",new HashMap<>(), component, toscaNode, nodeTypes,
421 toscaNodeType, dataTypes);
423 component = new Service();
425 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
426 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
428 // test when component is service
429 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
430 toscaNodeType, dataTypes);
435 public void testConvertNodeTemplates() throws Exception {
436 Component component = getNewResource();
437 List<ComponentInstance> componentInstances = new ArrayList<>();
438 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
439 Map<String, Component> componentCache = new HashMap<>();
440 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
441 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
442 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
443 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
444 List<ComponentInstanceInput> inputs = new ArrayList<>();
445 inputs.add(new ComponentInstanceInput());
446 componentInstancesInputs.put("key", inputs);
447 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
448 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
449 reldef.setFromNode("node");
450 resourceInstancesRelations.add(reldef);
451 component.setComponentInstancesRelations(resourceInstancesRelations);
453 ComponentInstance instance = new ComponentInstance();
454 instance.setUniqueId("id");
455 instance.setComponentUid("uid");
456 instance.setOriginType(OriginTypeEnum.ServiceProxy);
457 List<GroupInstance> groupInstances = new ArrayList<>();
458 GroupInstance groupInst = new GroupInstance();
459 List<String> artifacts = new ArrayList<>();
460 artifacts.add("artifact");
461 groupInst.setArtifacts(artifacts);
462 groupInst.setType("type");
463 groupInstances.add(groupInst);
464 instance.setGroupInstances(groupInstances);
465 componentInstances.add(instance);
467 component.setComponentInstancesInputs(componentInstancesInputs);
468 component.setInvariantUUID("uuid");
469 component.setUUID("uuid");
470 component.setDescription("desc");
472 componentCache.put("uid", component);
474 componentInstancesProperties.put("id", new ArrayList<>());
475 componentInstancesInputs.put("id", new ArrayList<>());
477 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
478 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
480 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
481 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
482 .thenReturn(Either.left(new ToscaNodeTemplate()));
485 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
486 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
490 public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
491 Component component = getNewService();
492 List<ComponentInstance> componentInstances = new ArrayList<>();
493 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
494 Map<String, Component> componentCache = new HashMap<>();
495 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
496 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
497 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
498 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
499 List<ComponentInstanceInput> inputs = new ArrayList<>();
500 inputs.add(new ComponentInstanceInput());
501 componentInstancesInputs.put("key", inputs);
502 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
503 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
504 reldef.setFromNode("node");
505 resourceInstancesRelations.add(reldef);
506 component.setComponentInstancesRelations(resourceInstancesRelations);
508 ComponentInstance instance = new ComponentInstance();
509 instance.setUniqueId("id");
510 instance.setComponentUid("uid");
511 instance.setOriginType(OriginTypeEnum.ServiceProxy);
512 List<GroupInstance> groupInstances = new ArrayList<>();
513 GroupInstance groupInst = new GroupInstance();
514 List<String> artifacts = new ArrayList<>();
515 artifacts.add("artifact");
516 groupInst.setArtifacts(artifacts);
517 groupInst.setType("type");
518 groupInstances.add(groupInst);
519 instance.setGroupInstances(groupInstances);
520 componentInstances.add(instance);
522 component.setComponentInstancesInputs(componentInstancesInputs);
523 component.setInvariantUUID("uuid");
524 component.setUUID("uuid");
525 component.setDescription("desc");
527 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
528 ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
529 ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
530 path.setPathElements(list);
531 forwardingPaths.put("key", path);
533 ((Service) component).setForwardingPaths(forwardingPaths);
535 componentCache.put("uid", component);
537 componentInstancesProperties.put("id", new ArrayList<>());
538 componentInstancesInputs.put("id", new ArrayList<>());
540 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
541 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
543 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
544 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
545 .thenReturn(Either.left(new ToscaNodeTemplate()));
548 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
549 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
553 public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
554 Component component = getNewResource();
555 List<ComponentInstance> componentInstances = new ArrayList<>();
556 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
557 Map<String, Component> componentCache = new HashMap<>();
558 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
559 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
560 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
561 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
562 List<ComponentInstanceInput> inputs = new ArrayList<>();
563 inputs.add(new ComponentInstanceInput());
564 componentInstancesInputs.put("key", inputs);
565 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
566 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
567 reldef.setFromNode("node");
568 resourceInstancesRelations.add(reldef);
569 component.setComponentInstancesRelations(resourceInstancesRelations);
571 ComponentInstance instance = new ComponentInstance();
572 instance.setUniqueId("id");
573 instance.setComponentUid("uid");
574 instance.setOriginType(OriginTypeEnum.ServiceProxy);
575 componentInstances.add(instance);
577 component.setComponentInstancesInputs(componentInstancesInputs);
578 component.setInvariantUUID("uuid");
579 component.setUUID("uuid");
580 component.setDescription("desc");
582 componentCache.put("uid", component);
584 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
585 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
587 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
588 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
589 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
592 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
593 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
597 public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
598 Component component = getNewResource();
599 List<ComponentInstance> componentInstances = new ArrayList<>();
600 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
601 Map<String, Component> componentCache = new HashMap<>();
602 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
603 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
604 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
605 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
606 List<ComponentInstanceInput> inputs = new ArrayList<>();
607 inputs.add(new ComponentInstanceInput());
608 componentInstancesInputs.put("key", inputs);
609 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
610 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
611 reldef.setFromNode("id");
612 resourceInstancesRelations.add(reldef);
613 component.setComponentInstancesRelations(resourceInstancesRelations);
615 ComponentInstance instance = new ComponentInstance();
616 instance.setUniqueId("id");
617 instance.setComponentUid("uid");
618 instance.setOriginType(OriginTypeEnum.ServiceProxy);
619 componentInstances.add(instance);
621 component.setComponentInstancesInputs(componentInstancesInputs);
622 component.setInvariantUUID("uuid");
623 component.setUUID("uuid");
624 component.setDescription("desc");
626 componentCache.put("uid", component);
628 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
629 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
632 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
633 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
637 public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
638 Component component = new Resource();
639 List<ComponentInstance> componentInstances = new ArrayList<>();
640 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
641 Map<String, Component> componentCache = new HashMap<>();
642 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
643 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
644 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
645 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
646 List<ComponentInstanceInput> inputs = new ArrayList<>();
647 inputs.add(new ComponentInstanceInput());
648 componentInstancesInputs.put("key", inputs);
649 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
650 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
651 reldef.setFromNode("id");
652 reldef.setToNode("node");
653 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
654 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
655 relationship.setRelation(new RelationshipInfo());
656 relationships.add(relationship);
657 reldef.setRelationships(relationships);
658 resourceInstancesRelations.add(reldef);
659 component.setComponentInstancesRelations(resourceInstancesRelations);
661 ComponentInstance instance = new ComponentInstance();
662 instance.setUniqueId("id");
663 componentInstances.add(instance);
665 component.setComponentInstancesInputs(componentInstancesInputs);
666 component.setComponentInstances(componentInstances);
668 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
669 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
672 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
673 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
677 public void testAddComponentInstanceInputs() throws Exception {
679 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
680 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
681 ComponentInstance componentInstance = new ComponentInstance();
682 String instanceUniqueId = "id";
683 Map<String, Object> props = new HashMap<>();
685 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
686 componentInstanceInputs.add(new ComponentInstanceInput());
688 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
691 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
692 instanceUniqueId, props);
696 public void testAddPropertiesOfComponentInstance() throws Exception {
697 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
698 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
699 ComponentInstance componentInstance = new ComponentInstance();
700 String instanceUniqueId = "id";
701 Map<String, Object> props = new HashMap<>();
703 ComponentInstanceProperty cip = new ComponentInstanceProperty();
704 cip.setInstanceUniqueId("id");
706 List<ComponentInstanceProperty> list = new ArrayList<>();
709 componentInstancesProperties.put("id", list);
712 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
713 instanceUniqueId, props);
717 public void testAddPropertiesOfParentComponent() throws Exception {
718 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
719 ComponentInstance componentInstance = new ComponentInstance();
720 Component componentOfInstance = new Resource();
721 Map<String, Object> props = new HashMap<>();
723 List<PropertyDefinition> properties = new ArrayList<>();
724 properties.add(new PropertyDefinition());
726 ((Resource) componentOfInstance).setProperties(properties);
729 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
730 componentOfInstance, props);
735 public void testCreateNodeType() throws Exception {
737 Component component = new Resource();
738 List<String> array = new ArrayList<>();
740 ((Resource) component).setDerivedFrom(array);
741 ToscaNodeType result;
743 // test when component is resource
744 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
746 component = new Service();
747 // test when component is service
748 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
752 public void testCreateProxyNodeTypes() throws Exception {
753 Map<String, Component> componentCache = new HashMap<>();
754 Component container = new Resource();
755 Either<Map<String, ToscaNodeType>, ToscaError> result;
756 List<ComponentInstance> componentInstances = new ArrayList<>();
757 ComponentInstance instance = new ComponentInstance();
758 instance.setOriginType(OriginTypeEnum.ServiceProxy);
759 instance.setSourceModelUid("targetModelUid");
761 componentInstances.add(instance);
762 container.setComponentInstances(componentInstances);
764 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
765 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
767 // test when getLatestByName return is right
768 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
773 public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
774 Map<String, Component> componentCache = new HashMap<>();
775 Component container = new Resource();
776 Either<Map<String, ToscaNodeType>, ToscaError> result;
777 List<ComponentInstance> componentInstances = new ArrayList<>();
778 ComponentInstance instance = new ComponentInstance();
779 instance.setOriginType(OriginTypeEnum.ServiceProxy);
780 instance.setSourceModelUid("targetModelUid");
782 componentInstances.add(instance);
783 container.setComponentInstances(componentInstances);
785 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
787 ComponentParametersView parameterView = new ComponentParametersView();
788 parameterView.disableAll();
789 parameterView.setIgnoreCategories(false);
791 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
792 Mockito.any(ComponentParametersView.class)))
793 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
795 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
797 // test when getLatestByName is left
798 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
802 public void testCreateProxyNodeType() throws Exception {
803 Map<String, Component> componentCache = new HashMap<>();
804 Component origComponent = new Resource();
805 Component proxyComponent = new Resource();
806 ComponentInstance instance = new ComponentInstance();
807 ToscaNodeType result;
809 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
812 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
813 proxyComponent, instance);
817 public void testConvertComponentInstanceRequirements() throws Exception {
818 Component component = new Resource();
819 ComponentInstance componentInstance = new ComponentInstance();
820 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
821 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
822 Component originComponent = new Resource();
823 Map<String, Component> componentCache = new HashMap<>();
824 Either<ToscaNodeTemplate, ToscaError> result;
827 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
828 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
830 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
831 reldef.setFromNode("name");
832 reldef.setToNode("name1");
833 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
834 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
835 cap.setRelation(new RelationshipInfo());
836 relationships.add(cap);
837 reldef.setRelationships(relationships);
838 relations.add(reldef);
839 componentInstance.setUniqueId("name");
841 List<ComponentInstance> instances = new ArrayList<>();
842 instances.add(componentInstance);
843 component.setComponentInstances(instances);
845 // test when filteredRElations ins't empty
846 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
847 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
851 public void testAddRequirement() throws Exception {
852 ComponentInstance fromInstance = new ComponentInstance();
853 Component fromOriginComponent = new Resource();
854 List<ComponentInstance> instancesList = new ArrayList<>();
855 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
856 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
857 Map<String, Component> componentCache = new HashMap<>();
860 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
861 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
862 cap.setRequirement(new RequirementDataDefinition());
863 RelationshipInfo relation = new RelationshipInfo();
864 relation.setRequirementUid("Uid");
865 relation.setRequirement("requirment");
866 relation.setCapability("cap");
867 relation.setCapabilityOwnerId("id1");
868 cap.setRelation(relation);
869 relationships.add(cap);
870 rel.setRelationships(relationships);
871 rel.setToNode("name");
872 fromInstance.setUniqueId("name");
873 fromInstance.setComponentUid("string");
874 instancesList.add(fromInstance);
875 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
876 fromOriginComponent.setRequirements(requirements);
879 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
880 rel, toscaRequirements, componentCache);
885 public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
887 ComponentInstance fromInstance = new ComponentInstance();
888 Component fromOriginComponent = new Resource();
889 List<ComponentInstance> instancesList = new ArrayList<>();
890 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
891 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
892 Map<String, Component> componentCache = new HashMap<>();
895 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
896 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
897 cap.setRequirement(new RequirementDataDefinition());
898 RelationshipInfo relation = new RelationshipInfo();
899 relation.setRequirementUid("Uid");
900 relation.setRequirement("requirment");
901 relation.setCapability("cap");
902 relation.setCapabilityOwnerId("id1");
903 cap.setRelation(relation);
904 relationships.add(cap);
905 rel.setRelationships(relationships);
906 rel.setToNode("name");
907 fromInstance.setUniqueId("name");
908 fromInstance.setComponentUid("string");
909 instancesList.add(fromInstance);
910 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
912 List<RequirementDefinition> defs = new ArrayList<>();
913 RequirementDefinition def = new RequirementDefinition();
914 def.setName("requirment");
915 def.setCapability("cap");
917 requirements.put("key", defs);
918 fromOriginComponent.setRequirements(requirements);
920 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
921 Mockito.any(ComponentParametersView.class)))
922 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
925 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
926 rel, toscaRequirements, componentCache);
930 public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
931 ComponentInstance fromInstance = new ComponentInstance();
932 Component fromOriginComponent = new Resource();
933 List<ComponentInstance> instancesList = new ArrayList<>();
934 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
935 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
936 Map<String, Component> componentCache = new HashMap<>();
939 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
940 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
941 cap.setRequirement(new RequirementDataDefinition());
942 RelationshipInfo relation = new RelationshipInfo();
943 relation.setRequirementUid("Uid");
944 relation.setRequirement("requirment");
945 relation.setCapability("cap");
946 relation.setCapabilityOwnerId("id1");
947 cap.setRelation(relation);
948 relationships.add(cap);
949 rel.setRelationships(relationships);
950 rel.setToNode("name");
951 fromInstance.setUniqueId("name");
952 fromInstance.setComponentUid("string");
953 instancesList.add(fromInstance);
954 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
956 List<RequirementDefinition> defs = new ArrayList<>();
957 RequirementDefinition def = new RequirementDefinition();
958 def.setName("requirment");
959 def.setCapability("cap");
961 requirements.put("key", defs);
962 fromOriginComponent.setRequirements(requirements);
964 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
965 List<CapabilityDefinition> caps = new ArrayList<>();
966 CapabilityDefinition capdef = new CapabilityDefinition();
967 capdef.setOwnerId("id");
968 capdef.setName("name");
969 capdef.setType("type");
971 capabilities.put("cap", caps);
973 fromOriginComponent.setCapabilities(capabilities);
975 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
976 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
979 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
980 rel, toscaRequirements, componentCache);
982 @Ignore("need to fix change in injected class.")
984 public void testAddRequirmentsWithBuildAndAddRequirements() {
985 ComponentInstance fromInstance = new ComponentInstance();
986 Component fromOriginComponent = new Resource();
987 List<ComponentInstance> instancesList = new ArrayList<>();
988 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
989 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
990 Map<String, Component> componentCache = new HashMap<>();
993 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
994 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
995 cap.setRequirement(new RequirementDataDefinition());
996 RelationshipInfo relation = new RelationshipInfo();
997 relation.setRequirementUid("Uid");
998 relation.setRequirement("requirment");
999 relation.setCapability("cap");
1000 relation.setCapabilityOwnerId("id");
1001 cap.setRelation(relation);
1002 relationships.add(cap);
1003 rel.setRelationships(relationships);
1004 rel.setToNode("name");
1005 fromInstance.setUniqueId("name");
1006 fromInstance.setComponentUid("string");
1007 instancesList.add(fromInstance);
1008 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1010 List<RequirementDefinition> defs = new ArrayList<>();
1011 RequirementDefinition def = new RequirementDefinition();
1012 def.setName("requirment");
1013 def.setCapability("cap");
1015 requirements.put("key", defs);
1016 fromOriginComponent.setRequirements(requirements);
1018 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1019 List<CapabilityDefinition> caps = new ArrayList<>();
1020 CapabilityDefinition capdef = new CapabilityDefinition();
1021 capdef.setOwnerId("id");
1022 capdef.setName("cap");
1023 capdef.setType("type");
1025 capabilities.put("cap", caps);
1026 fromOriginComponent.setCapabilities(capabilities);
1028 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1029 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1031 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
1032 Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString(),Mockito.anyString()))
1033 .thenReturn(Either.right(false));
1036 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1037 rel, toscaRequirements, componentCache);
1039 @Ignore("need to fix change in injected class.")
1041 public void testBuildAndAddRequirement() throws Exception {
1042 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1043 Component fromOriginComponent = new Resource();
1044 Component toOriginComponent = new Resource();
1045 CapabilityDefinition capability = new CapabilityDefinition();
1046 RequirementDefinition requirement = new RequirementDefinition();
1047 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1048 ComponentInstance toInstance = new ComponentInstance();
1049 Map<String, Component> componentCache = new HashMap<>();
1051 capability.setPath(new ArrayList<>());
1052 reqAndRelationshipPair.setCapability("cap");
1053 requirement.setPath(new ArrayList<>());
1054 reqAndRelationshipPair.setRequirement("req");
1056 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
1057 new ArrayList<>(),Mockito.anyString(), "cap")).thenReturn(Either.left("buildCapNameRes"));
1059 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
1060 new ArrayList<>(),Mockito.anyString(), "req")).thenReturn(Either.right(false));
1063 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1064 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1067 @Ignore("need to fix change in injected class.")
1069 public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
1070 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1071 Component fromOriginComponent = new Resource();
1072 Component toOriginComponent = new Resource();
1073 CapabilityDefinition capability = new CapabilityDefinition();
1074 RequirementDefinition requirement = new RequirementDefinition();
1075 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1076 ComponentInstance toInstance = new ComponentInstance();
1077 Map<String, Component> componentCache = new HashMap<>();
1079 capability.setPath(new ArrayList<>());
1080 reqAndRelationshipPair.setCapability("cap");
1081 requirement.setPath(new ArrayList<>());
1082 reqAndRelationshipPair.setRequirement("req");
1084 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
1085 Mockito.anyList(), Mockito.anyString(),Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
1088 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1089 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1093 public void testIsRequirementBelongToRelation() throws Exception {
1095 Component originComponent = new Resource();
1096 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1097 RequirementDefinition requirement = new RequirementDefinition();
1098 String fromInstanceId = "";
1101 requirement.setName("name");
1102 reqAndRelationshipPair.setRequirement("name1");
1104 // test return false
1105 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1106 reqAndRelationshipPair, requirement, fromInstanceId);
1110 public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1112 Component originComponent = new Service();
1113 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1114 RequirementDefinition requirement = new RequirementDefinition();
1115 String fromInstanceId = "";
1118 // default test return true
1119 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1120 reqAndRelationshipPair, requirement, fromInstanceId);
1124 public void testIsRequirementBelongToOwner() throws Exception {
1126 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1127 RequirementDefinition requirement = new RequirementDefinition();
1128 String fromInstanceId = "";
1129 Component originComponent = new Resource();
1132 requirement.setOwnerId("owner1");
1133 reqAndRelationshipPair.setRequirementOwnerId("owner");
1136 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1137 fromInstanceId, originComponent);
1141 public void testIsCvfc() throws Exception {
1143 Component component = new Resource();
1146 component = new Service();
1148 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1152 public void testConvertCapabilities() throws Exception {
1153 Component component = new Resource();
1154 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1155 Map<String, Component> componentCache = new HashMap<>();
1156 Either<SubstitutionMapping, ToscaError> result;
1158 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
1159 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1161 // default test return isRight
1162 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1165 @Ignore("need to fix change in injected class.")
1167 public void testConvertCapabilities_1() throws Exception {
1168 Component component = new Resource();
1169 ToscaNodeType nodeType = new ToscaNodeType();
1170 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1171 Either<ToscaNodeType, ToscaError> result;
1173 Map<String, ToscaCapability> capabilities = new HashMap<>();
1174 capabilities.put("key", new ToscaCapability());
1176 Mockito.when(capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class), component, dataTypes)).thenReturn(capabilities);
1179 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);