Change paging and sorting of list workflows api

Use offset+limit instead page+size.

Issue-ID: SDC-1483
Change-Id: Ied1a05d08de82ac5474aad7ac6427afa5baf083f
Signed-off-by: talig <talig@amdocs.com>

1 files changed, 90 insertions, 139 deletions

diff --git a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java
index 337fea79..95f7fffa 100644
--- a/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java
+++ b/workflow-designer-be/src/test/java/org/onap/sdc/workflow/api/WorkflowControllerTest.java
@@ -8,11 +8,9 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.verify;
 import static org.onap.sdc.workflow.TestUtil.createWorkflow;
-import static org.onap.sdc.workflow.api.RestConstants.PAGE_DEFAULT;
-import static org.onap.sdc.workflow.api.RestConstants.SIZE_DEFAULT;
-import static org.onap.sdc.workflow.api.RestConstants.SORT_FIELD_NAME;
-import static org.onap.sdc.workflow.api.RestConstants.SORT_PARAM;
-import static org.onap.sdc.workflow.api.RestConstants.USER_ID_HEADER_PARAM;
+import static org.onap.sdc.workflow.api.RestParams.USER_ID_HEADER;
+import static org.onap.sdc.workflow.services.types.PagingConstants.DEFAULT_LIMIT;
+import static org.onap.sdc.workflow.services.types.PagingConstants.DEFAULT_OFFSET;
 import static org.springframework.http.MediaType.APPLICATION_JSON;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
@@ -22,13 +20,10 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
 
 import com.amdocs.zusammen.datatypes.Id;
 import com.amdocs.zusammen.datatypes.item.Item;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.google.common.collect.ImmutableSet;
 import com.google.gson.Gson;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.Set;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -37,10 +32,11 @@ import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 import org.onap.sdc.workflow.RestPath;
 import org.onap.sdc.workflow.api.exceptionshandlers.CustomizedResponseEntityExceptionHandler;
-import org.onap.sdc.workflow.api.types.CollectionWrapper;
 import org.onap.sdc.workflow.persistence.types.Workflow;
 import org.onap.sdc.workflow.persistence.types.WorkflowVersionState;
 import org.onap.sdc.workflow.services.WorkflowManager;
+import org.onap.sdc.workflow.services.types.Page;
+import org.onap.sdc.workflow.services.types.PagingRequest;
 import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
 import org.springframework.mock.web.MockHttpServletResponse;
 import org.springframework.test.web.servlet.MockMvc;
