openecomp-be/lib/openecomp-tosca-lib/src/test/java/org/openecomp/sdc/tosca/datatypes/ToscaModelTest.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.datatypes;
  22
  23 import org.junit.Assert;
  24 import org.junit.Test;
  25 import org.openecomp.sdc.tosca.datatypes.model.ArtifactType;
  26 import org.openecomp.sdc.tosca.datatypes.model.AttributeDefinition;
  27 import org.openecomp.sdc.tosca.datatypes.model.CapabilityAssignment;
  28 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
  29 import org.openecomp.sdc.tosca.datatypes.model.Constraint;
  30 import org.openecomp.sdc.tosca.datatypes.model.Directive;
  31 import org.openecomp.sdc.tosca.datatypes.model.Import;
  32 import org.openecomp.sdc.tosca.datatypes.model.InterfaceDefinition;
  33 import org.openecomp.sdc.tosca.datatypes.model.InterfaceType;
  34 import org.openecomp.sdc.tosca.datatypes.model.NodeFilter;
  35 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
  36 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
  37 import org.openecomp.sdc.tosca.datatypes.model.OperationDefinition;
  38 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
  39 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
  40 import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
  41 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
  42 import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
  43 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
  44 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
  45 import org.openecomp.sdc.tosca.datatypes.model.TopologyTemplate;
  46 import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
  47 import org.openecomp.sdc.tosca.services.DataModelUtil;
  48 import org.openecomp.sdc.tosca.services.ToscaConstants;
  49 import org.openecomp.sdc.tosca.services.ToscaExtensionYamlUtil;
  50 import org.openecomp.sdc.tosca.services.YamlUtil;
  51
  52 import java.io.IOException;
  53 import java.io.InputStream;
  54 import java.util.ArrayList;
  55 import java.util.HashMap;
  56 import java.util.List;
  57 import java.util.Map;
  58 import java.util.Optional;
  59
  60
  61 public class ToscaModelTest {
  62   private YamlUtil yamlUtil = new YamlUtil();
  63   private static final String INTERFACE_ID = "inter_1";
  64   private static final String NODE_TEMPLATE_ID = "firstNodeTemplate";
  65   private static final String BASE_DIR = "/mock/model";
  66   private static final String ST = "/serviceTemplate.yaml";
  67   private static final String ST_WITH_INTERFACE = "/serviceTemplateWithInterface.yaml";
  68   private static final String ST_WITH_OPERATIONS = "/serviceTemplateWithInterfaceAndOperation.yaml";
  69   private static final String ST_WITH_INTERFACE_DEF =
  70       "/serviceTemplateWithNodeTemplateInterface.yaml";
  71
  72
  73   @Test
  74   public void testServiceTemplateJavaToYaml() {
  75     ServiceTemplate serviceTemplate = new ServiceTemplate();
  76     Map<String, String> metadata = new HashMap<>();
  77     metadata.put("Template_author", "OPENECOMP");
  78     metadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, "Test");
  79     metadata.put("Template_version", "1.0.0");
  80     serviceTemplate.setTosca_definitions_version("tosca_simple_yaml_1_0_0");
  81     serviceTemplate.setDescription("testing desc tosca service template");
  82
  83     Import fileImport1 = new Import();
  84     fileImport1.setFile("path1/path2/file1.yaml");
  85     Import fileImport2 = new Import();
  86     fileImport2.setFile("path1/path2/file2.yaml");
  87     List<Map<String, Import>> imports = new ArrayList<>();
  88     Map<String, Import> importsMap = new HashMap<>();
  89     importsMap.put("myfile1", fileImport1);
  90     imports.add(importsMap);
  91     importsMap = new HashMap<>();
  92     importsMap.put("myfile2", fileImport2);
  93     imports.add(importsMap);
  94     serviceTemplate.setImports(imports);
  95
  96     OperationDefinition operationDefinition = new OperationDefinition();
  97     operationDefinition.setDescription("test operation");
  98     InterfaceType interfaceType = new InterfaceType();
  99     interfaceType.setDerived_from("derived_from");
 100     interfaceType.setDescription("desc");
 101     interfaceType.addOperation("test", operationDefinition);
 102     serviceTemplate.addInterfaceType("test_interface", interfaceType);
 103
 104     ArtifactType artifact = new ArtifactType();
 105     artifact.setMime_type("application/java-archive");
 106     ArrayList<String> ext = new ArrayList<>();
 107     ext.add("yaml");
 108     ext.add("xml");
 109     artifact.setFile_ext(ext);
 110     Map<String, ArtifactType> artifactTypes = new HashMap<>();
 111     artifactTypes.put("one_artifact", artifact);
 112     serviceTemplate.setArtifact_types(artifactTypes);
 113
 114     NodeType nodeType = new NodeType();
 115     nodeType.setDerived_from("tosca.nodes.Root");
 116     nodeType.setVersion("1.0.0");
 117     nodeType.setDescription("tosca compute test");
 118
 119     PropertyDefinition propDef1 = new PropertyDefinition();
 120     propDef1.setType("integer");
 121     propDef1.setDescription("Number of CPUs requested for a software node instance");
 122     propDef1.setRequired(true);
 123     propDef1.set_default(1);
 124
 125     Constraint graterOrEqual = new Constraint();
 126     graterOrEqual.setGreater_or_equal((float) 5.0);
 127     Constraint constraintEqual = new Constraint();
 128     constraintEqual.setEqual(5);
 129     Constraint greater_than = new Constraint();
 130     greater_than.setGreater_than(6.02);
 131     Constraint inRange = new Constraint();
 132     inRange.setIn_range(new Object[2]);
 133     inRange.getIn_range()[0] = 0;
 134     inRange.getIn_range()[1] = ToscaConstants.UNBOUNDED;
 135
 136     List<Constraint> constraints = new ArrayList<>();
 137     constraints.add(graterOrEqual);
 138     constraints.add(constraintEqual);
 139     constraints.add(greater_than);
 140     constraints.add(inRange);
 141     propDef1.setConstraints(constraints);
 142
 143     Map<String, PropertyDefinition> properties = new HashMap<>();
 144     properties.put("cpu_num", propDef1);
 145     nodeType.setProperties(properties);
 146
 147     Map<String, AttributeDefinition> attributesDef = new HashMap<>();
 148     AttributeDefinition attDef = new AttributeDefinition();
 149     attDef.setType(PropertyType.STRING.getDisplayName());
 150     attDef.set_default("hi");
 151     attributesDef.put("attDef1", attDef);
 152     nodeType.setAttributes(attributesDef);
 153
 154     Map<String, RequirementDefinition> reqsDef = new HashMap<>();
 155     RequirementDefinition reqDef = new RequirementDefinition();
 156     reqDef.setCapability("tosca.cap1");
 157     reqDef.getOccurrences()[0] = 5;
 158     reqsDef.put("re1", reqDef);
 159     List<Map<String, RequirementDefinition>> reqList = new ArrayList<>();
 160     reqList.add(reqsDef);
 161     nodeType.setRequirements(reqList);
 162
 163
 164     Map<String, CapabilityDefinition> capsDef = new HashMap<>();
 165     CapabilityDefinition capdef = new CapabilityDefinition();
 166     capdef.setType("tosca.cap");
 167     List<String> vvSource = new ArrayList<>();
 168     vvSource.add("node1");
 169     vvSource.add("node2");
 170     capdef.setValid_source_types(vvSource);
 171     capsDef.put("cap1", capdef);
 172     nodeType.setCapabilities(capsDef);
 173
 174     Map<String, NodeType> nodeTypes = new HashMap<>();
 175     nodeTypes.put("compute_node_type", nodeType);
 176     serviceTemplate.setNode_types(nodeTypes);
 177
 178     TopologyTemplate topologyTemplate = new TopologyTemplate();
 179     topologyTemplate.setDescription("topologi template descroption");
 180     Map<String, ParameterDefinition> inputs = new HashMap<>();
 181     ParameterDefinition paramDef = new ParameterDefinition();
 182     paramDef.setType(PropertyType.STRING.getDisplayName());
 183     paramDef.setDescription("desc");
 184     paramDef.set_default("my default val");
 185     paramDef.setRequired(false);
 186     paramDef.setEntry_schema(DataModelUtil.createEntrySchema("tosca.myType", null, null));
 187     List<Constraint> paramConstraint = new ArrayList<>();
 188     Constraint paramConst1 = new Constraint();
 189     paramConst1.setGreater_than(6);
 190     Constraint paramConst2 = new Constraint();
 191     paramConst2.setGreater_or_equal(9);
 192     paramConstraint.add(paramConst1);
 193     paramConstraint.add(paramConst2);
 194     paramDef.setConstraints(paramConstraint);
 195     inputs.put("inParam1", paramDef);
 196     topologyTemplate.setInputs(inputs);
 197
 198     Map<String, NodeTemplate> nodeTemplates = new HashMap<>();
 199     NodeTemplate nodeTemplate = new NodeTemplate();
 200     nodeTemplate.setType("nodeTypeRef");
 201     List<String> directives = new ArrayList<>();
 202     directives.add(Directive.SELECTABLE.getDisplayName());
 203     directives.add(Directive.SUBSTITUTABLE.getDisplayName());
 204     nodeTemplate.setDirectives(directives);
 205     Map<String, Object> nodeTemplateProperties = new HashMap<>();
 206     nodeTemplateProperties.put("prop1", "abcd");
 207     nodeTemplateProperties.put("prop2", "{ get_input: my_mysql_rootpw }");
 208     nodeTemplate.setProperties(nodeTemplateProperties);
 209     Map<String, Object> nodeTemplateAtts = new HashMap<>();
 210     nodeTemplateAtts.put("att1", "att1Val");
 211     nodeTemplateAtts.put("att2", "{ get_input: my_mysql_rootpw }");
 212     nodeTemplate.setAttributes(nodeTemplateAtts);
 213
 214
 215     RequirementAssignment reqAssignment1 = new RequirementAssignment();
 216     reqAssignment1.setNode("nodeA");
 217     reqAssignment1.setCapability("capA");
 218     reqAssignment1.setRelationship("relationB");
 219     Object[] reqAssOccurrences = new Object[2];
 220     reqAssOccurrences[0] = 1;
 221     reqAssOccurrences[1] = 2;
 222     reqAssignment1.setOccurrences(reqAssOccurrences);
 223     NodeFilter reqNodeFilter = new NodeFilter();
 224     List<Constraint> propConstrain1 = new ArrayList<>();
 225     Constraint propConst1 = new Constraint();
 226     propConst1.setGreater_or_equal(9);
 227     propConstrain1.add(propConst1);
 228     List<Constraint> propConstrain2 = new ArrayList<>();
 229     Constraint propConst2 = new Constraint();
 230     propConst2.setMin_length(1);
 231     propConstrain2.add(propConst2);
 232     Constraint propConst3 = new Constraint();
 233     propConst3.setMax_length(2);
 234     propConstrain2.add(propConst3);
 235     Map<String, List<Constraint>> nodeFilterProp = new HashMap<>();
 236     nodeFilterProp.put("propName1", propConstrain1);
 237     nodeFilterProp.put("propName2", propConstrain2);
 238     reqNodeFilter.setProperties(nodeFilterProp);
 239     reqAssignment1.setNode_filter(reqNodeFilter);
 240
 241     RequirementAssignment reqAssignment2 = new RequirementAssignment();
 242     reqAssignment2.setNode("nodeA");
 243     reqAssignment2.setCapability("capA");
 244     reqAssignment2.setRelationship("relationB");
 245     Map<String, RequirementAssignment> nodeTemplateRequirement1 = new HashMap<>();
 246     Map<String, RequirementAssignment> nodeTemplateRequirement2 = new HashMap<>();
 247     nodeTemplateRequirement1.put("req1", reqAssignment1);
 248     nodeTemplateRequirement2.put("req2", reqAssignment2);
 249     nodeTemplate.setRequirements(new ArrayList<>());
 250     nodeTemplate.getRequirements().add(nodeTemplateRequirement1);
 251     nodeTemplate.getRequirements().add(nodeTemplateRequirement2);
 252
 253     Map<String, CapabilityAssignment> nodeTemplateCapability = new HashMap<>();
 254     CapabilityAssignment capAss = new CapabilityAssignment();
 255     Map<String, Object> capProps = new HashMap<>();
 256     capProps.put("num_cpus", "{ get_input: cpus }");
 257     capAss.setProperties(capProps);
 258     Map<String, Object> capAtts = new HashMap<>();
 259     capAtts.put("num_cpus", "66");
 260     capAss.setAttributes(capAtts);
 261     nodeTemplateCapability.put("cap1", capAss);
 262     nodeTemplate.setCapabilities(nodeTemplateCapability);
 263
 264     NodeFilter nodeTemplateNodeFilter = new NodeFilter();
 265     Map<String, List<Constraint>> ntProp = new HashMap<>();
 266     Constraint c1 = new Constraint();
 267     c1.setEqual("1 MB");
 268     List<Constraint> consList = new ArrayList<>();
 269     consList.add(c1);
 270     ntProp.put("test1", consList);
 271     nodeTemplateNodeFilter.setProperties(ntProp);
 272     nodeTemplate.setNode_filter(nodeTemplateNodeFilter);
 273     nodeTemplates.put("firatNodeTemplate", nodeTemplate);
 274     topologyTemplate.setNode_templates(nodeTemplates);
 275
 276     SubstitutionMapping subMap = new SubstitutionMapping();
 277     subMap.setNode_type("myNodeType.node");
 278     Map<String, List<String>> mapCapabilities = new HashMap<>();
 279     List<String> NodeCap = new ArrayList<>();
 280     NodeCap.add("database");
 281     NodeCap.add("database_endpoint");
 282     mapCapabilities.put("database_endpoint", NodeCap);
 283     subMap.setCapabilities(mapCapabilities);
 284     topologyTemplate.setSubstitution_mappings(subMap);
 285     serviceTemplate.setTopology_template(topologyTemplate);
 286
 287     String yaml = new YamlUtil().objectToYaml(serviceTemplate);
 288     ServiceTemplate serviceTemplateFromYaml =
 289         new YamlUtil().yamlToObject(yaml, ServiceTemplate.class);
 290     Assert.assertNotNull(serviceTemplateFromYaml);
 291   }
 292
 293
 294   @Test
 295   public void testYamlToServiceTemplateObj() throws IOException {
 296     ServiceTemplate serviceTemplateFromYaml =
 297         getServiceTemplate(BASE_DIR + ST);
 298     Assert.assertNotNull(serviceTemplateFromYaml);
 299   }
 300
 301   @Test
 302   public void testYamlWithInterfaceToServiceTemplateObj() throws IOException {
 303     ServiceTemplate serviceTemplateWithOperation =
 304         getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 305     Assert.assertNotNull(serviceTemplateWithOperation);
 306
 307     InterfaceType expectedInterfaceType = getInterfaceType();
 308
 309     Map<String, InterfaceType> interfaceTypes =
 310         DataModelUtil.getInterfaceTypes(serviceTemplateWithOperation);
 311     Assert.assertEquals(1, interfaceTypes.size());
 312     InterfaceType actualInterfaceType = interfaceTypes.get(INTERFACE_ID);
 313     Assert.assertEquals(expectedInterfaceType, actualInterfaceType);
 314   }
 315
 316   @Test
 317   public void testAddOperationToInterface() throws IOException {
 318     YamlUtil yamlUtil = new YamlUtil();
 319     ServiceTemplate serviceTemplateWithInterface =
 320         getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE);
 321     ServiceTemplate serviceTemplateWithOperation =
 322         getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 323
 324     OperationDefinition operationDefinition = getOperationDefinition();
 325
 326     DataModelUtil
 327         .addInterfaceOperation(serviceTemplateWithInterface, INTERFACE_ID, "start",
 328             operationDefinition);
 329     String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithOperation);
 330     String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterface);
 331     Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
 332   }
 333
 334   @Test
 335   public void testInterfaceTypeToObjConversion() throws IOException {
 336     ServiceTemplate serviceTemplateWithInterface =
 337         getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE);
 338     ServiceTemplate serviceTemplateWithOperation =
 339         getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 340     InterfaceType interfaceType = getInterfaceType();
 341
 342     Optional<Object> interfaceAsObj = DataModelUtil.convertInterfaceTypeToObj(interfaceType);
 343     Assert.assertTrue(interfaceAsObj.isPresent());
 344
 345     Map<String, Object> interfaceTypes = new HashMap<>();
 346     interfaceTypes.put(INTERFACE_ID, interfaceAsObj.get());
 347     serviceTemplateWithInterface.setInterface_types(interfaceTypes);
 348
 349     String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithOperation);
 350     String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterface);
 351     Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
 352   }
 353
 354   @Test
 355   public void testObjToInterfaceTypeConversion() throws IOException, ReflectiveOperationException {
 356     ServiceTemplate serviceTemplateWithOperation =
 357         getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 358     Map<String, Object> interfaceTypes = serviceTemplateWithOperation.getInterface_types();
 359     Object interfaceObj = interfaceTypes.get(INTERFACE_ID);
 360     Optional<InterfaceType> actualInterfaceType =
 361         DataModelUtil.convertObjToInterfaceType(INTERFACE_ID, interfaceObj);
 362
 363     Assert.assertTrue(actualInterfaceType.isPresent());
 364     InterfaceType expectedInterfaceType = getInterfaceType();
 365     Assert.assertEquals(expectedInterfaceType, actualInterfaceType.get());
 366   }
 367
 368   @Test
 369   public void testInterfaceDefinitionToObjConversion() throws IOException {
 370     ServiceTemplate serviceTemplate =
 371         getServiceTemplate(BASE_DIR + ST);
 372     ServiceTemplate serviceTemplateWithInterfaceDef =
 373         getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE_DEF);
 374
 375     NodeTemplate nodeTemplate =
 376         DataModelUtil.getNodeTemplate(serviceTemplate, NODE_TEMPLATE_ID);
 377     InterfaceDefinition interfaceDefinition = getInterfaceDefinition();
 378     Optional<Object> interfaceObj = DataModelUtil.convertInterfaceDefinitionToObj(interfaceDefinition);
 379
 380     Assert.assertTrue(interfaceObj.isPresent());
 381     Map<String, Object> interfaces = new HashMap<>();
 382     interfaces.put(INTERFACE_ID, interfaceObj.get());
 383     nodeTemplate.setInterfaces(interfaces);
 384
 385     String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterfaceDef);
 386     String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplate);
 387     Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
 388   }
 389
 390   @Test
 391   public void testObjToInterfaceDefinitionConversion()
 392       throws IOException, ReflectiveOperationException {
 393     ServiceTemplate serviceTemplateWithInterfaceDef =
 394         getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE_DEF);
 395     NodeTemplate nodeTemplateWithInterface =
 396         DataModelUtil.getNodeTemplate(serviceTemplateWithInterfaceDef, NODE_TEMPLATE_ID);
 397     Map<String, Object> interfaces = nodeTemplateWithInterface.getInterfaces();
 398     Object interfaceObj = interfaces.get(INTERFACE_ID);
 399     Optional<InterfaceDefinition> actualInterfaceDefinition =
 400         DataModelUtil.convertObjToInterfaceDefinition(INTERFACE_ID, interfaceObj);
 401
 402     Assert.assertTrue(actualInterfaceDefinition.isPresent());
 403
 404     InterfaceDefinition expectedInterfaceDefinition = getInterfaceDefinition();
 405     Assert.assertEquals(expectedInterfaceDefinition, actualInterfaceDefinition.get());
 406   }
 407
 408   @Test
 409   public void testYamlToServiceTemplateIncludingHeatExtend() throws IOException {
 410     ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 411     try (InputStream yamlFile =
 412              toscaExtensionYamlUtil.loadYamlFileIs(BASE_DIR + "/serviceTemplateHeatExtend.yaml")) {
 413       ServiceTemplate serviceTemplateFromYaml =
 414           toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 415       ParameterDefinitionExt parameterDefinitionExt =
 416           (ParameterDefinitionExt) serviceTemplateFromYaml.getTopology_template().getInputs()
 417               .get("inParam1");
 418       Assert.assertNotNull(parameterDefinitionExt.getLabel());
 419       String backToYamlString = toscaExtensionYamlUtil.objectToYaml(serviceTemplateFromYaml);
 420       Assert.assertNotNull(backToYamlString);
 421     }
 422   }
 423
 424   private ServiceTemplate getServiceTemplate(String inputPath) throws IOException {
 425     try (InputStream yamlFile = yamlUtil.loadYamlFileIs(inputPath)) {
 426       return yamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 427     }
 428   }
 429
 430   private InterfaceType getInterfaceType() {
 431     OperationDefinition operationDefinition = getOperationDefinition();
 432     InterfaceType interfaceType = new InterfaceType();
 433     interfaceType.setDescription("test interface");
 434     interfaceType.addOperation("start", operationDefinition);
 435     return interfaceType;
 436   }
 437
 438   private OperationDefinition getOperationDefinition() {
 439     OperationDefinition operationDefinition = new OperationDefinition();
 440     operationDefinition.setDescription("start operation");
 441     operationDefinition.setImplementation("start.sh");
 442     return operationDefinition;
 443   }
 444
 445   private InterfaceDefinition getInterfaceDefinition() {
 446     OperationDefinition operationDefinition = getOperationDefinition();
 447     InterfaceDefinition interfaceDefinition = new InterfaceDefinition();
 448     interfaceDefinition.setType("test interface");
 449     interfaceDefinition.addOperation("start", operationDefinition);
 450     return interfaceDefinition;
 451   }
 452
 453 }
 454
 455
 456
 457
 458
 459