import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
-import com.google.common.collect.ImmutableMap
import org.modelmapper.ModelMapper
import org.onap.cps.api.CpsAdminService
import org.onap.cps.api.CpsDataService
import spock.lang.Specification
import spock.lang.Unroll
-import javax.annotation.PostConstruct
-
@WebMvcTest
class DataRestControllerSpec extends Specification {
@Value('${rest.api.cps-base-path}')
def basePath
- String dataNodeEndpoint
+ def dataNodeEndpoint
def dataspaceName = 'my_dataspace'
def anchorName = 'my_anchor'
@Shared
- static DataNode dataNodeNoChildren = new DataNodeBuilder().withXpath("/xpath")
- .withLeaves(ImmutableMap.of("leaf", "value")).build()
+ static DataNode dataNodeWithLeavesNoChildren = new DataNodeBuilder().withXpath('/xpath')
+ .withLeaves([leaf:'value', leafList:['leaveListElement1','leaveListElement2']]).build()
@Shared
- static DataNode dataNodeWithChild = new DataNodeBuilder().withXpath("/parent")
- .withChildDataNodes(Arrays.asList(
- new DataNodeBuilder().withXpath("/parent/child").build()
- )).build()
+ static DataNode dataNodeWithChild = new DataNodeBuilder().withXpath('/parent')
+ .withChildDataNodes([new DataNodeBuilder().withXpath("/parent/child").build()]).build()
- @PostConstruct
- def initEndpoints() {
+ def setup() {
dataNodeEndpoint = "$basePath/v1/dataspaces/$dataspaceName/anchors/$anchorName/nodes"
}
def 'Create a node.'() {
- given: 'an endpoint'
+ given: 'some json to create a data node'
def json = 'some json (this is not validated)'
- when: 'post is invoked'
+ when: 'post is invoked with datanode endpoint and json'
def response = mvc.perform(
post(dataNodeEndpoint).contentType(MediaType.APPLICATION_JSON).content(json)
).andReturn().response
- then: 'the java API is called with the correct parameters'
- 1 * mockCpsDataService.saveData(dataspaceName, anchorName, json)
+ then: 'a created response is returned'
response.status == HttpStatus.CREATED.value()
+ then: 'the java API was called with the correct parameters'
+ 1 * mockCpsDataService.saveData(dataspaceName, anchorName, json)
}
@Unroll
- def 'Get data node with #scenario.'() {
- given: 'the service returns data node #scenario'
- mockCpsDataService.getDataNode(dataspaceName, anchorName, xpath, fetchDescendantsOption) >> dataNode
+ def 'Get data node with leaves'() {
+ given: 'the service returns data node leaves'
+ def xpath = 'some xPath'
+ mockCpsDataService.getDataNode(dataspaceName, anchorName, xpath, OMIT_DESCENDANTS) >> dataNodeWithLeavesNoChildren
when: 'get request is performed through REST API'
def response = mvc.perform(
get(dataNodeEndpoint)
.param('cps-path', xpath)
- .param('include-descendants', includeDescendants)
).andReturn().response
- then: 'assert the success response returned'
+ then: 'a success response is returned'
+ response.status == HttpStatus.OK.value()
+ and: 'response contains expected leaf and value'
+ response.contentAsString.contains('"leaf":"value"')
+ and: 'response contains expected leaf-list and values'
+ response.contentAsString.contains('"leafList":["leaveListElement1","leaveListElement2"]')
+ }
+
+ @Unroll
+ def 'Get data node with #scenario.'() {
+ given: 'the service returns data node with #scenario'
+ def xpath = 'some xPath'
+ mockCpsDataService.getDataNode(dataspaceName, anchorName, xpath, expectedCpsDataServiceOption) >> dataNode
+ when: 'get request is performed through REST API'
+ def response = mvc.perform(get(dataNodeEndpoint)
+ .param('cps-path', xpath)
+ .param('include-descendants', urlOption))
+ .andReturn().response
+ then: 'a success response is returned'
response.status == HttpStatus.OK.value()
- and: 'response contains expected value'
- response.contentAsString.contains(checkString)
+ and: 'the response contains child is #expectChildInResponse'
+ response.contentAsString.contains('"child"') == expectChildInResponse
where:
- scenario | dataNode | xpath | includeDescendants | fetchDescendantsOption || checkString
- 'no descendants by default' | dataNodeNoChildren | '/xpath' | '' | OMIT_DESCENDANTS || '"leaf"'
- 'no descendant explicitly' | dataNodeNoChildren | '/xpath' | 'false' | OMIT_DESCENDANTS || '"leaf"'
- 'with descendants' | dataNodeWithChild | '/parent' | 'true' | INCLUDE_ALL_DESCENDANTS || '"child"'
+ scenario | dataNode | urlOption || expectedCpsDataServiceOption | expectChildInResponse
+ 'no descendants by default' | dataNodeWithLeavesNoChildren | '' || OMIT_DESCENDANTS | false
+ 'no descendant explicitly' | dataNodeWithLeavesNoChildren | 'false' || OMIT_DESCENDANTS | false
+ 'with descendants' | dataNodeWithChild | 'true' || INCLUDE_ALL_DESCENDANTS | true
}
@Unroll
def 'Get data node error scenario: #scenario.'() {
- given: 'the service returns throws an exception'
+ given: 'the service throws an exception'
mockCpsDataService.getDataNode(dataspaceName, anchorName, xpath, _) >> { throw exception }
when: 'get request is performed through REST API'
def response = mvc.perform(
get(dataNodeEndpoint).param("cps-path", xpath)
).andReturn().response
- then: 'assert the success response returned'
+ then: 'a success response is returned'
response.status == httpStatus.value()
where:
scenario | xpath | exception || httpStatus
'no data' | '/x-path' | new DataNodeNotFoundException('', '', '') || HttpStatus.NOT_FOUND
'empty path' | '' | new IllegalStateException() || HttpStatus.NOT_IMPLEMENTED
}
-}
\ No newline at end of file
+}
/*
* ============LICENSE_START=======================================================
* Copyright (C) 2021 Pantheon.tech
+ * Modifications Copyright (C) 2020 Nordix Foundation
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
package org.onap.cps.utils
-import com.google.common.collect.ImmutableMap
-import org.onap.cps.spi.model.DataNode
import org.onap.cps.spi.model.DataNodeBuilder
import spock.lang.Specification
-import static java.util.Arrays.asList
-
class DataMapUtilsSpec extends Specification {
- DataNode dataNode = buildDataNode(
- "/parent",
- ImmutableMap.<String, Object> of("a", "b", "c", asList("d", "e")),
- asList(
- buildDataNode(
- "/parent/child-list[@name='x']",
- ImmutableMap.<String, Object> of("name", "x"),
- Collections.emptyList()),
- buildDataNode(
- "/parent/child-list[@name='y']",
- ImmutableMap.<String, Object> of("name", "y"),
- Collections.emptyList()),
- buildDataNode(
- "/parent/child-object",
- ImmutableMap.<String, Object> of("m", "n"),
- asList(
- buildDataNode(
- "/parent/child-object/grand-child",
- ImmutableMap.<String, Object> of("o", "p"),
- Collections.emptyList()
- )
- )
- ),
- ))
+ def noChildren = []
+
+ def dataNode = buildDataNode(
+ "/parent",[parentLeaf:'parentLeafValue', parentLeafList:['parentLeafListEntry1','parentLeafListEntry2']],[
+ buildDataNode('/parent/child-list[@id=1]',[listElementLeaf:'listElement1leafValue'],noChildren),
+ buildDataNode('/parent/child-list[@id=2]',[listElementLeaf:'listElement2leafValue'],noChildren),
+ buildDataNode('/parent/child-object',[childLeaf:'childLeafValue'],
+ [buildDataNode('/parent/child-object/grand-child-object',[grandChildLeaf:'grandChildLeafValue'],noChildren)]
+ ),
+ ])
- static DataNode buildDataNode(String xpath, Map<String, Object> leaves, List<DataNode> children) {
+ static def buildDataNode(xpath, leaves, children) {
return new DataNodeBuilder().withXpath(xpath).withLeaves(leaves).withChildDataNodes(children).build()
}
def 'Data node structure conversion to map.'() {
- when: 'data node structure converted to map'
- def result = DataMapUtils.toDataMap(dataNode)
+ when: 'data node structure is converted to a map'
+ Map result = DataMapUtils.toDataMap(dataNode)
+
then: 'root node leaves are top level elements'
- assert result["a"] == "b"
- assert ((Collection) result["c"]).containsAll("d", "e")
+ result.parentLeaf == 'parentLeafValue'
+ result.parentLeafList == ['parentLeafListEntry1','parentLeafListEntry2']
+
and: 'leaves of child list element are listed as structures under common identifier'
- assert ((Collection) result["child-list"]).size() == 2
- assert ((Collection) result["child-list"]).containsAll(["name": "x"], ["name": "y"])
- and: 'leaves for child and grand-child elements are populated under their node identifiers'
- assert result["child-object"]["m"] == "n"
- assert result["child-object"]["grand-child"]["o"] == "p"
+ result.'child-list'.collect().containsAll(['listElementLeaf': 'listElement1leafValue'],
+ ['listElementLeaf': 'listElement2leafValue'])
+
+ and: 'leaves for child element is populated under its node identifier'
+ Map childObjectData = result.'child-object'
+ childObjectData.childLeaf == 'childLeafValue'
+
+ and: 'leaves for grandchild element is populated under its node identifier'
+ Map grandChildObjectData = childObjectData.'grand-child-object'
+ grandChildObjectData.grandChildLeaf == 'grandChildLeafValue'
}
}
Code Review / cps.git / commitdiff