@@ -49,15 +45,12 @@ import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 @RunWith(MockitoJUnitRunner.class)
 public class WorkflowControllerTest {
 
+
     private static final String MISSING_REQUEST_HEADER_ERRROR_FORMAT =
             "Missing request header '%s' for method parameter of type String";
     private static final String USER_ID = "userId";
     private static final Gson GSON = new Gson();
-    private static final String USER_ID_HEADER = "USER_ID";
-    private static final String INVALID_PAGINATION_PARAMETER_FORMAT = "Requested %s: %s %s";
-    private static final String PAGINATION_PARAMETER_INVALID_SORT_FIELD_SUFFIX =
-            "is not supported. Supported values are: ";
-    private static final String DEFAULT_SORT_VALUE = "name,asc";
+    private static final String DEFAULT_SORT_VALUE = "name:asc";
 
     private MockMvc mockMvc;
 
@@ -90,7 +83,7 @@ public class WorkflowControllerTest {
     public void shouldReturnWorkflowDataWhenRequestPathIsOk() throws Exception {
         Workflow workflowMock = createWorkflow(1, true);
         doReturn(workflowMock).when(workflowManagerMock).get(any(Workflow.class));
-        mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).header(USER_ID_HEADER_PARAM, USER_ID)
+        mockMvc.perform(get(RestPath.getWorkflowPath(workflowMock.getId())).header(USER_ID_HEADER, USER_ID)
                                                                            .contentType(APPLICATION_JSON))
                .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.id", is(workflowMock.getId())))
                .andExpect(jsonPath("$.name", is(workflowMock.getName())));
@@ -101,148 +94,114 @@ public class WorkflowControllerTest {
         MockHttpServletResponse response =
                 mockMvc.perform(get(RestPath.getWorkflowsPath()).contentType(APPLICATION_JSON)).andDo(print())
                        .andExpect(status().isBadRequest()).andExpect(status().is(400)).andReturn().getResponse();
-        assertEquals(String.format(MISSING_REQUEST_HEADER_ERRROR_FORMAT, USER_ID_HEADER_PARAM),
+        assertEquals(String.format(MISSING_REQUEST_HEADER_ERRROR_FORMAT, USER_ID_HEADER),
                 response.getContentAsString());
     }
 
     @Test
     public void shouldReturn5WorkflowWhen5WorkflowsExists() throws Exception {
         int numOfWorkflows = 5;
-        List<Workflow> workflowMocks = createWorkflows(numOfWorkflows);
+        Page<Workflow> workflowMocks = createWorkflows(numOfWorkflows);
         doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
-        mockMvc.perform(
-                get(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(numOfWorkflows)));
+        mockMvc.perform(get(RestPath.getWorkflowsPath()).header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.items", hasSize(numOfWorkflows)));
     }
 
     @Test
     public void listWithValidVersionStateFilter() throws Exception {
         int numOfWorkflows = 3;
-        List<Workflow> workflows = createWorkflows(numOfWorkflows);
+        Page<Workflow> workflows = createWorkflows(numOfWorkflows);
         doReturn(workflows).when(workflowManagerMock)
                            .list(eq(Collections.singleton(WorkflowVersionState.CERTIFIED)), any());
         mockMvc.perform(
-                get(RestPath.getWorkflowsWithVersionStateFilterPath("CERTIFIED")).header(USER_ID_HEADER_PARAM, USER_ID)
+                get(RestPath.getWorkflowsWithVersionStateFilterPath("CERTIFIED")).header(USER_ID_HEADER, USER_ID)
                                                                                  .contentType(APPLICATION_JSON))
-               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.total", is(numOfWorkflows)))
-               .andExpect(jsonPath("$.results", hasSize(numOfWorkflows)));
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.paging.total", is(numOfWorkflows)))
+               .andExpect(jsonPath("$.items", hasSize(numOfWorkflows)));
     }
 
     @Test
     public void listWithInvalidVersionStateFilter() throws Exception {
+        int numOfWorkflows = 0;
+        Page<Workflow> workflows = createWorkflows(numOfWorkflows);
+        doReturn(workflows).when(workflowManagerMock).list(eq(Collections.emptySet()), any());
+
         mockMvc.perform(
-                get(RestPath.getWorkflowsWithVersionStateFilterPath("hasdhf")).header(USER_ID_HEADER_PARAM, USER_ID)
-                                                                              .contentType(APPLICATION_JSON))
-               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.total", is(0)));
+                get(RestPath.getWorkflowsWithVersionStateFilterPath("gibberish")).header(USER_ID_HEADER, USER_ID)
+                                                                                 .contentType(APPLICATION_JSON))
+               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.paging.total", is(numOfWorkflows)));
     }
 
     @Test
-    public void shouldReturnSortedSizeOffsetAppliedWorkflows() throws Exception {
-        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+    public void shouldReturnSortedLimitOffsetAppliedWorkflows() throws Exception {
+        Page<Workflow> workflowMocks = createLimit2AndOffset1For5WorkflowList();
         doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
         mockMvc.perform(get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "1"))
-                                .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-               .andDo(print()).andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2)));
+                                .header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.items", hasSize(2)));
     }
 
