단위테스트 작성

group-service/src/test/java/me/kong/groupservice/integration/GroupManagementServiceTest.java

@@ -8,13 +8,12 @@
 import me.kong.groupservice.domain.repository.GroupRepository;
 import me.kong.groupservice.domain.repository.ProfileRepository;
 import me.kong.groupservice.dto.request.SaveGroupRequestDto;
+import me.kong.groupservice.service.GroupJoinRequestService;
 import me.kong.groupservice.service.GroupService;
 import me.kong.groupservice.service.ProfileService;
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;
@@ -29,6 +28,9 @@ public class GroupManagementServiceTest {
     @Autowired
     private GroupService groupService;
 
+    @Autowired
+    private GroupJoinRequestService joinRequestService;
+
     @MockBean
     private ProfileService profileService;
 

group-service/src/test/java/me/kong/groupservice/service/GroupJoinRequestServiceTest.java

@@ -1,21 +1,27 @@
 package me.kong.groupservice.service;
 
 import me.kong.groupservice.common.JwtReader;
+import me.kong.groupservice.common.exception.DuplicateElementException;
 import me.kong.groupservice.domain.entity.GroupJoinRequest.GroupJoinRequest;
+import me.kong.groupservice.domain.entity.GroupJoinRequest.JoinResponse;
 import me.kong.groupservice.domain.entity.group.Group;
+import me.kong.groupservice.domain.entity.profile.GroupRole;
 import me.kong.groupservice.domain.repository.GroupJoinRequestRepository;
+import me.kong.groupservice.dto.request.GroupJoinProcessDto;
 import me.kong.groupservice.dto.request.GroupJoinRequestDto;
+import me.kong.groupservice.dto.request.enums.GroupJoinProcessAction;
+import me.kong.groupservice.dto.request.enums.JoinRequestSearchCondition;
 import me.kong.groupservice.mapper.GroupJoinRequestMapper;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.DisabledOnOs;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.util.Optional;
+
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
@@ -27,6 +33,9 @@ class GroupJoinRequestServiceTest {
     @InjectMocks
     GroupJoinRequestService groupJoinRequestService;
 
+    @Mock
+    ProfileService profileService;
+
     @Mock
     GroupJoinRequestRepository groupJoinRequestRepository;
 
@@ -40,6 +49,9 @@ class GroupJoinRequestServiceTest {
     GroupJoinRequest request;
     GroupJoinRequestDto dto;
     Group group;
+    Long groupId;
+    JoinRequestSearchCondition condition;
+    GroupJoinProcessDto processDto;
 
     @BeforeEach
     void init() {
@@ -49,6 +61,7 @@ void init() {
                 .requestInfo("sample")
                 .nickname("testuser")
                 .build();
+        groupId = 1L;
     }
 
     @Test
@@ -76,4 +89,110 @@ void failedByDatabaseProblem() {
         assertThrows(RuntimeException.class, () -> groupJoinRequestService.createNewGroupJoinRequest(dto, group));
     }
 
+    @Test
+    @DisplayName("searchCondition이 ALL이라면 해당 그룹의 모든 그룹 가입 요청을 조회한다")
+    void successToFindAllGroupJoinRequests() {
+        //given
+        JoinRequestSearchCondition condition = JoinRequestSearchCondition.ALL;
+
+        //when
+        groupJoinRequestService.getGroupJoinRequestsByGroupIdAndCondition(groupId, condition);
+
+        //then
+        verify(groupJoinRequestRepository, times(1)).findAllByGroupId(groupId);
+    }
+
+    @Test
+    @DisplayName("searchCondition이 PENDING이라면 해당 그룹의 대기중인 그룹 가입 요청을 조회한다")
+    void successToFindPendingGroupJOinRequests() {
+        //given
+        condition = JoinRequestSearchCondition.PENDING;
+
+        //when
+        groupJoinRequestService.getGroupJoinRequestsByGroupIdAndCondition(groupId, condition);
+
+        //then
+        verify(groupJoinRequestRepository, times(1))
+                .findPendingGroupJoinRequests(groupId);
+    }
+
+    @Test
+    @DisplayName("searchCondition이 PROCESSED라면 처리된 그룹 가입 요청을 조회한다")
+    void successToFindProcessedGroupJoinRequests() {
+        //given
+        condition = JoinRequestSearchCondition.PROCESSED;
+
+        //when
+        groupJoinRequestService.getGroupJoinRequestsByGroupIdAndCondition(groupId, condition);
+
+        //then
+        verify(groupJoinRequestRepository, times(1))
+                .findProcessedGroupJoinRequests(groupId);
+    }
+
+    @Test
+    @DisplayName("가입 승인 시, 우 가입 요청 상태가 승인으로 변경되고 새로운 프로필을 생성한다")
+    void successToApproveGroupJoinRequest() {
+        //given
+        Long requestId = 1L;
+        processDto = getProcessDto(GroupJoinProcessAction.APPROVE);
+        request = getJoinRequest(JoinResponse.PENDING);
+        when(groupJoinRequestRepository.findById(requestId)).thenReturn(Optional.of(request));
+        doNothing().when(profileService).checkLoggedInProfileIsGroupManager(anyLong());
+
+        // when
+        groupJoinRequestService.processGroupJoinRequest(requestId, processDto);
+
+        // then
+        assertEquals(JoinResponse.APPROVED, request.getResponse());
+        verify(profileService, times(1)).createNewProfile(request.getNickname(), GroupRole.MEMBER, request.getGroup());
+    }
+
+    @Test
+    @DisplayName("가입 거절 시, 가입 요청 상태가 거절로 변경된다")
+    void successToRejectGroupJoinRequest() {
+        //given
+        Long requestId = 1L;
+        processDto = getProcessDto(GroupJoinProcessAction.REJECT);
+        request = getJoinRequest(JoinResponse.PENDING);
+        when(groupJoinRequestRepository.findById(requestId)).thenReturn(Optional.of(request));
+        doNothing().when(profileService).checkLoggedInProfileIsGroupManager(anyLong());
+
+        //when
+        groupJoinRequestService.processGroupJoinRequest(requestId, processDto);
+
+        //then
+        assertEquals(JoinResponse.REJECTED, request.getResponse());
+    }
+
+
+    @Test
+    @DisplayName("가입 요청이 이미 처리되었다면 예외가 발생한다")
+    void testProcessGroupJoinRequest_AlreadyProcessed() {
+        // given
+        Long requestId = 1L;
+        processDto = getProcessDto(GroupJoinProcessAction.APPROVE);
+        request = getJoinRequest(JoinResponse.APPROVED);
+        when(groupJoinRequestRepository.findById(requestId)).thenReturn(Optional.of(request));
+
+        // then
+        assertThrows(DuplicateElementException.class, () -> {
+            groupJoinRequestService.processGroupJoinRequest(requestId, processDto);
+        });
+    }
+
+
+
+    private GroupJoinProcessDto getProcessDto(GroupJoinProcessAction action) {
+        return GroupJoinProcessDto.builder()
+                .action(action)
+                .build();
+    }
+
+    private GroupJoinRequest getJoinRequest(JoinResponse response) {
+        return GroupJoinRequest.builder()
+                .response(response)
+                .group(group)
+                .build();
+    }
 }

group-service/src/test/java/me/kong/groupservice/service/ProfileServiceTest.java

@@ -1,6 +1,8 @@
 package me.kong.groupservice.service;
 
+import me.kong.commonlibrary.exception.auth.UnAuthorizedException;
 import me.kong.groupservice.common.JwtReader;
+import me.kong.groupservice.common.exception.NoLoggedInProfileException;
 import me.kong.groupservice.domain.entity.group.Group;
 import me.kong.groupservice.domain.entity.profile.GroupRole;
 import me.kong.groupservice.domain.entity.profile.Profile;
@@ -13,6 +15,8 @@
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
+import java.util.Optional;
+
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.*;
 
@@ -64,4 +68,20 @@ void failToCreateNewProfileByDatabaseProblem() {
         //then
         assertThrows(RuntimeException.class, () -> profileService.createNewProfile(nickname, groupRole, group));
     }
+
+    @Test
+    @DisplayName("그룹 매니저가 아닐 경우 예외가 발생한다")
+    void unAuthorizeOccurred() {
+        //given
+        Long userId = 1L;
+        Long groupId = 1L;
+        Profile profile = Profile.builder()
+                .groupRole(GroupRole.MEMBER)
+                .build();
+        when(jwtReader.getUserId()).thenReturn(userId);
+        when(profileRepository.findByUserIdAndGroupId(userId, groupId)).thenReturn(Optional.of(profile));
+
+        //then
+        assertThrows(UnAuthorizedException.class, () -> profileService.checkLoggedInProfileIsGroupManager(groupId));
+    }
 }

group-service/src/test/java/me/kong/groupservice/validation/GroupJoinRequestValidationTest.java

@@ -4,9 +4,9 @@
 import jakarta.validation.Validation;
 import jakarta.validation.Validator;
 import jakarta.validation.ValidatorFactory;
-import me.kong.groupservice.domain.entity.GroupJoinRequest.GroupJoinRequest;
+import me.kong.groupservice.dto.request.GroupJoinProcessDto;
 import me.kong.groupservice.dto.request.GroupJoinRequestDto;
-import me.kong.groupservice.dto.request.SaveGroupRequestDto;
+import me.kong.groupservice.dto.request.enums.GroupJoinProcessAction;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
@@ -51,4 +51,28 @@ void failedByEmptyNickname() {
         assertEquals("nickname", violation.getPropertyPath().toString());
         assertEquals("비어 있을 수 없습니다", violation.getMessage());
     }
+
+    @Test
+    @DisplayName("가입 요청 처리의 action이 존재한다면 검증에 성공한다")
+    void successToProcessGroupJoinRequest() {
+        GroupJoinProcessDto dto = GroupJoinProcessDto.builder()
+                .action(GroupJoinProcessAction.APPROVE)
+                .build();
+
+        Set<ConstraintViolation<GroupJoinProcessDto>> violations = validator.validate(dto);
+        assertThat(violations).isEmpty();
+    }
+
+    @Test
+    @DisplayName("가입 요청 처리의 action이 비어있다면 검증에 실패한다")
+    void failedByEmptyAction() {
+        GroupJoinProcessDto dto = GroupJoinProcessDto.builder()
+                .action(null)
+                .build();
+
+        Set<ConstraintViolation<GroupJoinProcessDto>> violations = validator.validate(dto);
+        ConstraintViolation<GroupJoinProcessDto> violation = violations.iterator().next();
+        assertEquals("action", violation.getPropertyPath().toString());
+        assertEquals("널이어서는 안됩니다", violation.getMessage());
+    }
 }