Fix the datanode build logic (incorrect parsing of containers and mapped lists)

[cps.git] / cps-service / src / test / groovy / org / onap / cps / model / DataNodeBuilderSpec.groovy

diff --git a/cps-service/src/test/groovy/org/onap/cps/model/DataNodeBuilderSpec.groovy b/cps-service/src/test/groovy/org/onap/cps/model/DataNodeBuilderSpec.groovy
index 0dbde88..d881e77 100644 (file)
--- a/cps-service/src/test/groovy/org/onap/cps/model/DataNodeBuilderSpec.groovy
+++ b/cps-service/src/test/groovy/org/onap/cps/model/DataNodeBuilderSpec.groovy
@@ -1,6 +1,7 @@
 package org.onap.cps.model
 
 import org.onap.cps.TestUtils
+import org.onap.cps.spi.model.DataNode
 import org.onap.cps.spi.model.DataNodeBuilder
 import org.onap.cps.utils.YangUtils
 import org.onap.cps.yang.YangTextSchemaSourceSetBuilder
@@ -8,22 +9,52 @@ import spock.lang.Specification
 
 class DataNodeBuilderSpec extends Specification {
 
+    Map<String, Map<String, Object>> expectedLeavesByXpathMap = [
+            '/test-tree'                             : [],
+            '/test-tree/branch[@name=\'Left\']'      : [name: 'Left'],
+            '/test-tree/branch[@name=\'Left\']/nest' : [name: 'Small', birds: ['Sparrow', 'Robin', 'Finch']],
+            '/test-tree/branch[@name=\'Right\']'     : [name: 'Right'],
+            '/test-tree/branch[@name=\'Right\']/nest': [name: 'Big', birds: ['Owl', 'Raven', 'Crow']]
+    ]
+
     def 'Converting Normalized Node (tree) to a DataNode (tree).'() {
         given: 'a Yang module'
-            def yangResourceNameToContent = TestUtils.getYangResourcesAsMap('bookstore.yang')
-            def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceNameToContent)getSchemaContext()
+            def yangResourceNameToContent = TestUtils.getYangResourcesAsMap('test-tree.yang')
+            def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceNameToContent) getSchemaContext()
         and: 'a normalized node for that model'
-            def jsonData = TestUtils.getResourceFileContent('bookstore.json')
+            def jsonData = TestUtils.getResourceFileContent('test-tree.json')
             def normalizedNode = YangUtils.parseJsonData(jsonData, schemaContext)
         when: 'the normalized node is converted to a DataNode (tree)'
             def result = new DataNodeBuilder().withNormalizedNodeTree(normalizedNode).build()
-        then: 'the system creates a (root) fragment without a parent and 2 children (categories)'
-            result.childDataNodes.size() == 2
-        and: 'each child (category) has the root fragment (result) as parent and in turn as 1 child (a list of books)'
-            result.childDataNodes.each { it.childDataNodes.size() == 1 }
-        and: 'the fragments have the correct xpaths'
-            assert result.xpath == '/bookstore'
-            assert result.childDataNodes.collect { it.xpath }
-                    .containsAll(["/bookstore/categories[@code='01']", "/bookstore/categories[@code='02']"])
+            def mappedResult = treeToFlatMapByXpath(new HashMap<>(), result)
+        then: '5 DataNode objects with unique xpath were created in total'
+            mappedResult.size() == 5
+        and: 'all expected xpaths were built'
+            mappedResult.keySet().containsAll(expectedLeavesByXpathMap.keySet())
+        and: 'each data node contains the expected attributes'
+            mappedResult.each {
+                xpath, dataNode -> assertLeavesMaps(dataNode.getLeaves(), expectedLeavesByXpathMap[xpath])
+            }
+    }
+
+    def static assertLeavesMaps(actualLeavesMap, expectedLeavesMap) {
+        expectedLeavesMap.each { key, value ->
+            {
+                def actualValue = actualLeavesMap[key]
+                if (value instanceof Collection<?> && actualValue instanceof Collection<?>) {
+                    assert value.size() == actualValue.size()
+                    assert value.containsAll(actualValue)
+                } else {
+                    assert value == actualValue
+                }
+            }
+        }
+    }
+
+    def treeToFlatMapByXpath(Map<String, DataNode> flatMap, DataNode dataNodeTree) {
+        flatMap.put(dataNodeTree.getXpath(), dataNodeTree)
+        dataNodeTree.getChildDataNodes()
+                .forEach(childDataNode -> treeToFlatMapByXpath(flatMap, childDataNode))
+        return flatMap
     }
 }