gerrit.onap Code Review - ccsdk/cds.git/blob

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