diff --git a/README.md b/README.md index 4d17ea4..43f5e82 100644 --- a/README.md +++ b/README.md @@ -354,17 +354,18 @@ And for the page size are: - **page[size]** - **page[limit]** -#### Request page always starts from 0 for compatible with spring repositories and etc.! -#### If request page number < 1 resolver always return number = 0 and if size < 1 it always returns default value = 25! +#### Request page always starts from 0 for compatibility with spring repositories and etc.! +#### If request page number < 1, resolver always return number = 0, and if size < 1, it always returns default value of 10! +#### Those default values can be overridden by annotating the method parameter with ```@PageableDefault``` ### Sorting See documentation part: [fetching-sorting](https://jsonapi.org/format/#fetching-sorting) -If you want to use request sort with annotation ```@RequestJsonApiPage``` add argument resolver in your configuration +If you want to use request sort with annotation ```@RequestJsonApiPage```, add the argument resolver in your configuration as described in section [Pagination](#pagination). -Then you can use annotation ```@RequestJsonApiPage``` in controllers and get standard spring Pageable object. +Then you can use the annotation ```@RequestJsonApiPage``` in controllers and get a standard spring Pageable object. For example: ```java @@ -384,12 +385,78 @@ public class RestController { } ``` -Now if request will be contained list of fields like ```sort=field1,field2,-field3``` we can get them in the ```Pageable``` object. +Now if the request contains a list of fields like ```sort=field1,field2,-field3``` we can get them in the ```Pageable``` object. For ASC order we just put fields name as is, for example: ```sort=name,age,...``` (see JSON:API spec). For DESC order we should put fields name with prefix **-**, for example: ```sort=-name,age,...``` (see JSON:API spec). +To provide a default sort in case the request doesn't specify one, you can use either the one of the ```@SortDefault``` or +```@SortDefaults``` annotations, or the property **sort** and **direction** of the ```@PageableDefault``` +annotation. See the examples bellow: + +```java +@Slf4j +@RestController +@AllArgsConstructor +@RequestMapping(value = "/app", produces = MediaType.APPLICATION_JSON_UTF8_VALUE) +public class RestController { + @GetMapping + public Response get( + @sortDefault(sort={"name", "age"}, direction=Sort.Direction.ASC) + final @RequestJsonApiPage Pageable page) throws Exception { + final Sort sort = page.getSort(); + // do anything with sort + + return Response.builder() + .build(); + } +} +``` + +```java +@Slf4j +@RestController +@AllArgsConstructor +@RequestMapping(value = "/app", produces = MediaType.APPLICATION_JSON_UTF8_VALUE) +public class RestController { + @GetMapping + public Response get( + @SortDefault.SortDefaults({ + @SortDefault(sort={"name", "age"}, direction=Sort.Direction.ASC), + @SortDefault(sort={"updateAt"}, direction=Sort.Direction.DESC) + }) + final @RequestJsonApiPage Pageable page) throws Exception { + final Sort sort = page.getSort(); + // do anything with sort + + return Response.builder() + .build(); + } +} +``` + +```java +@Slf4j +@RestController +@AllArgsConstructor +@RequestMapping(value = "/app", produces = MediaType.APPLICATION_JSON_UTF8_VALUE) +public class RestController { + @GetMapping + public Response get( + @PageableDefault( + sort={"name", "age"}, direction=Sort.Direction.ASC + ) + final @RequestJsonApiPage Pageable page) throws Exception { + final Sort sort = page.getSort(); + // do anything with sort + + return Response.builder() + .build(); + } +} +``` + ### Other response examples Example response with one data object: ```java diff --git a/src/main/java/com/slmdev/jsonapi/simple/resolver/JsonApiPageArgumentResolver.java b/src/main/java/com/slmdev/jsonapi/simple/resolver/JsonApiPageArgumentResolver.java index a8d6641..7931b61 100644 --- a/src/main/java/com/slmdev/jsonapi/simple/resolver/JsonApiPageArgumentResolver.java +++ b/src/main/java/com/slmdev/jsonapi/simple/resolver/JsonApiPageArgumentResolver.java @@ -1,19 +1,29 @@ package com.slmdev.jsonapi.simple.resolver; -import com.slmdev.jsonapi.simple.annotation.RequestJsonApiPage; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import java.util.stream.Stream; + import org.springframework.core.MethodParameter; import org.springframework.data.domain.PageRequest; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; +import org.springframework.data.web.PageableArgumentResolver; +import org.springframework.data.web.PageableDefault; +import org.springframework.data.web.SortDefault; +import org.springframework.data.web.SortDefault.SortDefaults; +import org.springframework.lang.NonNull; +import org.springframework.lang.Nullable; import org.springframework.util.CollectionUtils; import org.springframework.web.bind.support.WebDataBinderFactory; import org.springframework.web.context.request.NativeWebRequest; -import org.springframework.web.method.support.HandlerMethodArgumentResolver; import org.springframework.web.method.support.ModelAndViewContainer; -import java.util.*; -import java.util.stream.Collectors; -import java.util.stream.Stream; +import com.slmdev.jsonapi.simple.annotation.RequestJsonApiPage; /** * Spring resolver using for extract page values from the request. @@ -21,27 +31,53 @@ *

