openecomp-be/lib/openecomp-tosca-lib/src/test/java/org/openecomp/sdc/tosca/services/DataModelUtilTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20
  21 package org.openecomp.sdc.tosca.services;
  22
  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;
  29
  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;
  35 import java.util.Map;
  36 import java.util.Optional;
  37 import java.util.stream.Collectors;
  38 import java.util.stream.Stream;
  39
  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;
  66
  67 /**
  68  * @author shiria
  69  * @since September 15, 2016.
  70  */
  71 @RunWith(MockitoJUnitRunner.class)
  72 public class DataModelUtilTest {
  73
  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";
  88
  89     @Rule
  90     public ExpectedException thrown = ExpectedException.none();
  91
  92     @Test
  93     public void testAddSubstitutionMappingTopolgyTemplateNull() {
  94         ServiceTemplate serviceTemplate = new ServiceTemplate();
  95         DataModelUtil.addSubstitutionMapping(serviceTemplate, new SubstitutionMapping());
  96
  97         Assert.assertNotNull(serviceTemplate.getTopology_template());
  98         Assert.assertNotNull(serviceTemplate.getTopology_template().getSubstitution_mappings());
  99     }
 100
 101     @Test
 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());
 107     }
 108
 109     @Test
 110     public void testGetDirectivesNodeTemplateNull() {
 111         assertTrue(DataModelUtil.getDirectives(null).isEmpty());
 112     }
 113
 114     @Test
 115     public void testGetDirectivesWhenDirectivesNull() {
 116         assertTrue(DataModelUtil.getDirectives(new NodeTemplate()).isEmpty());
 117     }
 118
 119     @Test
 120     public void testGetDirectives() {
 121         NodeTemplate nodeTemplate = new NodeTemplate();
 122         nodeTemplate.setDirectives(Collections.singletonList("directive"));
 123
 124         Assert.assertEquals(1, DataModelUtil.getDirectives(nodeTemplate).size());
 125     }
 126
 127     @Test
 128     public void testAddSubstitutionMappingReq() {
 129         ServiceTemplate serviceTemplate = new ServiceTemplate();
 130         DataModelUtil.addSubstitutionMappingReq(serviceTemplate,
 131                 REQUIREMENT_ID, Collections.singletonList("requirement"));
 132
 133         Assert.assertNotNull(serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements());
 134         Assert.assertEquals(1,
 135                 serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements().size());
 136     }
 137
 138     @Test
 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());
 144     }
 145
 146     @Test
 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());
 152     }
 153
 154     @Test
 155     public void testAddSubstitutionMappingCapability() {
 156         ServiceTemplate serviceTemplate = new ServiceTemplate();
 157         DataModelUtil.addSubstitutionMappingCapability(serviceTemplate,
 158                 CAPABILITY_ID, Collections.singletonList("requirement"));
 159
 160         Assert.assertNotNull(serviceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities());
 161         Assert.assertEquals(1,
 162                 serviceTemplate.getTopology_template().getSubstitution_mappings().getCapabilities().size());
 163     }
 164
 165     @Test
 166     public void testGetNodeTemplatesNull() {
 167         ServiceTemplate serviceTemplate = new ServiceTemplate();
 168         serviceTemplate.setTopology_template(new TopologyTemplate());
 169
 170         Map<String, NodeTemplate> nodeTemplateMap = DataModelUtil.getNodeTemplates(serviceTemplate);
 171
 172         Assert.assertNotNull(nodeTemplateMap);
 173         assertTrue(MapUtils.isEmpty(nodeTemplateMap));
 174     }
 175
 176     @Test
 177     public void testGetNodeTemplates() {
 178         ServiceTemplate serviceTemplate = new ServiceTemplate();
 179         serviceTemplate.setTopology_template(new TopologyTemplate());
 180
 181         Map<String, NodeTemplate> nodeTemplateMap = Stream.of(new AbstractMap.SimpleEntry<>("nodeTemplate1", new
 182                 NodeTemplate())).collect(
 183                 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
 184
 185         serviceTemplate.getTopology_template().setNode_templates(nodeTemplateMap);
 186
 187         nodeTemplateMap = DataModelUtil.getNodeTemplates(serviceTemplate);
 188
 189         Assert.assertNotNull(nodeTemplateMap);
 190         Assert.assertEquals(1, nodeTemplateMap.size());
 191     }
 192
 193     @Test
 194     public void testGetGroupsNull() {
 195         ServiceTemplate serviceTemplate = new ServiceTemplate();
 196         serviceTemplate.setTopology_template(new TopologyTemplate());
 197
 198         Map<String, GroupDefinition> nodeTemplateMap = DataModelUtil.getGroups(serviceTemplate);
 199
 200         Assert.assertNotNull(nodeTemplateMap);
 201         assertTrue(MapUtils.isEmpty(nodeTemplateMap));
 202     }
 203
 204     @Test
 205     public void testGetGroups() {
 206         ServiceTemplate serviceTemplate = new ServiceTemplate();
 207         serviceTemplate.setTopology_template(new TopologyTemplate());
 208
 209         Map<String, GroupDefinition> nodeTemplateMap = Stream.of(new AbstractMap.SimpleEntry<>("group1", new
 210                 GroupDefinition())).collect(
 211                 Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));
 212
 213         serviceTemplate.getTopology_template().setGroups(nodeTemplateMap);
 214
 215         nodeTemplateMap = DataModelUtil.getGroups(serviceTemplate);
 216
 217         Assert.assertNotNull(nodeTemplateMap);
 218         Assert.assertEquals(1, nodeTemplateMap.size());
 219     }
 220
 221     @Test
 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());
 227     }
 228
 229     @Test
 230     public void testAddNodeTemplate() {
 231         ServiceTemplate serviceTemplate = new ServiceTemplate();
 232         DataModelUtil.addNodeTemplate(serviceTemplate, NODE_TEMPLATE_ID, new NodeTemplate());
 233
 234         assertEquals(1, serviceTemplate.getTopology_template().getNode_templates().size());
 235     }
 236
 237     @Test
 238     public void testAddNodeTypeCapabilitiesDefCapabilitiesNull() {
 239         NodeType nodeType = new NodeType();
 240         DataModelUtil.addNodeTypeCapabilitiesDef(nodeType, null);
 241
 242         assertNull(nodeType.getCapabilities());
 243     }
 244
 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));
 251
 252         DataModelUtil.addNodeTypeCapabilitiesDef(null, capabilityDefinitionMap);
 253     }
 254
 255     @Test
 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));
 262
 263         DataModelUtil.addNodeTypeCapabilitiesDef(nodeType, capabilityDefinitionMap);
 264
 265         Assert.assertEquals(1, nodeType.getCapabilities().size());
 266     }
 267
 268     @Test
 269     public void testSetNodeTypeCapabilitiesDefCapabilitiesNull() {
 270         NodeType nodeType = new NodeType();
 271         DataModelUtil.setNodeTypeCapabilitiesDef(nodeType, null);
 272
 273         assertNull(nodeType.getCapabilities());
 274     }
 275
 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));
 282
 283         DataModelUtil.setNodeTypeCapabilitiesDef(null, capabilityDefinitionMap);
 284     }
 285
 286     @Test
 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));
 293
 294         DataModelUtil.setNodeTypeCapabilitiesDef(nodeType, capabilityDefinitionMap);
 295
 296         Assert.assertEquals(1, nodeType.getCapabilities().size());
 297     }
 298
 299     @Test
 300     public void testGetCapabilityDefinitionCapabilityDefinitionIdNull() {
 301         NodeType nodeType = new NodeType();
 302         nodeType.setCapabilities(new HashMap<>());
 303         assertFalse(DataModelUtil.getCapabilityDefinition(nodeType, null).isPresent());
 304     }
 305
 306     @Test
 307     public void testGetCapabilityDefinition() {
 308         NodeType nodeType = new NodeType();
 309         nodeType.setCapabilities(Collections.singletonMap("capabilityDefinitionId", new CapabilityDefinition()));
 310         assertTrue(DataModelUtil.getCapabilityDefinition(nodeType, "capabilityDefinitionId").isPresent());
 311     }
 312
 313     @Test
 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());
 319     }
 320
 321     @Test
 322     public void testAddPolicyDefinition() {
 323         ServiceTemplate serviceTemplate = new ServiceTemplate();
 324         DataModelUtil.addPolicyDefinition(serviceTemplate, "policyId", new PolicyDefinition());
 325         assertEquals(1, serviceTemplate.getTopology_template().getPolicies().size());
 326     }
 327
 328     @Test
 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());
 334     }
 335
 336     @Test
 337     public void testAddNodeType() {
 338         ServiceTemplate serviceTemplate = new ServiceTemplate();
 339         DataModelUtil.addNodeType(serviceTemplate, NODE_TYPE_ID, new NodeType());
 340
 341         assertEquals(1, serviceTemplate.getNode_types().size());
 342     }
 343
 344     @Test
 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());
 350     }
 351
 352     @Test
 353     public void testAddRelationshipTemplate() {
 354         ServiceTemplate serviceTemplate = new ServiceTemplate();
 355         DataModelUtil.addRelationshipTemplate(serviceTemplate, "relationshipTemplateId", new RelationshipTemplate());
 356
 357         assertEquals(1, serviceTemplate.getTopology_template().getRelationship_templates().size());
 358     }
 359
 360     @Test
 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());
 366     }
 367
 368     @Test(expected = CoreException.class)
 369     public void testAddRequirementAssignmentNodeNotAssigned() {
 370         DataModelUtil.addRequirementAssignment(new NodeTemplate(), REQUIREMENT_ID, new RequirementAssignment());
 371     }
 372
 373     @Test
 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);
 379
 380         assertEquals(1, nodeTemplate.getRequirements().size());
 381     }
 382
 383     @Test
 384     public void testCreateAttachmentRequirementAssignment() {
 385         assertNotNull(DataModelUtil.createAttachmentRequirementAssignment("node"));
 386     }
 387
 388     @Test
 389     public void testGetNodeTemplate() {
 390         ServiceTemplate serviceTemplate = new ServiceTemplate();
 391         serviceTemplate.setTopology_template(new TopologyTemplate());
 392
 393         assertNull(DataModelUtil.getNodeTemplate(serviceTemplate, NODE_TEMPLATE_ID));
 394     }
 395
 396     @Test
 397     public void testGetNodeType() {
 398         assertNull(DataModelUtil.getNodeType(new ServiceTemplate(), NODE_TYPE_ID));
 399     }
 400
 401     @Test
 402     public void testGetRequirementDefinitionRequirementIdIsNull() {
 403         assertFalse(DataModelUtil.getRequirementDefinition(new NodeType(), null).isPresent());
 404     }
 405
 406     @Test
 407     public void testGetRequirementDefinitionListIsEmpty() {
 408         NodeType nodeType = new NodeType();
 409
 410         nodeType.setRequirements(Collections.emptyList());
 411         assertFalse(DataModelUtil.getRequirementDefinition(new NodeType(), REQUIREMENT_DEFINITION_ID).isPresent());
 412     }
 413
 414     @Test
 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));
 419
 420         assertFalse(DataModelUtil.getRequirementDefinition(Collections.singletonList(requirementDefinitionMap),
 421                 "wrongKey").isPresent());
 422     }
 423
 424     @Test
 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());
 430     }
 431
 432     @Test
 433     public void testAddGroupToTopologyTemplate() {
 434         ServiceTemplate serviceTemplate = new ServiceTemplate();
 435
 436         DataModelUtil.addGroupDefinitionToTopologyTemplate(serviceTemplate, "groupId", new GroupDefinition());
 437
 438         assertEquals(1, serviceTemplate.getTopology_template().getGroups().size());
 439     }
 440
 441     @Test
 442     public void testAddRequirementToList() {
 443         Map<String, RequirementDefinition> requirementDefinitionMap = new HashMap<>();
 444         requirementDefinitionMap.put("requirmentDefinitionId", new RequirementDefinition());
 445
 446         List<Map<String, RequirementDefinition>> mapList = new ArrayList<>();
 447
 448         DataModelUtil.addRequirementToList(mapList, requirementDefinitionMap);
 449
 450         assertEquals(1, mapList.size());
 451     }
 452
 453     @Test
 454     public void testAddGroupMemberGroupNotExist() {
 455         ServiceTemplate serviceTemplate = new ServiceTemplate();
 456         serviceTemplate.setTopology_template(new TopologyTemplate());
 457         DataModelUtil.addGroupMember(serviceTemplate, "groupName", "memberId");
 458
 459         assertNull(serviceTemplate.getTopology_template().getGroups());
 460     }
 461
 462     @Test
 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));
 469
 470         serviceTemplate.getTopology_template().setGroups(groupDefinitionMap);
 471
 472         DataModelUtil.addGroupMember(serviceTemplate, "groupName", "memberId");
 473
 474         assertEquals(1, serviceTemplate.getTopology_template().getGroups().size());
 475     }
 476
 477     @Test
 478     public void testCreateParameterDefinition() {
 479         assertNotNull(DataModelUtil
 480                 .createParameterDefinition("parameterType", "description", true, Collections.emptyList(), new
 481                         EntrySchema(), null));
 482     }
 483
 484     @Test
 485     public void testCreateRequirement() {
 486         assertNotNull(DataModelUtil.createRequirement("capability", "node", "relationShip", new Object[1]));
 487     }
 488
 489     @Test
 490     public void testCreateEntrySchema() {
 491         assertNull(DataModelUtil.createEntrySchema(null, null, null));
 492     }
 493
 494     @Test
 495     public void testCreateGetInputPropertyValueFromListParameter() {
 496         Map inputPropertyMap = DataModelUtil.createGetInputPropertyValueFromListParameter("inputPropertyList", 1,
 497                 "nestedPropertyName");
 498
 499         assertNotNull(inputPropertyMap.get(ToscaFunctions.GET_INPUT.getFunctionName()));
 500     }
 501
 502     @Test
 503     public void testConvertPropertyDefToParameterDefNull() {
 504         assertNull(DataModelUtil.convertPropertyDefToParameterDef(null));
 505     }
 506
 507     @Test
 508     public void testConvertPropertyDefToParameterDef() {
 509         PropertyDefinition propertyDefinition = new PropertyDefinition();
 510         propertyDefinition.setType(PROPERTY_DEF_TYPE);
 511
 512         ParameterDefinitionExt parameterDefinitionExt =
 513                 DataModelUtil.convertPropertyDefToParameterDef(propertyDefinition);
 514         assertNotNull(parameterDefinitionExt);
 515         assertEquals(PROPERTY_DEF_TYPE, parameterDefinitionExt.getType());
 516     }
 517
 518     @Test
 519     public void testConvertAttributeDefToParameterDefAttDefNull() {
 520         assertNull(DataModelUtil.convertAttributeDefToParameterDef(null, null));
 521     }
 522
 523     @Test
 524     public void testConvertAttributeDefToParameterDef() {
 525         ParameterDefinitionExt parameterDefinitionExt =
 526                 DataModelUtil.convertAttributeDefToParameterDef(new AttributeDefinition(), Collections.emptyMap());
 527
 528         assertTrue(MapUtils.isEmpty((Map) parameterDefinitionExt.getValue()));
 529     }
 530
 531     @Test
 532     public void testIsNodeTemplateTrue() {
 533         ServiceTemplate serviceTemplate = new ServiceTemplate();
 534         TopologyTemplate topologyTemplate = new TopologyTemplate();
 535
 536         serviceTemplate.setTopology_template(topologyTemplate);
 537
 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);
 542
 543         assertTrue(DataModelUtil.isNodeTemplate(ENTRY_ID, serviceTemplate));
 544     }
 545
 546     @Test
 547     public void testIsNodeTemplateEntryMissing() {
 548         ServiceTemplate serviceTemplate = new ServiceTemplate();
 549         TopologyTemplate topologyTemplate = new TopologyTemplate();
 550
 551         serviceTemplate.setTopology_template(topologyTemplate);
 552         topologyTemplate.setNode_templates(Collections.emptyMap());
 553
 554         assertFalse(DataModelUtil.isNodeTemplate(ENTRY_ID, serviceTemplate));
 555     }
 556
 557     @Test(expected = CoreException.class)
 558     public void testAddInputParameterToTopologyTemplateServiceTemplateNull() {
 559         DataModelUtil.addInputParameterToTopologyTemplate(null, null, null);
 560     }
 561
 562     @Test
 563     public void testAddInputParameterToTopologyTemplate() {
 564         ServiceTemplate serviceTemplate = new ServiceTemplate();
 565         DataModelUtil.addInputParameterToTopologyTemplate(serviceTemplate, PARAMETER_ID, new ParameterDefinition());
 566
 567         assertEquals(1, serviceTemplate.getTopology_template().getInputs().size());
 568     }
 569
 570     @Test(expected = CoreException.class)
 571     public void testAddOutputParameterToTopologyTemplateServiceTemplateNull() {
 572         DataModelUtil.addOutputParameterToTopologyTemplate(null, null, null);
 573     }
 574
 575     @Test
 576     public void testAddOutputParameterToTopologyTemplate() {
 577         ServiceTemplate serviceTemplate = new ServiceTemplate();
 578         DataModelUtil.addOutputParameterToTopologyTemplate(serviceTemplate, PARAMETER_ID, new ParameterDefinition());
 579
 580         assertEquals(1, serviceTemplate.getTopology_template().getOutputs().size());
 581     }
 582
 583     @Test
 584     public void testGetNodeTemplateRequirementsNodeTemplateNull() {
 585         assertNull(DataModelUtil.getNodeTemplateRequirements(null));
 586     }
 587
 588     @Test
 589     public void testGetNodeTemplateRequirementsNodeTemplateRequirementsNull() {
 590         assertTrue(MapUtils.isEmpty(DataModelUtil.getNodeTemplateRequirements(new NodeTemplate())));
 591     }
 592
 593     @Test
 594     public void testGetNodeTemplateRequirementListNodeTemplateRequirementListNull() {
 595         assertNull(DataModelUtil.getNodeTemplateRequirementList(new NodeTemplate()));
 596     }
 597
 598     @Test
 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));
 603
 604         List<Map<String, RequirementAssignment>> requirementList = new ArrayList<>();
 605         requirementList.add(requirementAssignmentMap);
 606
 607         NodeTemplate nodeTemplate = new NodeTemplate();
 608         nodeTemplate.setRequirements(requirementList);
 609
 610         assertEquals(requirementList.size(), DataModelUtil.getNodeTemplateRequirementList(nodeTemplate).size());
 611     }
 612
 613     @Test
 614     public void testGetRequirementAssignmentRequirementAssignmentListEmpty() {
 615         assertFalse(DataModelUtil.getRequirementAssignment(null, null).isPresent());
 616     }
 617
 618     @Test
 619     public void testGetRequirementAssignmentRequirementAssignmentListDoseNotContainsKeyPassed() {
 620         assertFalse(DataModelUtil.getRequirementAssignment(
 621                 Collections.singletonList(new HashMap<>()), REQUIREMENT_KEY).isPresent());
 622     }
 623
 624     @Test
 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));
 629
 630         assertTrue(DataModelUtil.getRequirementAssignment(
 631                 Collections.singletonList(requirementAssignmentMap), REQUIREMENT_KEY).isPresent());
 632     }
 633
 634     @Test
 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));
 639
 640
 641         List<Map<String, RequirementDefinition>> requirementList =
 642                 Stream.of(requirementDefinitionMap).collect(Collectors.toList());
 643         DataModelUtil.removeRequirementsDefinition(requirementList, REQUIREMENT_KEY);
 644
 645         assertTrue(requirementList.isEmpty());
 646     }
 647
 648     @Test
 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));
 653
 654
 655         List<Map<String, RequirementAssignment>> requirementList =
 656                 Stream.of(requirementDefinitionMap).collect(Collectors.toList());
 657         DataModelUtil.removeRequirementsAssignment(requirementList, REQUIREMENT_KEY);
 658
 659         assertTrue(requirementList.isEmpty());
 660     }
 661
 662     @Test
 663     public void testRemoveRequirementAssignmentNodeTemplate() {
 664
 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));
 672
 673         List<Map<String, RequirementAssignment>> requirementList =
 674                 Stream.of(requirementDefinitionMap).collect(Collectors.toList());
 675         NodeTemplate nodeTemplate = new NodeTemplate();
 676         nodeTemplate.setRequirements(requirementList);
 677
 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);
 683
 684         assertTrue(nodeTemplate.getRequirements().isEmpty());
 685     }
 686
 687     @Test
 688     public void testGetNamespaceSuffixNull() {
 689         assertNull(DataModelUtil.getNamespaceSuffix(null));
 690     }
 691
 692     @Test
 693     public void testGetNamespaceSuffix() {
 694         assertEquals("suffix", DataModelUtil.getNamespaceSuffix("name.suffix"));
 695     }
 696
 697     @Test
 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));
 701
 702         assertTrue(DataModelUtil.isImportAddedToServiceTemplate(Collections.singletonList(importMap), "imp1"));
 703     }
 704
 705     @Test
 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));
 709
 710         assertFalse(DataModelUtil.isImportAddedToServiceTemplate(Collections.singletonList(importMap), "imp2"));
 711     }
 712
 713     @Test
 714     public void testGetOutputParameterOutputIsNull() {
 715         ServiceTemplate serviceTemplate = new ServiceTemplate();
 716         serviceTemplate.setTopology_template(new TopologyTemplate());
 717
 718         assertNull(DataModelUtil.getOuputParameter(serviceTemplate, OUTPUT_ID));
 719     }
 720
 721     @Test
 722     public void testGetOutputParameter() {
 723         ServiceTemplate serviceTemplate = new ServiceTemplate();
 724         serviceTemplate.setTopology_template(new TopologyTemplate());
 725
 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);
 730
 731         assertNotNull(DataModelUtil.getOuputParameter(serviceTemplate, OUTPUT_ID));
 732     }
 733
 734     @Test
 735     public void testGetInputParametersNull() {
 736         ServiceTemplate serviceTemplate = new ServiceTemplate();
 737         serviceTemplate.setTopology_template(new TopologyTemplate());
 738
 739         assertNull(DataModelUtil.getInputParameters(serviceTemplate));
 740     }
 741
 742     @Test
 743     public void testGetInputParameters() {
 744         ServiceTemplate serviceTemplate = new ServiceTemplate();
 745         serviceTemplate.setTopology_template(new TopologyTemplate());
 746
 747         serviceTemplate.getTopology_template().setInputs(new HashMap<>());
 748
 749         assertNotNull(DataModelUtil.getInputParameters(serviceTemplate));
 750     }
 751
 752     @Test
 753     public void testGetRelationshipTemplatesNull() {
 754         ServiceTemplate serviceTemplate = new ServiceTemplate();
 755         serviceTemplate.setTopology_template(new TopologyTemplate());
 756
 757         assertNull(DataModelUtil.getInputParameters(serviceTemplate));
 758     }
 759
 760     @Test
 761     public void testGetRelationshipTemplates() {
 762         ServiceTemplate serviceTemplate = new ServiceTemplate();
 763         serviceTemplate.setTopology_template(new TopologyTemplate());
 764
 765         serviceTemplate.getTopology_template().setRelationship_templates(new HashMap<>());
 766
 767         assertNotNull(DataModelUtil.getRelationshipTemplates(serviceTemplate));
 768     }
 769
 770     @Test
 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));
 775
 776         nodeTemplate.setProperties(objectMap);
 777         assertNull(DataModelUtil.getPropertyValue(nodeTemplate, "wrongId"));
 778     }
 779
 780     @Test
 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));
 785
 786         nodeTemplate.setProperties(objectMap);
 787         assertNotNull(DataModelUtil.getPropertyValue(nodeTemplate, PROPERTY_ID));
 788     }
 789
 790     @Test
 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));
 799
 800         serviceTemplate.getTopology_template().setNode_templates(nodeTemplateMap);
 801
 802         assertNotNull(DataModelUtil.getNodeTemplateProperties(serviceTemplate, NODE_TEMPLATE_ID));
 803     }
 804
 805     @Test
 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<>());
 811
 812         serviceTemplate.getTopology_template().setNode_templates(new HashMap<>());
 813
 814         assertNull(DataModelUtil.getNodeTemplateProperties(serviceTemplate, NODE_TEMPLATE_ID));
 815     }
 816
 817     @Test
 818     public void testGetSubstitutionMappingsNullCheck() {
 819         ServiceTemplate serviceTemplate = new ServiceTemplate();
 820         serviceTemplate.setTopology_template(new TopologyTemplate());
 821         assertNull(DataModelUtil.getSubstitutionMappings(serviceTemplate));
 822     }
 823
 824     @Test
 825     public void testGetClonedObject() {
 826         RequirementAssignment requirementAssignment = new RequirementAssignment();
 827         requirementAssignment.setNode(NODE_ID);
 828
 829         Object obj = DataModelUtil.getClonedObject(requirementAssignment, requirementAssignment.getClass());
 830
 831         assertTrue(obj instanceof RequirementAssignment);
 832         RequirementAssignment assignment = (RequirementAssignment) obj;
 833         assertNotSame(assignment, requirementAssignment);
 834     }
 835
 836     @Test
 837     public void testGetCloneObject() {
 838         RequirementAssignment requirementAssignment = new RequirementAssignment();
 839         requirementAssignment.setNode(NODE_ID);
 840
 841         assertNotSame(DataModelUtil.getClonedObject(requirementAssignment), requirementAssignment);
 842     }
 843
 844     @Test
 845     public void testGetCloneObjectSerializableObject() {
 846         List<String> stringList = new ArrayList<>();
 847
 848         assertNotSame(DataModelUtil.getClonedObject(stringList), stringList);
 849     }
 850
 851     @Test
 852     public void testAddSubstitutionFilteringProperty() {
 853         NodeTemplate nodeTemplate = new NodeTemplate();
 854         nodeTemplate.setProperties(new HashMap<>());
 855
 856         DataModelUtil.addSubstitutionFilteringProperty(TEMPLATE_NAME, nodeTemplate, 5);
 857
 858         assertNotNull(nodeTemplate.getProperties().get(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME));
 859     }
 860
 861     @Test
 862     public void testAddBindingReqFromPortToCompute() {
 863         NodeTemplate nodeTemplate = new NodeTemplate();
 864
 865         DataModelUtil.addBindingReqFromPortToCompute("computeNodeId", nodeTemplate);
 866
 867         assertNotNull(nodeTemplate.getRequirements());
 868         assertEquals(1, nodeTemplate.getRequirements().size());
 869     }
 870
 871     @Test
 872     public void testCreateSubstitutionTemplateSubMappingCapabilityAndRequirementNull() {
 873         Map<String, Map<String, List<String>>> mapping = new HashMap<>();
 874
 875         Map<String, List<String>> capabilityStringList = new HashMap<>();
 876         capabilityStringList.put(CAPABILITY_ID, Collections.singletonList("test"));
 877
 878         Map<String, List<String>> requirementStringList = new HashMap<>();
 879         capabilityStringList.put(REQUIREMENT_ID, Collections.singletonList("test"));
 880
 881         mapping.put(ToscaConstants.CAPABILITY, capabilityStringList);
 882         mapping.put(ToscaConstants.REQUIREMENT, requirementStringList);
 883
 884         NodeType nodeType = new NodeType();
 885
 886         Map<String, CapabilityDefinition> capabilityMap = new HashMap<>();
 887         capabilityMap.put(CAPABILITY_ID, new CapabilityDefinition());
 888
 889         Map<String, RequirementDefinition> requirementMap = new HashMap<>();
 890         requirementMap.put(REQUIREMENT_ID, new RequirementDefinition());
 891
 892         nodeType.setRequirements(Collections.singletonList(requirementMap));
 893         nodeType.setCapabilities(capabilityMap);
 894
 895         assertNotNull(DataModelUtil.createSubstitutionTemplateSubMapping(NODE_TYPE_KEY, nodeType, mapping));
 896     }
 897
 898     @Test
 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);
 903
 904         assertNotNull(DataModelUtil.createSubstitutionTemplateSubMapping(NODE_TYPE_KEY, new NodeType(), mapping));
 905     }
 906
 907     @Test
 908     public void testAddNodeTemplateCapability() {
 909         NodeTemplate nodeTemplate = new NodeTemplate();
 910
 911         DataModelUtil.addNodeTemplateCapability(nodeTemplate, CAPABILITY_ID, null, null);
 912         assertNotNull(nodeTemplate.getCapabilities());
 913     }
 914
 915     @Test
 916     public void testAddSubstitutionNodeTypeRequirements() {
 917
 918         NodeType nodeType = new NodeType();
 919
 920         Map<String, RequirementDefinition> requirementDefinitionMap = new HashMap<>();
 921         requirementDefinitionMap.put(REQUIREMENT_ID, new RequirementDefinition());
 922
 923         DataModelUtil.addSubstitutionNodeTypeRequirements(
 924                 nodeType, Collections.singletonList(requirementDefinitionMap), TEMPLATE_NAME);
 925
 926         assertEquals(1, nodeType.getRequirements().size());
 927         assertNotNull(nodeType.getRequirements().get(0).get("requirementId_templateName"));
 928     }
 929
 930     @Test
 931     public void testIsNodeTemplateSectionMissingFromServiceTemplateNodeTemplateMissing() {
 932         ServiceTemplate serviceTemplate = new ServiceTemplate();
 933         serviceTemplate.setTopology_template(new TopologyTemplate());
 934
 935         assertTrue(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(serviceTemplate));
 936     }
 937
 938     @Test
 939     public void testIsNodeTemplateSectionMissingFromServiceTemplateTopologyTemplateMissing() {
 940         ServiceTemplate serviceTemplate = new ServiceTemplate();
 941
 942         assertTrue(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(serviceTemplate));
 943     }
 944
 945     @Test
 946     public void testIsNodeTemplateSectionMissingFromServiceTemplate() {
 947         ServiceTemplate serviceTemplate = new ServiceTemplate();
 948         serviceTemplate.setTopology_template(new TopologyTemplate());
 949
 950         Map<String, NodeTemplate> nodeTemplateMap = new HashMap<>();
 951         nodeTemplateMap.put(NODE_TEMPLATE_ID, new NodeTemplate());
 952         serviceTemplate.getTopology_template().setNode_templates(nodeTemplateMap);
 953
 954         assertFalse(DataModelUtil.isNodeTemplateSectionMissingFromServiceTemplate(serviceTemplate));
 955     }
 956
 957     @Test
 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);
 968
 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());
 974     }
 975
 976     @Test
 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());
 984     }
 985
 986     @Test
 987     public void testAddNodeTemplateProperty() {
 988         NodeTemplate nodeTemplate = new NodeTemplate();
 989
 990         DataModelUtil.addNodeTemplateProperty(nodeTemplate, PROPERTY_ID, null);
 991
 992         assertNotNull(nodeTemplate.getProperties());
 993     }
 994 }