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