[BE] feat: 내가 받은 리뷰 목록에 페이지네이션 적용

backend/src/docs/asciidoc/review-list.adoc

@@ -2,6 +2,6 @@
 
 operation::received-reviews[snippets="curl-request,request-headers,http-response,response-fields"]
 
-==== 자신이 받은 리뷰 목록 조회 (세션 사용)
+==== 자신이 받은 리뷰 목록 조회
 
-operation::received-review-list-with-session[snippets="curl-request,request-cookies,http-response,response-fields"]
+operation::received-review-list-with-pagination[snippets="curl-request,request-cookies,query-parameters,http-response,response-fields"]

backend/src/main/java/reviewme/review/controller/ReviewController.java

@@ -8,6 +8,7 @@
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.SessionAttribute;
 import reviewme.review.service.ReviewDetailLookupService;
@@ -35,9 +36,12 @@ public ResponseEntity<Void> createReview(@Valid @RequestBody ReviewRegisterReque
 
     @GetMapping("/v2/reviews")
     public ResponseEntity<ReceivedReviewsResponse> findReceivedReviews(
+            @RequestParam(required = false) Long lastReviewId,
+            @RequestParam(required = false) Integer size,
             @SessionAttribute("reviewRequestCode") String reviewRequestCode
     ) {
-        ReceivedReviewsResponse response = reviewListLookupService.getReceivedReviews(reviewRequestCode);
+        ReceivedReviewsResponse response = reviewListLookupService.getReceivedReviews(
+                lastReviewId, size, reviewRequestCode);
         return ResponseEntity.ok(response);
     }
 

backend/src/main/java/reviewme/review/repository/ReviewRepository.java

@@ -17,5 +17,16 @@ public interface ReviewRepository extends JpaRepository<Review, Long> {
             """, nativeQuery = true)
     List<Review> findAllByGroupId(long reviewGroupId);
 
+    @Query(value = """
+            SELECT r.* FROM review r
+            WHERE r.review_group_id = :reviewGroupId
+            AND r.id < :lastReviewId
+            ORDER BY r.created_at DESC 
+            LIMIT :limit
+            """, nativeQuery = true)
+    List<Review> findByReviewGroupIdWithLimit(long reviewGroupId, long lastReviewId, int limit);
+
     Optional<Review> findByIdAndReviewGroupId(long reviewId, long reviewGroupId);
+
+    int countByReviewGroupId(long id);
 }

backend/src/main/java/reviewme/review/service/LastReviewId.java

@@ -0,0 +1,19 @@
+package reviewme.review.service;
+
+import lombok.Getter;
+
+@Getter
+public class LastReviewId {
+
+    private static final long DEFAULT_LAST_REVIEW_ID = Long.MAX_VALUE;
+
+    private final long id;
+
+    LastReviewId(Long id) {
+        if (id == null) {
+            this.id = DEFAULT_LAST_REVIEW_ID;
+            return;
+        }
+        this.id = id;
+    }
+}

backend/src/main/java/reviewme/review/service/PageSize.java

@@ -0,0 +1,20 @@
+package reviewme.review.service;
+
+import lombok.Getter;
+
+@Getter
+public class PageSize {
+
+    private static final int DEFAULT_SIZE = 5;
+    private static final int MAX_SIZE = 50;
+
+    private final int size;
+
+    PageSize(Integer size) {
+        if (size == null || size < 1 || size > MAX_SIZE) {
+            this.size = DEFAULT_SIZE;
+            return;
+        }
+        this.size = size;
+    }
+}

backend/src/main/java/reviewme/review/service/ReviewListLookupService.java

@@ -4,6 +4,7 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import reviewme.review.repository.ReviewRepository;
 import reviewme.review.service.dto.response.list.ReceivedReviewsResponse;
 import reviewme.review.service.dto.response.list.ReviewListElementResponse;
 import reviewme.review.service.exception.ReviewGroupNotFoundByReviewRequestCodeException;
@@ -17,15 +18,28 @@ public class ReviewListLookupService {
 
     private final ReviewGroupRepository reviewGroupRepository;
     private final ReviewListMapper reviewListMapper;
+    private final ReviewRepository reviewRepository;
 
     @Transactional(readOnly = true)
-    public ReceivedReviewsResponse getReceivedReviews(String reviewRequestCode) {
+    public ReceivedReviewsResponse getReceivedReviews(Long lastReviewId, Integer size, String reviewRequestCode) {
         ReviewGroup reviewGroup = reviewGroupRepository.findByReviewRequestCode(reviewRequestCode)
                 .orElseThrow(() -> new ReviewGroupNotFoundByReviewRequestCodeException(reviewRequestCode));
 
-        List<ReviewListElementResponse> reviewGroupResponse = reviewListMapper.mapToReviewList(reviewGroup);
+        LastReviewId lastId = new LastReviewId(lastReviewId);
+        PageSize pageSize = new PageSize(size);
+        List<ReviewListElementResponse> reviewListResponse
+                = reviewListMapper.mapToReviewList(reviewGroup, lastId.getId(), pageSize.getSize());
+        int totalSize = reviewRepository.countByReviewGroupId(reviewGroup.getId());
+        long newLastReviewId = calculateLastReviewId(reviewListResponse);
         return new ReceivedReviewsResponse(
-                reviewGroup.getReviewee(), reviewGroup.getProjectName(), reviewGroupResponse
+                reviewGroup.getReviewee(), reviewGroup.getProjectName(), totalSize, newLastReviewId, reviewListResponse
         );
     }
+
+    private long calculateLastReviewId(List<ReviewListElementResponse> elements) {
+        if (elements.isEmpty()) {
+            return 0;
+        }
+        return elements.get(elements.size() - 1).reviewId();
+    }
 }

backend/src/main/java/reviewme/review/service/dto/response/list/ReceivedReviewsResponse.java

@@ -5,6 +5,8 @@
 public record ReceivedReviewsResponse(
         String revieweeName,
         String projectName,
+        int totalSize,
+        long lastReviewId,
         List<ReviewListElementResponse> reviews
 ) {
 }

backend/src/main/java/reviewme/review/service/mapper/ReviewListMapper.java

@@ -22,9 +22,10 @@ public class ReviewListMapper {
 
     private final ReviewPreviewGenerator reviewPreviewGenerator = new ReviewPreviewGenerator();
 
-    public List<ReviewListElementResponse> mapToReviewList(ReviewGroup reviewGroup) {
+    public List<ReviewListElementResponse> mapToReviewList(ReviewGroup reviewGroup,
+                                                           long lastReviewId, int size) {
         List<OptionItem> categoryOptionIds = optionItemRepository.findAllByOptionType(OptionType.CATEGORY);
-        return reviewRepository.findAllByGroupId(reviewGroup.getId())
+        return reviewRepository.findByReviewGroupIdWithLimit(reviewGroup.getId(), lastReviewId, size)
                 .stream()
                 .map(review -> mapToReviewListElementResponse(review, categoryOptionIds))
                 .toList();
@@ -43,7 +44,7 @@ private ReviewListElementResponse mapToReviewListElementResponse(Review review,
     }
 
     private List<ReviewCategoryResponse> mapToCategoryOptionResponse(Review review,
-                                                                            List<OptionItem> categoryOptionItems) {
+                                                                     List<OptionItem> categoryOptionItems) {
         Set<Long> checkBoxOptionIds = review.getAllCheckBoxOptionIds();
         return categoryOptionItems.stream()
                 .filter(optionItem -> checkBoxOptionIds.contains(optionItem.getId()))

backend/src/test/java/reviewme/api/ReviewApiTest.java

@@ -1,6 +1,7 @@
 package reviewme.api;
 
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.springframework.restdocs.cookies.CookieDocumentation.cookieWithName;
@@ -11,6 +12,7 @@
 import static org.springframework.restdocs.payload.PayloadDocumentation.responseFields;
 import static org.springframework.restdocs.request.RequestDocumentation.parameterWithName;
 import static org.springframework.restdocs.request.RequestDocumentation.pathParameters;
+import static org.springframework.restdocs.request.RequestDocumentation.queryParameters;
 
 import java.time.LocalDate;
 import java.util.List;
@@ -156,24 +158,33 @@ class ReviewApiTest extends ApiTest {
     }
 
     @Test
-    void 세션으로_자신이_받은_리뷰_목록을_조회한다() {
+    void 자신이_받은_리뷰_목록을_조회한다() {
         List<ReviewListElementResponse> receivedReviews = List.of(
                 new ReviewListElementResponse(1L, LocalDate.of(2024, 8, 1), "(리뷰 미리보기 1)",
                         List.of(new ReviewCategoryResponse(1L, "카테고리 1"))),
                 new ReviewListElementResponse(2L, LocalDate.of(2024, 8, 2), "(리뷰 미리보기 2)",
                         List.of(new ReviewCategoryResponse(2L, "카테고리 2")))
         );
-        ReceivedReviewsResponse response = new ReceivedReviewsResponse("아루", "리뷰미", receivedReviews);
-        BDDMockito.given(reviewListLookupService.getReceivedReviews(anyString()))
+        ReceivedReviewsResponse response = new ReceivedReviewsResponse(
+                "아루3", "리뷰미", receivedReviews.size(), 2, receivedReviews);
+        BDDMockito.given(reviewListLookupService.getReceivedReviews(anyLong(), anyInt(), anyString()))
                 .willReturn(response);
 
         CookieDescriptor[] cookieDescriptors = {
                 cookieWithName("JSESSIONID").description("세션 쿠키")
         };
 
+        ParameterDescriptor[] queryParameter = {
+                parameterWithName("reviewRequestCode").description("리뷰 요청 코드"),
+                parameterWithName("lastReviewId").description("페이지의 마지막 리뷰 ID - 기본으로 최신순 첫번째 페이지 응답"),
+                parameterWithName("size").description("페이지의 크기 - 기본으로 5개씩 응답")
+        };
+
         FieldDescriptor[] responseFieldDescriptors = {
                 fieldWithPath("revieweeName").description("리뷰이 이름"),
                 fieldWithPath("projectName").description("프로젝트 이름"),
+                fieldWithPath("totalSize").description("받은 리뷰 전체 개수"),
+                fieldWithPath("lastReviewId").description("페이지의 마지막 리뷰 ID"),
 
                 fieldWithPath("reviews[]").description("리뷰 목록"),
                 fieldWithPath("reviews[].reviewId").description("리뷰 ID"),
@@ -186,13 +197,17 @@ class ReviewApiTest extends ApiTest {
         };
 
         RestDocumentationResultHandler handler = document(
-                "received-review-list-with-session",
+                "received-review-list-with-pagination",
                 requestCookies(cookieDescriptors),
+                queryParameters(queryParameter),
                 responseFields(responseFieldDescriptors)
         );
 
         givenWithSpec().log().all()
                 .cookie("JSESSIONID", "ASVNE1VAKDNV4")
+                .queryParam("reviewRequestCode", "hello!!")
+                .queryParam("lastReviewId", "2")
+                .queryParam("size", "5")
                 .when().get("/v2/reviews")
                 .then().log().all()
                 .apply(handler)

backend/src/test/java/reviewme/review/repository/ReviewRepositoryTest.java

@@ -1,13 +1,13 @@
 package reviewme.review.repository;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.*;
 import static reviewme.fixture.QuestionFixture.서술형_필수_질문;
 import static reviewme.fixture.ReviewGroupFixture.리뷰_그룹;
 import static reviewme.fixture.SectionFixture.항상_보이는_섹션;
 import static reviewme.fixture.TemplateFixture.템플릿;
 
 import java.util.List;
+import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
@@ -59,4 +59,83 @@ class ReviewRepositoryTest {
         // then
         assertThat(actual).containsExactly(review2, review1);
     }
+
+    @Nested
+    class 리뷰그룹_아이디에_해당하는_리뷰를_생성일_기준_내림차순으로_페이징하여_불러온다 {
+
+        private final Question question = questionRepository.save(서술형_필수_질문());
+        private final Section section = sectionRepository.save(항상_보이는_섹션(List.of(question.getId())));
+        private final Template template = templateRepository.save(템플릿(List.of(section.getId())));
+        private final ReviewGroup reviewGroup = reviewGroupRepository.save(리뷰_그룹());
+
+        private final Review review1 = reviewRepository.save(
+                new Review(template.getId(), reviewGroup.getId(), null, null));
+        private final Review review2 = reviewRepository.save(
+                new Review(template.getId(), reviewGroup.getId(), null, null));
+        private final Review review3 = reviewRepository.save(
+                new Review(template.getId(), reviewGroup.getId(), null, null));
+
+
+        @Test
+        void 페이징_크기보다_적은_수의_리뷰가_등록되었으면_그_크기만큼의_리뷰만_반환한다() {
+            // given
+            int limit = 5;
+            long lastReviewId = Long.MAX_VALUE;
+
+            // when
+            List<Review> actual = reviewRepository.findByReviewGroupIdWithLimit(
+                    reviewGroup.getId(), lastReviewId, limit);
+
+            // then
+            assertThat(actual)
+                    .hasSize(3)
+                    .containsExactly(review3, review2, review1);
+        }
+
+        @Test
+        void 페이징_크기보다_큰_수의_리뷰가_등록되었으면_페이징_크기만큼의_리뷰를_반환한다() {
+            // given
+            int limit = 2;
+            long lastReviewId = Long.MAX_VALUE;
+
+            // when
+            List<Review> actual = reviewRepository.findByReviewGroupIdWithLimit(
+                    reviewGroup.getId(), lastReviewId, limit);
+
+            // then
+            assertThat(actual)
+                    .hasSize(2)
+                    .containsExactly(review3, review2);
+        }
+
+        @Test
+        void 마지막_리뷰_아이디를_기준으로_그보다_전에_적힌_리뷰를_반환한다() {
+            // given
+            int limit = 5;
+            long lastReviewId = review3.getId();
+
+            // when
+            List<Review> actual = reviewRepository.findByReviewGroupIdWithLimit(
+                    reviewGroup.getId(), lastReviewId, limit);
+
+            // then
+            assertThat(actual)
+                    .hasSize(2)
+                    .containsExactly(review2, review1);
+        }
+
+        @Test
+        void 마지막으로_온_리뷰_전에_작성된_리뷰가_없으면_빈_리스트를_반환한다() {
+            // given
+            int limit = 5;
+            long lastReviewId = review1.getId();
+
+            // when
+            List<Review> actual = reviewRepository.findByReviewGroupIdWithLimit(
+                    reviewGroup.getId(), lastReviewId, limit);
+
+            // then
+            assertThat(actual).isEmpty();
+        }
+    }
 }

backend/src/test/java/reviewme/review/service/LastReviewIdTest.java

@@ -0,0 +1,21 @@
+package reviewme.review.service;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+
+class LastReviewIdTest {
+
+    @Test
+    void null이_들어오면_기본값이_설정된다() {
+        LastReviewId lastReviewId = new LastReviewId(null);
+        assertEquals(Long.MAX_VALUE, lastReviewId.getId());
+    }
+
+    @Test
+    void 유효한_값이_들어오면_그_값이_설정된다() {
+        long id = 10L;
+        LastReviewId lastReviewId = new LastReviewId(id);
+        assertEquals(id, lastReviewId.getId());
+    }
+}

backend/src/test/java/reviewme/review/service/PageSizeTest.java

@@ -0,0 +1,44 @@
+package reviewme.review.service;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class PageSizeTest {
+
+    @Test
+    void 유효한_값이_들어오면_그_값을_설정한다() {
+        int size = 10;
+
+        PageSize pageSize = new PageSize(size);
+
+        assertEquals(size, pageSize.getSize());
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, 51})
+    void 유효한_범위_외의_값이_들어오면_기본값으로_설정한다(Integer size) {
+        // given
+        int defaultSize = 5;
+
+        // when
+        PageSize pageSize = new PageSize(size);
+
+        // then
+        assertEquals(defaultSize, pageSize.getSize());
+    }
+
+    @Test
+    void null이_들어오면_기본값으로_설정한다() {
+        // given
+        int defaultSize = 5;
+
+        // when
+        PageSize pageSize = new PageSize(null);
+
+        // then
+        assertEquals(defaultSize, pageSize.getSize());
+    }
+}