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

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2018 IBM.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.onap.ccsdk.cds.controllerblueprints.core.service
  19
  20 import com.fasterxml.jackson.databind.ObjectMapper
  21 import org.junit.Test
  22 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
  23 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
  24 import org.onap.ccsdk.cds.controllerblueprints.core.TestConstants
  25 import org.onap.ccsdk.cds.controllerblueprints.core.data.Activity
  26 import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
  27 import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityAssignment
  28 import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
  29 import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceAssignment
  30 import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceDefinition
  31 import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
  32 import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
  33 import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationAssignment
  34 import org.onap.ccsdk.cds.controllerblueprints.core.data.PolicyType
  35 import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementAssignment
  36 import org.onap.ccsdk.cds.controllerblueprints.core.data.ServiceTemplate
  37 import org.onap.ccsdk.cds.controllerblueprints.core.data.Step
  38 import org.onap.ccsdk.cds.controllerblueprints.core.data.TopologyTemplate
  39 import org.onap.ccsdk.cds.controllerblueprints.core.data.Workflow
  40 import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
  41 import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
  42 import org.slf4j.LoggerFactory
  43 import kotlin.test.assertEquals
  44 import kotlin.test.assertNotNull
  45 import kotlin.test.assertNull
  46 import kotlin.test.assertTrue
  47
  48 /**
  49  *
  50  *
  51  * @author Brinda Santh
  52  */
  53 class BluePrintContextTest {
  54
  55     private val log = LoggerFactory.getLogger(this::class.toString())
  56
  57     val blueprintBasePath = TestConstants.PATH_TEST_BLUEPRINTS_BASECONFIG
  58
  59     @Test
  60     fun testBluePrintContextCreation() {
  61         val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(blueprintBasePath)
  62         assertNotNull(bluePrintContext, "Failed to populate Blueprint context")
  63     }
  64
  65     @Test
  66     fun testChainedProperty() {
  67         val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(blueprintBasePath)
  68         val nodeType = bluePrintContext.nodeTypeChained("component-resource-resolution")
  69         assertNotNull(nodeType, "Failed to get chained node type")
  70         log.trace("Properties {}", JacksonUtils.getJson(nodeType, true))
  71     }
  72
  73     @Test
  74     fun testImports() {
  75         val serviceTemplate = ServiceTemplate()
  76         serviceTemplate.imports = mutableListOf()
  77         val bluePrintContext = BluePrintContext(serviceTemplate)
  78
  79         assertTrue(bluePrintContext.imports()!!.isEmpty())
  80
  81         serviceTemplate.imports = null
  82         assertNull(bluePrintContext.imports())
  83     }
  84
  85     @Test
  86     fun testDataTypes() {
  87         val serviceTemplate = ServiceTemplate()
  88         serviceTemplate.dataTypes = mutableMapOf()
  89         val bluePrintContext = BluePrintContext(serviceTemplate)
  90
  91         assertTrue(bluePrintContext.dataTypes()!!.isEmpty())
  92
  93         serviceTemplate.dataTypes = null
  94         assertNull(bluePrintContext.dataTypes())
  95     }
  96
  97     @Test
  98     fun testInputs() {
  99         val topologyTemplate = TopologyTemplate()
 100         topologyTemplate.inputs = mutableMapOf()
 101         val serviceTemplate = ServiceTemplate()
 102         serviceTemplate.topologyTemplate = topologyTemplate
 103         val bluePrintContext = BluePrintContext(serviceTemplate)
 104
 105         assertTrue(bluePrintContext.inputs()!!.isEmpty())
 106
 107         topologyTemplate.inputs = null
 108
 109         assertNull(bluePrintContext.inputs())
 110     }
 111
 112     @Test
 113     fun testBluePrintJson() {
 114         val serviceTemplate = ServiceTemplate()
 115         val bluePrintContext = BluePrintContext(serviceTemplate)
 116
 117         assertEquals("{\"tosca_definitions_version\":\"controller_blueprint_1_0_0\"}", bluePrintContext.blueprintJson())
 118     }
 119
 120     @Test(expected = BluePrintException::class)
 121     fun testName() {
 122         val serviceTemplate = ServiceTemplate()
 123         serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_NAME to "hello")
 124         val bluePrintContext = BluePrintContext(serviceTemplate)
 125
 126         assertEquals("hello", bluePrintContext.name())
 127
 128         serviceTemplate.metadata = mutableMapOf()
 129         val bluePrintContext2 = BluePrintContext(serviceTemplate)
 130         bluePrintContext2.name()
 131     }
 132
 133     @Test(expected = BluePrintException::class)
 134     fun testVersion() {
 135         val serviceTemplate = ServiceTemplate()
 136         serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_VERSION to "hello")
 137         val bluePrintContext = BluePrintContext(serviceTemplate)
 138
 139         assertEquals("hello", bluePrintContext.version())
 140
 141         serviceTemplate.metadata = mutableMapOf()
 142         val bluePrintContext2 = BluePrintContext(serviceTemplate)
 143         bluePrintContext2.version()
 144     }
 145
 146     @Test(expected = BluePrintException::class)
 147     fun testAuthor() {
 148         val serviceTemplate = ServiceTemplate()
 149         serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_AUTHOR to "hello")
 150         val bluePrintContext = BluePrintContext(serviceTemplate)
 151
 152         assertEquals("hello", bluePrintContext.author())
 153
 154         serviceTemplate.metadata = mutableMapOf()
 155         val bluePrintContext2 = BluePrintContext(serviceTemplate)
 156         bluePrintContext2.author()
 157     }
 158
 159     @Test
 160     fun testWorkflows() {
 161         val topologyTemplate = TopologyTemplate()
 162         topologyTemplate.workflows = mutableMapOf()
 163         val serviceTemplate = ServiceTemplate()
 164         serviceTemplate.topologyTemplate = topologyTemplate
 165         val bluePrintContext = BluePrintContext(serviceTemplate)
 166
 167         assertTrue(bluePrintContext.workflows()!!.isEmpty())
 168
 169         topologyTemplate.workflows = null
 170         assertNull(bluePrintContext.workflows())
 171     }
 172
 173     @Test(expected = BluePrintException::class)
 174     fun testWorkFlowsByName() {
 175         val topologyTemplate = TopologyTemplate()
 176         topologyTemplate.workflows = mutableMapOf("workflow" to Workflow())
 177         val serviceTemplate = ServiceTemplate()
 178         serviceTemplate.topologyTemplate = topologyTemplate
 179         val bluePrintContext = BluePrintContext(serviceTemplate)
 180
 181         assertNotNull(bluePrintContext.workflowByName("workflow"))
 182
 183         bluePrintContext.workflowByName("")
 184     }
 185
 186     @Test
 187     fun testWorkflowInput() {
 188         val topologyTemplate = TopologyTemplate()
 189         val workflow = Workflow()
 190         workflow.inputs = mutableMapOf()
 191         topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
 192         val serviceTemplate = ServiceTemplate()
 193         serviceTemplate.topologyTemplate = topologyTemplate
 194         val bluePrintContext = BluePrintContext(serviceTemplate)
 195
 196         assertTrue(bluePrintContext.workflowInputs("workflow")!!.isEmpty())
 197
 198         workflow.inputs = null
 199
 200         assertNull(bluePrintContext.workflowInputs("workflow"))
 201     }
 202
 203     @Test(expected = BluePrintException::class)
 204     fun testWorkflowStepByName() {
 205         val topologyTemplate = TopologyTemplate()
 206         val workflow = Workflow()
 207         workflow.steps = mutableMapOf("step" to Step())
 208         topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
 209         val serviceTemplate = ServiceTemplate()
 210         serviceTemplate.topologyTemplate = topologyTemplate
 211         val bluePrintContext = BluePrintContext(serviceTemplate)
 212
 213         assertNotNull(bluePrintContext.workflowStepByName("workflow", "step"))
 214
 215         bluePrintContext.workflowStepByName("workflow", "")
 216     }
 217
 218     @Test(expected = BluePrintException::class)
 219     fun testWorkflowStepNodeTemplate() {
 220         val topologyTemplate = TopologyTemplate()
 221         val workflow = Workflow()
 222         val step = Step()
 223         step.target = "hello"
 224         workflow.steps = mutableMapOf("step" to step)
 225         topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
 226         val serviceTemplate = ServiceTemplate()
 227         serviceTemplate.topologyTemplate = topologyTemplate
 228         val bluePrintContext = BluePrintContext(serviceTemplate)
 229
 230         assertEquals("hello", bluePrintContext.workflowStepNodeTemplate("workflow", "step"))
 231
 232         bluePrintContext.workflowStepNodeTemplate("workflow", "")
 233     }
 234
 235     @Test(expected = BluePrintException::class)
 236     fun testWorkflowFirstStepNodeTemplate() {
 237         val topologyTemplate = TopologyTemplate()
 238         val workflow = Workflow()
 239         val step = Step()
 240         step.target = "hello"
 241         workflow.steps = mutableMapOf("step" to step, "step2" to Step())
 242         topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
 243         val serviceTemplate = ServiceTemplate()
 244         serviceTemplate.topologyTemplate = topologyTemplate
 245         val bluePrintContext = BluePrintContext(serviceTemplate)
 246
 247         assertEquals("hello", bluePrintContext.workflowFirstStepNodeTemplate("workflow"))
 248
 249         workflow.steps = null
 250         bluePrintContext.workflowFirstStepNodeTemplate("workflow")
 251     }
 252
 253     @Test(expected = BluePrintException::class)
 254     fun testWorkflowStepFirstCallOperation() {
 255         val topologyTemplate = TopologyTemplate()
 256         val workflow = Workflow()
 257         val step = Step()
 258         val activity = Activity()
 259         activity.callOperation = "hello"
 260         step.activities = arrayListOf(activity)
 261         workflow.steps = mutableMapOf("step" to step)
 262         topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
 263         val serviceTemplate = ServiceTemplate()
 264         serviceTemplate.topologyTemplate = topologyTemplate
 265         val bluePrintContext = BluePrintContext(serviceTemplate)
 266
 267         assertEquals("hello", bluePrintContext.workflowStepFirstCallOperation("workflow", "step"))
 268
 269         bluePrintContext.workflowStepFirstCallOperation("workflow", "")
 270     }
 271
 272     @Test
 273     fun testDatatypeByName() {
 274         val serviceTemplate = ServiceTemplate()
 275         serviceTemplate.dataTypes = mutableMapOf("data" to DataType())
 276         val bluePrintContext = BluePrintContext(serviceTemplate)
 277
 278         assertNotNull(bluePrintContext.dataTypeByName("data"))
 279         assertNull(bluePrintContext.dataTypeByName(""))
 280     }
 281
 282     @Test
 283     fun testArtifactTypes() {
 284         val serviceTemplate = ServiceTemplate()
 285         serviceTemplate.artifactTypes = mutableMapOf()
 286         val bluePrintContext = BluePrintContext(serviceTemplate)
 287
 288         assertTrue(bluePrintContext.artifactTypes()!!.isEmpty())
 289
 290         serviceTemplate.artifactTypes = null
 291         assertNull(bluePrintContext.artifactTypes())
 292     }
 293
 294     @Test
 295     fun testPolicyTypes() {
 296         val serviceTemplate = ServiceTemplate()
 297         serviceTemplate.policyTypes = mutableMapOf()
 298         val bluePrintContext = BluePrintContext(serviceTemplate)
 299
 300         assertTrue(bluePrintContext.policyTypes()!!.isEmpty())
 301
 302         serviceTemplate.policyTypes = null
 303         assertNull(bluePrintContext.policyTypes())
 304     }
 305
 306     @Test(expected = BluePrintException::class)
 307     fun testPolicyTypeByName() {
 308         val serviceTemplate = ServiceTemplate()
 309         serviceTemplate.policyTypes = mutableMapOf("policy" to PolicyType())
 310         val bluePrintContext = BluePrintContext(serviceTemplate)
 311
 312         assertNotNull(bluePrintContext.policyTypeByName("policy"))
 313
 314         bluePrintContext.policyTypeByName("")
 315     }
 316
 317     @Test
 318     fun testPolicyTypesDerivedFrom() {
 319         val serviceTemplate = ServiceTemplate()
 320         val policyType = PolicyType()
 321         policyType.derivedFrom = "hi"
 322         val policyType2 = PolicyType()
 323         policyType2.derivedFrom = "hello"
 324         serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
 325         val bluePrintContext = BluePrintContext(serviceTemplate)
 326
 327         assertEquals(1, bluePrintContext.policyTypesDerivedFrom("hi")!!.size)
 328
 329         serviceTemplate.policyTypes = null
 330         assertNull(bluePrintContext.policyTypesDerivedFrom("hi"))
 331     }
 332
 333     @Test
 334     fun testPolicyTypesTarget() {
 335         val serviceTemplate = ServiceTemplate()
 336         val policyType = PolicyType()
 337         policyType.targets = mutableListOf("hi")
 338         val policyType2 = PolicyType()
 339         policyType2.targets = mutableListOf()
 340         serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
 341         val bluePrintContext = BluePrintContext(serviceTemplate)
 342
 343         assertEquals(1, bluePrintContext.policyTypesTarget("hi")!!.size)
 344
 345         serviceTemplate.policyTypes = null
 346         assertNull(bluePrintContext.policyTypesTarget("hi"))
 347     }
 348
 349     @Test
 350     fun testPolicyTypesTargetNDerivedFrom() {
 351         val serviceTemplate = ServiceTemplate()
 352         val policyType = PolicyType()
 353         policyType.targets = mutableListOf("hi")
 354         policyType.derivedFrom = "hi"
 355         val policyType2 = PolicyType()
 356         policyType2.targets = mutableListOf()
 357         policyType2.derivedFrom = "hi"
 358         serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
 359         val bluePrintContext = BluePrintContext(serviceTemplate)
 360
 361         assertEquals(1, bluePrintContext.policyTypesTargetNDerivedFrom("hi", "hi")!!.size)
 362
 363         serviceTemplate.policyTypes = null
 364         assertNull(bluePrintContext.policyTypesTargetNDerivedFrom("hi", "hi"))
 365     }
 366
 367     @Test
 368     fun testNodeTypeDerivedFrom() {
 369         val serviceTemplate = ServiceTemplate()
 370         val nodeType = NodeType()
 371         nodeType.derivedFrom = "hi"
 372         val nodeType2 = NodeType()
 373         nodeType2.derivedFrom = "hiii"
 374         serviceTemplate.nodeTypes = mutableMapOf("node" to nodeType, "node2" to nodeType2)
 375         val bluePrintContext = BluePrintContext(serviceTemplate)
 376
 377         assertEquals(1, bluePrintContext.nodeTypeDerivedFrom("hi")!!.size)
 378
 379         serviceTemplate.nodeTypes = null
 380         assertNull(bluePrintContext.nodeTypeDerivedFrom("hi"))
 381     }
 382
 383     @Test(expected = BluePrintException::class)
 384     fun testInterfaceNameForNodeType() {
 385         val serviceTemplate = ServiceTemplate()
 386         val nodeType = NodeType()
 387         nodeType.interfaces = mutableMapOf("hello" to InterfaceDefinition(), "hi" to InterfaceDefinition())
 388         serviceTemplate.nodeTypes = mutableMapOf("node" to nodeType)
 389         val bluePrintContext = BluePrintContext(serviceTemplate)
 390
 391         assertEquals("hello", bluePrintContext.interfaceNameForNodeType("node"))
 392
 393         bluePrintContext.interfaceNameForNodeType("")
 394     }
 395
 396     @Test
 397     fun testNodeTemplateForNodeType() {
 398         val serviceTemplate = ServiceTemplate()
 399         val nodeTemplate = NodeTemplate()
 400         nodeTemplate.type = "hello"
 401         val nodeTemplate2 = NodeTemplate()
 402         nodeTemplate2.type = "hi"
 403         serviceTemplate.topologyTemplate = TopologyTemplate()
 404         serviceTemplate.topologyTemplate!!.nodeTemplates =
 405             mutableMapOf("node" to nodeTemplate, "node2" to nodeTemplate2)
 406         val bluePrintContext = BluePrintContext(serviceTemplate)
 407
 408         assertEquals(1, bluePrintContext.nodeTemplateForNodeType("hello")!!.size)
 409
 410         serviceTemplate.topologyTemplate!!.nodeTemplates = null
 411         assertNull(bluePrintContext.nodeTemplateForNodeType("hello"))
 412     }
 413
 414     @Test
 415     fun testNodeTemplateProperty() {
 416         val serviceTemplate = ServiceTemplate()
 417         val nodeTemplate = NodeTemplate()
 418         nodeTemplate.properties = mutableMapOf("prop" to ObjectMapper().createObjectNode())
 419         serviceTemplate.topologyTemplate = TopologyTemplate()
 420         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 421         val bluePrintContext = BluePrintContext(serviceTemplate)
 422
 423         assertNotNull(bluePrintContext.nodeTemplateProperty("node", "prop"))
 424
 425         assertNull(bluePrintContext.nodeTemplateProperty("node", ""))
 426
 427         nodeTemplate.properties = null
 428         assertNull(bluePrintContext.nodeTemplateProperty("node", "prop"))
 429     }
 430
 431     @Test
 432     fun testNodeTemplateArtifacts() {
 433         val serviceTemplate = ServiceTemplate()
 434         val nodeTemplate = NodeTemplate()
 435         nodeTemplate.artifacts = mutableMapOf()
 436         serviceTemplate.topologyTemplate = TopologyTemplate()
 437         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 438         val bluePrintContext = BluePrintContext(serviceTemplate)
 439
 440         assertTrue(bluePrintContext.nodeTemplateArtifacts("node")!!.isEmpty())
 441     }
 442
 443     @Test(expected = BluePrintException::class)
 444     fun testNodeTemplateArtifact() {
 445         val serviceTemplate = ServiceTemplate()
 446         val nodeTemplate = NodeTemplate()
 447         nodeTemplate.artifacts = mutableMapOf("art" to ArtifactDefinition())
 448         serviceTemplate.topologyTemplate = TopologyTemplate()
 449         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 450         val bluePrintContext = BluePrintContext(serviceTemplate)
 451
 452         assertNotNull(bluePrintContext.nodeTemplateArtifact("node", "art"))
 453
 454         bluePrintContext.nodeTemplateArtifact("node", "")
 455     }
 456
 457     @Test(expected = BluePrintException::class)
 458     fun testNodeTemplateArtifactForArtifactType() {
 459         val serviceTemplate = ServiceTemplate()
 460         val nodeTemplate = NodeTemplate()
 461         val artifactDefinition = ArtifactDefinition()
 462         artifactDefinition.type = "type"
 463         val artifactDefinition2 = ArtifactDefinition()
 464         artifactDefinition2.type = "No type"
 465         nodeTemplate.artifacts = mutableMapOf("art" to artifactDefinition, "art2" to artifactDefinition2)
 466         serviceTemplate.topologyTemplate = TopologyTemplate()
 467         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 468         val bluePrintContext = BluePrintContext(serviceTemplate)
 469
 470         assertNotNull(bluePrintContext.nodeTemplateArtifactForArtifactType("node", "type"))
 471
 472         bluePrintContext.nodeTemplateArtifactForArtifactType("", "")
 473     }
 474
 475     @Test(expected = BluePrintException::class)
 476     fun testNodeTemplateFirstInterface() {
 477         val serviceTemplate = ServiceTemplate()
 478         val nodeTemplate = NodeTemplate()
 479         nodeTemplate.interfaces = mutableMapOf("interface" to InterfaceAssignment(), "interf" to InterfaceAssignment())
 480         serviceTemplate.topologyTemplate = TopologyTemplate()
 481         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 482         val bluePrintContext = BluePrintContext(serviceTemplate)
 483
 484         assertNotNull(bluePrintContext.nodeTemplateFirstInterface("node"))
 485
 486         nodeTemplate.interfaces = null
 487         bluePrintContext.nodeTemplateFirstInterface("node")
 488     }
 489
 490     @Test(expected = BluePrintException::class)
 491     fun testNodeTemplateFirstInterfaceName() {
 492         val serviceTemplate = ServiceTemplate()
 493         val nodeTemplate = NodeTemplate()
 494         nodeTemplate.interfaces = mutableMapOf("interface" to InterfaceAssignment(), "interf" to InterfaceAssignment())
 495         serviceTemplate.topologyTemplate = TopologyTemplate()
 496         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 497         val bluePrintContext = BluePrintContext(serviceTemplate)
 498
 499         assertEquals("interface", bluePrintContext.nodeTemplateFirstInterfaceName("node"))
 500
 501         nodeTemplate.interfaces = null
 502         bluePrintContext.nodeTemplateFirstInterfaceName("node")
 503     }
 504
 505     @Test(expected = BluePrintException::class)
 506     fun testNodeTemplateFirstInterfaceFirstOperationName() {
 507         val serviceTemplate = ServiceTemplate()
 508         val nodeTemplate = NodeTemplate()
 509         val interfaceAssignment = InterfaceAssignment()
 510         interfaceAssignment.operations = mutableMapOf("op" to OperationAssignment(), "op2" to OperationAssignment())
 511         nodeTemplate.interfaces = mutableMapOf("intf" to interfaceAssignment)
 512         serviceTemplate.topologyTemplate = TopologyTemplate()
 513         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 514         val bluePrintContext = BluePrintContext(serviceTemplate)
 515
 516         assertEquals("op", bluePrintContext.nodeTemplateFirstInterfaceFirstOperationName("node"))
 517
 518         interfaceAssignment.operations = null
 519         bluePrintContext.nodeTemplateFirstInterfaceFirstOperationName("node")
 520     }
 521
 522     @Test(expected = BluePrintException::class)
 523     fun testNodeTemplateCapability() {
 524         val serviceTemplate = ServiceTemplate()
 525         val nodeTemplate = NodeTemplate()
 526         nodeTemplate.capabilities = mutableMapOf("cap" to CapabilityAssignment())
 527         serviceTemplate.topologyTemplate = TopologyTemplate()
 528         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 529         val bluePrintContext = BluePrintContext(serviceTemplate)
 530
 531         assertNotNull(bluePrintContext.nodeTemplateCapability("node", "cap"))
 532
 533         bluePrintContext.nodeTemplateCapability("node", "")
 534     }
 535
 536     @Test(expected = BluePrintException::class)
 537     fun testNodeTemplateRequirement() {
 538         val serviceTemplate = ServiceTemplate()
 539         val nodeTemplate = NodeTemplate()
 540         nodeTemplate.requirements = mutableMapOf("req" to RequirementAssignment())
 541         serviceTemplate.topologyTemplate = TopologyTemplate()
 542         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 543         val bluePrintContext = BluePrintContext(serviceTemplate)
 544
 545         assertNotNull(bluePrintContext.nodeTemplateRequirement("node", "req"))
 546
 547         bluePrintContext.nodeTemplateRequirement("node", "")
 548     }
 549
 550     @Test(expected = BluePrintException::class)
 551     fun testNodeTemplateRequirementNode() {
 552         val serviceTemplate = ServiceTemplate()
 553         val nodeTemplate = NodeTemplate()
 554         val requirementAssignment = RequirementAssignment()
 555         requirementAssignment.node = "node"
 556         nodeTemplate.requirements = mutableMapOf("req" to requirementAssignment)
 557         serviceTemplate.topologyTemplate = TopologyTemplate()
 558         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 559         val bluePrintContext = BluePrintContext(serviceTemplate)
 560
 561         assertNotNull(bluePrintContext.nodeTemplateRequirementNode("node", "req"))
 562
 563         bluePrintContext.nodeTemplateRequirementNode("node", "")
 564     }
 565
 566     @Test
 567     fun testNodeTemplateCapabilityProperty() {
 568         val serviceTemplate = ServiceTemplate()
 569         val nodeTemplate = NodeTemplate()
 570         val capabilityAssignment = CapabilityAssignment()
 571         capabilityAssignment.properties = mutableMapOf("prop" to ObjectMapper().createObjectNode())
 572         nodeTemplate.capabilities = mutableMapOf("cap" to capabilityAssignment)
 573         serviceTemplate.topologyTemplate = TopologyTemplate()
 574         serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
 575         val bluePrintContext = BluePrintContext(serviceTemplate)
 576
 577         assertNotNull(bluePrintContext.nodeTemplateCapabilityProperty("node", "cap", "prop"))
 578
 579         capabilityAssignment.properties = null
 580
 581         assertNull(bluePrintContext.nodeTemplateCapabilityProperty("node", "cap", "prop"))
 582     }
 583 }