ms/blueprintsprocessor/modules/blueprints/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/dsl/BlueprintDSLTest.kt

   1 /*
   2  *  Copyright © 2019 IBM.
   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.onap.ccsdk.cds.controllerblueprints.core.dsl
  18
  19 import com.fasterxml.jackson.databind.JsonNode
  20 import org.junit.Test
  21 import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
  22 import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
  23 import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
  24 import org.onap.ccsdk.cds.controllerblueprints.core.jsonAsJsonType
  25 import kotlin.test.assertNotNull
  26
  27 class BlueprintDSLTest {
  28
  29     @Test
  30     fun testOperationDSLWorkflow() {
  31
  32         val blueprint = blueprint(
  33             "sample-bp", "1.0.0",
  34             "brindasanth@onap.com", "sample, blueprints"
  35         ) {
  36
  37             artifactType(BlueprintTypes.artifactTypeTemplateVelocity())
  38
  39             // For New Component Definition
  40             component(
  41                 "resource-resolution", "component-script-executor", "1.0.0",
  42                 "Resource Resolution component."
  43             ) {
  44                 implementation(180)
  45                 // Attributes ( Properties which will be set during execution)
  46                 attribute("template1-data", "string", true, "")
  47
  48                 // Properties
  49                 property("string-value1", "string", true, "sample")
  50                 property("string-value2", "string", true, getInput("key-1"))
  51                 // Inputs
  52                 input("json-content", "json", true, """{ "name" : "cds"}""")
  53                 input("template-content", "string", true, getArtifact("template1"))
  54                 // Outputs
  55                 output("self-attribute-expression", "json", true, getAttribute("template1-data"))
  56                 // Artifacts
  57                 artifact("template1", "artifact-template-velocity", "Templates/template1.vtl")
  58             }
  59
  60             // Already definitions Registered Components
  61             registryComponent(
  62                 "activate-restconf", "component-resource-resolution", "1.0.0",
  63                 "RestconfExecutor", "Resource Resolution component."
  64             ) {
  65                 implementation(180)
  66                 // Properties
  67                 property("string-value1", "data")
  68                 // Inputs
  69                 input("json-content", """{ "name" : "cds"}""")
  70                 // Outputs
  71                 output("self-attribute-expression", getAttribute("template1-data"))
  72                 // Artifacts
  73                 artifact("template2", "artifact-template-velocity", "Templates/template1.vtl")
  74             }
  75
  76             workflow("resource-resolution-process", "Resource Resolution wf") {
  77                 input("json-content", "json", true, "")
  78                 input("key-1", "string", true, "")
  79                 output("status", "string", true, "success")
  80                 step("resource-resolution-call", "resource-resolution", "Resource Resolution component invoke")
  81             }
  82         }
  83         assertNotNull(blueprint.components, "failed to get components")
  84         assertNotNull(blueprint.workflows, "failed to get workflows")
  85         // println(blueprint.asJsonString(true))
  86
  87         val serviceTemplateGenerator = BlueprintServiceTemplateGenerator(blueprint)
  88         val serviceTemplate = serviceTemplateGenerator.serviceTemplate()
  89         assertNotNull(serviceTemplate.topologyTemplate, "failed to get service topology template")
  90         // println(serviceTemplate.asJsonString(true))
  91     }
  92
  93     @Test
  94     fun testServiceTemplate() {
  95         val serviceTemplate = serviceTemplate(
  96             "sample-bp", "1.0.0",
  97             "brindasanth@onap.com", "sample, blueprints"
  98         ) {
  99             metadata("release", "1806")
 100             import("Definition/data_types.json")
 101             dsl("rest-endpoint", """{ "selector" : "odl-selector"}""")
 102             dsl("db-endpoint", """{ "selector" : "db-selector"}""")
 103
 104             nodeTypeComponent()
 105             nodeTypeResourceSource()
 106             nodeTypeVnf()
 107
 108             artifactTypeTemplateVelocity()
 109             artifactTypeTempleJinja()
 110             artifactTypeScriptKotlin()
 111             artifactTypeMappingResource()
 112             artifactTypeComponentJar()
 113             artifactTypeK8sProfileFolder()
 114
 115             relationshipTypeConnectsTo()
 116             relationshipTypeDependsOn()
 117             relationshipTypeHostedOn()
 118
 119             topologyTemplate {
 120                 nodeTemplateOperation(
 121                     nodeTemplateName = "activate", type = "sample-node-type", interfaceName = "RestconfExecutor",
 122                     description = "sample activation"
 123                 ) {
 124                     implementation(360, "SELF") {
 125                         primary("Scripts/sample.py")
 126                         dependencies("one", "two")
 127                     }
 128                     inputs {
 129                         property("json-content", """{ "name" : "cds"}""")
 130                         property("array-content", """["controller", "blueprints"]""")
 131                         property("int-value", 234)
 132                         property("boolean-value", true)
 133                         property("string-value", "sample")
 134                         property("input-expression", getInput("key-1"))
 135                         property("self-property-expression", getProperty("key-1"))
 136                         property("self-artifact-expression", getArtifact("key-1"))
 137                         property("other-artifact-expression", getNodeTemplateArtifact("node-1", "key-1"))
 138                     }
 139                     outputs {
 140                         property("self-attribute-expression", getAttribute("key-1"))
 141                     }
 142                 }
 143                 // Other way of defining Node Template with artifacts, implementation
 144                 nodeTemplate("resolve", "sample-resolve-type", "Resource Resolution") {
 145                     operation("ResourceResolutionExecutor", "") {
 146                         implementation(180)
 147                         inputs {
 148                             property("boolean-value", true)
 149                             property("string-value", "sample")
 150                         }
 151                         outputs {
 152                             property("resolve-expression", getAttribute("key-1"))
 153                         }
 154                     }
 155                     artifact("sample-template", "artifact-velocity", "Templates/sample-template.vtl")
 156                 }
 157
 158                 workflow("resource-resolution", "to resolve resources") {
 159                     step("resource-resolution-call", "resolve", "Resource Resolution component invoke")
 160                 }
 161                 // Alternate way to define workflow
 162                 workflow("activate", "to resolve resources") {
 163                     // Alternate step definition
 164                     step("netconf-activate-call", "activate", "call activation component") {
 165                         success("END")
 166                         failure("END")
 167                     }
 168                     inputs {
 169                         property("request-content", "json", true)
 170                     }
 171                     outputs {
 172                         property("response-content", "json", true) {
 173                             value(getAttribute("key-1"))
 174                             defaultValue("""{ "status" : "success"}""".jsonAsJsonType())
 175                         }
 176                     }
 177                 }
 178             }
 179         }
 180
 181         // println(serviceTemplate.asJsonString(true))
 182         assertNotNull(serviceTemplate.artifactTypes, "failed to get artifactTypes")
 183         assertNotNull(serviceTemplate.nodeTypes, "failed to get nodeTypes")
 184         assertNotNull(serviceTemplate.relationshipTypes, "failed to get relationshipTypes")
 185         assertNotNull(serviceTemplate.topologyTemplate, "failed to get topology template")
 186         assertNotNull(serviceTemplate.topologyTemplate?.nodeTemplates, "failed to get nodeTypes")
 187         assertNotNull(
 188             serviceTemplate.topologyTemplate?.nodeTemplates!!["activate"],
 189             "failed to get nodeTypes(activate)"
 190         )
 191     }
 192
 193     @Test
 194     fun testNodeTypePropertyConstrains() {
 195         val nodeType = nodeType("data-node", "1.0.0", "tosca.Nodes.root", "") {
 196             property("ip-address", "string", true, "") {
 197                 defaultValue("127.0.0.1")
 198                 constrain {
 199                     validValues(arrayListOf("""127.0.0.1""".asJsonPrimitive()))
 200                     length(10)
 201                     maxLength(20)
 202                     minLength(10)
 203                 }
 204             }
 205             property("disk-space", "string", true, "") {
 206                 defaultValue(10)
 207                 constrain {
 208                     validValues("""["200KB", "400KB"]""")
 209                     equal("200KB")
 210                     inRange("""["100KB", "500KB" ]""")
 211                     maxLength("10MB")
 212                     minLength("10KB")
 213                 }
 214                 constrain {
 215                     validValues("""[ 200, 400]""")
 216                     greaterOrEqual("10KB")
 217                     greaterThan("20KB")
 218                     lessOrEqual("200KB")
 219                     lessThan("190KB")
 220                 }
 221             }
 222         }
 223         assertNotNull(nodeType, "failed to get nodeType")
 224         // println(nodeType.asJsonString(true))
 225     }
 226
 227     @Test
 228     fun testServiceTemplateWorkflow() {
 229         val serviceTemplate = serviceTemplate(
 230             "sample-bp", "1.0.0",
 231             "brindasanth@onap.com", "sample, blueprints"
 232         ) {
 233             topologyTemplate {
 234                 workflowNodeTemplate("activate", "component-resource-resolution", "") {
 235                     operation("ResourceResolutionExecutor", "") {
 236                         inputs {
 237                             property("string-value", "sample")
 238                         }
 239                     }
 240                 }
 241             }
 242         }
 243         assertNotNull(serviceTemplate.topologyTemplate, "failed to get topology template")
 244         assertNotNull(serviceTemplate.topologyTemplate?.workflows?.get("activate"), "failed to get workflow(activate)")
 245         // println(serviceTemplate.asJsonString(true))
 246     }
 247
 248     @Test
 249     fun testNodeTemplateOperationTypes() {
 250
 251         val testNodeTemplateInstance = BlueprintTypes.nodeTemplateComponentTestExecutor(
 252             id = "test-node-template",
 253             description = ""
 254         ) {
 255             definedProperties {
 256                 prop1("i am property1")
 257                 prop2("i am property2")
 258             }
 259             definedOperation("") {
 260                 implementation(360)
 261                 inputs {
 262                     request("i am request")
 263                 }
 264                 outputs {
 265                     response(getAttribute("attribute1"))
 266                 }
 267             }
 268         }
 269         assertNotNull(testNodeTemplateInstance, "failed to get test node template")
 270         // println(testNodeTemplateInstance.asJsonString(true))
 271     }
 272 }
 273
 274 fun BlueprintTypes.nodeTemplateComponentTestExecutor(
 275     id: String,
 276     description: String,
 277     block: TestNodeTemplateOperationImplBuilder.() -> Unit
 278 ):
 279     NodeTemplate {
 280         return TestNodeTemplateOperationImplBuilder(id, description).apply(block).build()
 281     }
 282
 283 class TestNodeTemplateOperationImplBuilder(id: String, description: String) :
 284     AbstractNodeTemplateOperationImplBuilder<TestProperty, TestInput, TestOutput>(
 285         id, "component-test-executor",
 286         "ComponentTestExecutor",
 287         description
 288     )
 289
 290 class TestProperty : PropertiesAssignmentBuilder() {
 291
 292     fun prop1(prop1: String) {
 293         property("prop1", prop1.asJsonPrimitive())
 294     }
 295
 296     fun prop2(prop2: String) {
 297         property("prop2", prop2.asJsonPrimitive())
 298     }
 299 }
 300
 301 class TestInput : PropertiesAssignmentBuilder() {
 302
 303     fun request(request: String) {
 304         property("request", request.asJsonPrimitive())
 305     }
 306 }
 307
 308 class TestOutput : PropertiesAssignmentBuilder() {
 309
 310     fun response(response: String) {
 311         response(response.asJsonPrimitive())
 312     }
 313
 314     fun response(response: JsonNode) {
 315         property("response", response)
 316     }
 317 }