-    @Test
-    public void shouldReturnResultsWithDefaultWhenSizeIsNegative() throws Exception {
-        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+/*    @Test
+    public void shouldReturnResultsWithDefaultWhenLimitIsNegative() throws Exception {
+        Page<Workflow> workflowMocks = createLimit2AndOffset1For5WorkflowList();
         doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
-        MockHttpServletResponse response = mockMvc.perform(
-                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "-2", "1"))
-                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
-                                                  .andReturn().getResponse();
-        CollectionWrapper workflowListResponse =
-                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
-        assertEquals(SIZE_DEFAULT, workflowListResponse.getSize());
-        assertEquals(1, workflowListResponse.getPage());
-        assertEquals(2, workflowListResponse.getTotal());
-    }
-
-    @Test
+        mockMvc.perform(get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "-2", "1"))
+                                .header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk())
+               .andExpect(jsonPath("$.paging.offset", is(1)))
+               .andExpect(jsonPath("$.paging.limit", is(DEFAULT_LIMIT)))
+               .andExpect(jsonPath("$.paging.total", is(2)));
+    }*/
+
+/*    @Test
     public void shouldFallbackOnDefaultOffsetWhenOffsetIsNegative() throws Exception {
-        MockHttpServletResponse response = mockMvc.perform(
+        mockMvc.perform(
                 get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "-1"))
-                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
-                                                  .andReturn().getResponse();
-        CollectionWrapper workflowListResponse =
-                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
-        assertEquals(2, workflowListResponse.getSize());
-        assertEquals(PAGE_DEFAULT, workflowListResponse.getPage());
-        assertEquals(0, workflowListResponse.getTotal());
-    }
-
-    @Test
-    public void shouldFallbackOnDefaultSizeWhenSizeIsNotAnInteger() throws Exception {
-        MockHttpServletResponse response = mockMvc.perform(
+                        .header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)).andDo(print())
+                                                  .andExpect(status().isOk())
+               .andExpect(jsonPath("$.paging.offset", is(DEFAULT_OFFSET)))
+               .andExpect(jsonPath("$.paging.limit", is(2)))
+               .andExpect(jsonPath("$.paging.total", is(0)));
+    }*/
+
+/*    @Test
+    public void shouldFallbackOnDefaultLimitWhenLimitIsNotAnInteger() throws Exception {
+        mockMvc.perform(
                 get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "abc", "0"))
-                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
-                                                  .andReturn().getResponse();
-        CollectionWrapper workflowListResponse =
-                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
-        assertEquals(SIZE_DEFAULT, workflowListResponse.getSize());
-        assertEquals(0, workflowListResponse.getPage());
-        assertEquals(0, workflowListResponse.getTotal());
-    }
-
-    @Test
+                        .header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)).andDo(print())
+                                                  .andExpect(status().isOk())
+                                                  .andExpect(jsonPath("$.paging.offset", is(0)))
+                                                  .andExpect(jsonPath("$.paging.limit", is(DEFAULT_LIMIT)))
+                                                  .andExpect(jsonPath("$.paging.total", is(0)));
+    }*/
+
+/*    @Test
     public void shouldFallbackOnDefaultOffsetWhenOffsetIsNotAnInteger() throws Exception {
-        MockHttpServletResponse response = mockMvc.perform(
-                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "abc"))
-                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-                                                  .andDo(print()).andExpect(status().isOk()).andExpect(status().is(200))
-                                                  .andReturn().getResponse();
-        CollectionWrapper workflowListResponse =
-                new ObjectMapper().readValue(response.getContentAsString(), CollectionWrapper.class);
-        assertEquals(2, workflowListResponse.getSize());
-        assertEquals(PAGE_DEFAULT, workflowListResponse.getPage());
-        assertEquals(0, workflowListResponse.getTotal());
-    }
-
-    @Test
-    public void shouldThrowExceptionWhenSortFieldIsInvalid() throws Exception {
-        MockHttpServletResponse response = mockMvc.perform(
-                get(RestPath.getWorkflowsPathAllQueryParams("invalidSortField,asc", "2", "1"))
-                        .header(RestConstants.USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON))
-                                                  .andDo(print()).andExpect(status().isBadRequest())
-                                                  .andExpect(status().is(400)).andReturn().getResponse();
-        assertEquals(String.format(INVALID_PAGINATION_PARAMETER_FORMAT, SORT_PARAM, "invalidSortField",
-                PAGINATION_PARAMETER_INVALID_SORT_FIELD_SUFFIX + getSupportedSortFields()),
-                response.getContentAsString());
-    }
-
-    @Test
-    public void shouldReturnAscSortedSizeOffsetAppliedWorkflowsWhenSortIsNotSpecified() throws Exception {
-        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
-        doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
         mockMvc.perform(
-                get(RestPath.getWorkflowsPathNoSort("2", "1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
-                                                              .contentType(APPLICATION_JSON)).andDo(print())
-               .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2)));
-    }
+                get(RestPath.getWorkflowsPathAllQueryParams(DEFAULT_SORT_VALUE, "2", "abc"))
+                        .header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)).andDo(print())
+                                                  .andExpect(status().isOk())
+                                                  .andExpect(jsonPath("$.paging.offset", is(DEFAULT_OFFSET)))
+                                                  .andExpect(jsonPath("$.paging.limit", is(2)))
+                                                  .andExpect(jsonPath("$.paging.total", is(0)));
+    }*/
 
     @Test
-    public void shouldReturnDefaultSizeOffsetAppliedWorkflowsWhenSizeIsNotSpecified() throws Exception {
-        List<Workflow> workflowMocks = createSize2AndOffset1For5WorkflowList();
+    public void shouldReturnDefaultLimitOffsetAppliedWorkflowsWhenLimitIsNotSpecified() throws Exception {
+        Page<Workflow> workflowMocks = createLimit2AndOffset1For5WorkflowList();
         doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
-        mockMvc.perform(
-                get(RestPath.getWorkflowsPathNoSortAndSize("1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
-                                                                .contentType(APPLICATION_JSON)).andDo(print())
-               .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(2)));
+        mockMvc.perform(get(RestPath.getWorkflowsPathNoSortAndLimit("1")).header(USER_ID_HEADER, USER_ID)
+                                                                         .contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.items", hasSize(2)));
     }
 
     @Test
     public void shouldReturnDefaultOffsetAppliedWorkflowsWhenOffsetIsNotSpecified() throws Exception {
-        List<Workflow> workflowMocks = createSize1WorkflowList();
+        Page<Workflow> workflowMocks = createLimit1WorkflowList();
         doReturn(workflowMocks).when(workflowManagerMock).list(any(), any());
-        mockMvc.perform(
-                get(RestPath.getWorkflowsPathNoSortAndOffset("1")).header(RestConstants.USER_ID_HEADER_PARAM, USER_ID)
-                                                                  .contentType(APPLICATION_JSON)).andDo(print())
-               .andExpect(status().isOk()).andExpect(jsonPath("$.results", hasSize(1)));
+        mockMvc.perform(get(RestPath.getWorkflowsPathNoSortAndOffset("1")).header(USER_ID_HEADER, USER_ID)
+                                                                          .contentType(APPLICATION_JSON)).andDo(print())
+               .andExpect(status().isOk()).andExpect(jsonPath("$.items", hasSize(1)));
     }
 
     @Test
@@ -250,9 +209,8 @@ public class WorkflowControllerTest {
         Item item = new Item();
         item.setId(new Id("abc"));
         Workflow reqWorkflow = createWorkflow(1, false);
-        mockMvc.perform(
-                post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)
-                                                 .content(GSON.toJson(reqWorkflow))).andDo(print())
+        mockMvc.perform(post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)
+                                                         .content(GSON.toJson(reqWorkflow))).andDo(print())
                .andExpect(status().isCreated());
         verify(workflowManagerMock).create(reqWorkflow);
     }
@@ -263,37 +221,30 @@ public class WorkflowControllerTest {
         Workflow reqWorkflow = new Workflow();
         reqWorkflow.setName("Invalid workflow name %");
         MockHttpServletResponse response = mockMvc.perform(
-                post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER_PARAM, USER_ID).contentType(APPLICATION_JSON)
+                post(RestPath.getWorkflowsPath()).header(USER_ID_HEADER, USER_ID).contentType(APPLICATION_JSON)
                                                  .content(GSON.toJson(reqWorkflow))).andDo(print())
                                                   .andExpect(status().isBadRequest()).andReturn().getResponse();
         assertEquals("Workflow name must contain only letters, digits and underscores", response.getContentAsString());
     }
 
