diff options
4 files changed, 716 insertions, 2 deletions
diff --git a/cds-ui/client/src/app/feature-modules/blueprint/modify-template/editor/editor.component.ts b/cds-ui/client/src/app/feature-modules/blueprint/modify-template/editor/editor.component.ts index 7fd4ef07a..ffe69029b 100644 --- a/cds-ui/client/src/app/feature-modules/blueprint/modify-template/editor/editor.component.ts +++ b/cds-ui/client/src/app/feature-modules/blueprint/modify-template/editor/editor.component.ts @@ -426,6 +426,7 @@ export class EditorComponent implements OnInit { if (this.validfile) { this.fetchTOSACAMetadata(); + this.filesData = this.paths; this.tree = this.arrangeTreeData(this.paths); } else { alert('Please update proper file with TOSCA metadata'); 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")) + } } |