UT for Blueprint core

CustomFunctions and BluePrintContext

Issue-ID: CCSDK-1244

Change-Id: I0d676714684ffc9f913f8e296b73f867278df8c2
Signed-off-by: Rami <rmohamed.ext@orange.com>
(cherry picked from commit a4175e9411ad38de3af3f93475662b5589df82b0)

diff --git a/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/BluePrintErrorTest.kt b/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/BluePrintErrorTest.kt
new file mode 100644 (file)
index 0000000..e3e5c26
--- /dev/null
+++ b/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/BluePrintErrorTest.kt
@@ -0,0 +1,33 @@
+package org.onap.ccsdk.cds.controllerblueprints.core
+
+import org.junit.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+class BluePrintErrorTest {
+
+    @Test
+    fun testBluePrintErrorIsCreatedWithemptyList() {
+        val bluePrintError = BluePrintError()
+
+        assertTrue(bluePrintError.errors.isEmpty())
+    }
+
+    @Test
+    fun testAddErrorWith3Params() {
+        val bluePrintError = BluePrintError()
+
+        bluePrintError.addError("type", "name", "error")
+
+        assertEquals("type : name : error", bluePrintError.errors[0])
+    }
+
+    @Test
+    fun testAddErrorWith1Params() {
+        val bluePrintError = BluePrintError()
+
+        bluePrintError.addError("error")
+
+        assertEquals("error", bluePrintError.errors[0])
+    }
+}
\ No newline at end of file

diff --git a/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/CustomFunctionsTest.kt b/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/CustomFunctionsTest.kt
index d5334dc..487b1d1 100644 (file)
--- a/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/CustomFunctionsTest.kt
+++ b/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/CustomFunctionsTest.kt
@@ -16,8 +16,12 @@
 
 package org.onap.ccsdk.cds.controllerblueprints.core
 
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.databind.node.*
 import org.junit.Test
