openecomp-be/lib/openecomp-tosca-lib/src/test/java/org/openecomp/sdc/tosca/datatypes/ToscaModelTest.java

   1 /*
   2  * Copyright © 2016-2018 European Support Limited
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.openecomp.sdc.tosca.datatypes;
  18
  19 import java.io.IOException;
  20 import java.io.InputStream;
  21 import java.util.ArrayList;
  22 import java.util.HashMap;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Optional;
  26 import org.junit.Assert;
  27 import org.junit.Test;
  28 import org.onap.sdc.tosca.datatypes.model.*;
  29 import org.onap.sdc.tosca.datatypes.model.RequirementAssignment;
  30 import org.onap.sdc.tosca.datatypes.model.extension.*;
  31 import org.onap.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
  32 import org.onap.sdc.tosca.services.ToscaExtensionYamlUtil;
  33 import org.onap.sdc.tosca.services.YamlUtil;
  34 import org.openecomp.sdc.tosca.services.DataModelUtil;
  35 import org.openecomp.sdc.tosca.services.ToscaConstants;
  36
  37
  38 public class ToscaModelTest {
  39
  40     public static final String FIRST_NODE_TEMPLATE = "firstNodeTemplate";
  41     public static final String REQ1 = "req1";
  42     public static final String REQ2 = "req2";
  43     public static final String SERVICE_FILTER_TOSCA_ID = "{get_input=inParam1}";
  44     public static final String VMD_NAME = "vmdName";
  45     public static final String DIRECTOR = "director";
  46     private YamlUtil yamlUtil = new YamlUtil();
  47     private ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
  48     private static final String INTERFACE_ID = "inter_1";
  49     private static final String NODE_TEMPLATE_ID = "firstNodeTemplate";
  50     private static final String NODE_TYPE_ID = "compute_node_type";
  51     private static final String BASE_DIR = "/mock/model";
  52     private static final String ST = "/serviceTemplate.yaml";
  53     private static final String ST_WITH_INTERFACE = "/serviceTemplateWithInterface.yaml";
  54     private static final String ST_WITH_OPERATIONS = "/serviceTemplateWithInterfaceAndOperation.yaml";
  55     private static final String ST_WITH_INTERFACE_DEF = "/serviceTemplateWithNodeTemplateInterface.yaml";
  56     private static final String ST_WITH_NODE_INTERFACE_DEF = "/serviceTemplateWithNodeTypeInterface.yaml";
  57     private static final String INTERFACE_TYPE_VALUE = "tosca.interfaces.node.lifecycle.Standard";
  58     private static final String OPERATION_START = "start";
  59     private static final String OPERATION_DESC = "start operation";
  60     private static final String IMPLEMENTATION_NAME = "startWorkFlow.json";
  61     private static final String PRIMARY_IMPL = "myImpl.yaml";
  62     private static final String DEPENDENCY_NAME = "script1.sh";
  63     private static final String STRING_TYPE = "string";
  64     private static final String ST_WITH_SERVICE_FILTER = "/serviceTemplateWithServiceFilter.yaml";
  65     private static final String SUBSTITUTION_MAPPING = "/serviceTemplateWithSubstitutionMapping.yaml";
  66     private static final String SUBSTITUTION_MAPPING_EXT = "/substitutionMappingExt.yaml";
  67
  68     @Test
  69     public void testServiceTemplateJavaToYaml() {
  70         ServiceTemplate serviceTemplate = new ServiceTemplate();
  71         Map<String, String> metadata = new HashMap<>();
  72         metadata.put("Template_author", "OPENECOMP");
  73         metadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, "Test");
  74         metadata.put("Template_version", "1.0.0");
  75         serviceTemplate.setTosca_definitions_version("tosca_simple_yaml_1_0_0");
  76         serviceTemplate.setDescription("testing desc tosca service template");
  77
  78         Import fileImport1 = new Import();
  79         fileImport1.setFile("path1/path2/file1.yaml");
  80         Import fileImport2 = new Import();
  81         fileImport2.setFile("path1/path2/file2.yaml");
  82         List<Map<String, Import>> imports = new ArrayList<>();
  83         Map<String, Import> importsMap = new HashMap<>();
  84         importsMap.put("myfile1", fileImport1);
  85         imports.add(importsMap);
  86         importsMap = new HashMap<>();
  87         importsMap.put("myfile2", fileImport2);
  88         imports.add(importsMap);
  89         serviceTemplate.setImports(imports);
  90
  91         OperationDefinition operationDefinition = new OperationDefinition();
  92         operationDefinition.setDescription("test operation");
  93         InterfaceType interfaceType = new InterfaceType();
  94         interfaceType.setDerived_from("derived_from");
  95         interfaceType.setDescription("desc");
  96         interfaceType.addOperation("test", operationDefinition);
  97         serviceTemplate.addInterfaceType("test_interface", interfaceType);
  98
  99         ArtifactType artifact = new ArtifactType();
 100         artifact.setMime_type("application/java-archive");
 101         ArrayList<String> ext = new ArrayList<>();
 102         ext.add("yaml");
 103         ext.add("xml");
 104         artifact.setFile_ext(ext);
 105         Map<String, ArtifactType> artifactTypes = new HashMap<>();
 106         artifactTypes.put("one_artifact", artifact);
 107         serviceTemplate.setArtifact_types(artifactTypes);
 108
 109         NodeType nodeType = new NodeType();
 110         nodeType.setDerived_from("tosca.nodes.Root");
 111         nodeType.setVersion("1.0.0");
 112         nodeType.setDescription("tosca compute test");
 113
 114         PropertyDefinition propDef1 = new PropertyDefinition();
 115         propDef1.setType("integer");
 116         propDef1.setDescription("Number of CPUs requested for a software node instance");
 117         propDef1.setRequired(true);
 118         propDef1.set_default(1);
 119
 120         Constraint graterOrEqual = new Constraint();
 121         graterOrEqual.setGreater_or_equal((float) 5.0);
 122         Constraint constraintEqual = new Constraint();
 123         constraintEqual.setEqual(5);
 124         Constraint greater_than = new Constraint();
 125         greater_than.setGreater_than(6.02);
 126         Constraint inRange = new Constraint();
 127         inRange.setIn_range(new Object[2]);
 128         inRange.getIn_range()[0] = 0;
 129         inRange.getIn_range()[1] = ToscaConstants.UNBOUNDED;
 130
 131         List<Constraint> constraints = new ArrayList<>();
 132         constraints.add(graterOrEqual);
 133         constraints.add(constraintEqual);
 134         constraints.add(greater_than);
 135         constraints.add(inRange);
 136         propDef1.setConstraints(constraints);
 137
 138         Map<String, PropertyDefinition> properties = new HashMap<>();
 139         properties.put("cpu_num", propDef1);
 140         nodeType.setProperties(properties);
 141
 142         Map<String, AttributeDefinition> attributesDef = new HashMap<>();
 143         AttributeDefinition attDef = new AttributeDefinition();
 144         attDef.setType(PropertyType.STRING.getDisplayName());
 145         attDef.set_default("hi");
 146         attributesDef.put("attDef1", attDef);
 147         nodeType.setAttributes(attributesDef);
 148
 149         Map<String, RequirementDefinition> reqsDef = new HashMap<>();
 150         RequirementDefinition reqDef = new RequirementDefinition();
 151         reqDef.setCapability("tosca.cap1");
 152         reqDef.getOccurrences()[0] = 5;
 153         reqsDef.put("re1", reqDef);
 154         List<Map<String, RequirementDefinition>> reqList = new ArrayList<>();
 155         reqList.add(reqsDef);
 156         nodeType.setRequirements(reqList);
 157
 158
 159         Map<String, CapabilityDefinition> capsDef = new HashMap<>();
 160         CapabilityDefinition capdef = new CapabilityDefinition();
 161         capdef.setType("tosca.cap");
 162         List<String> vvSource = new ArrayList<>();
 163         vvSource.add("node1");
 164         vvSource.add("node2");
 165         capdef.setValid_source_types(vvSource);
 166         capsDef.put("cap1", capdef);
 167         nodeType.setCapabilities(capsDef);
 168
 169         Map<String, NodeType> nodeTypes = new HashMap<>();
 170         nodeTypes.put("compute_node_type", nodeType);
 171         serviceTemplate.setNode_types(nodeTypes);
 172
 173         TopologyTemplate topologyTemplate = new TopologyTemplate();
 174         topologyTemplate.setDescription("topologi template descroption");
 175         Map<String, ParameterDefinition> inputs = new HashMap<>();
 176         ParameterDefinition paramDef = new ParameterDefinition();
 177         paramDef.setType(PropertyType.STRING.getDisplayName());
 178         paramDef.setDescription("desc");
 179         paramDef.set_default("my default val");
 180         paramDef.setRequired(false);
 181         paramDef.setEntry_schema(DataModelUtil.createEntrySchema("tosca.myType", null, null));
 182         List<Constraint> paramConstraint = new ArrayList<>();
 183         Constraint paramConst1 = new Constraint();
 184         paramConst1.setGreater_than(6);
 185         Constraint paramConst2 = new Constraint();
 186         paramConst2.setGreater_or_equal(9);
 187         paramConstraint.add(paramConst1);
 188         paramConstraint.add(paramConst2);
 189         paramDef.setConstraints(paramConstraint);
 190         inputs.put("inParam1", paramDef);
 191         topologyTemplate.setInputs(inputs);
 192
 193         Map<String, NodeTemplate> nodeTemplates = new HashMap<>();
 194         NodeTemplate nodeTemplate = new NodeTemplate();
 195         nodeTemplate.setType("nodeTypeRef");
 196         List<String> directives = new ArrayList<>();
 197         directives.add(Directive.SELECTABLE.getDisplayName());
 198         directives.add(Directive.SUBSTITUTABLE.getDisplayName());
 199         nodeTemplate.setDirectives(directives);
 200         Map<String, Object> nodeTemplateProperties = new HashMap<>();
 201         nodeTemplateProperties.put("prop1", "abcd");
 202         nodeTemplateProperties.put("prop2", "{ get_input: my_mysql_rootpw }");
 203         nodeTemplate.setProperties(nodeTemplateProperties);
 204         Map<String, Object> nodeTemplateAtts = new HashMap<>();
 205         nodeTemplateAtts.put("att1", "att1Val");
 206         nodeTemplateAtts.put("att2", "{ get_input: my_mysql_rootpw }");
 207         nodeTemplate.setAttributes(nodeTemplateAtts);
 208
 209
 210         RequirementAssignment reqAssignment1 = new RequirementAssignment();
 211         reqAssignment1.setNode("nodeA");
 212         reqAssignment1.setCapability("capA");
 213         reqAssignment1.setRelationship("relationB");
 214         Object[] reqAssOccurrences = new Object[2];
 215         reqAssOccurrences[0] = 1;
 216         reqAssOccurrences[1] = 2;
 217         reqAssignment1.setOccurrences(reqAssOccurrences);
 218         NodeFilter reqNodeFilter = new NodeFilter();
 219         List<Constraint> propConstraint1 = new ArrayList<>();
 220         Constraint propConst1 = new Constraint();
 221         propConst1.setGreater_or_equal(9);
 222         propConstraint1.add(propConst1);
 223         List<Constraint> propConstraint2 = new ArrayList<>();
 224         Constraint propConst2 = new Constraint();
 225         propConst2.setMin_length(1);
 226         propConstraint2.add(propConst2);
 227         Constraint propConst3 = new Constraint();
 228         propConst3.setMax_length(2);
 229         propConstraint2.add(propConst3);
 230         List<Map<String, List<Constraint>>> nodeFilterProp = new ArrayList<>();
 231         Map<String, List<Constraint>> propsMap = new HashMap<>();
 232         propsMap.put("propName1", propConstraint1);
 233         propsMap.put("propName2", propConstraint2);
 234         nodeFilterProp.add(propsMap);
 235         reqNodeFilter.setProperties(nodeFilterProp);
 236         reqAssignment1.setNode_filter(reqNodeFilter);
 237
 238         RequirementAssignment reqAssignment2 = new RequirementAssignment();
 239         reqAssignment2.setNode("nodeA");
 240         reqAssignment2.setCapability("capA");
 241         reqAssignment2.setRelationship("relationB");
 242         Map<String, RequirementAssignment> nodeTemplateRequirement1 = new HashMap<>();
 243         Map<String, RequirementAssignment> nodeTemplateRequirement2 = new HashMap<>();
 244         nodeTemplateRequirement1.put(REQ1, reqAssignment1);
 245         nodeTemplateRequirement2.put(REQ2, reqAssignment2);
 246         nodeTemplate.setRequirements(new ArrayList<>());
 247         nodeTemplate.getRequirements().add(nodeTemplateRequirement1);
 248         nodeTemplate.getRequirements().add(nodeTemplateRequirement2);
 249
 250         Map<String, CapabilityAssignment> nodeTemplateCapability = new HashMap<>();
 251         CapabilityAssignment capAss = new CapabilityAssignment();
 252         Map<String, Object> capProps = new HashMap<>();
 253         capProps.put("num_cpus", "{ get_input: cpus }");
 254         capAss.setProperties(capProps);
 255         Map<String, Object> capAtts = new HashMap<>();
 256         capAtts.put("num_cpus", "66");
 257         capAss.setAttributes(capAtts);
 258         nodeTemplateCapability.put("cap1", capAss);
 259         nodeTemplate.setCapabilities(nodeTemplateCapability);
 260
 261         NodeFilter nodeTemplateNodeFilter = new NodeFilter();
 262         List<Map<String, List<Constraint>>> nodeFilterProp2 = new ArrayList<>();
 263         Map<String, List<Constraint>> propsMap2 = new HashMap<>();
 264         Constraint c1 = new Constraint();
 265         c1.setEqual("1 MB");
 266         List<Constraint> consList = new ArrayList<>();
 267         consList.add(c1);
 268         propsMap2.put("test1", consList);
 269         nodeFilterProp2.add(propsMap2);
 270         nodeTemplateNodeFilter.setProperties(nodeFilterProp2);
 271         nodeTemplate.setNode_filter(nodeTemplateNodeFilter);
 272         nodeTemplates.put("firatNodeTemplate", nodeTemplate);
 273         topologyTemplate.setNode_templates(nodeTemplates);
 274
 275         SubstitutionMapping subMap = new SubstitutionMapping();
 276         subMap.setNode_type("myNodeType.node");
 277         Map<String, List<String>> mapCapabilities = new HashMap<>();
 278         List<String> NodeCap = new ArrayList<>();
 279         NodeCap.add("database");
 280         NodeCap.add("database_endpoint");
 281         mapCapabilities.put("database_endpoint", NodeCap);
 282         subMap.setCapabilities(mapCapabilities);
 283         topologyTemplate.setSubstitution_mappings(subMap);
 284         serviceTemplate.setTopology_template(topologyTemplate);
 285
 286         String yaml = new YamlUtil().objectToYaml(serviceTemplate);
 287         ServiceTemplate serviceTemplateFromYaml = new YamlUtil().yamlToObject(yaml, ServiceTemplate.class);
 288         Assert.assertNotNull(serviceTemplateFromYaml);
 289     }
 290
 291
 292   @Test
 293   public void testYamlToServiceTemplateObj() throws IOException {
 294     ServiceTemplate serviceTemplateFromYaml =
 295         getServiceTemplate(BASE_DIR + ST);
 296     Assert.assertNotNull(serviceTemplateFromYaml);
 297   }
 298
 299     @Test
 300     public void testYamlWithInterfaceToServiceTemplateObj() throws IOException {
 301         ServiceTemplate serviceTemplateWithOperation = getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 302         Assert.assertNotNull(serviceTemplateWithOperation);
 303
 304         InterfaceType expectedInterfaceType = createInterfaceType();
 305
 306         Map<String, InterfaceType> interfaceTypes = DataModelUtil.getInterfaceTypes(serviceTemplateWithOperation);
 307         Assert.assertEquals(1, interfaceTypes.size());
 308         InterfaceType actualInterfaceType = interfaceTypes.get(INTERFACE_ID);
 309         Assert.assertEquals(expectedInterfaceType, actualInterfaceType);
 310     }
 311
 312     @Test
 313     public void testAddOperationToInterface() throws IOException {
 314         YamlUtil yamlUtil = new YamlUtil();
 315         ServiceTemplate serviceTemplateWithInterface = getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE);
 316         ServiceTemplate serviceTemplateWithOperation = getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 317
 318         OperationDefinition operationDefinition = createOperationDefinition();
 319
 320         DataModelUtil.addInterfaceOperation(serviceTemplateWithInterface, INTERFACE_ID, OPERATION_START,
 321                 operationDefinition);
 322         String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithOperation);
 323         String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterface);
 324         Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
 325     }
 326
 327     @Test
 328     public void testInterfaceTypeToObjConversion() throws IOException {
 329         ServiceTemplate serviceTemplateWithInterface = getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE);
 330         ServiceTemplate serviceTemplateWithOperation = getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 331         InterfaceType interfaceType = createInterfaceType();
 332
 333         Optional<Object> interfaceAsObj = DataModelUtil.convertInterfaceTypeToObj(interfaceType);
 334         Assert.assertTrue(interfaceAsObj.isPresent());
 335
 336         Map<String, Object> interfaceTypes = new HashMap<>();
 337         interfaceTypes.put(INTERFACE_ID, interfaceAsObj.get());
 338         serviceTemplateWithInterface.setInterface_types(interfaceTypes);
 339
 340         String expectedServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithOperation);
 341         String actualServiceTemplate = yamlUtil.objectToYaml(serviceTemplateWithInterface);
 342         Assert.assertEquals(expectedServiceTemplate, actualServiceTemplate);
 343     }
 344
 345     @Test
 346     public void testObjToInterfaceTypeConversion() throws IOException, ReflectiveOperationException {
 347         ServiceTemplate serviceTemplateWithOperation = getServiceTemplate(BASE_DIR + ST_WITH_OPERATIONS);
 348         Map<String, Object> interfaceTypes = serviceTemplateWithOperation.getInterface_types();
 349         Object interfaceObj = interfaceTypes.get(INTERFACE_ID);
 350         Optional<InterfaceType> actualInterfaceType =
 351                 DataModelUtil.convertObjToInterfaceType(INTERFACE_ID, interfaceObj);
 352
 353         Assert.assertTrue(actualInterfaceType.isPresent());
 354         InterfaceType expectedInterfaceType = createInterfaceType();
 355         Assert.assertEquals(expectedInterfaceType, actualInterfaceType.get());
 356     }
 357
 358     @Test
 359     public void testObjToInterfaceDefinitionTypeConversion() throws IOException, ReflectiveOperationException {
 360         ServiceTemplate serviceTemplateWithInterfaceDef = getServiceTemplate(BASE_DIR + ST_WITH_NODE_INTERFACE_DEF);
 361         NodeType nodeTypeWithInterface = DataModelUtil.getNodeType(serviceTemplateWithInterfaceDef, NODE_TYPE_ID);
 362         Map<String, Object> interfaces = nodeTypeWithInterface.getInterfaces();
 363         Object interfaceObj = interfaces.get(INTERFACE_ID);
 364
 365         Optional<? extends InterfaceDefinition> actualInterfaceDefinition = DataModelUtil
 366                                                                                     .convertObjToInterfaceDefinition(
 367                                                                                             INTERFACE_ID, interfaceObj,
 368                                                                                             InterfaceDefinitionType.class);
 369
 370         Assert.assertTrue(actualInterfaceDefinition.isPresent());
 371
 372         InterfaceDefinitionType expectedInterfaceDefinitionType = createInterfaceDefinitionType();
 373         Assert.assertEquals(expectedInterfaceDefinitionType, actualInterfaceDefinition.get());
 374     }
 375
 376     @Test
 377     public void testObjToInterfaceDefinitionTemplateConversion() throws IOException, ReflectiveOperationException {
 378         ServiceTemplate serviceTemplateWithInterfaceDef = getServiceTemplate(BASE_DIR + ST_WITH_INTERFACE_DEF);
 379         NodeTemplate nodeTemplateWithInterface =
 380                 DataModelUtil.getNodeTemplate(serviceTemplateWithInterfaceDef, NODE_TEMPLATE_ID);
 381         Map<String, Object> interfaces = nodeTemplateWithInterface.getInterfaces();
 382         Object interfaceObj = interfaces.get(INTERFACE_ID);
 383
 384         Optional<? extends InterfaceDefinition> actualInterfaceDefinition = DataModelUtil
 385                                                                                     .convertObjToInterfaceDefinition(
 386                                                                                             INTERFACE_ID, interfaceObj,
 387                                                                                             InterfaceDefinitionTemplate.class);
 388
 389         Assert.assertTrue(actualInterfaceDefinition.isPresent());
 390         InterfaceDefinitionTemplate expectedInterfaceDefinitionTemplate = createInterfaceDefinitionTemplate();
 391         Assert.assertEquals(expectedInterfaceDefinitionTemplate, actualInterfaceDefinition.get());
 392     }
 393
 394     @Test
 395     public void testYamlToServiceTemplateIncludingHeatExtend() throws IOException {
 396         ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
 397         try (InputStream yamlFile = toscaExtensionYamlUtil
 398                                             .loadYamlFileIs(BASE_DIR + "/serviceTemplateHeatExtend.yaml")) {
 399             ServiceTemplate serviceTemplateFromYaml =
 400                     toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 401             ParameterDefinitionExt parameterDefinitionExt =
 402                     (ParameterDefinitionExt) serviceTemplateFromYaml.getTopology_template().getInputs().get("inParam1");
 403             Assert.assertNotNull(parameterDefinitionExt.getLabel());
 404             String backToYamlString = toscaExtensionYamlUtil.objectToYaml(serviceTemplateFromYaml);
 405             Assert.assertNotNull(backToYamlString);
 406         }
 407     }
 408
 409     @Test
 410     public void testServiceFilter() throws IOException {
 411         ServiceTemplate serviceTemplateWithServiceFilter = getServiceTemplateExt(BASE_DIR + ST_WITH_SERVICE_FILTER);
 412
 413         NodeTemplate firstNodeTemplate =
 414                 DataModelUtil.getNodeTemplate(serviceTemplateWithServiceFilter, FIRST_NODE_TEMPLATE);
 415         Map<String, RequirementAssignment> nodeTemplateRequirements =
 416                 DataModelUtil.getNodeTemplateRequirements(firstNodeTemplate);
 417
 418         Object req1 = nodeTemplateRequirements.get(REQ1);
 419         Assert.assertEquals(true, req1 instanceof org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment);
 420         Assert.assertNotNull(((org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment)req1).getService_filter());
 421         List<Map<String, List<Constraint>>> properties =
 422                 ((org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment) req1).getService_filter()
 423                                                                                            .getProperties();
 424         Assert.assertNotNull(properties);
 425         List<Constraint> vmdNameConstrain = properties.get(0).get(VMD_NAME);
 426         Assert.assertNotNull(vmdNameConstrain);
 427         Assert.assertNotNull(vmdNameConstrain.get(0).getEqual());
 428
 429         List<Map<String, CapabilityFilter>> capabilities =
 430                 ((org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment) req1).getService_filter()
 431                                                                                            .getCapabilities();
 432         Assert.assertNotNull(capabilities);
 433         CapabilityFilter capabilityFilter = capabilities.get(0).get(DIRECTOR);
 434         Assert.assertNotNull(capabilityFilter);
 435         Assert.assertNotNull(capabilityFilter.getProperties());
 436
 437
 438         Object req2 = nodeTemplateRequirements.get(REQ2);
 439         Assert.assertEquals(true, req2 instanceof org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment);
 440         Assert.assertNotNull(((org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment)req2).getService_filter());
 441         Object tosca_id =
 442                 ((org.onap.sdc.tosca.datatypes.model.extension.RequirementAssignment) req2).getService_filter()
 443                                                                                            .getTosca_id();
 444         Assert.assertNotNull(tosca_id);
 445         Assert.assertEquals(SERVICE_FILTER_TOSCA_ID, tosca_id.toString());
 446
 447
 448         String serviceTemplateYaml = toscaExtensionYamlUtil.objectToYaml(serviceTemplateWithServiceFilter);
 449         Assert.assertNotNull(serviceTemplateYaml);
 450
 451     }
 452
 453     @Test
 454     public void testSubstitutionMapping() throws IOException {
 455         ServiceTemplate serviceTemplate = getServiceTemplateExt(BASE_DIR + SUBSTITUTION_MAPPING);
 456
 457         SubstitutionMapping substitutionMappings = DataModelUtil.getSubstitutionMappings(serviceTemplate);
 458         Assert.assertEquals("myNodeType.node", substitutionMappings.getNode_type());
 459         Assert.assertNotNull(substitutionMappings.getCapabilities());
 460         Assert.assertEquals(1,substitutionMappings.getCapabilities().size());
 461         Assert.assertNotNull(substitutionMappings.getRequirements());
 462         Assert.assertEquals(1,substitutionMappings.getRequirements().size());
 463         Assert.assertEquals(true, substitutionMappings instanceof SubstitutionMappingExt);
 464         Assert.assertNull(((SubstitutionMappingExt)substitutionMappings).getSubstitution_filter());
 465
 466     }
 467
 468     @Test
 469     public void testSubstitutionMappingExt() throws IOException {
 470         ServiceTemplate serviceTemplate = getServiceTemplateExt(BASE_DIR + SUBSTITUTION_MAPPING_EXT);
 471
 472         SubstitutionMapping substitutionMappings = DataModelUtil.getSubstitutionMappings(serviceTemplate);
 473         Assert.assertEquals("myNodeType.node", substitutionMappings.getNode_type());
 474         Assert.assertNotNull(substitutionMappings.getCapabilities());
 475         Assert.assertEquals(1,substitutionMappings.getCapabilities().size());
 476         Assert.assertNotNull(substitutionMappings.getRequirements());
 477         Assert.assertEquals(1,substitutionMappings.getRequirements().size());
 478         Assert.assertEquals(true, substitutionMappings instanceof SubstitutionMappingExt);
 479         SubstitutionFilter substitutionFilter = ((SubstitutionMappingExt) substitutionMappings).getSubstitution_filter();
 480         Assert.assertNotNull(substitutionFilter);
 481         Assert.assertNotNull(substitutionFilter.getProperties());
 482         Assert.assertEquals(2,substitutionFilter.getProperties().size());
 483         List<Constraint> vendorFilter = substitutionFilter.getProperties().get(0).get("vendor");
 484         Assert.assertNotNull(vendorFilter);
 485         Assert.assertNotNull(vendorFilter.get(0).getEqual());
 486
 487
 488
 489     }
 490
 491     private ServiceTemplate getServiceTemplate(String inputPath) throws IOException {
 492         try (InputStream yamlFile = yamlUtil.loadYamlFileIs(inputPath)) {
 493             return yamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 494         }
 495     }
 496
 497     private ServiceTemplate getServiceTemplateExt(String inputPath) throws IOException {
 498         try (InputStream yamlFile = toscaExtensionYamlUtil.loadYamlFileIs(inputPath)) {
 499             return toscaExtensionYamlUtil.yamlToObject(yamlFile, ServiceTemplate.class);
 500         }
 501     }
 502
 503     private InterfaceType createInterfaceType() {
 504         OperationDefinition operationDefinition = createOperationDefinition();
 505         InterfaceType interfaceType = new InterfaceType();
 506         interfaceType.setDescription("test interface");
 507         interfaceType.addOperation(OPERATION_START, operationDefinition);
 508         return interfaceType;
 509     }
 510
 511     private OperationDefinition createOperationDefinition() {
 512         OperationDefinition operationDefinition = new OperationDefinition();
 513         operationDefinition.setDescription(OPERATION_DESC);
 514         return operationDefinition;
 515     }
 516
 517     private InterfaceDefinitionType createInterfaceDefinitionType() {
 518         OperationDefinitionType operationDefinitionType = createOperationDefinitionType();
 519         InterfaceDefinitionType interfaceDefinitionType = new InterfaceDefinitionType();
 520         interfaceDefinitionType.setType(INTERFACE_TYPE_VALUE);
 521         interfaceDefinitionType.addOperation(OPERATION_START, operationDefinitionType);
 522         return interfaceDefinitionType;
 523     }
 524
 525     private InterfaceDefinitionTemplate createInterfaceDefinitionTemplate() {
 526         OperationDefinitionTemplate operationDefinitionTemplate = createOperationDefinitionTemplate();
 527         InterfaceDefinitionTemplate interfaceDefinitionTemplate = new InterfaceDefinitionTemplate();
 528         interfaceDefinitionTemplate.addOperation(OPERATION_START, operationDefinitionTemplate);
 529         return interfaceDefinitionTemplate;
 530     }
 531
 532     private OperationDefinitionTemplate createOperationDefinitionTemplate() {
 533         OperationDefinitionTemplate operationDefinitionTemplate = new OperationDefinitionTemplate();
 534         operationDefinitionTemplate.setDescription(OPERATION_DESC);
 535         Implementation implementation = new Implementation();
 536         implementation.setPrimary(PRIMARY_IMPL);
 537         List<String> dependencies = new ArrayList<>();
 538         dependencies.add(DEPENDENCY_NAME);
 539         implementation.setDependencies(dependencies);
 540         operationDefinitionTemplate.setImplementation(implementation);
 541         return operationDefinitionTemplate;
 542     }
 543
 544     private OperationDefinitionType createOperationDefinitionType() {
 545         OperationDefinitionType operationDefinitionType = new OperationDefinitionType();
 546         operationDefinitionType.setDescription(OPERATION_DESC);
 547         operationDefinitionType.setImplementation(IMPLEMENTATION_NAME);
 548         PropertyDefinition propertyDefinition = new PropertyDefinition();
 549         propertyDefinition.setType(STRING_TYPE);
 550         return operationDefinitionType;
 551     }
 552 }
 553
 554
 555
 556
 557
 558