X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=ms%2Fblueprintsprocessor%2Ffunctions%2Fresource-resolution%2Fsrc%2Ftest%2Fkotlin%2Forg%2Fonap%2Fccsdk%2Fcds%2Fblueprintsprocessor%2Ffunctions%2Fresource%2Fresolution%2Futils%2FResourceAssignmentUtilsTest.kt;h=59be79568c5ec0662d6202c09bc40ea5844f63a2;hb=505c338d1a59e97ce4489dcf60037ff90abdbba5;hp=9365c3e34b7b4605b17d053c69fe9f591c38d54d;hpb=a21724910b109cd07da051eb6d5ab5245ed40c19;p=ccsdk%2Fcds.git diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtilsTest.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtilsTest.kt index 9365c3e34..59be79568 100644 --- a/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtilsTest.kt +++ b/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtilsTest.kt @@ -22,39 +22,65 @@ 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" @@ -75,11 +101,11 @@ class ResourceAssignmentUtilsTest { id = "ipAddress" } - var mapOfPropertiesIpAddress = mutableMapOf() + val mapOfPropertiesIpAddress = mutableMapOf() mapOfPropertiesIpAddress["port"] = propertiesDefinition1 mapOfPropertiesIpAddress["ip"] = propertiesDefinition2 - var mapOfPropertiesHost = mutableMapOf() + val mapOfPropertiesHost = mutableMapOf() mapOfPropertiesHost["name"] = propertiesDefinition3 mapOfPropertiesHost["ipAddress"] = propertiesDefinition4 @@ -93,7 +119,9 @@ class ResourceAssignmentUtilsTest { 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 @@ -102,41 +130,86 @@ class ResourceAssignmentUtilsTest { @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(validResourceAssignment) + // and a list containing that resource assignment + val resourceAssignmentList = listOf(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(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 { @@ -148,154 +221,241 @@ class ResourceAssignmentUtilsTest { } @Test - fun parseResponseNodeTestForPrimitivesTypes(){ - // Input values for primitive type - val keyValue = mutableMapOf() - 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() - 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() - 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() - 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() - 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() - 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() - 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() - 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()) + } - // Input values for collection type + private fun initInputMapAndExpectedValuesForPrimitiveType() { + inputMapToTestPrimitiveTypeWithValue = "1.2.3.1".asJsonType() + val keyValue = mutableMapOf() + 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("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("value", it.asJsonType()) + arrayNodeForList2.add(arrayChildNode) + } + inputMapToTestCollectionOfComplexTypeWithOneOutputKeyMapping = arrayNodeForList2 + + val arrayNodeForList3 = JacksonUtils.objectMapper.createArrayNode() + var childNode = JacksonUtils.objectMapper.createObjectNode() + childNode.set("port", "1111".asJsonPrimitive()) + childNode.set("ip", "1.2.3.1".asJsonPrimitive()) + arrayNodeForList3.add(childNode) + childNode = JacksonUtils.objectMapper.createObjectNode() + childNode.set("port", "2222".asJsonPrimitive()) + childNode.set("ip", "1.2.3.2".asJsonPrimitive()) + arrayNodeForList3.add(childNode) + childNode = JacksonUtils.objectMapper.createObjectNode() + childNode.set("port", "3333".asJsonPrimitive()) + childNode.set("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() + } + + private fun initInputMapAndExpectedValuesForComplexType() { val mapOfComplexType = mutableMapOf() 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() - 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("name", "my-ipAddress".asJsonPrimitive()) + childNode1.set("ipAddress", IpAddress("1111", "1.2.3.1").asJsonType()) + childNode1.set("port", "8888".asJsonType()) + childNode1.set("something", IpAddress("2222", "1.2.3.1").asJsonType()) + inputMapToTestComplexTypeWithAllOutputKeyMapping = childNode1 + + val childNode2 = JacksonUtils.objectMapper.createObjectNode() + childNode2.set("name", "my-ipAddress".asJsonPrimitive()) + childNode2.set("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" -> { @@ -312,7 +472,12 @@ class ResourceAssignmentUtilsTest { 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 { @@ -326,7 +491,11 @@ class ResourceAssignmentUtilsTest { } } - 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" @@ -340,7 +509,11 @@ class ResourceAssignmentUtilsTest { } } - 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" @@ -355,34 +528,34 @@ class ResourceAssignmentUtilsTest { val outputMapping = mutableMapOf() 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 +}