-import kotlin.test.assertEquals
+import kotlin.test.*
+
 /**
  *
  *
@@ -25,11 +29,172 @@ import kotlin.test.assertEquals
  */
 class CustomFunctionsTest {
     @Test
-    fun testFormat(): Unit {
+    fun testFormat() {
         val returnValue : String = format("This is {} for times {}", "test", 2)
         assertEquals("This is test for times 2", returnValue, "Failed to format String")
 
         val returnValue1 : String = format("This is test for times 2")
         assertEquals("This is test for times 2", returnValue1, "Failed to format empty args")
     }
+
+    @Test
+    fun testStringAsJsonPrimitive() {
+        val returnValue: TextNode = "hello".asJsonPrimitive()
+        assertEquals("hello", returnValue.textValue())
+    }
+
+    @Test
+    fun testIntAsJsonPrimitive() {
+        val returnValue: IntNode = 1.asJsonPrimitive()
+        assertEquals(1, returnValue.intValue())
+    }
+
+    @Test
+    fun testBooleanAsJsonPrimitive() {
+        val returnValue: BooleanNode = false.asJsonPrimitive()
+        assertFalse(returnValue.asBoolean())
+    }
+
+    @Test
+    fun testAsJsonType() {
+        val nullReturnValue: JsonNode = null.asJsonType()
+        assertEquals(NullNode.instance, nullReturnValue)
+
+        val returnValueString: JsonNode = "hello".asJsonType()
+        assertEquals("hello", returnValueString.textValue())
+
+        val returnValueJsonNode: JsonNode = returnValueString.asJsonType()
+        assertEquals(returnValueString, returnValueJsonNode)
+
+        val returnValueInt: JsonNode = 1.asJsonType()
+        assertEquals(1, returnValueInt.intValue())
+
+        val returnValueBool: JsonNode = false.asJsonType()
+        assertFalse(returnValueBool.asBoolean())
+
+        val returnValue: JsonNode = BluePrintError().asJsonType()
+        assertEquals(JsonNodeType.OBJECT, returnValue.getNodeType())
+    }
+
+    @Test
+    fun testMapAsObjectNode() {
+        val returnValue: ObjectNode = hashMapOf("test" to BluePrintError()).asObjectNode()
+        assertNotNull(returnValue.get("test"))
+    }
+
+    @Test
+    fun testCastOptionalValue() {
+        val initMap: Map<String, *> = hashMapOf("test" to 1.1, "test2" to null)
+        val returnValue = initMap.castOptionalValue("test", Number::class)
+
+        assert(returnValue is Number)
+
+        val returnValueNull = initMap.castOptionalValue("test1", Number::class)
+
+        assertNull(returnValueNull)
+
+        val returnValueString: String? = initMap.castOptionalValue("test2", String::class)
+
+        assertNull(returnValueString)
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testCastValue() {
+        val initMap: Map<String, Double> = hashMapOf("test" to 1.1)
+        val returnValue = initMap.castValue("test", Number::class)
+
+        assertNotNull(returnValue)
+
+        initMap.castValue("test1", Number::class)
+    }
+
+    @Test
+    fun testAsListOfString() {
+        val arrayNode: ArrayNode = ObjectMapper().createObjectNode().putArray("array")
+
+        val result: List<String> = arrayNode.asListOfString()
+
+        assertTrue(result.isEmpty())
+    }
+
+    @Test
+    fun testReturnNullIfMissing() {
+        val valueExist = "hello".asJsonType().returnNullIfMissing()
+        assertNotNull(valueExist)
+
+        val valueNull = NullNode.instance.returnNullIfMissing()
+        assertNull(valueNull)
+
+        val missingValue = MissingNode.getInstance().returnNullIfMissing()
+        assertNull(missingValue)
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testRootFieldsToMap() {
+        1.asJsonType().rootFieldsToMap()
+    }
+
+    @Test
+    fun testPutJsonElement() {
+        val mutMap = mutableMapOf("test" to 2.asJsonType())
+
+        mutMap.putJsonElement("hello", 3)
+
+        assertEquals(3, mutMap["hello"]?.asInt())
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testMapGetAsString() {
+        val initMap = hashMapOf("test" to "hello".asJsonType())
+
+        assertEquals("hello", initMap.getAsString("test"))
+
+        initMap.getAsString("test2")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testMapGetAsBoolean() {
+        val initMap = hashMapOf("test" to true.asJsonType())
+
+        assertTrue(initMap.getAsBoolean("test"))
+
+        initMap.getAsBoolean("test2")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testMapGetAsInt() {
+        val initMap = hashMapOf("test" to 1.asJsonType())
+
+        assertEquals(1, initMap.getAsInt("test"))
+
+        initMap.getAsInt("test2")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testCheckEquals() {
+        assertTrue(checkEquals("hello", "hello", { -> "error"}))
+
+        checkEquals("hello", "test", { -> "error"})
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun testCheckNotEmpty() {
+        assertEquals("hello", checkNotEmpty("hello", { -> "error"}))
+
+        checkNotEmpty("", { -> "error"})
+    }
+
+    @Test(expected = IllegalStateException::class)
+    fun testCheckNotBlank() {
+        assertEquals("hello", checkNotBlank("hello", { -> "error"}))
+
+        checkNotBlank("  ", { -> "error"})
+    }
+
+    @Test
+    fun testNullToEmpty() {
+        assertEquals("", nullToEmpty(null))
+
+        assertEquals("hello", nullToEmpty("hello"))
+    }
 }
\ No newline at end of file

diff --git a/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/service/BluePrintContextTest.kt b/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/service/BluePrintContextTest.kt
index 2c6561f..3389027 100644 (file)
--- a/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/service/BluePrintContextTest.kt
+++ b/ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/service/BluePrintContextTest.kt
@@ -18,11 +18,18 @@
 package org.onap.ccsdk.cds.controllerblueprints.core.service
 
 
+import com.fasterxml.jackson.databind.ObjectMapper
 import org.slf4j.LoggerFactory
 import org.junit.Test
+import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.data.*
 import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
 import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
+import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
 
 /**
  *
@@ -49,5 +56,513 @@ class BluePrintContextTest {
         log.trace("Properties {}", JacksonUtils.getJson(nodeType, true))
     }
 
+    @Test
+    fun testImports() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.imports = mutableListOf()
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.imports()!!.isEmpty())
+
+        serviceTemplate.imports = null
+        assertNull(bluePrintContext.imports())
+    }
+
+    @Test
+    fun testDataTypes() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.dataTypes = mutableMapOf()
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.dataTypes()!!.isEmpty())
+
+        serviceTemplate.dataTypes = null
+        assertNull(bluePrintContext.dataTypes())
+    }
+
+    @Test
+    fun testInputs() {
+        val topologyTemplate = TopologyTemplate()
+        topologyTemplate.inputs = mutableMapOf()
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.inputs()!!.isEmpty())
+
+        topologyTemplate.inputs = null
+
+        assertNull(bluePrintContext.inputs())
+    }
+
+    @Test
+    fun testBluePrintJson() {
+        val serviceTemplate = ServiceTemplate()
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("{\"tosca_definitions_version\":\"controller_blueprint_1_0_0\"}", bluePrintContext.blueprintJson())
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testName() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_NAME to "hello")
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.name())
+
+        serviceTemplate.metadata = mutableMapOf()
+        val bluePrintContext2 = BluePrintContext(serviceTemplate)
+        bluePrintContext2.name()
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testVersion() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_VERSION to "hello")
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.version())
+
+        serviceTemplate.metadata = mutableMapOf()
+        val bluePrintContext2 = BluePrintContext(serviceTemplate)
+        bluePrintContext2.version()
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testAuthor() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.metadata = mutableMapOf(BluePrintConstants.METADATA_TEMPLATE_AUTHOR to "hello")
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.author())
+
+        serviceTemplate.metadata = mutableMapOf()
+        val bluePrintContext2 = BluePrintContext(serviceTemplate)
+        bluePrintContext2.author()
+    }
+
+    @Test
+    fun testWorkflows() {
+        val topologyTemplate = TopologyTemplate()
+        topologyTemplate.workflows = mutableMapOf()
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.workflows()!!.isEmpty())
+
+        topologyTemplate.workflows = null
+        assertNull(bluePrintContext.workflows())
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testWorkFlowsByName() {
+        val topologyTemplate = TopologyTemplate()
+        topologyTemplate.workflows = mutableMapOf("workflow" to Workflow())
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.workflowByName("workflow"))
+
+        bluePrintContext.workflowByName("")
+    }
+
+    @Test
+    fun testWorkflowInput() {
+        val topologyTemplate = TopologyTemplate()
+        val workflow = Workflow()
+        workflow.inputs = mutableMapOf()
+        topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.workflowInputs("workflow")!!.isEmpty())
+
+        workflow.inputs = null
+
+        assertNull(bluePrintContext.workflowInputs("workflow"))
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testWorkflowStepByName() {
+        val topologyTemplate = TopologyTemplate()
+        val workflow = Workflow()
+        workflow.steps = mutableMapOf("step" to Step())
+        topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.workflowStepByName("workflow", "step"))
+
+        bluePrintContext.workflowStepByName("workflow", "")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testWorkflowStepNodeTemplate() {
+        val topologyTemplate = TopologyTemplate()
+        val workflow = Workflow()
+        val step = Step()
+        step.target = "hello"
+        workflow.steps = mutableMapOf("step" to step)
+        topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.workflowStepNodeTemplate("workflow", "step"))
+
+        bluePrintContext.workflowStepNodeTemplate("workflow", "")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testWorkflowFirstStepNodeTemplate() {
+        val topologyTemplate = TopologyTemplate()
+        val workflow = Workflow()
+        val step = Step()
+        step.target = "hello"
+        workflow.steps = mutableMapOf("step" to step, "step2" to Step())
+        topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.workflowFirstStepNodeTemplate("workflow"))
+
+        workflow.steps = null
+        bluePrintContext.workflowFirstStepNodeTemplate("workflow")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testWorkflowStepFirstCallOperation() {
+        val topologyTemplate = TopologyTemplate()
+        val workflow = Workflow()
+        val step = Step()
+        val activity = Activity()
+        activity.callOperation = "hello"
+        step.activities = arrayListOf(activity)
+        workflow.steps = mutableMapOf("step" to step)
+        topologyTemplate.workflows = mutableMapOf("workflow" to workflow)
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.topologyTemplate = topologyTemplate
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.workflowStepFirstCallOperation("workflow", "step"))
+
+        bluePrintContext.workflowStepFirstCallOperation("workflow", "")
+    }
+
+    @Test
+    fun testDatatypeByName() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.dataTypes = mutableMapOf("data" to DataType())
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.dataTypeByName("data"))
+        assertNull(bluePrintContext.dataTypeByName(""))
+    }
+
+    @Test
+    fun testArtifactTypes() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.artifactTypes = mutableMapOf()
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.artifactTypes()!!.isEmpty())
+
+        serviceTemplate.artifactTypes = null
+        assertNull(bluePrintContext.artifactTypes())
+    }
+
+    @Test
+    fun testPolicyTypes() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.policyTypes = mutableMapOf()
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.policyTypes()!!.isEmpty())
+
+        serviceTemplate.policyTypes = null
+        assertNull(bluePrintContext.policyTypes())
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testPolicyTypeByName() {
+        val serviceTemplate = ServiceTemplate()
+        serviceTemplate.policyTypes = mutableMapOf("policy" to PolicyType())
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.policyTypeByName("policy"))
 
+        bluePrintContext.policyTypeByName("")
+    }
+
+    @Test
+    fun testPolicyTypesDerivedFrom() {
+        val serviceTemplate = ServiceTemplate()
+        val policyType = PolicyType()
+        policyType.derivedFrom = "hi"
+        val policyType2 = PolicyType()
+        policyType2.derivedFrom = "hello"
+        serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals(1, bluePrintContext.policyTypesDerivedFrom("hi")!!.size)
+
+        serviceTemplate.policyTypes = null
+        assertNull(bluePrintContext.policyTypesDerivedFrom("hi"))
+    }
+
+    @Test
+    fun testPolicyTypesTarget() {
+        val serviceTemplate = ServiceTemplate()
+        val policyType = PolicyType()
+        policyType.targets = mutableListOf("hi")
+        val policyType2 = PolicyType()
+        policyType2.targets = mutableListOf()
+        serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals(1, bluePrintContext.policyTypesTarget("hi")!!.size)
+
+        serviceTemplate.policyTypes = null
+        assertNull(bluePrintContext.policyTypesTarget("hi"))
+    }
+
+    @Test
+    fun testPolicyTypesTargetNDerivedFrom() {
+        val serviceTemplate = ServiceTemplate()
+        val policyType = PolicyType()
+        policyType.targets = mutableListOf("hi")
+        policyType.derivedFrom = "hi"
+        val policyType2 = PolicyType()
+        policyType2.targets = mutableListOf()
+        policyType2.derivedFrom = "hi"
+        serviceTemplate.policyTypes = mutableMapOf("policy" to policyType, "policy2" to policyType2)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals(1, bluePrintContext.policyTypesTargetNDerivedFrom("hi", "hi")!!.size)
+
+        serviceTemplate.policyTypes = null
+        assertNull(bluePrintContext.policyTypesTargetNDerivedFrom("hi", "hi"))
+    }
+
+    @Test
+    fun testNodeTypeDerivedFrom() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeType = NodeType()
+        nodeType.derivedFrom = "hi"
+        val nodeType2 = NodeType()
+        nodeType2.derivedFrom = "hiii"
+        serviceTemplate.nodeTypes = mutableMapOf("node" to nodeType, "node2" to nodeType2)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals(1, bluePrintContext.nodeTypeDerivedFrom("hi")!!.size)
+
+        serviceTemplate.nodeTypes = null
+        assertNull(bluePrintContext.nodeTypeDerivedFrom("hi"))
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testInterfaceNameForNodeType() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeType = NodeType()
+        nodeType.interfaces = mutableMapOf("hello" to InterfaceDefinition(), "hi" to InterfaceDefinition())
+        serviceTemplate.nodeTypes = mutableMapOf("node" to nodeType)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("hello", bluePrintContext.interfaceNameForNodeType("node"))
+
+        bluePrintContext.interfaceNameForNodeType("")
+    }
+
+    @Test
+    fun testNodeTemplateForNodeType() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.type = "hello"
+        val nodeTemplate2 = NodeTemplate()
+        nodeTemplate2.type = "hi"
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate, "node2" to nodeTemplate2)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals(1, bluePrintContext.nodeTemplateForNodeType("hello")!!.size)
+
+        serviceTemplate.topologyTemplate!!.nodeTemplates = null
+        assertNull(bluePrintContext.nodeTemplateForNodeType("hello"))
+    }
+
+    @Test
+    fun testNodeTemplateProperty() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.properties = mutableMapOf("prop" to ObjectMapper().createObjectNode())
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateProperty("node", "prop"))
+
+        assertNull(bluePrintContext.nodeTemplateProperty("node", ""))
+
+        nodeTemplate.properties = null
+        assertNull(bluePrintContext.nodeTemplateProperty("node", "prop"))
+    }
+
+    @Test
+    fun testNodeTemplateArtifacts() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.artifacts = mutableMapOf()
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertTrue(bluePrintContext.nodeTemplateArtifacts("node")!!.isEmpty())
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateArtifact() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.artifacts = mutableMapOf("art" to ArtifactDefinition())
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateArtifact("node", "art"))
+
+        bluePrintContext.nodeTemplateArtifact("node", "")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateArtifactForArtifactType() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        val artifactDefinition = ArtifactDefinition()
+        artifactDefinition.type = "type"
+        val artifactDefinition2 = ArtifactDefinition()
+        artifactDefinition2.type = "No type"
+        nodeTemplate.artifacts = mutableMapOf("art" to artifactDefinition, "art2" to artifactDefinition2)
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateArtifactForArtifactType("node", "type"))
+
+        bluePrintContext.nodeTemplateArtifactForArtifactType("", "")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateFirstInterface() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.interfaces = mutableMapOf("interface" to InterfaceAssignment(), "interf" to InterfaceAssignment())
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateFirstInterface("node"))
+
+        nodeTemplate.interfaces = null
+        bluePrintContext.nodeTemplateFirstInterface("node")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateFirstInterfaceName() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.interfaces = mutableMapOf("interface" to InterfaceAssignment(), "interf" to InterfaceAssignment())
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("interface", bluePrintContext.nodeTemplateFirstInterfaceName("node"))
+
+        nodeTemplate.interfaces = null
+        bluePrintContext.nodeTemplateFirstInterfaceName("node")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateFirstInterfaceFirstOperationName() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        val interfaceAssignment = InterfaceAssignment()
+        interfaceAssignment.operations = mutableMapOf("op" to OperationAssignment(), "op2" to OperationAssignment())
+        nodeTemplate.interfaces = mutableMapOf("intf" to interfaceAssignment)
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertEquals("op", bluePrintContext.nodeTemplateFirstInterfaceFirstOperationName("node"))
+
+        interfaceAssignment.operations = null
+        bluePrintContext.nodeTemplateFirstInterfaceFirstOperationName("node")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateCapability() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.capabilities = mutableMapOf("cap" to CapabilityAssignment())
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateCapability("node", "cap"))
+
+        bluePrintContext.nodeTemplateCapability("node", "")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateRequirement() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        nodeTemplate.requirements = mutableMapOf("req" to RequirementAssignment())
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateRequirement("node", "req"))
+
+        bluePrintContext.nodeTemplateRequirement("node", "")
+    }
+
+    @Test(expected = BluePrintException::class)
+    fun testNodeTemplateRequirementNode() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        val requirementAssignment = RequirementAssignment()
+        requirementAssignment.node = "node"
+        nodeTemplate.requirements = mutableMapOf("req" to requirementAssignment)
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateRequirementNode("node", "req"))
+
+        bluePrintContext.nodeTemplateRequirementNode("node", "")
+    }
+
+    @Test
+    fun testNodeTemplateCapabilityProperty() {
+        val serviceTemplate = ServiceTemplate()
+        val nodeTemplate = NodeTemplate()
+        val capabilityAssignment = CapabilityAssignment()
+        capabilityAssignment.properties = mutableMapOf("prop" to ObjectMapper().createObjectNode())
+        nodeTemplate.capabilities = mutableMapOf("cap" to capabilityAssignment)
+        serviceTemplate.topologyTemplate = TopologyTemplate()
+        serviceTemplate.topologyTemplate!!.nodeTemplates = mutableMapOf("node" to nodeTemplate)
+        val bluePrintContext = BluePrintContext(serviceTemplate)
+
+        assertNotNull(bluePrintContext.nodeTemplateCapabilityProperty("node", "cap", "prop"))
+
+        capabilityAssignment.properties = null
+
+        assertNull(bluePrintContext.nodeTemplateCapabilityProperty("node", "cap", "prop"))
+    }
 }