refactor: 멘티의 멘토링 목록 조회 시 연관된 채팅방 ID를 함께 응답하도록 (#465)

* refactor: 멘티의 멘토링 목록 조회 시, chatRoomId를 포함하여 응답하도록

* test: 멘토링 채팅방 픽스쳐 추가

* test: 멘티의 멘토링 목록 조회 시 채팅방 ID 포함 테스트 추가

* refactor: 멘토링 조회 순서를 보장하도록

- map이 아니라 순서가 보장되는 slice를 기준으로 순회하며 응답을 생성하도록

Author: nayonsoso

src/main/java/com/example/solidconnection/chat/repository/ChatRoomRepository.java

@@ -35,4 +35,6 @@ SELECT COUNT(cm) FROM ChatMessage cm
     long countUnreadMessages(@Param("chatRoomId") long chatRoomId, @Param("userId") long userId);
 
     boolean existsByMentoringId(long mentoringId);
+
+    List<ChatRoom> findAllByMentoringIdIn(List<Long> mentoringIds);
 }

src/main/java/com/example/solidconnection/mentor/dto/MentoringForMenteeResponse.java

@@ -9,16 +9,18 @@ public record MentoringForMenteeResponse(
         String profileImageUrl,
         String nickname,
         boolean isChecked,
-        ZonedDateTime createdAt
+        ZonedDateTime createdAt,
+        Long chatRoomId
 ) {
 
-    public static MentoringForMenteeResponse of(Mentoring mentoring, SiteUser partner) {
+    public static MentoringForMenteeResponse of(Mentoring mentoring, SiteUser partner, Long chatRoomId) {
         return new MentoringForMenteeResponse(
                 mentoring.getId(),
                 partner.getProfileImageUrl(),
                 partner.getNickname(),
                 mentoring.getCheckedAtByMentee() != null,
-                mentoring.getCreatedAt()
+                mentoring.getCreatedAt(),
+                chatRoomId
         );
     }
 }

src/main/java/com/example/solidconnection/mentor/service/MentoringQueryService.java

@@ -2,6 +2,8 @@
 
 import static com.example.solidconnection.common.exception.ErrorCode.MENTOR_NOT_FOUND;
 
+import com.example.solidconnection.chat.domain.ChatRoom;
+import com.example.solidconnection.chat.repository.ChatRoomRepository;
 import com.example.solidconnection.common.VerifyStatus;
 import com.example.solidconnection.common.dto.SliceResponse;
 import com.example.solidconnection.common.exception.CustomException;
@@ -17,7 +19,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import lombok.RequiredArgsConstructor;
@@ -33,6 +34,7 @@ public class MentoringQueryService {
     private final MentoringRepository mentoringRepository;
     private final MentorRepository mentorRepository;
     private final SiteUserRepository siteUserRepository;
+    private final ChatRoomRepository chatRoomRepository;
 
     @Transactional(readOnly = true)
     public SliceResponse<MentoringForMenteeResponse> getMentoringsForMentee(
@@ -47,15 +49,30 @@ public SliceResponse<MentoringForMenteeResponse> getMentoringsForMentee(
                 mentoringSlice.toList(),
                 Mentoring::getMentorId
         );
+        Map<Long, Long> mentoringIdToChatRoomId = mapMentoringIdToChatRoomIdWithBatchQuery(mentoringSlice.getContent());
 
         List<MentoringForMenteeResponse> content = new ArrayList<>();
-        for (Entry<Mentoring, SiteUser> entry : mentoringToPartnerUser.entrySet()) {
-            content.add(MentoringForMenteeResponse.of(entry.getKey(), entry.getValue()));
+        for (Mentoring mentoring : mentoringSlice) {
+            content.add(MentoringForMenteeResponse.of(
+                    mentoring,
+                    mentoringToPartnerUser.get(mentoring),
+                    mentoringIdToChatRoomId.get(mentoring.getId())
+            ));
         }
-
         return SliceResponse.of(content, mentoringSlice);
     }
 
+    // N+1 을 해결하면서 멘토링의 채팅방 정보 조회
+    private Map<Long, Long> mapMentoringIdToChatRoomIdWithBatchQuery(List<Mentoring> mentorings) {
+        List<Long> mentoringIds = mentorings.stream()
+                .map(Mentoring::getId)
+                .distinct()
+                .toList();
+        List<ChatRoom> chatRooms = chatRoomRepository.findAllByMentoringIdIn(mentoringIds);
+        return chatRooms.stream()
+                .collect(Collectors.toMap(ChatRoom::getMentoringId, ChatRoom::getId));
+    }
+
     @Transactional(readOnly = true)
     public SliceResponse<MentoringForMentorResponse> getMentoringsForMentor(long siteUserId, Pageable pageable) {
         Mentor mentor = mentorRepository.findBySiteUserId(siteUserId)
@@ -68,8 +85,8 @@ public SliceResponse<MentoringForMentorResponse> getMentoringsForMentor(long sit
         );
 
         List<MentoringForMentorResponse> content = new ArrayList<>();
-        for (Entry<Mentoring, SiteUser> entry : mentoringToPartnerUser.entrySet()) {
-            content.add(MentoringForMentorResponse.of(entry.getKey(), entry.getValue()));
+        for (Mentoring mentoring : mentoringSlice) {
+            content.add(MentoringForMentorResponse.of(mentoring, mentoringToPartnerUser.get(mentoring)));
         }
 
         return SliceResponse.of(content, mentoringSlice);

src/test/java/com/example/solidconnection/chat/fixture/ChatRoomFixture.java

@@ -15,4 +15,11 @@ public class ChatRoomFixture {
                 .isGroup(isGroup)
                 .create();
     }
+
+    public ChatRoom 멘토링_채팅방(long mentoringId) {
+        return chatRoomFixtureBuilder.chatRoom()
+                .mentoringId(mentoringId)
+                .isGroup(false)
+                .create();
+    }
 }

src/test/java/com/example/solidconnection/chat/fixture/ChatRoomFixtureBuilder.java

@@ -12,6 +12,7 @@ public class ChatRoomFixtureBuilder {
     private final ChatRoomRepository chatRoomRepository;
 
     private boolean isGroup;
+    private Long mentoringId;
 
     public ChatRoomFixtureBuilder chatRoom() {
         return new ChatRoomFixtureBuilder(chatRoomRepository);
@@ -22,8 +23,13 @@ public ChatRoomFixtureBuilder isGroup(boolean isGroup) {
         return this;
     }
 
+    public ChatRoomFixtureBuilder mentoringId(long mentoringId) {
+        this.mentoringId = mentoringId;
+        return this;
+    }
+
     public ChatRoom create() {
-        ChatRoom chatRoom = new ChatRoom(isGroup);
+        ChatRoom chatRoom = new ChatRoom(mentoringId, isGroup);
         return chatRoomRepository.save(chatRoom);
     }
 }

src/test/java/com/example/solidconnection/mentor/service/MentoringQueryServiceTest.java

@@ -4,6 +4,8 @@
 import static org.assertj.core.api.Assertions.assertThatCode;
 import static org.assertj.core.api.AssertionsForClassTypes.tuple;
 
+import com.example.solidconnection.chat.domain.ChatRoom;
+import com.example.solidconnection.chat.fixture.ChatRoomFixture;
 import com.example.solidconnection.common.VerifyStatus;
 import com.example.solidconnection.common.dto.SliceResponse;
 import com.example.solidconnection.common.exception.CustomException;
@@ -45,6 +47,9 @@ class MentoringQueryServiceTest {
     @Autowired
     private MentoringRepository mentoringRepository;
 
+    @Autowired
+    private ChatRoomFixture chatRoomFixture;
+
     private SiteUser mentorUser1, mentorUser2;
     private SiteUser menteeUser1, menteeUser2, menteeUser3;
     private Mentor mentor1, mentor2, mentor3;
@@ -146,21 +151,23 @@ class 멘티의_멘토링_목록_조회_테스트 {
         }
 
         @Test
-        void 승인된_멘토링_목록을_조회한다() {
+        void 승인된_멘토링_목록과_대응하는_채팅방을_조회한다() {
             // given
             Mentoring mentoring1 = mentoringFixture.승인된_멘토링(mentor1.getId(), menteeUser1.getId());
             Mentoring mentoring2 = mentoringFixture.승인된_멘토링(mentor2.getId(), menteeUser1.getId());
+            ChatRoom mentoringChatRoom1 = chatRoomFixture.멘토링_채팅방(mentoring1.getId());
+            ChatRoom mentoringChatRoom2 = chatRoomFixture.멘토링_채팅방(mentoring2.getId());
             mentoringFixture.대기중_멘토링(mentor3.getId(), menteeUser1.getId());
 
             // when
             SliceResponse<MentoringForMenteeResponse> response = mentoringQueryService.getMentoringsForMentee(
                     menteeUser1.getId(), VerifyStatus.APPROVED, pageable);
 
             // then
-            assertThat(response.content()).extracting(MentoringForMenteeResponse::mentoringId)
+            assertThat(response.content()).extracting(MentoringForMenteeResponse::mentoringId, MentoringForMenteeResponse::chatRoomId)
                     .containsExactlyInAnyOrder(
-                            mentoring1.getId(),
-                            mentoring2.getId()
+                            tuple(mentoring1.getId(), mentoringChatRoom1.getId()),
+                            tuple(mentoring2.getId(), mentoringChatRoom2.getId())
                     );
         }