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 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
@Test
fun `generateResourceDataForAssignments - positive test`() {
// given a valid resource assignment
- val validResourceAssignment = createResourceAssignmentForTest("valid_value")
+ 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)
+ val resourceAssignmentList = listOf<ResourceAssignment>(validResourceAssignment1, validResourceAssignment2)
// 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.replace("\r\n", "\n"), "unexpected outcome generated")
+ val expected = """
+ {
+ "a1" : "also_valid",
+ "pnf-id" : "valid_value"
+ }
+ """.trimIndent()
+ assertEquals(expected, outcome.trimIndent(), "unexpected outcome generated")
}
@Test
assertEquals(expected, outcome.replace("\r\n", "\n"), "unexpected outcome generated")
}
- private fun createResourceAssignmentForTest(resourceValue: String?): ResourceAssignment {
+ @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?, 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 {
outcome,
"Unexpected outcome returned for primitive type of simple String"
)
+ assertEquals(0, resourceAssignment.keyIdentifiers.size)
outcome = prepareResponseNodeForTest(
"sample-key-value", "string", "",
outcome,
"Unexpected outcome returned for primitive type of key-value String"
)
+ assertEquals(
+ expectedValueToTestPrimitiveType,
+ resourceAssignment.keyIdentifiers[0].value
+ )
}
@Test
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",
outcome,
"Unexpected outcome returned for complex type"
)
+ assertEquals(
+ expectedValueToTestComplexTypeWithOneOutputKeyMapping["host"],
+ resourceAssignment.keyIdentifiers[0].value
+ )
}
@Test
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 `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() {
val arrayNodeForList1 = JacksonUtils.objectMapper.createArrayNode()
listOfIps.forEach {
val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode.set("value", it.asJsonPrimitive())
+ arrayChildNode.set<JsonNode>("value", it.asJsonPrimitive())
arrayNodeForList1.add(arrayChildNode)
}
inputMapToTestCollectionOfPrimitiveType = arrayNodeForList1
val arrayNodeForList2 = JacksonUtils.objectMapper.createArrayNode()
listOfIpAddresses.forEach {
val arrayChildNode = JacksonUtils.objectMapper.createObjectNode()
- arrayChildNode.set("value", it.asJsonType())
+ arrayChildNode.set<JsonNode>("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())
+ childNode.set<JsonNode>("port", "1111".asJsonPrimitive())
+ childNode.set<JsonNode>("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())
+ childNode.set<JsonNode>("port", "2222".asJsonPrimitive())
+ childNode.set<JsonNode>("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())
+ 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(
+ ExpectedResponseIpAddress(IpAddress("2222", "1.2.3.2")),
+ ExpectedResponseIpAddress(
IpAddress("3333", "1.2.3.3")
)
).asJsonType()
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())
+ 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("name", "my-ipAddress".asJsonPrimitive())
- childNode2.set("ipAddress", IpAddress("1111", "1.2.3.1").asJsonType())
+ childNode2.set<JsonNode>("name", "my-ipAddress".asJsonPrimitive())
+ childNode2.set<JsonNode>("ipAddress", IpAddress("1111", "1.2.3.1").asJsonType())
expectedValueToTestComplexTypeWithAllOutputKeyMapping = childNode2
}
response: Any
): JsonNode {
- val resourceAssignment = when (sourceType) {
+ resourceAssignment = when (sourceType) {
"list" -> {
prepareRADataDictionaryCollection(dictionary_source, sourceType, entrySchema)
}
Code Review / ccsdk / cds.git / blobdiff