gerrit.onap Code Review - sdc.git/blob

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