By default using {@code page} param name and key names in square brackets, * for example {@code page[number]=3&page[size]=15}. * - * After parsing will be created new spring {@link org.springframework.data.domain.Pageable} object. + * Optionally, if provided with a {@link org.springframework.data.web.PageableDefault}, it uses those + * values as the defaults when parsing the request parameters. + * + * After the parsing, a new spring {@link org.springframework.data.domain.Pageable} object will be created. * *

This resolver must be registered in Spring application. */ -public class JsonApiPageArgumentResolver implements HandlerMethodArgumentResolver { +public class JsonApiPageArgumentResolver implements PageableArgumentResolver { private static final String REQUEST_PAGE_KEY_BRACKET_START = "["; private static final String REQUEST_PAGE_KEY_BRACKET_END = "]"; public boolean supportsParameter(MethodParameter parameter) { - return parameter.getParameterAnnotation(RequestJsonApiPage.class) != null; + return Pageable.class.equals(parameter.getParameterType()) && + parameter.getParameterAnnotation(RequestJsonApiPage.class) != null; } + @NonNull + @Override public Pageable resolveArgument(final MethodParameter methodParameter, final ModelAndViewContainer modelAndViewContainer, final NativeWebRequest nativeWebRequest, final WebDataBinderFactory webDataBinderFactory) { - final RequestJsonApiPage RequestJsonApiPage = methodParameter.getParameterAnnotation(RequestJsonApiPage.class); - final String pageKeyStart = RequestJsonApiPage.name() + REQUEST_PAGE_KEY_BRACKET_START; - final Sort sort = parseSortField(nativeWebRequest); - int page = 0; - int size = 25; + + final SortDefault sortDefault = methodParameter.getParameterAnnotation(SortDefault.class); + final SortDefaults sortDefaults = methodParameter.getParameterAnnotation(SortDefaults.class); + final PageableDefault pageableDefault = methodParameter.getParameterAnnotation(PageableDefault.class); + + if (sortDefault != null && sortDefaults != null) { + throw new IllegalArgumentException( + String.format( + "Cannot use both @%s and @%s on parameter %s; Move %s into %s to define sorting order", + SortDefaults.class.getSimpleName(), + SortDefault.class.getSimpleName(), + methodParameter.toString(), + SortDefault.class.getSimpleName(), + SortDefaults.class.getSimpleName() + ) + ); + } + + final RequestJsonApiPage requestJsonApiPage = methodParameter.getParameterAnnotation(RequestJsonApiPage.class); + + final String pageKeyStart = requestJsonApiPage.name() + REQUEST_PAGE_KEY_BRACKET_START; + + final Sort sort = parseSortField(nativeWebRequest, sortDefault, sortDefaults, pageableDefault); + int page = pageableDefault == null ? 0 : pageableDefault.page(); + int size = pageableDefault == null ? 10 : pageableDefault.size(); final List> entries = nativeWebRequest.getParameterMap() .entrySet() @@ -101,10 +137,42 @@ private List valueToList(final String[] values) { return valueItems; } - private Sort parseSortField(final NativeWebRequest nativeWebRequest) { + @Nullable + private Sort parseSortField( + final NativeWebRequest nativeWebRequest, + @Nullable final SortDefault sortDefault, + @Nullable final SortDefaults sortDefaults, + @Nullable final PageableDefault pageableDefault + ) { + if (CollectionUtils.isEmpty(nativeWebRequest.getParameterMap()) || nativeWebRequest.getParameterMap().get("sort") == null) { + + SortDefault[] sortDefaultArray = + sortDefaults != null ? + sortDefaults.value() : + sortDefault != null ? + new SortDefault[]{sortDefault} : + new SortDefault[0]; + + // Takes the sort from sortDefalt(s) + if (sortDefaultArray.length > 0) { + return Arrays.stream(sortDefaultArray).map( + currentSortDefault -> Sort.by( + currentSortDefault.direction(), + currentSortDefault.sort() + ) + ).reduce( + Sort.unsorted(), + Sort::and + ); + // Takes the sort from pageableDefault + } else if (pageableDefault != null && pageableDefault.sort().length > 0) { + return Sort.by(pageableDefault.direction(), pageableDefault.sort()); + } + return null; + } final var sortOrders = Arrays.stream(nativeWebRequest.getParameterMap() .get("sort")) diff --git a/src/test/java/com/slmdev/jsonapi/simple/response/PageDefaultsTest.java b/src/test/java/com/slmdev/jsonapi/simple/response/PageDefaultsTest.java new file mode 100644 index 0000000..fbb0b39 --- /dev/null +++ b/src/test/java/com/slmdev/jsonapi/simple/response/PageDefaultsTest.java @@ -0,0 +1,332 @@ +package com.slmdev.jsonapi.simple.response; + +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.mock; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; + +import java.util.stream.IntStream; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.core.MethodParameter; +import org.springframework.data.domain.Pageable; +import org.springframework.data.domain.Sort.Direction; +import org.springframework.data.domain.Sort.Order; +import org.springframework.data.web.PageableDefault; +import org.springframework.data.web.SortDefault; +import org.springframework.data.web.SortDefault.SortDefaults; +import org.springframework.web.context.request.NativeWebRequest; + +import com.slmdev.jsonapi.simple.annotation.RequestJsonApiPage; +import com.slmdev.jsonapi.simple.resolver.JsonApiPageArgumentResolver; + +public class PageDefaultsTest extends BaseTest { + private static final String REQUEST_PAGE_ARGUMENT_NAME = "page"; + private static final int DEFAULT_PAGE_NUMBER = 0; + private static final int DEFAULT_PAGE_SIZE = 10; + + private JsonApiPageArgumentResolver jsonApiPageArgumentResolver; + + @Mock + private MethodParameter methodParameter; + @Mock + private RequestJsonApiPage requestJsonApiPage; + @Mock + private SortDefault sortDefault; + @Mock + private SortDefaults sortDefaults; + @Mock + private PageableDefault pageableDefault; + @Mock + private NativeWebRequest nativeWebRequest; + + @BeforeEach + public void setUp() { + MockitoAnnotations.openMocks(this); + + Mockito.when(methodParameter.getParameterAnnotation(RequestJsonApiPage.class)) + .thenReturn(requestJsonApiPage); + Mockito.when(requestJsonApiPage.name()) + .thenReturn(REQUEST_PAGE_ARGUMENT_NAME); + + jsonApiPageArgumentResolver = new JsonApiPageArgumentResolver(); + } + + @Test + public void shouldParsePageWithPage2AndSize10AndNoSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(pageableDefault); + Mockito.when(pageableDefault.size()) + .thenReturn(2); + Mockito.when(pageableDefault.page()) + .thenReturn(10); + Mockito.when(pageableDefault.sort()) + .thenReturn(new String[0]); + + // Mocks the SortDefault and SortDefaults annotations + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(null); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(null); + + shouldParsePageFromPageableDefault(); + } + + @Test + public void shouldParsePageWithPage2AndSize10AndAscSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(pageableDefault); + Mockito.when(pageableDefault.size()) + .thenReturn(2); + Mockito.when(pageableDefault.page()) + .thenReturn(10); + Mockito.when(pageableDefault.direction()) + .thenReturn(Direction.ASC); + Mockito.when(pageableDefault.sort()) + .thenReturn(new String[]{"foo", "bar"}); + + // Mocks the SortDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(null); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(null); + + shouldParsePageFromPageableDefault(); + } + + @Test + public void shouldParsePageWithPage2AndSize10AndDescSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(pageableDefault); + Mockito.when(pageableDefault.size()) + .thenReturn(2); + Mockito.when(pageableDefault.page()) + .thenReturn(10); + Mockito.when(pageableDefault.direction()) + .thenReturn(Direction.DESC); + Mockito.when(pageableDefault.sort()) + .thenReturn(new String[]{"foo", "bar"}); + + // Mocks the SortDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(null); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(null); + + shouldParsePageFromPageableDefault(); + } + + @Test + public void shouldParsePageWithAscSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(null); + + // Mocks the SortDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(sortDefault); + Mockito.when(sortDefault.sort()) + .thenReturn(new String[]{"foo", "bar"}); + Mockito.when(sortDefault.direction()) + .thenReturn(Direction.DESC); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(null); + + shouldParsePageFromSortDefault(); + } + + @Test + public void shouldParsePageWithDescSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(null); + + // Mocks the SortDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(sortDefault); + Mockito.when(sortDefault.sort()) + .thenReturn(new String[]{"foo", "bar"}); + Mockito.when(sortDefault.direction()) + .thenReturn(Direction.ASC); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(null); + + shouldParsePageFromSortDefault(); + } + + @Test + public void shouldParsePageWithTwoAscAndOneDescSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(null); + + // Mocks the SortDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(null); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(sortDefaults); + + SortDefault sortDefaultMock1 = mock(SortDefault.class); + Mockito.when(sortDefaultMock1.sort()) + .thenReturn(new String[]{"foo", "bar"}); + Mockito.when(sortDefaultMock1.direction()) + .thenReturn(Direction.ASC); + + SortDefault sortDefaultMock2 = mock(SortDefault.class); + Mockito.when(sortDefaultMock2.sort()) + .thenReturn(new String[]{"baz"}); + Mockito.when(sortDefaultMock2.direction()) + .thenReturn(Direction.DESC); + + SortDefault[] sSortDefaultArrayMock = new SortDefault[] { sortDefaultMock1, sortDefaultMock2 }; + + Mockito.when(sortDefaults.value()) + .thenReturn(sSortDefaultArrayMock); + + shouldParsePageFromSortDefaults(); + } + + @Test + public void shouldParsePageWithOneAscAndTwoDescSortParams() { + + // Mocks the PageableDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(null); + + // Mocks the SortDefault annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefault.class)) + .thenReturn(null); + + // Mocks the SortDefaults annotation + Mockito.when(methodParameter.getParameterAnnotation(SortDefaults.class)) + .thenReturn(sortDefaults); + + SortDefault sortDefaultMock1 = mock(SortDefault.class); + Mockito.when(sortDefaultMock1.sort()) + .thenReturn(new String[]{"foo"}); + Mockito.when(sortDefaultMock1.direction()) + .thenReturn(Direction.ASC); + + SortDefault sortDefaultMock2 = mock(SortDefault.class); + Mockito.when(sortDefaultMock2.sort()) + .thenReturn(new String[]{"bar", "baz"}); + Mockito.when(sortDefaultMock2.direction()) + .thenReturn(Direction.DESC); + + SortDefault[] sSortDefaultArrayMock = new SortDefault[] { sortDefaultMock1, sortDefaultMock2 }; + + Mockito.when(sortDefaults.value()) + .thenReturn(sSortDefaultArrayMock); + + shouldParsePageFromSortDefaults(); + } + + private void shouldParsePageFromPageableDefault() { + + // No page parameters should be passed in order for pageableDefault to take effect + final var pageParams = new HashMap(); + + Mockito.when(nativeWebRequest.getParameterMap()) + .thenReturn(pageParams); + + final Pageable page = jsonApiPageArgumentResolver.resolveArgument(methodParameter, null, nativeWebRequest, null); + + assertEquals(page.getPageSize(), pageableDefault.size()); + assertEquals(page.getPageNumber(), pageableDefault.page()); + + List pageOrders = page.getSort().toList(); + assertEquals(pageOrders.size(), pageableDefault.sort().length); + assertAll("all orders match", IntStream.range(0, page.getSort().toList().size()).mapToObj(i -> + () -> { + assertEquals(pageOrders.get(i).getDirection(), pageableDefault.direction()); + assertEquals(pageOrders.get(i).getProperty(), pageableDefault.sort()[i]); + } + )); + + } + + private void shouldParsePageFromSortDefault() { + + // No page parameters should be passed in order for SortDefault to take effect + final var pageParams = new HashMap(); + + Mockito.when(nativeWebRequest.getParameterMap()) + .thenReturn(pageParams); + + final Pageable page = jsonApiPageArgumentResolver.resolveArgument(methodParameter, null, nativeWebRequest, null); + + assertEquals(page.getPageSize(), DEFAULT_PAGE_SIZE); + assertEquals(page.getPageNumber(), DEFAULT_PAGE_NUMBER); + + List pageOrders = page.getSort().toList(); + assertEquals(pageOrders.size(), sortDefault.sort().length); + assertAll("all orders match", IntStream.range(0, page.getSort().toList().size()).mapToObj(i -> + () -> { + assertEquals(pageOrders.get(i).getDirection(), sortDefault.direction()); + assertEquals(pageOrders.get(i).getProperty(), sortDefault.sort()[i]); + } + )); + + } + + private void shouldParsePageFromSortDefaults() { + + // No page parameters should be passed in order for SortDefaults to take effect + final var pageParams = new HashMap(); + + Mockito.when(nativeWebRequest.getParameterMap()) + .thenReturn(pageParams); + + final Pageable page = jsonApiPageArgumentResolver.resolveArgument(methodParameter, null, nativeWebRequest, null); + + assertEquals(page.getPageSize(), DEFAULT_PAGE_SIZE); + assertEquals(page.getPageNumber(), DEFAULT_PAGE_NUMBER); + + List pageOrders = page.getSort().toList(); + SortDefault[] sortDefaultsArray = sortDefaults.value(); + String[] properties = Arrays.stream(sortDefaultsArray).map(SortDefault::sort).flatMap(Arrays::stream).toArray(String[]::new); + Direction[] directions = Arrays.stream(sortDefaultsArray).map(sortDefault -> { + int n = sortDefault.sort().length; + Direction[] sortDefaultDirections = new Direction[n]; + Arrays.fill(sortDefaultDirections, sortDefault.direction()); + return sortDefaultDirections; + }).flatMap(Arrays::stream).toArray(Direction[]::new); + assertEquals(pageOrders.size(), properties.length); + assertAll("all orders match", IntStream.range(0, page.getSort().toList().size()).mapToObj(i -> + () -> { + assertEquals(pageOrders.get(i).getDirection(), directions[i]); + assertEquals(pageOrders.get(i).getProperty(), properties[i]); + } + )); + + } + +} diff --git a/src/test/java/com/slmdev/jsonapi/simple/response/PageSortTest.java b/src/test/java/com/slmdev/jsonapi/simple/response/PageSortTest.java index 5e4ec66..910a6b2 100644 --- a/src/test/java/com/slmdev/jsonapi/simple/response/PageSortTest.java +++ b/src/test/java/com/slmdev/jsonapi/simple/response/PageSortTest.java @@ -9,6 +9,7 @@ import org.mockito.MockitoAnnotations; import org.springframework.core.MethodParameter; import org.springframework.data.domain.Pageable; +import org.springframework.data.web.PageableDefault; import org.springframework.web.context.request.NativeWebRequest; import java.util.HashMap; @@ -18,7 +19,6 @@ import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.Matchers.is; -import static org.mockito.ArgumentMatchers.any; public class PageSortTest extends BaseTest { private static final String REQUEST_PAGE_ARGUMENT_NAME = "page"; @@ -43,8 +43,10 @@ public class PageSortTest extends BaseTest { public void setUp() { MockitoAnnotations.openMocks(this); - Mockito.when(methodParameter.getParameterAnnotation(any())) + Mockito.when(methodParameter.getParameterAnnotation(RequestJsonApiPage.class)) .thenReturn(requestJsonApiPage); + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(null); Mockito.when(requestJsonApiPage.name()) .thenReturn(REQUEST_PAGE_ARGUMENT_NAME); diff --git a/src/test/java/com/slmdev/jsonapi/simple/response/PageTest.java b/src/test/java/com/slmdev/jsonapi/simple/response/PageTest.java index 19e730f..ef3c6f9 100644 --- a/src/test/java/com/slmdev/jsonapi/simple/response/PageTest.java +++ b/src/test/java/com/slmdev/jsonapi/simple/response/PageTest.java @@ -1,7 +1,13 @@ package com.slmdev.jsonapi.simple.response; -import com.slmdev.jsonapi.simple.annotation.RequestJsonApiPage; -import com.slmdev.jsonapi.simple.resolver.JsonApiPageArgumentResolver; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.is; +import static org.mockito.ArgumentMatchers.isNotNull; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mockito.Mock; @@ -10,27 +16,22 @@ import org.springframework.core.MethodParameter; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; +import org.springframework.data.web.PageableDefault; import org.springframework.web.context.request.NativeWebRequest; -import java.util.HashMap; -import java.util.Map; -import java.util.Optional; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.is; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.isNotNull; +import com.slmdev.jsonapi.simple.annotation.RequestJsonApiPage; +import com.slmdev.jsonapi.simple.resolver.JsonApiPageArgumentResolver; public class PageTest extends BaseTest { private static final String REQUEST_PAGE_ARGUMENT_NAME = "page"; private static final String REQUEST_PAGE_NUMBER_KEY = "number"; private static final String REQUEST_PAGE_SIZE_KEY = "size"; private static final int DEFAULT_PAGE_NUMBER = 0; - private static final int DEFAULT_PAGE_SIZE = 25; + private static final int DEFAULT_PAGE_SIZE = 10; private static final int TEST_PAGE_NUMBER_1 = 1; private static final int TEST_PAGE_NUMBER_2 = 2; private static final int TEST_PAGE_SIZE_10 = 10; - private static final int TEST_PAGE_SIZE_25 = DEFAULT_PAGE_SIZE; + private static final int TEST_PAGE_SIZE_25 = 25; private JsonApiPageArgumentResolver jsonApiPageArgumentResolver; @@ -45,8 +46,10 @@ public class PageTest extends BaseTest { public void setUp() { MockitoAnnotations.openMocks(this); - Mockito.when(methodParameter.getParameterAnnotation(any())) + Mockito.when(methodParameter.getParameterAnnotation(RequestJsonApiPage.class)) .thenReturn(requestJsonApiPage); + Mockito.when(methodParameter.getParameterAnnotation(PageableDefault.class)) + .thenReturn(null); Mockito.when(requestJsonApiPage.name()) .thenReturn(REQUEST_PAGE_ARGUMENT_NAME);