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, false);
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, false);
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
403 @Ignore("need to fix change in injected class.")
405 public void testConvertReqCapAndTypeName() throws Exception {
406 Component component = new Resource();
407 ToscaTemplate toscaNode = new ToscaTemplate("");
408 Map<String, ToscaNodeType> nodeTypes = new HashMap();
409 ToscaNodeType toscaNodeType = new ToscaNodeType();
410 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
411 Either<ToscaTemplate, ToscaError> result;
414 capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class),Mockito.any(Resource.class), Mockito.any(Map.class)))
415 .thenReturn(new HashMap<>());
417 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Resource.class),
418 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
421 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName",new HashMap<>(), component, toscaNode, nodeTypes,
422 toscaNodeType, dataTypes);
424 component = new Service();
426 Mockito.when(capabiltyRequirementConvertor.convertRequirements(Mockito.any(Map.class),Mockito.any(Service.class),
427 Mockito.any(ToscaNodeType.class))).thenReturn(Either.left(new ToscaNodeType()));
429 // test when component is service
430 result = Deencapsulation.invoke(testSubject, "convertReqCapAndTypeName", component, toscaNode, nodeTypes,
431 toscaNodeType, dataTypes);
436 public void testConvertNodeTemplates() throws Exception {
437 Component component = getNewResource();
438 List<ComponentInstance> componentInstances = new ArrayList<>();
439 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
440 Map<String, Component> componentCache = new HashMap<>();
441 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
442 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
443 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
444 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
445 List<ComponentInstanceInput> inputs = new ArrayList<>();
446 inputs.add(new ComponentInstanceInput());
447 componentInstancesInputs.put("key", inputs);
448 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
449 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
450 reldef.setFromNode("node");
451 resourceInstancesRelations.add(reldef);
452 component.setComponentInstancesRelations(resourceInstancesRelations);
454 ComponentInstance instance = new ComponentInstance();
455 instance.setUniqueId("id");
456 instance.setComponentUid("uid");
457 instance.setOriginType(OriginTypeEnum.ServiceProxy);
458 List<GroupInstance> groupInstances = new ArrayList<>();
459 GroupInstance groupInst = new GroupInstance();
460 List<String> artifacts = new ArrayList<>();
461 artifacts.add("artifact");
462 groupInst.setArtifacts(artifacts);
463 groupInst.setType("type");
464 groupInstances.add(groupInst);
465 instance.setGroupInstances(groupInstances);
466 componentInstances.add(instance);
468 component.setComponentInstancesInputs(componentInstancesInputs);
469 component.setInvariantUUID("uuid");
470 component.setUUID("uuid");
471 component.setDescription("desc");
473 componentCache.put("uid", component);
475 componentInstancesProperties.put("id", new ArrayList<>());
476 componentInstancesInputs.put("id", new ArrayList<>());
478 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
479 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
481 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
482 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
483 .thenReturn(Either.left(new ToscaNodeTemplate()));
486 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
487 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
491 public void testConvertNodeTemplatesWhenComponentIsService() throws Exception {
492 Component component = getNewService();
493 List<ComponentInstance> componentInstances = new ArrayList<>();
494 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
495 Map<String, Component> componentCache = new HashMap<>();
496 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
497 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
498 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
499 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
500 List<ComponentInstanceInput> inputs = new ArrayList<>();
501 inputs.add(new ComponentInstanceInput());
502 componentInstancesInputs.put("key", inputs);
503 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
504 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
505 reldef.setFromNode("node");
506 resourceInstancesRelations.add(reldef);
507 component.setComponentInstancesRelations(resourceInstancesRelations);
509 ComponentInstance instance = new ComponentInstance();
510 instance.setUniqueId("id");
511 instance.setComponentUid("uid");
512 instance.setOriginType(OriginTypeEnum.ServiceProxy);
513 List<GroupInstance> groupInstances = new ArrayList<>();
514 GroupInstance groupInst = new GroupInstance();
515 List<String> artifacts = new ArrayList<>();
516 artifacts.add("artifact");
517 groupInst.setArtifacts(artifacts);
518 groupInst.setType("type");
519 groupInstances.add(groupInst);
520 instance.setGroupInstances(groupInstances);
521 componentInstances.add(instance);
523 component.setComponentInstancesInputs(componentInstancesInputs);
524 component.setInvariantUUID("uuid");
525 component.setUUID("uuid");
526 component.setDescription("desc");
528 Map<String, ForwardingPathDataDefinition> forwardingPaths = new HashMap<>();
529 ForwardingPathDataDefinition path = new ForwardingPathDataDefinition();
530 ListDataDefinition<ForwardingPathElementDataDefinition> list = new ListDataDefinition<>();
531 path.setPathElements(list);
532 forwardingPaths.put("key", path);
534 ((Service) component).setForwardingPaths(forwardingPaths);
536 componentCache.put("uid", component);
538 componentInstancesProperties.put("id", new ArrayList<>());
539 componentInstancesInputs.put("id", new ArrayList<>());
541 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
542 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
544 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
545 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
546 .thenReturn(Either.left(new ToscaNodeTemplate()));
549 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
550 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
554 public void testConvertNodeTemplatesWhenConvertComponentInstanceCapabilitiesIsRight() throws Exception {
555 Component component = getNewResource();
556 List<ComponentInstance> componentInstances = new ArrayList<>();
557 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
558 Map<String, Component> componentCache = new HashMap<>();
559 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
560 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
561 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
562 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
563 List<ComponentInstanceInput> inputs = new ArrayList<>();
564 inputs.add(new ComponentInstanceInput());
565 componentInstancesInputs.put("key", inputs);
566 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
567 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
568 reldef.setFromNode("node");
569 resourceInstancesRelations.add(reldef);
570 component.setComponentInstancesRelations(resourceInstancesRelations);
572 ComponentInstance instance = new ComponentInstance();
573 instance.setUniqueId("id");
574 instance.setComponentUid("uid");
575 instance.setOriginType(OriginTypeEnum.ServiceProxy);
576 componentInstances.add(instance);
578 component.setComponentInstancesInputs(componentInstancesInputs);
579 component.setInvariantUUID("uuid");
580 component.setUUID("uuid");
581 component.setDescription("desc");
583 componentCache.put("uid", component);
585 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
586 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
588 Mockito.when(capabiltyRequirementConvertor.convertComponentInstanceCapabilities(
589 Mockito.any(ComponentInstance.class), Mockito.any(Map.class), Mockito.any(ToscaNodeTemplate.class)))
590 .thenReturn(Either.right(ToscaError.GENERAL_ERROR));
593 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
594 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
598 public void testConvetNodeTemplateWhenGetOriginComponentIsRight() throws Exception {
599 Component component = getNewResource();
600 List<ComponentInstance> componentInstances = new ArrayList<>();
601 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
602 Map<String, Component> componentCache = new HashMap<>();
603 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
604 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
605 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
606 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
607 List<ComponentInstanceInput> inputs = new ArrayList<>();
608 inputs.add(new ComponentInstanceInput());
609 componentInstancesInputs.put("key", inputs);
610 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
611 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
612 reldef.setFromNode("id");
613 resourceInstancesRelations.add(reldef);
614 component.setComponentInstancesRelations(resourceInstancesRelations);
616 ComponentInstance instance = new ComponentInstance();
617 instance.setUniqueId("id");
618 instance.setComponentUid("uid");
619 instance.setOriginType(OriginTypeEnum.ServiceProxy);
620 componentInstances.add(instance);
622 component.setComponentInstancesInputs(componentInstancesInputs);
623 component.setInvariantUUID("uuid");
624 component.setUUID("uuid");
625 component.setDescription("desc");
627 componentCache.put("uid", component);
629 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
630 Mockito.any(ComponentInstance.class))).thenReturn(Either.right(false));
633 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
634 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
638 public void testConvertNodeTemplatesWhenConvertComponentInstanceRequirmentsIsRight() {
639 Component component = new Resource();
640 List<ComponentInstance> componentInstances = new ArrayList<>();
641 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
642 Map<String, Component> componentCache = new HashMap<>();
643 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
644 ToscaTopolgyTemplate topologyTemplate = new ToscaTopolgyTemplate();
645 Either<Map<String, ToscaNodeTemplate>, ToscaError> result;
646 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
647 List<ComponentInstanceInput> inputs = new ArrayList<>();
648 inputs.add(new ComponentInstanceInput());
649 componentInstancesInputs.put("key", inputs);
650 List<RequirementCapabilityRelDef> resourceInstancesRelations = new ArrayList<>();
651 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
652 reldef.setFromNode("id");
653 reldef.setToNode("node");
654 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
655 CapabilityRequirementRelationship relationship = new CapabilityRequirementRelationship();
656 relationship.setRelation(new RelationshipInfo());
657 relationships.add(relationship);
658 reldef.setRelationships(relationships);
659 resourceInstancesRelations.add(reldef);
660 component.setComponentInstancesRelations(resourceInstancesRelations);
662 ComponentInstance instance = new ComponentInstance();
663 instance.setUniqueId("id");
664 componentInstances.add(instance);
666 component.setComponentInstancesInputs(componentInstancesInputs);
667 component.setComponentInstances(componentInstances);
669 Mockito.when(capabiltyRequirementConvertor.getOriginComponent(Mockito.any(Map.class),
670 Mockito.any(ComponentInstance.class))).thenReturn(Either.left(component));
673 result = Deencapsulation.invoke(testSubject, "convertNodeTemplates", component, componentInstances,
674 componentInstancesProperties, componentCache, dataTypes, topologyTemplate);
678 public void testAddComponentInstanceInputs() throws Exception {
680 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
681 Map<String, List<ComponentInstanceInput>> componentInstancesInputs = new HashMap<>();
682 ComponentInstance componentInstance = new ComponentInstance();
683 String instanceUniqueId = "id";
684 Map<String, Object> props = new HashMap<>();
686 List<ComponentInstanceInput> componentInstanceInputs = new ArrayList<>();
687 componentInstanceInputs.add(new ComponentInstanceInput());
689 componentInstancesInputs.put(instanceUniqueId, componentInstanceInputs);
692 Deencapsulation.invoke(testSubject, "addComponentInstanceInputs", dataTypes, componentInstancesInputs,
693 instanceUniqueId, props);
697 public void testAddPropertiesOfComponentInstance() throws Exception {
698 Map<String, List<ComponentInstanceProperty>> componentInstancesProperties = new HashMap<>();
699 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
700 ComponentInstance componentInstance = new ComponentInstance();
701 String instanceUniqueId = "id";
702 Map<String, Object> props = new HashMap<>();
704 ComponentInstanceProperty cip = new ComponentInstanceProperty();
705 cip.setInstanceUniqueId("id");
707 List<ComponentInstanceProperty> list = new ArrayList<>();
710 componentInstancesProperties.put("id", list);
713 Deencapsulation.invoke(testSubject, "addPropertiesOfComponentInstance", componentInstancesProperties, dataTypes,
714 instanceUniqueId, props);
718 public void testAddPropertiesOfParentComponent() throws Exception {
719 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
720 ComponentInstance componentInstance = new ComponentInstance();
721 Component componentOfInstance = new Resource();
722 Map<String, Object> props = new HashMap<>();
724 List<PropertyDefinition> properties = new ArrayList<>();
725 properties.add(new PropertyDefinition());
727 ((Resource) componentOfInstance).setProperties(properties);
730 Deencapsulation.invoke(testSubject, "addPropertiesOfParentComponent", dataTypes,
731 componentOfInstance, props);
736 public void testCreateNodeType() throws Exception {
738 Component component = new Resource();
739 List<String> array = new ArrayList<>();
741 ((Resource) component).setDerivedFrom(array);
742 ToscaNodeType result;
744 // test when component is resource
745 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
747 component = new Service();
748 // test when component is service
749 result = Deencapsulation.invoke(testSubject, "createNodeType", component);
753 public void testCreateProxyNodeTypes() throws Exception {
754 Map<String, Component> componentCache = new HashMap<>();
755 Component container = new Resource();
756 Either<Map<String, ToscaNodeType>, ToscaError> result;
757 List<ComponentInstance> componentInstances = new ArrayList<>();
758 ComponentInstance instance = new ComponentInstance();
759 instance.setOriginType(OriginTypeEnum.ServiceProxy);
760 instance.setSourceModelUid("targetModelUid");
762 componentInstances.add(instance);
763 container.setComponentInstances(componentInstances);
765 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy"))
766 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
768 // test when getLatestByName return is right
769 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
774 public void testCreateProxyNodeTypesWhenGetLatestByNameReturnValue() {
775 Map<String, Component> componentCache = new HashMap<>();
776 Component container = new Resource();
777 Either<Map<String, ToscaNodeType>, ToscaError> result;
778 List<ComponentInstance> componentInstances = new ArrayList<>();
779 ComponentInstance instance = new ComponentInstance();
780 instance.setOriginType(OriginTypeEnum.ServiceProxy);
781 instance.setSourceModelUid("targetModelUid");
783 componentInstances.add(instance);
784 container.setComponentInstances(componentInstances);
786 Mockito.when(toscaOperationFacade.getLatestByName("serviceProxy")).thenReturn(Either.left(new Resource()));
788 ComponentParametersView parameterView = new ComponentParametersView();
789 parameterView.disableAll();
790 parameterView.setIgnoreCategories(false);
792 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
793 Mockito.any(ComponentParametersView.class)))
794 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
796 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
798 // test when getLatestByName is left
799 result = Deencapsulation.invoke(testSubject, "createProxyNodeTypes", componentCache, container);
803 public void testCreateProxyNodeType() throws Exception {
804 Map<String, Component> componentCache = new HashMap<>();
805 Component origComponent = new Resource();
806 Component proxyComponent = new Resource();
807 ComponentInstance instance = new ComponentInstance();
808 ToscaNodeType result;
810 Mockito.when(dataTypeCache.getAll()).thenReturn(Either.left(new HashMap<>()));
813 result = Deencapsulation.invoke(testSubject, "createProxyNodeType", componentCache, origComponent,
814 proxyComponent, instance);
818 public void testConvertComponentInstanceRequirements() throws Exception {
819 Component component = new Resource();
820 ComponentInstance componentInstance = new ComponentInstance();
821 List<RequirementCapabilityRelDef> relations = new ArrayList<>();
822 ToscaNodeTemplate nodeTypeTemplate = new ToscaNodeTemplate();
823 Component originComponent = new Resource();
824 Map<String, Component> componentCache = new HashMap<>();
825 Either<ToscaNodeTemplate, ToscaError> result;
828 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
829 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
831 RequirementCapabilityRelDef reldef = new RequirementCapabilityRelDef();
832 reldef.setFromNode("name");
833 reldef.setToNode("name1");
834 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
835 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
836 cap.setRelation(new RelationshipInfo());
837 relationships.add(cap);
838 reldef.setRelationships(relationships);
839 relations.add(reldef);
840 componentInstance.setUniqueId("name");
842 List<ComponentInstance> instances = new ArrayList<>();
843 instances.add(componentInstance);
844 component.setComponentInstances(instances);
846 // test when filteredRElations ins't empty
847 result = Deencapsulation.invoke(testSubject, "convertComponentInstanceRequirements", component,
848 componentInstance, relations, nodeTypeTemplate, originComponent, componentCache);
852 public void testAddRequirement() throws Exception {
853 ComponentInstance fromInstance = new ComponentInstance();
854 Component fromOriginComponent = new Resource();
855 List<ComponentInstance> instancesList = new ArrayList<>();
856 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
857 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
858 Map<String, Component> componentCache = new HashMap<>();
861 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
862 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
863 cap.setRequirement(new RequirementDataDefinition());
864 RelationshipInfo relation = new RelationshipInfo();
865 relation.setRequirementUid("Uid");
866 relation.setRequirement("requirment");
867 relation.setCapability("cap");
868 relation.setCapabilityOwnerId("id1");
869 cap.setRelation(relation);
870 relationships.add(cap);
871 rel.setRelationships(relationships);
872 rel.setToNode("name");
873 fromInstance.setUniqueId("name");
874 fromInstance.setComponentUid("string");
875 instancesList.add(fromInstance);
876 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
877 fromOriginComponent.setRequirements(requirements);
880 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
881 rel, toscaRequirements, componentCache);
886 public void testAddRequirmentsWhenFindRequirmentsReturnsValue() {
888 ComponentInstance fromInstance = new ComponentInstance();
889 Component fromOriginComponent = new Resource();
890 List<ComponentInstance> instancesList = new ArrayList<>();
891 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
892 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
893 Map<String, Component> componentCache = new HashMap<>();
896 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
897 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
898 cap.setRequirement(new RequirementDataDefinition());
899 RelationshipInfo relation = new RelationshipInfo();
900 relation.setRequirementUid("Uid");
901 relation.setRequirement("requirment");
902 relation.setCapability("cap");
903 relation.setCapabilityOwnerId("id1");
904 cap.setRelation(relation);
905 relationships.add(cap);
906 rel.setRelationships(relationships);
907 rel.setToNode("name");
908 fromInstance.setUniqueId("name");
909 fromInstance.setComponentUid("string");
910 instancesList.add(fromInstance);
911 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
913 List<RequirementDefinition> defs = new ArrayList<>();
914 RequirementDefinition def = new RequirementDefinition();
915 def.setName("requirment");
916 def.setCapability("cap");
918 requirements.put("key", defs);
919 fromOriginComponent.setRequirements(requirements);
921 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
922 Mockito.any(ComponentParametersView.class)))
923 .thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST));
926 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
927 rel, toscaRequirements, componentCache);
931 public void testAddRequirmentsWhenCapabilityBelongsToRelation() {
932 ComponentInstance fromInstance = new ComponentInstance();
933 Component fromOriginComponent = new Resource();
934 List<ComponentInstance> instancesList = new ArrayList<>();
935 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
936 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
937 Map<String, Component> componentCache = new HashMap<>();
940 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
941 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
942 cap.setRequirement(new RequirementDataDefinition());
943 RelationshipInfo relation = new RelationshipInfo();
944 relation.setRequirementUid("Uid");
945 relation.setRequirement("requirment");
946 relation.setCapability("cap");
947 relation.setCapabilityOwnerId("id1");
948 cap.setRelation(relation);
949 relationships.add(cap);
950 rel.setRelationships(relationships);
951 rel.setToNode("name");
952 fromInstance.setUniqueId("name");
953 fromInstance.setComponentUid("string");
954 instancesList.add(fromInstance);
955 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
957 List<RequirementDefinition> defs = new ArrayList<>();
958 RequirementDefinition def = new RequirementDefinition();
959 def.setName("requirment");
960 def.setCapability("cap");
962 requirements.put("key", defs);
963 fromOriginComponent.setRequirements(requirements);
965 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
966 List<CapabilityDefinition> caps = new ArrayList<>();
967 CapabilityDefinition capdef = new CapabilityDefinition();
968 capdef.setOwnerId("id");
969 capdef.setName("name");
970 capdef.setType("type");
972 capabilities.put("cap", caps);
974 fromOriginComponent.setCapabilities(capabilities);
976 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
977 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
980 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
981 rel, toscaRequirements, componentCache);
983 @Ignore("need to fix change in injected class.")
985 public void testAddRequirmentsWithBuildAndAddRequirements() {
986 ComponentInstance fromInstance = new ComponentInstance();
987 Component fromOriginComponent = new Resource();
988 List<ComponentInstance> instancesList = new ArrayList<>();
989 RequirementCapabilityRelDef rel = new RequirementCapabilityRelDef();
990 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
991 Map<String, Component> componentCache = new HashMap<>();
994 List<CapabilityRequirementRelationship> relationships = new ArrayList<>();
995 CapabilityRequirementRelationship cap = new CapabilityRequirementRelationship();
996 cap.setRequirement(new RequirementDataDefinition());
997 RelationshipInfo relation = new RelationshipInfo();
998 relation.setRequirementUid("Uid");
999 relation.setRequirement("requirment");
1000 relation.setCapability("cap");
1001 relation.setCapabilityOwnerId("id");
1002 cap.setRelation(relation);
1003 relationships.add(cap);
1004 rel.setRelationships(relationships);
1005 rel.setToNode("name");
1006 fromInstance.setUniqueId("name");
1007 fromInstance.setComponentUid("string");
1008 instancesList.add(fromInstance);
1009 Map<String, List<RequirementDefinition>> requirements = new HashMap<>();
1011 List<RequirementDefinition> defs = new ArrayList<>();
1012 RequirementDefinition def = new RequirementDefinition();
1013 def.setName("requirment");
1014 def.setCapability("cap");
1016 requirements.put("key", defs);
1017 fromOriginComponent.setRequirements(requirements);
1019 Map<String, List<CapabilityDefinition>> capabilities = new HashMap<>();
1020 List<CapabilityDefinition> caps = new ArrayList<>();
1021 CapabilityDefinition capdef = new CapabilityDefinition();
1022 capdef.setOwnerId("id");
1023 capdef.setName("cap");
1024 capdef.setType("type");
1026 capabilities.put("cap", caps);
1027 fromOriginComponent.setCapabilities(capabilities);
1029 Mockito.when(toscaOperationFacade.getToscaElement(Mockito.any(String.class),
1030 Mockito.any(ComponentParametersView.class))).thenReturn(Either.left(fromOriginComponent));
1032 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.any(Map.class),
1033 Mockito.any(Component.class), Mockito.any(List.class), Mockito.anyString(),Mockito.anyString()))
1034 .thenReturn(Either.right(false));
1037 result = Deencapsulation.invoke(testSubject, "addRequirement", fromInstance, fromOriginComponent, instancesList,
1038 rel, toscaRequirements, componentCache);
1040 @Ignore("need to fix change in injected class.")
1042 public void testBuildAndAddRequirement() throws Exception {
1043 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1044 Component fromOriginComponent = new Resource();
1045 Component toOriginComponent = new Resource();
1046 CapabilityDefinition capability = new CapabilityDefinition();
1047 RequirementDefinition requirement = new RequirementDefinition();
1048 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1049 ComponentInstance toInstance = new ComponentInstance();
1050 Map<String, Component> componentCache = new HashMap<>();
1052 capability.setPath(new ArrayList<>());
1053 reqAndRelationshipPair.setCapability("cap");
1054 requirement.setPath(new ArrayList<>());
1055 reqAndRelationshipPair.setRequirement("req");
1057 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), toOriginComponent,
1058 new ArrayList<>(),Mockito.anyString(), "cap")).thenReturn(Either.left("buildCapNameRes"));
1060 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(new HashMap<>(), fromOriginComponent,
1061 new ArrayList<>(),Mockito.anyString(), "req")).thenReturn(Either.right(false));
1064 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1065 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1068 @Ignore("need to fix change in injected class.")
1070 public void testBuildAndAddRequirementBuildSubtitutedNameReturnsValueTwice() {
1071 List<Map<String, ToscaTemplateRequirement>> toscaRequirements = new ArrayList<>();
1072 Component fromOriginComponent = new Resource();
1073 Component toOriginComponent = new Resource();
1074 CapabilityDefinition capability = new CapabilityDefinition();
1075 RequirementDefinition requirement = new RequirementDefinition();
1076 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1077 ComponentInstance toInstance = new ComponentInstance();
1078 Map<String, Component> componentCache = new HashMap<>();
1080 capability.setPath(new ArrayList<>());
1081 reqAndRelationshipPair.setCapability("cap");
1082 requirement.setPath(new ArrayList<>());
1083 reqAndRelationshipPair.setRequirement("req");
1085 Mockito.when(capabiltyRequirementConvertor.buildSubstitutedName(Mockito.anyMap(), Mockito.any(Resource.class),
1086 Mockito.anyList(), Mockito.anyString(),Mockito.anyString())).thenReturn(Either.left("buildCapNameRes"));
1089 result = Deencapsulation.invoke(testSubject, "buildAndAddRequirement", toscaRequirements, fromOriginComponent,
1090 toOriginComponent, capability, requirement, reqAndRelationshipPair, toInstance, componentCache);
1094 public void testIsRequirementBelongToRelation() throws Exception {
1096 Component originComponent = new Resource();
1097 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1098 RequirementDefinition requirement = new RequirementDefinition();
1099 String fromInstanceId = "";
1102 requirement.setName("name");
1103 reqAndRelationshipPair.setRequirement("name1");
1105 // test return false
1106 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1107 reqAndRelationshipPair, requirement, fromInstanceId);
1111 public void testIsRequirementBelongToRelationWithNonAtomicComponent() {
1113 Component originComponent = new Service();
1114 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1115 RequirementDefinition requirement = new RequirementDefinition();
1116 String fromInstanceId = "";
1119 // default test return true
1120 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToRelation", originComponent,
1121 reqAndRelationshipPair, requirement, fromInstanceId);
1125 public void testIsRequirementBelongToOwner() throws Exception {
1127 RelationshipInfo reqAndRelationshipPair = new RelationshipInfo();
1128 RequirementDefinition requirement = new RequirementDefinition();
1129 String fromInstanceId = "";
1130 Component originComponent = new Resource();
1133 requirement.setOwnerId("owner1");
1134 reqAndRelationshipPair.setRequirementOwnerId("owner");
1137 result = Deencapsulation.invoke(testSubject, "isRequirementBelongToOwner", reqAndRelationshipPair, requirement,
1138 fromInstanceId, originComponent);
1142 public void testIsCvfc() throws Exception {
1144 Component component = new Resource();
1147 component = new Service();
1149 result = Deencapsulation.invoke(testSubject, "isCvfc", component);
1153 public void testConvertCapabilities() throws Exception {
1154 Component component = new Resource();
1155 SubstitutionMapping substitutionMappings = new SubstitutionMapping();
1156 Map<String, Component> componentCache = new HashMap<>();
1157 Either<SubstitutionMapping, ToscaError> result;
1159 Mockito.when(capabiltyRequirementConvertor.convertSubstitutionMappingCapabilities(componentCache, component))
1160 .thenReturn(Either.right(ToscaError.NODE_TYPE_CAPABILITY_ERROR));
1162 // default test return isRight
1163 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, substitutionMappings,
1166 @Ignore("need to fix change in injected class.")
1168 public void testConvertCapabilities_1() throws Exception {
1169 Component component = new Resource();
1170 ToscaNodeType nodeType = new ToscaNodeType();
1171 Map<String, DataTypeDefinition> dataTypes = new HashMap<>();
1172 Either<ToscaNodeType, ToscaError> result;
1174 Map<String, ToscaCapability> capabilities = new HashMap<>();
1175 capabilities.put("key", new ToscaCapability());
1177 Mockito.when(capabiltyRequirementConvertor.convertCapabilities(Mockito.any(Map.class), component, dataTypes)).thenReturn(capabilities);
1180 result = Deencapsulation.invoke(testSubject, "convertCapabilities", component, nodeType, dataTypes);