2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.tosca.services;
23 import static org.junit.Assert.assertEquals;
24 import static org.junit.Assert.assertFalse;
25 import static org.junit.Assert.assertNotNull;
26 import static org.junit.Assert.assertNotSame;
27 import static org.junit.Assert.assertNull;
28 import static org.junit.Assert.assertTrue;
30 import java.util.AbstractMap;
31 import java.util.ArrayList;
32 import java.util.Collections;
33 import java.util.HashMap;
34 import java.util.List;
36 import java.util.Optional;
37 import java.util.stream.Collectors;
38 import java.util.stream.Stream;
40 import org.apache.commons.collections4.MapUtils;
41 import org.junit.Assert;
42 import org.junit.Rule;
43 import org.junit.Test;
44 import org.junit.rules.ExpectedException;
45 import org.junit.runner.RunWith;
46 import org.mockito.runners.MockitoJUnitRunner;
47 import org.onap.sdc.tosca.datatypes.model.AttributeDefinition;
48 import org.onap.sdc.tosca.datatypes.model.CapabilityDefinition;
49 import org.onap.sdc.tosca.datatypes.model.EntrySchema;
50 import org.onap.sdc.tosca.datatypes.model.GroupDefinition;
51 import org.onap.sdc.tosca.datatypes.model.Import;
52 import org.onap.sdc.tosca.datatypes.model.NodeTemplate;
53 import org.onap.sdc.tosca.datatypes.model.NodeType;
54 import org.onap.sdc.tosca.datatypes.model.ParameterDefinition;
55 import org.onap.sdc.tosca.datatypes.model.PolicyDefinition;
56 import org.onap.sdc.tosca.datatypes.model.PropertyDefinition;
57 import org.onap.sdc.tosca.datatypes.model.RelationshipTemplate;
58 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
59 import org.onap.sdc.tosca.datatypes.model.RequirementDefinition;
60 import org.onap.sdc.tosca.datatypes.model.ServiceTemplate;
61 import org.onap.sdc.tosca.datatypes.model.SubstitutionMapping;
62 import org.onap.sdc.tosca.datatypes.model.TopologyTemplate;
63 import org.onap.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
64 import org.openecomp.sdc.common.errors.CoreException;
65 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
69 * @since September 15, 2016.
71 @RunWith(MockitoJUnitRunner.class)
72 public class DataModelUtilTest {
74 private static final String REQUIREMENT_ID = "requirementId";
75 private static final String REQUIREMENT_DEFINITION_ID = "requirementDefinitionId";
76 private static final String NODE_TEMPLATE_ID = "nodeTemplateId";
77 private static final String NODE_TYPE_ID = "nodeTypeId";
78 private static final String CAPABILITY_ID = "capabilityId";
79 private static final String PROPERTY_ID = "propertyId";
80 private static final String NODE_TYPE_KEY = "nodeTypeKey";
81 private static final String TEMPLATE_NAME = "templateName";
82 private static final String OUTPUT_ID = "outputId";
83 private static final String REQUIREMENT_KEY = "requirementKey";
84 private static final String NODE_ID = "nodeId";
85 private static final String PARAMETER_ID = "parameterId";
86 private static final String ENTRY_ID = "entryId";
87 private static final String PROPERTY_DEF_TYPE = "propertyDefType";
90 public ExpectedException thrown = ExpectedException.none();
93 public void testAddSubstitutionMappingTopolgyTemplateNull() {
94 ServiceTemplate serviceTemplate = new ServiceTemplate();
95 DataModelUtil.addSubstitutionMapping(serviceTemplate, new SubstitutionMapping());
97 Assert.assertNotNull(serviceTemplate.getTopology_template());
98 Assert.assertNotNull(serviceTemplate.getTopology_template().getSubstitution_mappings());
102 public void testAddSubstitutionMapping() throws Exception {
103 thrown.expect(CoreException.class);
104 thrown.expectMessage(
105 "Invalid action, can't add 'Substitution Mapping' to 'Service Template', 'Service Template' entity is NULL.");
106 DataModelUtil.addSubstitutionMapping(null, new SubstitutionMapping());
110 public void testGetDirectivesNodeTemplateNull() {
111 assertTrue(DataModelUtil.getDirectives(null).isEmpty());
115 public void testGetDirectivesWhenDirectivesNull() {
116 assertTrue(DataModelUtil.getDirectives(new NodeTemplate()).isEmpty());
120 public void testGetDirectives() {
121 NodeTemplate nodeTemplate = new NodeTemplate();
122 nodeTemplate.setDirectives(Collections.singletonList("directive"));
124 Assert.assertEquals(1, DataModelUtil.getDirectives(nodeTemplate).size());
128 public void testAddSubstitutionMappingReq() {
129 ServiceTemplate serviceTemplate = new ServiceTemplate();
130 DataModelUtil.addSubstitutionMappingReq(serviceTemplate,
131 REQUIREMENT_ID, Collections.singletonList("requirement"));
133 Assert.assertNotNull(serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements());
134 Assert.assertEquals(1,
135 serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements().size());
139 public void testAddSubstitutionMappingReqServiceTemplateNull() {
140 thrown.expect(CoreException.class);
141 thrown.expectMessage(
142 "Invalid action, can't add 'Substitution Mapping Requirements' to 'Service Template', 'Service Template' entity is NULL.");
143 DataModelUtil.addSubstitutionMappingReq(null, REQUIREMENT_ID, Collections.emptyList());
147 public void testAddSubstitutionMappingCapabilityServiceTemplateNull() {
148 thrown.expect(CoreException.class);
149 thrown.expectMessage(
150 "Invalid action, can't add 'Substitution Mapping Capabilities' to 'Service Template', 'Service Template' entity is NULL.");
151 DataModelUtil.addSubstitutionMappingCapability(null, CAPABILITY_ID, Collections.emptyList());
155 public void testAddSubstitutionMappingCapability() {
156 ServiceTemplate serviceTemplate = new ServiceTemplate();
157 DataModelUtil.addSubstitutionMappingCapability(serviceTemplate,
158 CAPABILITY_ID, Collections.singletonList("requirement"));
160 Assert.assertNotNull(serviceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities());
161 Assert.assertEquals(1,
162 serviceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities().size());
166 public void testGetNodeTemplatesNull() {
167 ServiceTemplate serviceTemplate = new ServiceTemplate();
168 serviceTemplate.setTopology_template(new TopologyTemplate());
170 Map<String, NodeTemplate> nodeTemplateMap = DataModelUtil.getNodeTemplates(serviceTemplate);
172 Assert.assertNotNull(nodeTemplateMap);
173 assertTrue(MapUtils.isEmpty(nodeTemplateMap));
177 public void testGetNodeTemplates() {
178 ServiceTemplate serviceTemplate = new ServiceTemplate();
179 serviceTemplate.setTopology_template(new TopologyTemplate());
181 Map<String, NodeTemplate> nodeTemplateMap = Stream.of(new AbstractMap.SimpleEntry<>("nodeTemplate1", new
182 NodeTemplate())).collect(
183 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
185 serviceTemplate.getTopology_template().setNode_templates(nodeTemplateMap);
187 nodeTemplateMap = DataModelUtil.getNodeTemplates(serviceTemplate);
189 Assert.assertNotNull(nodeTemplateMap);
190 Assert.assertEquals(1, nodeTemplateMap.size());
194 public void testGetGroupsNull() {
195 ServiceTemplate serviceTemplate = new ServiceTemplate();
196 serviceTemplate.setTopology_template(new TopologyTemplate());
198 Map<String, GroupDefinition> nodeTemplateMap = DataModelUtil.getGroups(serviceTemplate);
200 Assert.assertNotNull(nodeTemplateMap);
201 assertTrue(MapUtils.isEmpty(nodeTemplateMap));
205 public void testGetGroups() {
206 ServiceTemplate serviceTemplate = new ServiceTemplate();
207 serviceTemplate.setTopology_template(new TopologyTemplate());
209 Map<String, GroupDefinition> nodeTemplateMap = Stream.of(new AbstractMap.SimpleEntry<>("group1", new
210 GroupDefinition())).collect(
211 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
213 serviceTemplate.getTopology_template().setGroups(nodeTemplateMap);
215 nodeTemplateMap = DataModelUtil.getGroups(serviceTemplate);
217 Assert.assertNotNull(nodeTemplateMap);
218 Assert.assertEquals(1, nodeTemplateMap.size());
222 public void testAddNodeTemplateServiceTemplateNull() {
223 thrown.expect(CoreException.class);
224 thrown.expectMessage(
225 "Invalid action, can't add 'Node Template' to 'Service Template', 'Service Template' entity is NULL.");
226 DataModelUtil.addNodeTemplate(null, "123", new NodeTemplate());
230 public void testAddNodeTemplate() {
231 ServiceTemplate serviceTemplate = new ServiceTemplate();
232 DataModelUtil.addNodeTemplate(serviceTemplate, NODE_TEMPLATE_ID, new NodeTemplate());
234 assertEquals(1, serviceTemplate.getTopology_template().getNode_templates().size());
238 public void testAddNodeTypeCapabilitiesDefCapabilitiesNull() {
239 NodeType nodeType = new NodeType();
240 DataModelUtil.addNodeTypeCapabilitiesDef(nodeType, null);
242 assertNull(nodeType.getCapabilities());
245 @Test(expected = CoreException.class)
246 public void testAddNodeTypeCapabilitiesDefThrowsException() {
247 Map<String, CapabilityDefinition> capabilityDefinitionMap =
248 Stream.of(new AbstractMap.SimpleEntry<>(CAPABILITY_ID, new
249 CapabilityDefinition())).collect(
250 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
252 DataModelUtil.addNodeTypeCapabilitiesDef(null, capabilityDefinitionMap);
256 public void testAddNodeTypeCapabilitiesDef() {
257 NodeType nodeType = new NodeType();
258 Map<String, CapabilityDefinition> capabilityDefinitionMap =
259 Stream.of(new AbstractMap.SimpleEntry<>(CAPABILITY_ID, new
260 CapabilityDefinition())).collect(
261 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
263 DataModelUtil.addNodeTypeCapabilitiesDef(nodeType, capabilityDefinitionMap);
265 Assert.assertEquals(1, nodeType.getCapabilities().size());
269 public void testSetNodeTypeCapabilitiesDefCapabilitiesNull() {
270 NodeType nodeType = new NodeType();
271 DataModelUtil.setNodeTypeCapabilitiesDef(nodeType, null);
273 assertNull(nodeType.getCapabilities());
276 @Test(expected = CoreException.class)
277 public void testSetNodeTypeCapabilitiesDefThrowsException() {
278 Map<String, CapabilityDefinition> capabilityDefinitionMap =
279 Stream.of(new AbstractMap.SimpleEntry<>(CAPABILITY_ID,
280 new CapabilityDefinition())).collect(
281 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
283 DataModelUtil.setNodeTypeCapabilitiesDef(null, capabilityDefinitionMap);
287 public void testSetNodeTypeCapabilitiesDef() {
288 NodeType nodeType = new NodeType();
289 Map<String, CapabilityDefinition> capabilityDefinitionMap =
290 Stream.of(new AbstractMap.SimpleEntry<>(CAPABILITY_ID, new
291 CapabilityDefinition())).collect(
292 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
294 DataModelUtil.setNodeTypeCapabilitiesDef(nodeType, capabilityDefinitionMap);
296 Assert.assertEquals(1, nodeType.getCapabilities().size());
300 public void testGetCapabilityDefinitionCapabilityDefinitionIdNull() {
301 NodeType nodeType = new NodeType();
302 nodeType.setCapabilities(new HashMap<>());
303 assertFalse(DataModelUtil.getCapabilityDefinition(nodeType, null).isPresent());
307 public void testGetCapabilityDefinition() {
308 NodeType nodeType = new NodeType();
309 nodeType.setCapabilities(Collections.singletonMap("capabilityDefinitionId", new CapabilityDefinition()));
310 assertTrue(DataModelUtil.getCapabilityDefinition(nodeType, "capabilityDefinitionId").isPresent());
314 public void testAddPolicyDefinitionThrowsException() {
315 thrown.expect(CoreException.class);
316 thrown.expectMessage(
317 "Invalid action, can't add 'Policy Definition' to 'Service Template', 'Service Template' entity is NULL.");
318 DataModelUtil.addPolicyDefinition(null, "policyId", new PolicyDefinition());
322 public void testAddPolicyDefinition() {
323 ServiceTemplate serviceTemplate = new ServiceTemplate();
324 DataModelUtil.addPolicyDefinition(serviceTemplate, "policyId", new PolicyDefinition());
325 assertEquals(1, serviceTemplate.getTopology_template().getPolicies().size());
329 public void testAddNodeTypeThrowsException() {
330 thrown.expect(CoreException.class);
331 thrown.expectMessage(
332 "Invalid action, can't add 'Node Type' to 'Service Template', 'Service Template' entity is NULL.");
333 DataModelUtil.addNodeType(null, NODE_TYPE_ID, new NodeType());
337 public void testAddNodeType() {
338 ServiceTemplate serviceTemplate = new ServiceTemplate();
339 DataModelUtil.addNodeType(serviceTemplate, NODE_TYPE_ID, new NodeType());
341 assertEquals(1, serviceTemplate.getNode_types().size());
345 public void testAddRelationshipTemplateThrowsException() {
346 thrown.expect(CoreException.class);
347 thrown.expectMessage(
348 "Invalid action, can't add 'Relationship Template' to 'Service Template', 'Service Template' entity is NULL.");
349 DataModelUtil.addRelationshipTemplate(null, "relationshipTemplateId", new RelationshipTemplate());
353 public void testAddRelationshipTemplate() {
354 ServiceTemplate serviceTemplate = new ServiceTemplate();
355 DataModelUtil.addRelationshipTemplate(serviceTemplate, "relationshipTemplateId", new RelationshipTemplate());
357 assertEquals(1, serviceTemplate.getTopology_template().getRelationship_templates().size());
361 public void testAddRequirementAssignmentThrowsException() {
362 thrown.expect(CoreException.class);
363 thrown.expectMessage(
364 "Invalid action, can't add 'Requirement Assignment' to 'Node Template', 'Node Template' entity is NULL.");
365 DataModelUtil.addRequirementAssignment(null, REQUIREMENT_ID, new RequirementAssignment());
368 @Test(expected = CoreException.class)
369 public void testAddRequirementAssignmentNodeNotAssigned() {
370 DataModelUtil.addRequirementAssignment(new NodeTemplate(), REQUIREMENT_ID, new RequirementAssignment());
374 public void testAddRequirementAssignment() {
375 NodeTemplate nodeTemplate = new NodeTemplate();
376 RequirementAssignment requirementAssignment = new RequirementAssignment();
377 requirementAssignment.setNode("node");
378 DataModelUtil.addRequirementAssignment(nodeTemplate, REQUIREMENT_ID, requirementAssignment);
380 assertEquals(1, nodeTemplate.getRequirements().size());
384 public void testCreateAttachmentRequirementAssignment() {
385 assertNotNull(DataModelUtil.createAttachmentRequirementAssignment("node"));
389 public void testGetNodeTemplate() {
390 ServiceTemplate serviceTemplate = new ServiceTemplate();
391 serviceTemplate.setTopology_template(new TopologyTemplate());
393 assertNull(DataModelUtil.getNodeTemplate(serviceTemplate, NODE_TEMPLATE_ID));
397 public void testGetNodeType() {
398 assertNull(DataModelUtil.getNodeType(new ServiceTemplate(), NODE_TYPE_ID));
402 public void testGetRequirementDefinitionRequirementIdIsNull() {
403 assertFalse(DataModelUtil.getRequirementDefinition(new NodeType(), null).isPresent());
407 public void testGetRequirementDefinitionListIsEmpty() {
408 NodeType nodeType = new NodeType();
410 nodeType.setRequirements(Collections.emptyList());
411 assertFalse(DataModelUtil.getRequirementDefinition(new NodeType(), REQUIREMENT_DEFINITION_ID).isPresent());
415 public void testGetRequirementDefinitionWrongKey() {
416 Map<String, RequirementDefinition> requirementDefinitionMap =
417 Stream.of(new AbstractMap.SimpleEntry<>(REQUIREMENT_ID, new RequirementDefinition()))
418 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
420 assertFalse(DataModelUtil.getRequirementDefinition(Collections.singletonList(requirementDefinitionMap),
421 "wrongKey").isPresent());
425 public void testAddGroupToTopologyTemplateThrowsException() {
426 thrown.expect(CoreException.class);
427 thrown.expectMessage(
428 "Invalid action, can't add 'Group Definition' to 'Service Template', 'Service Template' entity is NULL.");
429 DataModelUtil.addGroupDefinitionToTopologyTemplate(null, "groupId", new GroupDefinition());
433 public void testAddGroupToTopologyTemplate() {
434 ServiceTemplate serviceTemplate = new ServiceTemplate();
436 DataModelUtil.addGroupDefinitionToTopologyTemplate(serviceTemplate, "groupId", new GroupDefinition());
438 assertEquals(1, serviceTemplate.getTopology_template().getGroups().size());
442 public void testAddRequirementToList() {
443 Map<String, RequirementDefinition> requirementDefinitionMap = new HashMap<>();
444 requirementDefinitionMap.put("requirmentDefinitionId", new RequirementDefinition());
446 List<Map<String, RequirementDefinition>> mapList = new ArrayList<>();
448 DataModelUtil.addRequirementToList(mapList, requirementDefinitionMap);
450 assertEquals(1, mapList.size());
454 public void testAddGroupMemberGroupNotExist() {
455 ServiceTemplate serviceTemplate = new ServiceTemplate();
456 serviceTemplate.setTopology_template(new TopologyTemplate());
457 DataModelUtil.addGroupMember(serviceTemplate, "groupName", "memberId");
459 assertNull(serviceTemplate.getTopology_template().getGroups());
463 public void testAddGroupMemberGroup() {
464 ServiceTemplate serviceTemplate = new ServiceTemplate();
465 serviceTemplate.setTopology_template(new TopologyTemplate());
466 Map<String, GroupDefinition> groupDefinitionMap =
467 Stream.of(new AbstractMap.SimpleEntry<>("groupName", new GroupDefinition()))
468 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
470 serviceTemplate.getTopology_template().setGroups(groupDefinitionMap);
472 DataModelUtil.addGroupMember(serviceTemplate, "groupName", "memberId");
474 assertEquals(1, serviceTemplate.getTopology_template().getGroups().size());
478 public void testCreateParameterDefinition() {
479 assertNotNull(DataModelUtil
480 .createParameterDefinition("parameterType", "description", true, Collections.emptyList(), new
481 EntrySchema(), null));
485 public void testCreateRequirement() {
486 assertNotNull(DataModelUtil.createRequirement("capability", "node", "relationShip", new Object[1]));
490 public void testCreateEntrySchema() {
491 assertNull(DataModelUtil.createEntrySchema(null, null, null));
495 public void testCreateGetInputPropertyValueFromListParameter() {
496 Map inputPropertyMap = DataModelUtil.createGetInputPropertyValueFromListParameter("inputPropertyList", 1,
497 "nestedPropertyName");
499 assertNotNull(inputPropertyMap.get(ToscaFunctions.GET_INPUT.getFunctionName()));
503 public void testConvertPropertyDefToParameterDefNull() {
504 assertNull(DataModelUtil.convertPropertyDefToParameterDef(null));
508 public void testConvertPropertyDefToParameterDef() {
509 PropertyDefinition propertyDefinition = new PropertyDefinition();
510 propertyDefinition.setType(PROPERTY_DEF_TYPE);
512 ParameterDefinitionExt parameterDefinitionExt =
513 DataModelUtil.convertPropertyDefToParameterDef(propertyDefinition);
514 assertNotNull(parameterDefinitionExt);
515 assertEquals(PROPERTY_DEF_TYPE, parameterDefinitionExt.getType());
519 public void testConvertAttributeDefToParameterDefAttDefNull() {
520 assertNull(DataModelUtil.convertAttributeDefToParameterDef(null, null));
524 public void testConvertAttributeDefToParameterDef() {
525 ParameterDefinitionExt parameterDefinitionExt =
526 DataModelUtil.convertAttributeDefToParameterDef(new AttributeDefinition(), Collections.emptyMap());
528 assertTrue(MapUtils.isEmpty((Map) parameterDefinitionExt.getValue()));
532 public void testIsNodeTemplateTrue() {
533 ServiceTemplate serviceTemplate = new ServiceTemplate();
534 TopologyTemplate topologyTemplate = new TopologyTemplate();
536 serviceTemplate.setTopology_template(topologyTemplate);
538 Map<String, NodeTemplate> nodeTemplateMap =
539 Stream.of(new AbstractMap.SimpleEntry<>(ENTRY_ID, new NodeTemplate()))
540 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
541 topologyTemplate.setNode_templates(nodeTemplateMap);
543 assertTrue(DataModelUtil.isNodeTemplate(ENTRY_ID, serviceTemplate));
547 public void testIsNodeTemplateEntryMissing() {
548 ServiceTemplate serviceTemplate = new ServiceTemplate();
549 TopologyTemplate topologyTemplate = new TopologyTemplate();
551 serviceTemplate.setTopology_template(topologyTemplate);
552 topologyTemplate.setNode_templates(Collections.emptyMap());
554 assertFalse(DataModelUtil.isNodeTemplate(ENTRY_ID, serviceTemplate));
557 @Test(expected = CoreException.class)
558 public void testAddInputParameterToTopologyTemplateServiceTemplateNull() {
559 DataModelUtil.addInputParameterToTopologyTemplate(null, null, null);
563 public void testAddInputParameterToTopologyTemplate() {
564 ServiceTemplate serviceTemplate = new ServiceTemplate();
565 DataModelUtil.addInputParameterToTopologyTemplate(serviceTemplate, PARAMETER_ID, new ParameterDefinition());
567 assertEquals(1, serviceTemplate.getTopology_template().getInputs().size());
570 @Test(expected = CoreException.class)
571 public void testAddOutputParameterToTopologyTemplateServiceTemplateNull() {
572 DataModelUtil.addOutputParameterToTopologyTemplate(null, null, null);
576 public void testAddOutputParameterToTopologyTemplate() {
577 ServiceTemplate serviceTemplate = new ServiceTemplate();
578 DataModelUtil.addOutputParameterToTopologyTemplate(serviceTemplate, PARAMETER_ID, new ParameterDefinition());
580 assertEquals(1, serviceTemplate.getTopology_template().getOutputs().size());
584 public void testGetNodeTemplateRequirementsNodeTemplateNull() {
585 assertNull(DataModelUtil.getNodeTemplateRequirements(null));
589 public void testGetNodeTemplateRequirementsNodeTemplateRequirementsNull() {
590 assertTrue(MapUtils.isEmpty(DataModelUtil.getNodeTemplateRequirements(new NodeTemplate())));
594 public void testGetNodeTemplateRequirementListNodeTemplateRequirementListNull() {
595 assertNull(DataModelUtil.getNodeTemplateRequirementList(new NodeTemplate()));
599 public void testGetNodeTemplateRequirementList() {
600 Map<String, RequirementAssignment> requirementAssignmentMap =
601 Stream.of(new AbstractMap.SimpleEntry<>(REQUIREMENT_ID, new RequirementAssignment()))
602 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
604 List<Map<String, RequirementAssignment>> requirementList = new ArrayList<>();
605 requirementList.add(requirementAssignmentMap);
607 NodeTemplate nodeTemplate = new NodeTemplate();
608 nodeTemplate.setRequirements(requirementList);
610 assertEquals(requirementList.size(), DataModelUtil.getNodeTemplateRequirementList(nodeTemplate).size());
614 public void testGetRequirementAssignmentRequirementAssignmentListEmpty() {
615 assertFalse(DataModelUtil.getRequirementAssignment(null, null).isPresent());
619 public void testGetRequirementAssignmentRequirementAssignmentListDoseNotContainsKeyPassed() {
620 assertFalse(DataModelUtil.getRequirementAssignment(
621 Collections.singletonList(new HashMap<>()), REQUIREMENT_KEY).isPresent());
625 public void testGetRequirementAssignmentRequirementAssignmentListContainsKeyPassed() {
626 Map<String, RequirementAssignment> requirementAssignmentMap =
627 Stream.of(new AbstractMap.SimpleEntry<>(REQUIREMENT_KEY, new RequirementAssignment()))
628 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
630 assertTrue(DataModelUtil.getRequirementAssignment(
631 Collections.singletonList(requirementAssignmentMap), REQUIREMENT_KEY).isPresent());
635 public void testRemoveRequirementsDefinition() {
636 Map<String, RequirementDefinition> requirementDefinitionMap =
637 Stream.of(new AbstractMap.SimpleEntry<>(REQUIREMENT_KEY, new RequirementDefinition()))
638 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
641 List<Map<String, RequirementDefinition>> requirementList =
642 Stream.of(requirementDefinitionMap).collect(Collectors.toList());
643 DataModelUtil.removeRequirementsDefinition(requirementList, REQUIREMENT_KEY);
645 assertTrue(requirementList.isEmpty());
649 public void testRemoveRequirementsAssignment() {
650 Map<String, RequirementAssignment> requirementDefinitionMap =
651 Stream.of(new AbstractMap.SimpleEntry<>(REQUIREMENT_KEY, new RequirementAssignment()))
652 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
655 List<Map<String, RequirementAssignment>> requirementList =
656 Stream.of(requirementDefinitionMap).collect(Collectors.toList());
657 DataModelUtil.removeRequirementsAssignment(requirementList, REQUIREMENT_KEY);
659 assertTrue(requirementList.isEmpty());
663 public void testRemoveRequirementAssignmentNodeTemplate() {
665 RequirementAssignment requirementAssignment = new RequirementAssignment();
666 requirementAssignment.setNode(NODE_ID);
667 requirementAssignment.setCapability(CAPABILITY_ID);
668 requirementAssignment.setRelationship("relationshipId");
669 Map<String, RequirementAssignment> requirementDefinitionMap =
670 Stream.of(new AbstractMap.SimpleEntry<>(REQUIREMENT_KEY, requirementAssignment))
671 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
673 List<Map<String, RequirementAssignment>> requirementList =
674 Stream.of(requirementDefinitionMap).collect(Collectors.toList());
675 NodeTemplate nodeTemplate = new NodeTemplate();
676 nodeTemplate.setRequirements(requirementList);
678 RequirementAssignment requirementAssignment1 = new RequirementAssignment();
679 requirementAssignment1.setNode(NODE_ID);
680 requirementAssignment1.setCapability(CAPABILITY_ID);
681 requirementAssignment1.setRelationship("relationshipId");
682 DataModelUtil.removeRequirementAssignment(nodeTemplate, REQUIREMENT_KEY, requirementAssignment);
684 assertTrue(requirementList.isEmpty());
688 public void testGetNamespaceSuffixNull() {
689 assertNull(DataModelUtil.getNamespaceSuffix(null));
693 public void testGetNamespaceSuffix() {
694 assertEquals("suffix", DataModelUtil.getNamespaceSuffix("name.suffix"));
698 public void testIsImportAddedToServiceTemplateImportIdExists() {
699 Map<String, Import> importMap = Stream.of(new AbstractMap.SimpleEntry<>("imp1", new Import())).collect
700 (Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
702 assertTrue(DataModelUtil.isImportAddedToServiceTemplate(Collections.singletonList(importMap), "imp1"));
706 public void testIsImportAddedToServiceTemplateImportIdNotExists() {
707 Map<String, Import> importMap = Stream.of(new AbstractMap.SimpleEntry<>("imp1", new Import())).collect
708 (Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
710 assertFalse(DataModelUtil.isImportAddedToServiceTemplate(Collections.singletonList(importMap), "imp2"));
714 public void testGetOutputParameterOutputIsNull() {
715 ServiceTemplate serviceTemplate = new ServiceTemplate();
716 serviceTemplate.setTopology_template(new TopologyTemplate());
718 assertNull(DataModelUtil.getOuputParameter(serviceTemplate, OUTPUT_ID));
722 public void testGetOutputParameter() {
723 ServiceTemplate serviceTemplate = new ServiceTemplate();
724 serviceTemplate.setTopology_template(new TopologyTemplate());
726 Map<String, ParameterDefinition> outputMap = Stream.of(new AbstractMap.SimpleEntry<>(OUTPUT_ID, new
727 ParameterDefinition())).collect
728 (Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
729 serviceTemplate.getTopology_template().setOutputs(outputMap);
731 assertNotNull(DataModelUtil.getOuputParameter(serviceTemplate, OUTPUT_ID));
735 public void testGetInputParametersNull() {
736 ServiceTemplate serviceTemplate = new ServiceTemplate();
737 serviceTemplate.setTopology_template(new TopologyTemplate());
739 assertNull(DataModelUtil.getInputParameters(serviceTemplate));
743 public void testGetInputParameters() {
744 ServiceTemplate serviceTemplate = new ServiceTemplate();
745 serviceTemplate.setTopology_template(new TopologyTemplate());
747 serviceTemplate.getTopology_template().setInputs(new HashMap<>());
749 assertNotNull(DataModelUtil.getInputParameters(serviceTemplate));
753 public void testGetRelationshipTemplatesNull() {
754 ServiceTemplate serviceTemplate = new ServiceTemplate();
755 serviceTemplate.setTopology_template(new TopologyTemplate());
757 assertNull(DataModelUtil.getInputParameters(serviceTemplate));
761 public void testGetRelationshipTemplates() {
762 ServiceTemplate serviceTemplate = new ServiceTemplate();
763 serviceTemplate.setTopology_template(new TopologyTemplate());
765 serviceTemplate.getTopology_template().setRelationship_templates(new HashMap<>());
767 assertNotNull(DataModelUtil.getRelationshipTemplates(serviceTemplate));
771 public void testGetPropertyValuePropertyNotPresent() {
772 NodeTemplate nodeTemplate = new NodeTemplate();
773 Map<String, Object> objectMap = Stream.of(new AbstractMap.SimpleEntry<>(PROPERTY_ID, new PropertyDefinition()))
774 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
776 nodeTemplate.setProperties(objectMap);
777 assertNull(DataModelUtil.getPropertyValue(nodeTemplate, "wrongId"));
781 public void testGetPropertyValue() {
782 NodeTemplate nodeTemplate = new NodeTemplate();
783 Map<String, Object> objectMap = Stream.of(new AbstractMap.SimpleEntry<>(PROPERTY_ID, new PropertyDefinition()))
784 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
786 nodeTemplate.setProperties(objectMap);
787 assertNotNull(DataModelUtil.getPropertyValue(nodeTemplate, PROPERTY_ID));
791 public void testGetNodeTemplatePropertiesPresent() {
792 ServiceTemplate serviceTemplate = new ServiceTemplate();
793 serviceTemplate.setTopology_template(new TopologyTemplate());
794 NodeTemplate nodeTemplate = new NodeTemplate();
795 nodeTemplate.setProperties(new HashMap<>());
796 Map<String, NodeTemplate> nodeTemplateMap =
797 Stream.of(new AbstractMap.SimpleEntry<>(NODE_TEMPLATE_ID, nodeTemplate))
798 .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
800 serviceTemplate.getTopology_template().setNode_templates(nodeTemplateMap);
802 assertNotNull(DataModelUtil.getNodeTemplateProperties(serviceTemplate, NODE_TEMPLATE_ID));
806 public void testGetNodeTemplatePropertiesNotPresent() {
807 ServiceTemplate serviceTemplate = new ServiceTemplate();
808 serviceTemplate.setTopology_template(new TopologyTemplate());
809 NodeTemplate nodeTemplate = new NodeTemplate();
810 nodeTemplate.setProperties(new HashMap<>());
812 serviceTemplate.getTopology_template().setNode_templates(new HashMap<>());
814 assertNull(DataModelUtil.getNodeTemplateProperties(serviceTemplate, NODE_TEMPLATE_ID));
818 public void testGetSubstitutionMappingsNullCheck() {
819 ServiceTemplate serviceTemplate = new ServiceTemplate();
820 serviceTemplate.setTopology_template(new TopologyTemplate());
821 assertNull(DataModelUtil.getSubstitutionMappings(serviceTemplate));
825 public void testGetClonedObject() {
826 RequirementAssignment requirementAssignment = new RequirementAssignment();
827 requirementAssignment.setNode(NODE_ID);
829 Object obj = DataModelUtil.getClonedObject(requirementAssignment, requirementAssignment.getClass());
831 assertTrue(obj instanceof RequirementAssignment);
832 RequirementAssignment assignment = (RequirementAssignment) obj;
833 assertNotSame(assignment, requirementAssignment);
837 public void testGetCloneObject() {
838 RequirementAssignment requirementAssignment = new RequirementAssignment();
839 requirementAssignment.setNode(NODE_ID);
841 assertNotSame(DataModelUtil.getClonedObject(requirementAssignment), requirementAssignment);
845 public void testGetCloneObjectSerializableObject() {
846 List<String> stringList = new ArrayList<>();
848 assertNotSame(DataModelUtil.getClonedObject(stringList), stringList);
852 public void testAddSubstitutionFilteringProperty() {
853 NodeTemplate nodeTemplate = new NodeTemplate();
854 nodeTemplate.setProperties(new HashMap<>());
856 DataModelUtil.addSubstitutionFilteringProperty(TEMPLATE_NAME, nodeTemplate, 5);
858 assertNotNull(nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME));
862 public void testAddBindingReqFromPortToCompute() {
863 NodeTemplate nodeTemplate = new NodeTemplate();
865 DataModelUtil.addBindingReqFromPortToCompute("computeNodeId", nodeTemplate);
867 assertNotNull(nodeTemplate.getRequirements());
868 assertEquals(1, nodeTemplate.getRequirements().size());
872 public void testCreateSubstitutionTemplateSubMappingCapabilityAndRequirementNull() {
873 Map<String, Map<String, List<String>>> mapping = new HashMap<>();
875 Map<String, List<String>> capabilityStringList = new HashMap<>();
876 capabilityStringList.put(CAPABILITY_ID, Collections.singletonList("test"));
878 Map<String, List<String>> requirementStringList = new HashMap<>();
879 capabilityStringList.put(REQUIREMENT_ID, Collections.singletonList("test"));
881 mapping.put(ToscaConstants.CAPABILITY, capabilityStringList);
882 mapping.put(ToscaConstants.REQUIREMENT, requirementStringList);
884 NodeType nodeType = new NodeType();
886 Map<String, CapabilityDefinition> capabilityMap = new HashMap<>();
887 capabilityMap.put(CAPABILITY_ID, new CapabilityDefinition());
889 Map<String, RequirementDefinition> requirementMap = new HashMap<>();
890 requirementMap.put(REQUIREMENT_ID, new RequirementDefinition());
892 nodeType.setRequirements(Collections.singletonList(requirementMap));
893 nodeType.setCapabilities(capabilityMap);
895 assertNotNull(DataModelUtil.createSubstitutionTemplateSubMapping(NODE_TYPE_KEY, nodeType, mapping));
899 public void testCreateSubstitutionTemplateSubMapping() {
900 Map<String, Map<String, List<String>>> mapping = new HashMap<>();
901 mapping.put(ToscaConstants.CAPABILITY, null);
902 mapping.put(ToscaConstants.REQUIREMENT, null);
904 assertNotNull(DataModelUtil.createSubstitutionTemplateSubMapping(NODE_TYPE_KEY, new NodeType(), mapping));
908 public void testAddNodeTemplateCapability() {
909 NodeTemplate nodeTemplate = new NodeTemplate();
911 DataModelUtil.addNodeTemplateCapability(nodeTemplate, CAPABILITY_ID, null, null);
912 assertNotNull(nodeTemplate.getCapabilities());
916 public void testAddSubstitutionNodeTypeRequirements() {
918 NodeType nodeType = new NodeType();
920 Map<String, RequirementDefinition> requirementDefinitionMap = new HashMap<>();
921 requirementDefinitionMap.put(REQUIREMENT_ID, new RequirementDefinition());
923 DataModelUtil.addSubstitutionNodeTypeRequirements(
924 nodeType, Collections.singletonList(requirementDefinitionMap), TEMPLATE_NAME);
926 assertEquals(1, nodeType.getRequirements().size());
927 assertNotNull(nodeType.getRequirements().get(0).get("requirementId_templateName"));
931 public void testIsNodeTemplateSectionMissingFromServiceTemplateNodeTemplateMissing() {
932 ServiceTemplate serviceTemplate = new ServiceTemplate();
933 serviceTemplate.setTopology_template(new TopologyTemplate());
935 assertTrue(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(serviceTemplate));
939 public void testIsNodeTemplateSectionMissingFromServiceTemplateTopologyTemplateMissing() {
940 ServiceTemplate serviceTemplate = new ServiceTemplate();
942 assertTrue(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(serviceTemplate));
946 public void testIsNodeTemplateSectionMissingFromServiceTemplate() {
947 ServiceTemplate serviceTemplate = new ServiceTemplate();
948 serviceTemplate.setTopology_template(new TopologyTemplate());
950 Map<String, NodeTemplate> nodeTemplateMap = new HashMap<>();
951 nodeTemplateMap.put(NODE_TEMPLATE_ID, new NodeTemplate());
952 serviceTemplate.getTopology_template().setNode_templates(nodeTemplateMap);
954 assertFalse(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(serviceTemplate));
958 public void testGetRelationshipTemplate() {
959 RelationshipTemplate relationshipTemplate = new RelationshipTemplate();
960 String testingRelationshipType = "testingRelationshipType";
961 relationshipTemplate.setType(testingRelationshipType);
962 TopologyTemplate topologyTemplate = new TopologyTemplate();
963 topologyTemplate.setRelationship_templates(new HashMap<>());
964 String relationId = "rtest";
965 topologyTemplate.getRelationship_templates().put(relationId, relationshipTemplate);
966 ServiceTemplate serviceTemplate = new ServiceTemplate();
967 serviceTemplate.setTopology_template(topologyTemplate);
969 Optional<RelationshipTemplate> relationshipTemplateOut =
970 DataModelUtil.getRelationshipTemplate(serviceTemplate, relationId);
971 Assert.assertNotNull(relationshipTemplateOut);
972 Assert.assertEquals(true, relationshipTemplateOut.isPresent());
973 Assert.assertEquals(testingRelationshipType, relationshipTemplateOut.get().getType());
977 public void testGetEmptyRelationshipTemplate() {
978 ServiceTemplate serviceTemplate = new ServiceTemplate();
979 String relationId = "rtest";
980 Optional<RelationshipTemplate> relationshipTemplateOut =
981 DataModelUtil.getRelationshipTemplate(serviceTemplate, relationId);
982 Assert.assertNotNull(relationshipTemplateOut);
983 Assert.assertEquals(false, relationshipTemplateOut.isPresent());
987 public void testAddNodeTemplateProperty() {
988 NodeTemplate nodeTemplate = new NodeTemplate();
990 DataModelUtil.addNodeTemplateProperty(nodeTemplate, PROPERTY_ID, null);
992 assertNotNull(nodeTemplate.getProperties());