-    private List<Workflow> createWorkflows(int numOfWorkflows) {
-        List<Workflow> workflowList = new ArrayList<>(numOfWorkflows);
+    private Page<Workflow> createWorkflows(int numOfWorkflows) {
+        List<Workflow> workflows = new ArrayList<>(numOfWorkflows);
         for (int i = 0; i < numOfWorkflows; i++) {
-            workflowList.add(createWorkflow(i, true));
+            workflows.add(createWorkflow(i, true));
         }
-
-        return workflowList;
+        return new Page<>(workflows, new PagingRequest(0, 200), numOfWorkflows);
     }
 
-    private List<Workflow> createSize2AndOffset1For5WorkflowList() {
-        List<Workflow> workflowList = new ArrayList<>();
-        workflowList.add(createWorkflow(2, true));
-        workflowList.add(createWorkflow(3, true));
-        return workflowList;
+    private Page<Workflow> createLimit2AndOffset1For5WorkflowList() {
+        List<Workflow> workflows = new ArrayList<>();
+        workflows.add(createWorkflow(2, true));
+        workflows.add(createWorkflow(3, true));
+        return new Page<>(workflows, new PagingRequest(1, 200), 5);
     }
 
-    private List<Workflow> createSize1WorkflowList() {
-        List<Workflow> workflowList = new ArrayList<>();
-        workflowList.add(createWorkflow(0, true));
-        return workflowList;
+    private Page<Workflow> createLimit1WorkflowList() {
+        List<Workflow> workflows = new ArrayList<>();
+        workflows.add(createWorkflow(0, true));
+        return new Page<>(workflows, new PagingRequest(0, 1), 1);
     }
-
-
-    private Set<String> getSupportedSortFields() {
-        return ImmutableSet.of(SORT_FIELD_NAME);
-    }
-
 }
\ No newline at end of file