package org.onap.cps.rest.controller
+import org.onap.cps.api.CpsAnchorService
+
import static org.onap.cps.spi.CascadeDeleteAllowed.CASCADE_DELETE_PROHIBITED
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post
import org.mapstruct.factory.Mappers
-import org.onap.cps.api.CpsAdminService
+import org.onap.cps.api.CpsDataspaceService
import org.onap.cps.api.CpsModuleService
import org.onap.cps.spi.exceptions.AlreadyDefinedException
import org.onap.cps.spi.exceptions.SchemaSetInUseException
CpsModuleService mockCpsModuleService = Mock()
@SpringBean
- CpsAdminService mockCpsAdminService = Mock()
+ CpsDataspaceService mockCpsDataspaceService = Mock()
+
+ @SpringBean
+ CpsAnchorService mockCpsAnchorService = Mock()
@SpringBean
CpsRestInputMapper cpsRestInputMapper = Mappers.getMapper(CpsRestInputMapper)
def anchor = new Anchor(name: anchorName, dataspaceName: dataspaceName, schemaSetName: schemaSetName)
def dataspace = new Dataspace(name: dataspaceName)
- def 'Create new dataspace.'() {
- given: 'an endpoint'
- def createDataspaceEndpoint = "$basePath/v1/dataspaces"
+ def 'Create new dataspace with #scenario.'() {
when: 'post is invoked'
def response =
- mvc.perform(
- post(createDataspaceEndpoint)
- .param('dataspace-name', dataspaceName))
- .andReturn().response
+ mvc.perform(
+ post("/cps/api/${apiVersion}/dataspaces")
+ .param('dataspace-name', dataspaceName))
+ .andReturn().response
then: 'service method is invoked with expected parameters'
- 1 * mockCpsAdminService.createDataspace(dataspaceName)
+ 1 * mockCpsDataspaceService.createDataspace(dataspaceName)
and: 'dataspace is create successfully'
response.status == HttpStatus.CREATED.value()
+ assert response.getContentAsString() == expectedResponseBody
+ where: 'following cases are tested'
+ scenario | apiVersion || expectedResponseBody
+ 'V1 API' | 'v1' || 'my_dataspace'
+ 'V2 API' | 'v2' || ''
}
def 'Create dataspace over existing with same name.'() {
def createDataspaceEndpoint = "$basePath/v1/dataspaces"
and: 'the service method throws an exception indicating the dataspace is already defined'
def thrownException = new AlreadyDefinedException(dataspaceName, new RuntimeException())
- mockCpsAdminService.createDataspace(dataspaceName) >> { throw thrownException }
+ mockCpsDataspaceService.createDataspace(dataspaceName) >> { throw thrownException }
when: 'post is invoked'
def response =
mvc.perform(
def 'Get a dataspace.'() {
given: 'service method returns a dataspace'
- mockCpsAdminService.getDataspace(dataspaceName) >> dataspace
+ mockCpsDataspaceService.getDataspace(dataspaceName) >> dataspace
and: 'an endpoint'
def getDataspaceEndpoint = "$basePath/v1/admin/dataspaces/$dataspaceName"
when: 'get dataspace API is invoked'
def 'Get all dataspaces.'() {
given: 'service method returns all dataspace'
- mockCpsAdminService.getAllDataspaces() >> [dataspace, new Dataspace(name: "dataspace-test2")]
+ mockCpsDataspaceService.getAllDataspaces() >> [dataspace, new Dataspace(name: "dataspace-test2")]
and: 'an endpoint'
def getAllDataspaceEndpoint = "$basePath/v1/admin/dataspaces"
when: 'get all dataspace API is invoked'
response.getContentAsString().contains("dataspace-test2")
}
- def 'Create schema set from yang file.'() {
+ def 'Create schema set from yang file with #scenario.'() {
def yangResourceMapCapture
given: 'single yang file'
def multipartFile = createMultipartFile("filename.yang", "content")
- and: 'an endpoint'
- def schemaSetEndpoint = "$basePath/v1/dataspaces/$dataspaceName/schema-sets"
when: 'file uploaded with schema set create request'
def response =
mvc.perform(
- multipart(schemaSetEndpoint)
+ multipart("/cps/api/${apiVersion}/dataspaces/my_dataspace/schema-sets")
.file(multipartFile)
.param('schema-set-name', schemaSetName))
.andReturn().response
{ args -> yangResourceMapCapture = args[2] }
yangResourceMapCapture['filename.yang'] == 'content'
and: 'response code indicates success'
- response.status == HttpStatus.CREATED.value()
+ assert response.status == HttpStatus.CREATED.value()
+ assert response.getContentAsString() == expectedResponseBody
+ where: 'following cases are tested'
+ scenario | apiVersion || expectedResponseBody
+ 'V1 API' | 'v1' || 'my_schema_set'
+ 'V2 API' | 'v2' || ''
}
- def 'Create schema set from zip archive.'() {
+ def 'Create schema set from zip archive with #scenario.'() {
def yangResourceMapCapture
given: 'zip archive with multiple .yang files inside'
def multipartFile = createZipMultipartFileFromResource("/yang-files-set.zip")
- and: 'an endpoint'
- def schemaSetEndpoint = "$basePath/v1/dataspaces/$dataspaceName/schema-sets"
when: 'file uploaded with schema set create request'
def response =
mvc.perform(
- multipart(schemaSetEndpoint)
+ multipart("/cps/api/${apiVersion}/dataspaces/my_dataspace/schema-sets")
.file(multipartFile)
.param('schema-set-name', schemaSetName))
.andReturn().response
yangResourceMapCapture['assembly.yang'] == "fake assembly content 1\n"
yangResourceMapCapture['component.yang'] == "fake component content 1\n"
and: 'response code indicates success'
- response.status == HttpStatus.CREATED.value()
+ assert response.status == HttpStatus.CREATED.value()
+ assert response.getContentAsString() == expectedResponseBody
+ where: 'following cases are tested'
+ scenario | apiVersion || expectedResponseBody
+ 'V1 API' | 'v1' || 'my_schema_set'
+ 'V2 API' | 'v2' || ''
}
- def 'Create a schema set from a yang file that is greater than 1MB.'() {
+ def 'Create a schema set from a yang file that is greater than 1MB #scenario.'() {
given: 'a yang file greater than 1MB'
def multipartFile = createMultipartFileFromResource("/model-over-1mb.yang")
- and: 'an endpoint'
- def schemaSetEndpoint = "$basePath/v1/dataspaces/$dataspaceName/schema-sets"
when: 'a file is uploaded to the create schema set endpoint'
def response =
mvc.perform(
- multipart(schemaSetEndpoint)
+ multipart("/cps/api/${apiVersion}/dataspaces/my_dataspace/schema-sets")
.file(multipartFile)
.param('schema-set-name', schemaSetName))
.andReturn().response
then: 'the associated service method is invoked'
1 * mockCpsModuleService.createSchemaSet(dataspaceName, schemaSetName, _)
and: 'the response code indicates success'
- response.status == HttpStatus.CREATED.value()
+ assert response.status == HttpStatus.CREATED.value()
+ assert response.getContentAsString() == expectedResponseBody
+ where: 'following cases are tested'
+ scenario | apiVersion || expectedResponseBody
+ 'V1 API' | 'v1' || 'my_schema_set'
+ 'V2 API' | 'v2' || ''
}
def 'Create schema set from zip archive having #caseDescriptor.'() {
response.getContentAsString().contains(schemaSetName)
}
- def 'Create Anchor.'() {
+ def 'Get all schema sets for a given dataspace name.'() {
+ given: 'service method returns all schema sets for a dataspace'
+ mockCpsModuleService.getSchemaSets(dataspaceName) >>
+ [new SchemaSet(name: schemaSetName, dataspaceName: dataspaceName),
+ new SchemaSet(name: "test-schemaset", dataspaceName: dataspaceName)]
+ and: 'an endpoint'
+ def schemaSetEndpoint = "$basePath/v1/dataspaces/$dataspaceName/schema-sets"
+ when: 'get schema sets API is invoked'
+ def response = mvc.perform(get(schemaSetEndpoint)).andReturn().response
+ then: 'the correct schema sets is returned'
+ assert response.status == HttpStatus.OK.value()
+ assert response.getContentAsString() == '[{"dataspaceName":"my_dataspace","moduleReferences":[],"name":' +
+ '"my_schema_set"},{"dataspaceName":"my_dataspace","moduleReferences":[],"name":"test-schemaset"}]'
+ }
+
+ def 'Create Anchor with #scenario.'() {
given: 'request parameters'
def requestParams = new LinkedMultiValueMap<>()
requestParams.add('schema-set-name', schemaSetName)
requestParams.add('anchor-name', anchorName)
- and: 'an endpoint'
- def anchorEndpoint = "$basePath/v1/dataspaces/$dataspaceName/anchors"
when: 'post is invoked'
def response =
mvc.perform(
- post(anchorEndpoint).contentType(MediaType.APPLICATION_JSON)
+ post("/cps/api/${apiVersion}/dataspaces/my_dataspace/anchors")
+ .contentType(MediaType.APPLICATION_JSON)
.params(requestParams as MultiValueMap))
- .andReturn().response
+ .andReturn().response
then: 'anchor is created successfully'
- 1 * mockCpsAdminService.createAnchor(dataspaceName, schemaSetName, anchorName)
- response.status == HttpStatus.CREATED.value()
- response.getContentAsString().contains(anchorName)
+ 1 * mockCpsAnchorService.createAnchor(dataspaceName, schemaSetName, anchorName)
+ assert response.status == HttpStatus.CREATED.value()
+ assert response.getContentAsString() == expectedResponseBody
+ where: 'following cases are tested'
+ scenario | apiVersion || expectedResponseBody
+ 'V1 API' | 'v1' || 'my_anchor'
+ 'V2 API' | 'v2' || ''
}
def 'Get existing anchor.'() {
given: 'service method returns a list of anchors'
- mockCpsAdminService.getAnchors(dataspaceName) >> [anchor]
+ mockCpsAnchorService.getAnchors(dataspaceName) >> [anchor]
and: 'an endpoint'
def anchorEndpoint = "$basePath/v1/dataspaces/$dataspaceName/anchors"
when: 'get all anchors API is invoked'
def 'Get existing anchor by dataspace and anchor name.'() {
given: 'service method returns an anchor'
- mockCpsAdminService.getAnchor(dataspaceName, anchorName) >>
+ mockCpsAnchorService.getAnchor(dataspaceName, anchorName) >>
new Anchor(name: anchorName, dataspaceName: dataspaceName, schemaSetName: schemaSetName)
and: 'an endpoint'
def anchorEndpoint = "$basePath/v1/dataspaces/$dataspaceName/anchors/$anchorName"
when: 'delete method is invoked on anchor endpoint'
def response = mvc.perform(delete(anchorEndpoint)).andReturn().response
then: 'associated service method is invoked with expected parameters'
- 1 * mockCpsAdminService.deleteAnchor(dataspaceName, anchorName)
+ 1 * mockCpsAnchorService.deleteAnchor(dataspaceName, anchorName)
and: 'response code indicates success'
response.status == HttpStatus.NO_CONTENT.value()
}
.param('dataspace-name', dataspaceName))
.andReturn().response
then: 'associated service method is invoked with expected parameter'
- 1 * mockCpsAdminService.deleteDataspace(dataspaceName)
+ 1 * mockCpsDataspaceService.deleteDataspace(dataspaceName)
and: 'response code indicates success'
response.status == HttpStatus.NO_CONTENT.value()
}