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