23.10.27 항해 99 16기 실전 프로젝트 21일차

오늘 공부한 것

* 댓글 및 대댓글 Service 테스트 코드 작성

 

오늘은 기술면접 롤플레잉도했고 남는 시간에 계속 테스트 코드를 작성했다

 

결론적으론 댓글 및 대댓글의 POST, PUT, DELETE 메서드에 대한 테스트 코드는 모두 작성했으며

GET 메서드는 아직 작성하지 못했다.

 

테스트용 데이터가 없어서 에러가 나기도하고 참 많은 일이 있던 하루였지만 다행히 잘마쳤다

내일은 GET 메서드에 대한 테스트 코드에 도전해봐야겠다 아무래도 조회가 되는 부분이다보니

오늘 한것보다 조금은 복잡할 것으로 예상된다

 

또한 내일은 드디어 중간발표가 있는 날이다 오늘 우리가 만든 홈페이지를 둘러보았는데

아직 미흡한 점이 많았지만 감회가매우 새로웠다.

 

1. CommentsServiceTest

package com.sparta.team2project.comments;

import com.sparta.team2project.comments.dto.CommentsRequestDto;
import com.sparta.team2project.comments.entity.Comments;
import com.sparta.team2project.comments.repository.CommentsRepository;
import com.sparta.team2project.comments.service.CommentsService;
import com.sparta.team2project.commons.dto.MessageResponseDto;
import com.sparta.team2project.commons.entity.UserRoleEnum;
import com.sparta.team2project.commons.exceptionhandler.CustomException;
import com.sparta.team2project.commons.exceptionhandler.ErrorCode;
import com.sparta.team2project.posts.entity.PostCategory;
import com.sparta.team2project.posts.entity.Posts;
import com.sparta.team2project.posts.repository.PostsRepository;
import com.sparta.team2project.users.UserRepository;
import com.sparta.team2project.users.Users;
import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class CommentsServiceTest {

    // @Mock 이 붙은 목 객체를 주입시킬 수 있다
    @InjectMocks
    private CommentsService commentsService;

    // 로직이 삭제된 빈껍데기, 실제로 메서드는 가지고 있지만 내부구현이 없음
    @Mock
    private CommentsRepository commentsRepository;

    @Mock
    private PostsRepository postsRepository;

    @Mock
    private UserRepository userRepository;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    public CommentsRequestDto McokCommentsRequestDto() {
        CommentsRequestDto commentsRequestDto = mock(CommentsRequestDto.class);
        when(commentsRequestDto.getContents()).thenReturn("댓글");
        return commentsRequestDto;
    }

    public Users MockUsers1(){
        return new Users("rkawk@email.com", "감자", "test123!", UserRoleEnum.USER, "image/profileImg.png");
    }
    public Users MockUsers2(){
        return new Users("qksksk@email.com", "바나나", "test123!", UserRoleEnum.USER, "image/profileImg.png");
    }
    public Users MockAdmin(){
        return new Users("rhksflwk@email.com", "관리자", "test123!", UserRoleEnum.ADMIN, "image/profileImg.png");
    }

    public Posts MockPosts(){
        return new Posts("해돋이 보러간다", "정동진 해돋이", PostCategory.가족, "동해안 해돋이", MockUsers1());
    }

    public Comments MockComments() {
        return new Comments(McokCommentsRequestDto(), MockUsers1(), MockPosts());
    }


    @Test
    @DisplayName("[정상 작동] 댓글 생성")
    public void commentsCreateTest() {

        // Given
        Long postId = 1L;
        CommentsRequestDto requestDto = McokCommentsRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화
        Posts post = new Posts(); // 게시글 정보 초기화

        when(postsRepository.findById(postId)).thenReturn(Optional.of(post));
        when(commentsRepository.save(any(Comments.class))).thenReturn(new Comments());

        // When
        MessageResponseDto response = commentsService.commentsCreate(postId, requestDto, users);

        // Then
        System.out.println("댓글 생성");
        assertEquals("댓글을 작성하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[비정상 작동]댓글 생성")
    public void commentsCreatePostNotFoundTest() {

        // Given
        Long postId = 1L;
        CommentsRequestDto requestDto = McokCommentsRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화

        when(postsRepository.findById(postId)).thenReturn(Optional.empty());

        // When
        CustomException exception = assertThrows(CustomException.class, () -> {
            commentsService.commentsCreate(postId, requestDto, users);
        });

        // Then
        System.out.println("ErrorCode.POST_NOT_EXIST: " + "존재하지 않는 게시글입니다");
        System.out.println("exception.getErrorCode(): " + exception.getErrorCode());
        assertEquals(ErrorCode.POST_NOT_EXIST, exception.getErrorCode());
    }

    @Test
    @DisplayName("[정상 작동] 본인이 쓴 댓글 수정 USER")
    public void commentsUpdateUserTest() {

        // Given
        Long commentId = 1L;
        CommentsRequestDto requestDto = McokCommentsRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Comments comments = MockComments(); // 댓글 정보 초기화

        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = commentsService.commentsUpdate(commentId, requestDto, users);

        // Then
        System.out.println("댓글 수정");
        assertNotNull(response);
        assertEquals("댓글을 수정하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[정상 작동] 모든 댓글 수정 ADMIN")
    public void commentsUpdateAdminTest() {

        // Given
        Long commentId = 1L;
        CommentsRequestDto requestDto = McokCommentsRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화
        Users users1 = MockAdmin(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Comments comments = MockComments(); // 댓글 정보 초기화

        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = commentsService.commentsUpdate(commentId, requestDto, users1);

        // Then
        System.out.println("관리자 댓글 수정");
        assertNotNull(response);
        assertEquals("관리자가 댓글을 수정하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[비정상 작동]댓글 수정 본인이 쓴 댓글 아닌 경우")
    public void commentsUpdateNotAllowedTest() {

        // Given
        Long commentId = 1L;
        CommentsRequestDto requestDto = McokCommentsRequestDto();
        Users users2 = MockUsers2(); // 사용자 정보 초기화
        Comments comments = MockComments(); // 댓글 정보 초기화

        when(comments.getEmail()).thenReturn("다른 사용자의 이메일");
        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));

        // When
        CustomException exception = assertThrows(CustomException.class, () -> {
            commentsService.commentsUpdate(commentId, requestDto, users2);
        });

        // Then
        System.out.println("ErrorCode.NOT_ALLOWED: " + "권한이 없습니다");
        System.out.println("exception.getErrorCode(): " + exception.getErrorCode());
        assertEquals(ErrorCode.NOT_ALLOWED, exception.getErrorCode());
    }

    @Test
    @DisplayName("[정상 작동] 본인이 쓴 댓글 삭제 USER")
    public void commentsDeleteUserTest() {

        // Given
        Long commentId = 1L;
        Users users = MockUsers1(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Comments comments = MockComments(); // 댓글 정보 초기화

        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = commentsService.commentsDelete(commentId, users);

        // Then
        System.out.println("댓글 삭제");
        assertNotNull(response);
        assertEquals("댓글을 삭제하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[정상 작동] 모든 댓글 삭제 ADMIN")
    public void commentsDeleteAdminTest() {

        // Given
        Long commentId = 1L;
        Users users = MockUsers1(); // 사용자 정보 초기화
        Users users1 = MockAdmin(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Comments comments = MockComments(); // 댓글 정보 초기화

        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = commentsService.commentsDelete(commentId, users1);

        // Then
        System.out.println("관리자 댓글 삭제");
        assertNotNull(response);
        assertEquals("관리자가 댓글을 삭제하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[비정상 작동]댓글 삭제 본인이 쓴 댓글 아닌 경우")
    public void commentsDeleteNotAllowedTest() {

        // Given
        Long commentId = 1L;
        Users users2 = MockUsers2(); // 사용자 정보 초기화
        Comments comments = MockComments(); // 댓글 정보 초기화

        when(comments.getEmail()).thenReturn("다른 사용자의 이메일");
        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));

        // When
        CustomException exception = assertThrows(CustomException.class, () -> {
            commentsService.commentsDelete(commentId, users2);
        });

        // Then
        System.out.println("ErrorCode.NOT_ALLOWED: " + "권한이 없습니다");
        System.out.println("exception.getErrorCode(): " + exception.getErrorCode());
        assertEquals(ErrorCode.NOT_ALLOWED, exception.getErrorCode());
    }
}

 

2. RepliesServiceTest

package com.sparta.team2project.replies;

import com.sparta.team2project.comments.dto.CommentsRequestDto;
import com.sparta.team2project.comments.entity.Comments;
import com.sparta.team2project.comments.repository.CommentsRepository;
import com.sparta.team2project.commons.dto.MessageResponseDto;
import com.sparta.team2project.commons.entity.UserRoleEnum;
import com.sparta.team2project.commons.exceptionhandler.CustomException;
import com.sparta.team2project.commons.exceptionhandler.ErrorCode;
import com.sparta.team2project.posts.entity.PostCategory;
import com.sparta.team2project.posts.entity.Posts;
import com.sparta.team2project.replies.dto.RepliesRequestDto;
import com.sparta.team2project.replies.entity.Replies;
import com.sparta.team2project.replies.repository.RepliesRepository;
import com.sparta.team2project.replies.service.RepliesService;
import com.sparta.team2project.users.UserRepository;
import com.sparta.team2project.users.Users;
import jakarta.servlet.http.HttpServletResponse;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class RepliesServiceTest {

    // @Mock 이 붙은 목 객체를 주입시킬 수 있다
    @InjectMocks
    private RepliesService repliesService;

    // 로직이 삭제된 빈껍데기, 실제로 메서드는 가지고 있지만 내부구현이 없음
    @Mock
    private RepliesRepository repliesRepository;

    @Mock
    private CommentsRepository commentsRepository;

    @Mock
    private UserRepository userRepository;

    @BeforeEach
    public void setUp() {
        MockitoAnnotations.openMocks(this);
    }

    public CommentsRequestDto McokCommentsRequestDto() {
        CommentsRequestDto commentsRequestDto = mock(CommentsRequestDto.class);
        when(commentsRequestDto.getContents()).thenReturn("댓글");
        return commentsRequestDto;
    }

    public RepliesRequestDto McokRepliesRequestDto() {
        RepliesRequestDto repliesRequestDto = mock(RepliesRequestDto.class);
        when(repliesRequestDto.getContents()).thenReturn("대댓글");
        return repliesRequestDto;
    }

    public Users MockUsers1() {
        return new Users("rkawk@email.com", "감자", "test123!", UserRoleEnum.USER, "image/profileImg.png");
    }

    public Users MockUsers2() {
        return new Users("qksksk@email.com", "바나나", "test123!", UserRoleEnum.USER, "image/profileImg.png");
    }

    public Users MockAdmin() {
        return new Users("rhksflwk@email.com", "관리자", "test123!", UserRoleEnum.ADMIN, "image/profileImg.png");
    }

    public Posts MockPosts() {
        return new Posts("해돋이 보러간다", "정동진 해돋이", PostCategory.가족, "동해안 해돋이", MockUsers1());
    }

    public Comments MockComments() {
        return new Comments(McokCommentsRequestDto(), MockUsers1(), MockPosts());
    }

    public Replies MockResplies() {
        return new Replies(McokRepliesRequestDto(), MockUsers1(), MockComments());
    }

    @Test
    @DisplayName("[정상 작동] 대댓글 생성")
    public void repliesCreateTest() {

        // Given
        Long commentId = 1L;
        RepliesRequestDto requestDto = McokRepliesRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화
        Comments comments = new Comments(); // 게시글 정보 초기화

        when(commentsRepository.findById(commentId)).thenReturn(Optional.of(comments));
        when(repliesRepository.save(any(Replies.class))).thenReturn(new Replies());

        // When
        MessageResponseDto response = repliesService.repliesCreate(commentId, requestDto, users);

        // Then
        System.out.println("대댓글 생성");
        assertEquals("대댓글을 작성하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[비정상 작동]대댓글 생성")
    public void repliesCreatePostNotFoundTest() {

        // Given
        Long commentId = 1L;
        RepliesRequestDto requestDto = McokRepliesRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화

        when(commentsRepository.findById(commentId)).thenReturn(Optional.empty());

        // When
        CustomException exception = assertThrows(CustomException.class, () -> {
            repliesService.repliesCreate(commentId, requestDto, users);
        });

        // Then
        System.out.println("ErrorCode.COMMENTS_NOT_EXIST: " + "존재하지 않는 댓글입니다");
        System.out.println("exception.getErrorCode(): " + exception.getErrorCode());
        assertEquals(ErrorCode.COMMENTS_NOT_EXIST, exception.getErrorCode());
    }

    @Test
    @DisplayName("[정상 작동] 본인이 쓴 대댓글 수정 USER")
    public void repliesUpdateUserTest() {

        // Given
        Long reliesId = 1L;
        RepliesRequestDto requestDto = McokRepliesRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Replies replies = MockResplies();

        when(repliesRepository.findById(reliesId)).thenReturn(Optional.of(replies));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = repliesService.repliesUpdate(reliesId, requestDto, users);

        // Then
        System.out.println("대댓글 수정");
        assertNotNull(response);
        assertEquals("대댓글을 수정하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[정상 작동] 모든 대댓글 수정 ADMIN")
    public void repliesUpdateAdminTest() {

        // Given
        Long reliesId = 1L;
        RepliesRequestDto requestDto = McokRepliesRequestDto();
        Users users = MockUsers1(); // 사용자 정보 초기화
        Users users1 = MockAdmin(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Replies replies = MockResplies();

        when(repliesRepository.findById(reliesId)).thenReturn(Optional.of(replies));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = repliesService.repliesUpdate(reliesId, requestDto, users1);

        // Then
        System.out.println("관리자 대댓글 수정");
        assertNotNull(response);
        assertEquals("관리자가 대댓글을 수정하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[비정상 작동]대댓글 수정 본인이 쓴 대댓글 아닌 경우")
    public void repliesUpdateNotAllowedTest() {

        // Given
        Long repliesId = 1L;
        RepliesRequestDto requestDto = McokRepliesRequestDto();
        Users users2 = MockUsers2(); // 사용자 정보 초기화
        Replies replies = MockResplies(); // 댓글 정보 초기화

        when(replies.getEmail()).thenReturn("다른 사용자의 이메일");
        when(repliesRepository.findById(repliesId)).thenReturn(Optional.of(replies));

        // When
        CustomException exception = assertThrows(CustomException.class, () -> {
            repliesService.repliesUpdate(repliesId, requestDto, users2);
        });

        // Then
        System.out.println("ErrorCode.NOT_ALLOWED: " + "권한이 없습니다");
        System.out.println("exception.getErrorCode(): " + exception.getErrorCode());
        assertEquals(ErrorCode.NOT_ALLOWED, exception.getErrorCode());
    }

    @Test
    @DisplayName("[정상 작동] 본인이 쓴 대댓글 삭제 USER")
    public void repliesDeleteUserTest() {

        // Given
        Long reliesId = 1L;
        Users users = MockUsers1(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Replies replies = MockResplies();

        when(repliesRepository.findById(reliesId)).thenReturn(Optional.of(replies));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = repliesService.repliesDelete(reliesId, users);

        // Then
        System.out.println("대댓글 삭제");
        assertNotNull(response);
        assertEquals("대댓글을 삭제하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[정상 작동] 모든 대댓글 삭제 ADMIN")
    public void repliesDeleteAdminTest() {

        // Given
        Long reliesId = 1L;
        Users users = MockUsers1(); // 사용자 정보 초기화
        Users users1 = MockAdmin(); // 사용자 정보 초기화
        Posts posts = MockPosts(); // 게시글 정보 초기화
        Replies replies = MockResplies();

        when(repliesRepository.findById(reliesId)).thenReturn(Optional.of(replies));
        when(userRepository.findByEmail(users.getEmail())).thenReturn(Optional.of(posts.getUsers()));

        // When
        MessageResponseDto response = repliesService.repliesDelete(reliesId, users1);

        // Then
        System.out.println("관리자 대댓글 삭제");
        assertNotNull(response);
        assertEquals("관리자가 대댓글을 삭제하였습니다", response.getMsg());
        assertEquals(HttpServletResponse.SC_OK, response.getStatusCode());
    }

    @Test
    @DisplayName("[비정상 작동]대댓글 삭제 본인이 쓴 대댓글 아닌 경우")
    public void repliesDeleteNotAllowedTest() {

        // Given
        Long repliesId = 1L;
        Users users2 = MockUsers2(); // 사용자 정보 초기화
        Replies replies = MockResplies(); // 댓글 정보 초기화

        when(replies.getEmail()).thenReturn("다른 사용자의 이메일");
        when(repliesRepository.findById(repliesId)).thenReturn(Optional.of(replies));

        // When
        CustomException exception = assertThrows(CustomException.class, () -> {
            repliesService.repliesDelete(repliesId, users2);
        });

        // Then
        System.out.println("ErrorCode.NOT_ALLOWED: " + "권한이 없습니다");
        System.out.println("exception.getErrorCode(): " + exception.getErrorCode());
        assertEquals(ErrorCode.NOT_ALLOWED, exception.getErrorCode());
    }
}