aboutsummaryrefslogtreecommitdiffstats
path: root/ms/controllerblueprints
diff options
context:
space:
mode:
authorRami <rmohamed.ext@orange.com>2019-05-09 14:52:42 +0200
committerRami <rmohamed.ext@orange.com>2019-05-09 15:16:00 +0200
commita4175e9411ad38de3af3f93475662b5589df82b0 (patch)
tree108a1945fb575c14f9a7ca884e875720d6e77f50 /ms/controllerblueprints
parentfebb517be84666a67cb04a58f89aac4af788ac7c (diff)
UT for Blueprint core
CustomFunctions and BluePrintContext Issue-ID: CCSDK-1244 Change-Id: I0d676714684ffc9f913f8e296b73f867278df8c2 Signed-off-by: Rami <rmohamed.ext@orange.com>
Diffstat (limited to 'ms/controllerblueprints')
-rw-r--r--ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/BluePrintErrorTest.kt33
-rw-r--r--ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/CustomFunctionsTest.kt169
-rw-r--r--ms/controllerblueprints/modules/blueprint-core/src/test/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/service/BluePrintContextTest.kt515
3 files changed, 715 insertions, 2 deletions
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
index 000000000..e3e5c26a3
--- /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 d5334dc5f..487b1d15b 100644
--- 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 2c6561f23..33890277f 100644
--- 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"))
+ }
}