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