API versioning supported and added different versions for POST APIs

[cps.git] / cps-rest / src / test / groovy / org / onap / cps / rest / controller / AdminRestControllerSpec.groovy

diff --git a/cps-rest/src/test/groovy/org/onap/cps/rest/controller/AdminRestControllerSpec.groovy b/cps-rest/src/test/groovy/org/onap/cps/rest/controller/AdminRestControllerSpec.groovy
index 7120ce4..f81efd6 100755 (executable)
--- a/cps-rest/src/test/groovy/org/onap/cps/rest/controller/AdminRestControllerSpec.groovy
+++ b/cps-rest/src/test/groovy/org/onap/cps/rest/controller/AdminRestControllerSpec.groovy
@@ -73,21 +73,23 @@ class AdminRestControllerSpec extends Specification {
     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)
+                            post("/cps/api/${apiVersion}/dataspaces")
                                     .param('dataspace-name', dataspaceName))
                             .andReturn().response
         then: 'service method is invoked with expected parameters'
             1 * mockCpsAdminService.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.'() {
         given: 'an endpoint'
             def createDataspaceEndpoint = "$basePath/v1/dataspaces"
@@ -129,16 +131,14 @@ class AdminRestControllerSpec extends Specification {
             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
@@ -147,19 +147,22 @@ class AdminRestControllerSpec extends Specification {
                     { 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
@@ -169,25 +172,33 @@ class AdminRestControllerSpec extends Specification {
             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.'() {
@@ -293,23 +304,26 @@ class AdminRestControllerSpec extends Specification {
                    '"my_schema_set"},{"dataspaceName":"my_dataspace","moduleReferences":[],"name":"test-schemaset"}]'
     }
 
-    def 'Create Anchor.'() {
+    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)
+            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.'() {