package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils
import com.fasterxml.jackson.databind.JsonNode
-import com.fasterxml.jackson.databind.node.NullNode
import com.fasterxml.jackson.databind.node.TextNode
import io.mockk.every
import io.mockk.spyk
+import kotlinx.coroutines.runBlocking
import org.junit.Before
import org.junit.Test
import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
+import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.METADATA_TRANSFORM_TEMPLATE
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
import org.onap.ccsdk.cds.controllerblueprints.core.data.DataType
import org.onap.ccsdk.cds.controllerblueprints.core.data.EntrySchema
+import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
import org.onap.ccsdk.cds.controllerblueprints.core.data.PropertyDefinition
import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils
import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
+import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceDefinition
import kotlin.test.assertEquals
data class IpAddress(val port: String, val ip: String)
data class Host(val name: String, val ipAddress: IpAddress)
data class ExpectedResponseIp(val ip: String)
-data class ExpectedResponsePort(val port: String)
+data class ExpectedResponseIpAddress(val ipAddress: IpAddress)
class ResourceAssignmentUtilsTest {
+
private lateinit var resourceAssignmentRuntimeService: ResourceAssignmentRuntimeService
+ private lateinit var resourceAssignment: ResourceAssignment
+
+ private lateinit var inputMapToTestPrimitiveTypeWithValue: JsonNode
+ private lateinit var inputMapToTestPrimitiveTypeWithKeyValue: JsonNode
+ private lateinit var inputMapToTestCollectionOfPrimitiveType: JsonNode
+ private lateinit var inputMapToTestCollectionOfComplexTypeWithOneOutputKeyMapping: JsonNode
+ private lateinit var inputMapToTestCollectionOfComplexTypeWithAllOutputKeyMapping: JsonNode
+ private lateinit var inputMapToTestComplexTypeWithOneOutputKeyMapping: JsonNode
+ private lateinit var inputMapToTestComplexTypeWithAllOutputKeyMapping: JsonNode
+ private lateinit var expectedValueToTestPrimitiveType: JsonNode
+ private lateinit var expectedValueToTesCollectionOfPrimitiveType: JsonNode
+ private lateinit var expectedValueToTestCollectionOfComplexTypeWithOneOutputKeyMapping: JsonNode
+ private lateinit var expectedValueToTestComplexTypeWithOneOutputKeyMapping: JsonNode
+ private lateinit var expectedValueToTestComplexTypeWithAllOutputKeyMapping: JsonNode
+ private lateinit var expectedValueToTestCollectionOfComplexTypeWithAllOutputKeyMapping: JsonNode
@Before
fun setup() {
- val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(
- "./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration")
+ val bluePrintContext = runBlocking {
+ BluePrintMetadataUtils.getBluePrintContext(
+ "./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
+ )
+ }
resourceAssignmentRuntimeService = spyk(ResourceAssignmentRuntimeService("1234", bluePrintContext))
+ // Init input map and expected values for tests
+ initInputMapAndExpectedValuesForPrimitiveType()
+ initInputMapAndExpectedValuesForCollection()
+ initInputMapAndExpectedValuesForComplexType()
+
val propertiesDefinition1 = PropertyDefinition().apply {
type = "string"
id = "port"
id = "ipAddress"
}
- var mapOfPropertiesIpAddress = mutableMapOf<String, PropertyDefinition>()
+ val mapOfPropertiesIpAddress = mutableMapOf<String, PropertyDefinition>()
mapOfPropertiesIpAddress["port"] = propertiesDefinition1
mapOfPropertiesIpAddress["ip"] = propertiesDefinition2
- var mapOfPropertiesHost = mutableMapOf<String, PropertyDefinition>()
+ val mapOfPropertiesHost = mutableMapOf<String, PropertyDefinition>()
mapOfPropertiesHost["name"] = propertiesDefinition3
mapOfPropertiesHost["ipAddress"] = propertiesDefinition4
properties = mapOfPropertiesHost
}
- every { resourceAssignmentRuntimeService.bluePrintContext().dataTypeByName("ip-address") } returns myDataTypeIpaddress
+ every {
+ resourceAssignmentRuntimeService.bluePrintContext().dataTypeByName("ip-address")
+ } returns myDataTypeIpaddress
every { resourceAssignmentRuntimeService.bluePrintContext().dataTypeByName("host") } returns myDataTypeHost
@Test
fun `generateResourceDataForAssignments - positive test`() {
- //given a valid resource assignment
- val validResourceAssignment = createResourceAssignmentForTest("valid_value")
+ // given a valid resource assignment
+ val validResourceAssignment1 = createResourceAssignmentForTest("valid_value", "pnf-id")
+ val validResourceAssignment2 = createResourceAssignmentForTest("also_valid", "a1")
- //and a list containing that resource assignment
- val resourceAssignmentList = listOf<ResourceAssignment>(validResourceAssignment)
+ // and a list containing that resource assignment
+ val resourceAssignmentList = listOf<ResourceAssignment>(validResourceAssignment1, validResourceAssignment2)
- //when the values of the resources are evaluated
+ // when the values of the resources are evaluated
val outcome = ResourceAssignmentUtils.generateResourceDataForAssignments(resourceAssignmentList)
- //then the assignment should produce a valid result
- val expected = "{\n" + " \"pnf-id\" : \"valid_value\"\n" + "}"
- assertEquals(expected, outcome, "unexpected outcome generated")
+ // then the assignment should produce a valid result
+ val expected = """
+ {
+ "a1" : "also_valid",
+ "pnf-id" : "valid_value"
+ }
+ """.trimIndent()
+ assertEquals(expected, outcome.trimIndent(), "unexpected outcome generated")
}
@Test
fun `generateResourceDataForAssignments - resource without value is not resolved as null`() {
- //given a valid resource assignment
+ // given a valid resource assignment
val resourceAssignmentWithNullValue = createResourceAssignmentForTest(null)
- //and a list containing that resource assignment
+ // and a list containing that resource assignment
val resourceAssignmentList = listOf<ResourceAssignment>(resourceAssignmentWithNullValue)
- //when the values of the resources are evaluated
+ // when the values of the resources are evaluated
val outcome = ResourceAssignmentUtils.generateResourceDataForAssignments(resourceAssignmentList)
- //then the assignment should produce a valid result
+ // then the assignment should produce a valid result
val expected = "{\n" + " \"pnf-id\" : \"\${pnf-id}\"\n" + "}"
- assertEquals(expected, outcome, "unexpected outcome generated")
+ assertEquals(expected, outcome.replace("\r\n", "\n"), "unexpected outcome generated")
+ }
+
+ @Test
+ fun generateResolutionSummaryDataTest() {
+ val resourceAssignment = createResourceAssignmentForTest(null)
+ val resourceDefinition = ResourceDefinition()
+ val nodeTemplate = NodeTemplate().apply {
+ properties = mutableMapOf("resolved-payload" to JacksonUtils.jsonNode("{\"mock\": true}"))
+ }
+ resourceDefinition.sources = mutableMapOf("input" to nodeTemplate)
+ resourceDefinition.property = PropertyDefinition().apply {
+ this.description = "pnf-id"
+ this.metadata = mutableMapOf("aai-path" to "//path/in/aai")
+ }
+ val result = ResourceAssignmentUtils.generateResolutionSummaryData(
+ listOf(resourceAssignment), mapOf("pnf-id" to resourceDefinition)
+ )
+
+ assertEquals(
+ """
+ {
+ "resolution-summary":[
+ {
+ "name":"pnf-id",
+ "value":"",
+ "required":false,
+ "type":"string",
+ "key-identifiers":[],
+ "dictionary-description":"pnf-id",
+ "dictionary-metadata":[
+ {"name":"aai-path","value":"//path/in/aai"}
+ ],
+ "dictionary-name":"pnf-id",
+ "dictionary-source":"input",
+ "request-payload":{"mock":true},
+ "status":"",
+ "message":""
+ }
+ ]
+ }
+ """.replace("\n|\\s".toRegex(), ""),
+ result
+ )
}
- private fun createResourceAssignmentForTest(resourceValue: String?): ResourceAssignment {
+ private fun createResourceAssignmentForTest(resourceValue: String?, resourceName: String = "pnf-id"): ResourceAssignment {
val valueForTest = if (resourceValue == null) null else TextNode(resourceValue)
val resourceAssignmentForTest = ResourceAssignment().apply {
- name = "pnf-id"
+ name = resourceName
dictionaryName = "pnf-id"
dictionarySource = "input"
property = PropertyDefinition().apply {
}
@Test
- fun parseResponseNodeTestForPrimitivesTypes(){
- // Input values for primitive type
- val keyValue = mutableMapOf<String, String>()
- keyValue["value"]= "1.2.3.1"
- val expectedPrimitiveType = TextNode("1.2.3.1")
-
- var outcome = prepareResponseNodeForTest("sample-value", "string",
- "", "1.2.3.1".asJsonPrimitive())
- assertEquals(expectedPrimitiveType, outcome, "Unexpected outcome returned for primitive type of simple String")
- outcome = prepareResponseNodeForTest("sample-key-value", "string", "", keyValue)
- assertEquals(expectedPrimitiveType, outcome, "Unexpected outcome returned for primitive type of key-value String")
+ fun parseResponseNodeTestForPrimitivesTypes() {
+ var outcome = prepareResponseNodeForTest(
+ "sample-value", "string", "",
+ inputMapToTestPrimitiveTypeWithValue
+ )
+ assertEquals(
+ expectedValueToTestPrimitiveType,
+ outcome,
+ "Unexpected outcome returned for primitive type of simple String"
+ )
+ assertEquals(0, resourceAssignment.keyIdentifiers.size)
+
+ outcome = prepareResponseNodeForTest(
+ "sample-key-value", "string", "",
+ inputMapToTestPrimitiveTypeWithKeyValue
+ )
+ assertEquals(
+ expectedValueToTestPrimitiveType,
+ outcome,
+ "Unexpected outcome returned for primitive type of key-value String"
+ )
+ assertEquals(
+ expectedValueToTestPrimitiveType,
+ resourceAssignment.keyIdentifiers[0].value
+ )
}
@Test
- fun parseResponseNodeTestForCollectionsOfString(){
- // Input values for collection type
- val mapOfString = mutableMapOf<String, String>()
- mapOfString["value1"] = "1.2.3.1"
- mapOfString["port"] = "8888"
- mapOfString["value2"] = "1.2.3.2"
- val arrayOfKeyValue = arrayListOf(ExpectedResponseIp("1.2.3.1"),
- ExpectedResponsePort( "8888"), ExpectedResponseIp("1.2.3.2"))
-
- val mutableMapKeyValue = mutableMapOf<String, String>()
- mutableMapKeyValue["value1"] = "1.2.3.1"
- mutableMapKeyValue["port"] = "8888"
-
- //List
- val expectedListOfString = arrayOfKeyValue.asJsonType()
- var outcome = prepareResponseNodeForTest("listOfString", "list",
- "string", mapOfString.asJsonType())
- assertEquals(expectedListOfString, outcome, "unexpected outcome returned for list of String")
-
- //Map
- val expectedMapOfString = mutableMapOf<String, JsonNode>()
- expectedMapOfString["ip"] = "1.2.3.1".asJsonPrimitive()
- expectedMapOfString["port"] = "8888".asJsonPrimitive()
-
- val arrayNode = JacksonUtils.objectMapper.createArrayNode()
- expectedMapOfString.map {
- val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode.set(it.key, it.value)
- arrayNode.add(arrayChildNode)
- }
- val arrayChildNode1 = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode1.set("ip", NullNode.getInstance())
- arrayNode.add(arrayChildNode1)
- outcome = prepareResponseNodeForTest("mapOfString", "map", "string",
- mutableMapKeyValue.asJsonType())
- assertEquals(arrayNode, outcome, "unexpected outcome returned for map of String")
+ fun parseResponseNodeTestForCollectionsOfString() {
+ var outcome = prepareResponseNodeForTest(
+ "listOfString", "list",
+ "string", inputMapToTestCollectionOfPrimitiveType
+ )
+ assertEquals(
+ expectedValueToTesCollectionOfPrimitiveType,
+ outcome,
+ "unexpected outcome returned for list of String"
+ )
+
+ val expectedKeyIdentifierValue = JacksonUtils.getJsonNode(outcome.map { it["ip"] })
+ assertEquals(
+ expectedKeyIdentifierValue,
+ resourceAssignment.keyIdentifiers[0].value
+ )
+
+ // FIXME("Map is not collection type, It is known complex type")
+ // outcome = prepareResponseNodeForTest(
+ // "mapOfString", "map", "string",
+ // inputMapToTestCollectionOfPrimitiveType
+ // )
+ // assertEquals(
+ // expectedValueToTesCollectionOfPrimitiveType,
+ // outcome,
+ // "unexpected outcome returned for map of String"
+ // )
}
@Test
- fun parseResponseNodeTestForCollectionsOfJsonNode(){
- // Input values for collection type
- val mapOfString = mutableMapOf<String, JsonNode>()
- mapOfString["value1"] = "1.2.3.1".asJsonPrimitive()
- mapOfString["port"] = "8888".asJsonPrimitive()
- mapOfString["value2"] = "1.2.3.2".asJsonPrimitive()
- val arrayOfKeyValue = arrayListOf(ExpectedResponseIp("1.2.3.1"),
- ExpectedResponsePort( "8888"), ExpectedResponseIp("1.2.3.2"))
-
- val mutableMapKeyValue = mutableMapOf<String, JsonNode>()
- mutableMapKeyValue["value1"] = "1.2.3.1".asJsonPrimitive()
- mutableMapKeyValue["port"] = "8888".asJsonPrimitive()
-
- //List
- val expectedListOfString = arrayOfKeyValue.asJsonType()
- var outcome = prepareResponseNodeForTest("listOfString", "list",
- "string", mapOfString.asJsonType())
- assertEquals(expectedListOfString, outcome, "unexpected outcome returned for list of String")
-
- //Map
- val expectedMapOfString = mutableMapOf<String, JsonNode>()
- expectedMapOfString["ip"] = "1.2.3.1".asJsonPrimitive()
- expectedMapOfString["port"] = "8888".asJsonPrimitive()
- val arrayNode = JacksonUtils.objectMapper.createArrayNode()
- expectedMapOfString.map {
- val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode.set(it.key, it.value)
- arrayNode.add(arrayChildNode)
- }
- val arrayChildNode1 = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode1.set("ip", NullNode.getInstance())
- arrayNode.add(arrayChildNode1)
- outcome = prepareResponseNodeForTest("mapOfString", "map",
- "string", mutableMapKeyValue.asJsonType())
- assertEquals(arrayNode, outcome, "unexpected outcome returned for map of String")
+ fun parseResponseNodeTestForCollectionsOfComplexType() {
+ var outcome = prepareResponseNodeForTest(
+ "listOfMyDataTypeWithOneOutputKeyMapping", "list",
+ "ip-address", inputMapToTestCollectionOfComplexTypeWithOneOutputKeyMapping
+ )
+ assertEquals(
+ expectedValueToTestCollectionOfComplexTypeWithOneOutputKeyMapping,
+ outcome,
+ "unexpected outcome returned for list of String"
+ )
+
+ outcome = prepareResponseNodeForTest(
+ "listOfMyDataTypeWithAllOutputKeyMapping", "list",
+ "ip-address", inputMapToTestCollectionOfComplexTypeWithAllOutputKeyMapping
+ )
+ assertEquals(
+ expectedValueToTestCollectionOfComplexTypeWithAllOutputKeyMapping,
+ outcome,
+ "unexpected outcome returned for list of String"
+ )
}
@Test
- fun parseResponseNodeTestForCollectionsOfComplexType(){
- // Input values for collection type
- val mapOfComplexType = mutableMapOf<String, JsonNode>()
- mapOfComplexType["value1"] = IpAddress("1111", "1.2.3.1").asJsonType()
- mapOfComplexType["value2"] = IpAddress("2222", "1.2.3.2").asJsonType()
- mapOfComplexType["value3"] = IpAddress("3333", "1.2.3.3").asJsonType()
+ fun `parseResponseNodeTestForComplexType find one output key mapping`() {
+ val outcome = prepareResponseNodeForTest(
+ "complexTypeOneKeys", "host",
+ "", inputMapToTestComplexTypeWithOneOutputKeyMapping
+ )
+ assertEquals(
+ expectedValueToTestComplexTypeWithOneOutputKeyMapping,
+ outcome,
+ "Unexpected outcome returned for complex type"
+ )
+ assertEquals(
+ expectedValueToTestComplexTypeWithOneOutputKeyMapping["host"],
+ resourceAssignment.keyIdentifiers[0].value
+ )
+ }
- //List
- val arrayNode = JacksonUtils.objectMapper.createArrayNode()
- mapOfComplexType.map {
- val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode.set("ipAddress", it.value)
- arrayNode.add(arrayChildNode)
- }
- var outcome = prepareResponseNodeForTest("listOfMyDataType", "list",
- "ip-address", mapOfComplexType.asJsonType())
- assertEquals(arrayNode, outcome, "unexpected outcome returned for list of String")
+ @Test
+ fun `parseResponseNodeTestForComplexType find all output key mapping`() {
+ val outcome = prepareResponseNodeForTest(
+ "complexTypeAllKeys", "host",
+ "", inputMapToTestComplexTypeWithAllOutputKeyMapping
+ )
+ assertEquals(
+ expectedValueToTestComplexTypeWithAllOutputKeyMapping,
+ outcome,
+ "Unexpected outcome returned for complex type"
+ )
+ assertEquals(2, resourceAssignment.keyIdentifiers.size)
+ assertEquals(
+ expectedValueToTestComplexTypeWithAllOutputKeyMapping["name"],
+ resourceAssignment.keyIdentifiers[0].value
+ )
+
+ assertEquals(
+ expectedValueToTestComplexTypeWithAllOutputKeyMapping["ipAddress"],
+ resourceAssignment.keyIdentifiers[1].value
+ )
}
@Test
- fun `parseResponseNodeTestForComplexType find one output key mapping`(){
- // Input values for complex type
- val objectNode = JacksonUtils.objectMapper.createObjectNode()
+ fun `transform resolved value with inline template`() {
+ resourceAssignmentRuntimeService.putResolutionStore("vnf_name", "abc-vnf".asJsonType())
+ resourceAssignment = ResourceAssignment()
+ resourceAssignment.name = "int_pktgen_private_net_id"
+ resourceAssignment.property = PropertyDefinition()
+ resourceAssignment.property!!.type = "string"
+ val value = "".asJsonType()
+
+ // Enable transform template
+ resourceAssignment.property!!.metadata =
+ mutableMapOf(METADATA_TRANSFORM_TEMPLATE to "\${vnf_name}_private2")
+
+ ResourceAssignmentUtils
+ .setResourceDataValue(resourceAssignment, resourceAssignmentRuntimeService, value)
+
+ assertEquals(
+ "abc-vnf_private2",
+ resourceAssignment.property!!.value!!.asText()
+ )
+ }
+
+ private fun initInputMapAndExpectedValuesForPrimitiveType() {
+ inputMapToTestPrimitiveTypeWithValue = "1.2.3.1".asJsonType()
+ val keyValue = mutableMapOf<String, String>()
+ keyValue["value"] = "1.2.3.1"
+ inputMapToTestPrimitiveTypeWithKeyValue = keyValue.asJsonType()
+ expectedValueToTestPrimitiveType = TextNode("1.2.3.1")
+ }
+
+ private fun initInputMapAndExpectedValuesForCollection() {
+ val listOfIps = arrayListOf("1.2.3.1", "1.2.3.2", "1.2.3.3")
+ val arrayNodeForList1 = JacksonUtils.objectMapper.createArrayNode()
+ listOfIps.forEach {
+ val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
+ arrayChildNode.set<JsonNode>("value", it.asJsonPrimitive())
+ arrayNodeForList1.add(arrayChildNode)
+ }
+ inputMapToTestCollectionOfPrimitiveType = arrayNodeForList1
+
+ expectedValueToTesCollectionOfPrimitiveType = arrayListOf(
+ ExpectedResponseIp("1.2.3.1"),
+ ExpectedResponseIp("1.2.3.2"), ExpectedResponseIp("1.2.3.3")
+ ).asJsonType()
+
+ val listOfIpAddresses = arrayListOf(
+ IpAddress("1111", "1.2.3.1").asJsonType(),
+ IpAddress("2222", "1.2.3.2").asJsonType(), IpAddress("3333", "1.2.3.3").asJsonType()
+ )
+ val arrayNodeForList2 = JacksonUtils.objectMapper.createArrayNode()
+ listOfIpAddresses.forEach {
+ val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
+ arrayChildNode.set<JsonNode>("value", it.asJsonType())
+ arrayNodeForList2.add(arrayChildNode)
+ }
+ inputMapToTestCollectionOfComplexTypeWithOneOutputKeyMapping = arrayNodeForList2
+
+ val arrayNodeForList3 = JacksonUtils.objectMapper.createArrayNode()
+ var childNode = JacksonUtils.objectMapper.createObjectNode()
+ childNode.set<JsonNode>("port", "1111".asJsonPrimitive())
+ childNode.set<JsonNode>("ip", "1.2.3.1".asJsonPrimitive())
+ arrayNodeForList3.add(childNode)
+ childNode = JacksonUtils.objectMapper.createObjectNode()
+ childNode.set<JsonNode>("port", "2222".asJsonPrimitive())
+ childNode.set<JsonNode>("ip", "1.2.3.2".asJsonPrimitive())
+ arrayNodeForList3.add(childNode)
+ childNode = JacksonUtils.objectMapper.createObjectNode()
+ childNode.set<JsonNode>("port", "3333".asJsonPrimitive())
+ childNode.set<JsonNode>("ip", "1.2.3.3".asJsonPrimitive())
+ arrayNodeForList3.add(childNode)
+ inputMapToTestCollectionOfComplexTypeWithAllOutputKeyMapping = arrayNodeForList3
+
+ expectedValueToTestCollectionOfComplexTypeWithOneOutputKeyMapping = arrayListOf(
+ ExpectedResponseIpAddress(IpAddress("1111", "1.2.3.1")),
+ ExpectedResponseIpAddress(IpAddress("2222", "1.2.3.2")),
+ ExpectedResponseIpAddress(
+ IpAddress("3333", "1.2.3.3")
+ )
+ ).asJsonType()
+ expectedValueToTestCollectionOfComplexTypeWithAllOutputKeyMapping = arrayListOf(
+ IpAddress("1111", "1.2.3.1"),
+ IpAddress("2222", "1.2.3.2"),
+ IpAddress("3333", "1.2.3.3")
+ ).asJsonType()
+ }
- // Input values for collection type
+ private fun initInputMapAndExpectedValuesForComplexType() {
val mapOfComplexType = mutableMapOf<String, JsonNode>()
mapOfComplexType["value"] = Host("my-ipAddress", IpAddress("1111", "1.2.3.1")).asJsonType()
mapOfComplexType["port"] = "8888".asJsonType()
mapOfComplexType["something"] = "1.2.3.2".asJsonType()
+ inputMapToTestComplexTypeWithOneOutputKeyMapping = mapOfComplexType.asJsonType()
- val expectedComplexType = objectNode.set("ipAddress", Host("my-ipAddress", IpAddress("1111", "1.2.3.1")).asJsonType())
- val outcome = prepareResponseNodeForTest("complexTypeOneKeys", "host",
- "", mapOfComplexType.asJsonType())
- assertEquals(expectedComplexType, outcome, "Unexpected outcome returned for complex type")
- }
-
- @Test
- fun `parseResponseNodeTestForComplexType find all output key mapping`(){
- // Input values for complex type
val objectNode = JacksonUtils.objectMapper.createObjectNode()
-
- // Input values for collection type
- val mapOfComplexType = mutableMapOf<String, JsonNode>()
- mapOfComplexType["name"] = "my-ipAddress".asJsonType()
- mapOfComplexType["ipAddress"] = IpAddress("1111", "1.2.3.1").asJsonType()
-
- val expectedComplexType = Host("my-ipAddress", IpAddress("1111", "1.2.3.1")).asJsonType()
- val outcome = prepareResponseNodeForTest("complexTypeAllKeys", "host",
- "", mapOfComplexType.asJsonType())
- assertEquals(expectedComplexType, outcome, "Unexpected outcome returned for complex type")
+ expectedValueToTestComplexTypeWithOneOutputKeyMapping =
+ objectNode.set("host", Host("my-ipAddress", IpAddress("1111", "1.2.3.1")).asJsonType())
+
+ val childNode1 = JacksonUtils.objectMapper.createObjectNode()
+ childNode1.set<JsonNode>("name", "my-ipAddress".asJsonPrimitive())
+ childNode1.set<JsonNode>("ipAddress", IpAddress("1111", "1.2.3.1").asJsonType())
+ childNode1.set<JsonNode>("port", "8888".asJsonType())
+ childNode1.set<JsonNode>("something", IpAddress("2222", "1.2.3.1").asJsonType())
+ inputMapToTestComplexTypeWithAllOutputKeyMapping = childNode1
+
+ val childNode2 = JacksonUtils.objectMapper.createObjectNode()
+ childNode2.set<JsonNode>("name", "my-ipAddress".asJsonPrimitive())
+ childNode2.set<JsonNode>("ipAddress", IpAddress("1111", "1.2.3.1").asJsonType())
+ expectedValueToTestComplexTypeWithAllOutputKeyMapping = childNode2
}
- private fun prepareResponseNodeForTest(dictionary_source: String, sourceType: String, entrySchema: String,
- response: Any): JsonNode {
+ private fun prepareResponseNodeForTest(
+ dictionary_source: String,
+ sourceType: String,
+ entrySchema: String,
+ response: Any
+ ): JsonNode {
- val resourceAssignment = when (sourceType) {
- "list", "map" -> {
+ resourceAssignment = when (sourceType) {
+ "list" -> {
prepareRADataDictionaryCollection(dictionary_source, sourceType, entrySchema)
}
"string" -> {
val outputKeyMapping = prepareOutputKeyMapping(dictionary_source)
- return ResourceAssignmentUtils.parseResponseNode(responseNode, resourceAssignment, resourceAssignmentRuntimeService, outputKeyMapping)
+ return ResourceAssignmentUtils.parseResponseNode(
+ responseNode,
+ resourceAssignment,
+ resourceAssignmentRuntimeService,
+ outputKeyMapping
+ )
}
private fun prepareRADataDictionaryOfPrimaryType(dictionary_source: String): ResourceAssignment {
}
}
- private fun prepareRADataDictionaryCollection(dictionary_source: String, sourceType: String, schema: String): ResourceAssignment {
+ private fun prepareRADataDictionaryCollection(
+ dictionary_source: String,
+ sourceType: String,
+ schema: String
+ ): ResourceAssignment {
return ResourceAssignment().apply {
name = "ipAddress-list"
dictionaryName = "sample-licenses"
}
}
- private fun prepareRADataDictionaryComplexType(dictionary_source: String, sourceType: String, schema: String): ResourceAssignment {
+ private fun prepareRADataDictionaryComplexType(
+ dictionary_source: String,
+ sourceType: String,
+ schema: String
+ ): ResourceAssignment {
return ResourceAssignment().apply {
name = "ipAddress-complexType"
dictionaryName = "sample-licenses"
val outputMapping = mutableMapOf<String, String>()
when (dictionary_source) {
- "listOfString", "mapOfString" -> {
- //List of string
- outputMapping["value1"] = "ip"
- outputMapping["port"] = "port"
- outputMapping["value2"] = "ip"
- }
- "listOfMyDataType", "mapOfMyDataType" -> {
- //List or map of complex Type
- outputMapping["value1"] = "ipAddress"
- outputMapping["value2"] = "ipAddress"
- outputMapping["value3"] = "ipAddress"
- }
"sample-key-value", "sample-value" -> {
- //Primary Type
- if (dictionary_source=="sample-key-value")
+ // Primary Type
+ if (dictionary_source == "sample-key-value")
outputMapping["sample-ip"] = "value"
}
+ "listOfString", "mapOfString" -> {
+ // List of string
+ outputMapping["ip"] = "value"
+ }
+ "listOfMyDataTypeWithOneOutputKeyMapping", "listOfMyDataTypeWithAllOutputKeyMapping" -> {
+ // List or map of complex Type
+ if (dictionary_source == "listOfMyDataTypeWithOneOutputKeyMapping")
+ outputMapping["ipAddress"] = "value"
+ else {
+ outputMapping["port"] = "port"
+ outputMapping["ip"] = "ip"
+ }
+ }
else -> {
- //Complex Type
+ // Complex Type
if (dictionary_source == "complexTypeOneKeys")
- outputMapping["value"] = "ipAddress"
+ outputMapping["host"] = "value"
else {
outputMapping["name"] = "name"
outputMapping["ipAddress"] = "ipAddress"
}
-
}
}
return outputMapping
}
-}
\ No newline at end of file
+}
Code Review / ccsdk / cds.git / blobdiff