Merge pull request #173 from DayByQuest/test/service

[Test] 서비스에 대한 테스트를 작성한다

src/main/java/daybyquest/badge/application/SaveBadgeService.java

@@ -2,6 +2,7 @@
 
 import daybyquest.badge.domain.Badge;
 import daybyquest.badge.domain.Badges;
+import daybyquest.badge.dto.request.SaveBadgeRequest;
 import daybyquest.image.application.ImageService;
 import daybyquest.image.domain.Image;
 import org.springframework.stereotype.Service;
@@ -23,9 +24,9 @@ public SaveBadgeService(final Badges badges, final ImageService imageService) {
     }
 
     @Transactional
-    public void invoke(final String name, final MultipartFile file) {
+    public Long invoke(final SaveBadgeRequest request, final MultipartFile file) {
         final Image image = imageService.convertToImage(CATEGORY, file);
-        final Badge badge = new Badge(name, image);
-        badges.save(badge);
+        final Badge badge = new Badge(request.getName(), image);
+        return badges.save(badge).getId();
     }
 }

src/main/java/daybyquest/badge/presentation/BadgeCommandApi.java

@@ -25,7 +25,7 @@ public BadgeCommandApi(final SaveBadgeService saveBadgeService) {
     public ResponseEntity<Void> saveBadge(final AccessUser user,
             @RequestPart("image") final MultipartFile image,
             @RequestPart("request") @Valid final SaveBadgeRequest request) {
-        saveBadgeService.invoke(request.getName(), image);
+        saveBadgeService.invoke(request, image);
         return ResponseEntity.ok().build();
     }
 }

src/main/java/daybyquest/comment/application/SaveCommentService.java

@@ -16,8 +16,8 @@ public SaveCommentService(final Comments comments) {
     }
 
     @Transactional
-    public void invoke(final Long loginId, final Long postId, final SaveCommentRequest request) {
+    public Long invoke(final Long loginId, final Long postId, final SaveCommentRequest request) {
         final Comment comment = new Comment(loginId, postId, request.getContent());
-        comments.save(comment);
+        return comments.save(comment).getId();
     }
 }

src/main/java/daybyquest/comment/domain/Comments.java

@@ -1,5 +1,6 @@
 package daybyquest.comment.domain;
 
+import daybyquest.global.error.exception.NotExistCommentException;
 import daybyquest.post.domain.Posts;
 import daybyquest.user.domain.Users;
 import org.springframework.stereotype.Component;
@@ -19,9 +20,13 @@ public class Comments {
         this.posts = posts;
     }
 
-    public void save(final Comment comment) {
+    public Comment save(final Comment comment) {
         users.validateExistentById(comment.getUserId());
         posts.validateExistentById(comment.getPostId());
-        commentRepository.save(comment);
+        return commentRepository.save(comment);
+    }
+
+    public Comment getById(final Long id) {
+        return commentRepository.findById(id).orElseThrow(NotExistCommentException::new);
     }
 }

src/main/java/daybyquest/global/error/exception/NotExistCommentException.java

@@ -0,0 +1,10 @@
+package daybyquest.global.error.exception;
+
+import daybyquest.global.error.ExceptionCode;
+
+public class NotExistCommentException extends CustomException {
+
+    public NotExistCommentException() {
+        super(ExceptionCode.NOT_EXIST_COMMENT);
+    }
+}

src/main/java/daybyquest/profile/application/GetPresetBadgeService.java

@@ -28,8 +28,7 @@ public GetPresetBadgeService(final Users users, final ProfileSettings profileSet
     @Transactional(readOnly = true)
     public MultipleBadgesResponse invoke(final String username) {
         final Long userId = users.getUserIdByUsername(username);
-        final List<Long> badgeIds = profileSettings.getById(userId).getBadgeIds();
-        final List<BadgeResponse> responses = badgeDao.findAllByIdIn(badgeIds)
+        final List<BadgeResponse> responses = badgeDao.findAllByIdIn(profileSettings.getBadgeIdsById(userId))
                 .stream().map(BadgeResponse::of).toList();
         return new MultipleBadgesResponse(responses);
     }

src/main/java/daybyquest/profile/domain/ProfileSettings.java

@@ -1,7 +1,9 @@
 package daybyquest.profile.domain;
 
 import daybyquest.global.error.exception.NotExistUserException;
+import java.util.List;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 @Component
 public class ProfileSettings {
@@ -19,4 +21,9 @@ public void save(final ProfileSetting profileSetting) {
     public ProfileSetting getById(final Long userId) {
         return profileSettingRepository.findByUserId(userId).orElseThrow(NotExistUserException::new);
     }
+
+    @Transactional(readOnly = true)
+    public List<Long> getBadgeIdsById(final Long userId) {
+        return getById(userId).getBadgeIds();
+    }
 }

src/test/java/daybyquest/badge/application/GetMyBadgesServiceTest.java

@@ -0,0 +1,39 @@
+package daybyquest.badge.application;
+
+import static daybyquest.support.fixture.BadgeFixtures.BADGE_1;
+import static daybyquest.support.fixture.BadgeFixtures.BADGE_2;
+import static daybyquest.support.fixture.BadgeFixtures.BADGE_3;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import daybyquest.badge.dto.response.BadgeResponse;
+import daybyquest.badge.dto.response.PageBadgesResponse;
+import daybyquest.support.test.ServiceTest;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class GetMyBadgesServiceTest extends ServiceTest {
+
+    @Autowired
+    private GetMyBadgesService getMyBadgesService;
+
+    @Test
+    void 내_뱃지_목록을_조회한다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long badge1Id = badges.save(BADGE_1.생성()).getId();
+        final Long badge2Id = badges.save(BADGE_2.생성()).getId();
+        badges.save(BADGE_3.생성());
+        ownings.saveByUserIdAndBadgeId(aliceId, badge1Id);
+        ownings.saveByUserIdAndBadgeId(aliceId, badge2Id);
+
+        final List<Long> expected = List.of(badge1Id, badge2Id);
+
+        // when
+        final PageBadgesResponse response = getMyBadgesService.invoke(aliceId, 시간_페이지());
+        final List<Long> actual = response.badges().stream().map(BadgeResponse::id).toList();
+
+        // then
+        assertThat(actual).containsExactlyInAnyOrderElementsOf(expected);
+    }
+}

src/test/java/daybyquest/badge/application/SaveBadgeServiceTest.java

@@ -0,0 +1,42 @@
+package daybyquest.badge.application;
+
+import static daybyquest.support.fixture.BadgeFixtures.BADGE_1;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+import daybyquest.badge.domain.Badge;
+import daybyquest.badge.dto.request.SaveBadgeRequest;
+import daybyquest.support.test.ServiceTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+public class SaveBadgeServiceTest extends ServiceTest {
+
+    @Autowired
+    private SaveBadgeService saveBadgeService;
+
+    @Test
+    void 뱃지를_생성한다() {
+        // given
+        final SaveBadgeRequest request = 뱃지_생성_요청(BADGE_1.생성());
+        final MultipartFile file = 사진_파일(BADGE_1.imageIdentifier);
+
+        // when
+        final Long badgeId = saveBadgeService.invoke(request, file);
+        final Badge actual = badges.getById(badgeId);
+
+        // then
+        assertAll(() -> {
+            assertThat(actual.getName()).isEqualTo(BADGE_1.name);
+            assertThat(actual.getImage().getIdentifier()).isEqualTo(BADGE_1.imageIdentifier);
+        });
+    }
+
+    private SaveBadgeRequest 뱃지_생성_요청(final Badge badge) {
+        final SaveBadgeRequest request = new SaveBadgeRequest();
+        ReflectionTestUtils.setField(request, "name", badge.getName());
+        return request;
+    }
+}

src/test/java/daybyquest/badge/presentation/BadgeCommandApiTest.java

@@ -2,7 +2,6 @@
 
 import static daybyquest.support.fixture.BadgeFixtures.BADGE_1;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.then;
 import static org.springframework.restdocs.mockmvc.RestDocumentationRequestBuilders.multipart;
 import static org.springframework.restdocs.request.RequestDocumentation.partWithName;
@@ -50,7 +49,7 @@ public class BadgeCommandApiTest extends ApiTest {
                         requestParts(partWithName("image").description("사진"),
                                 partWithName("request").description("요청")))
                 );
-        then(saveBadgeService).should().invoke(eq(BADGE_1.name), any());
+        then(saveBadgeService).should().invoke(any(), any());
     }
 
     private SaveBadgeRequest 뱃지_생성_요청(final Badge badge) {

src/test/java/daybyquest/comment/application/GetCommentsByPostIdServiceTest.java

@@ -0,0 +1,39 @@
+package daybyquest.comment.application;
+
+import static daybyquest.support.fixture.CommentFixtures.댓글_1;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import daybyquest.comment.dto.response.CommentResponse;
+import daybyquest.comment.dto.response.PageCommentsResponse;
+import daybyquest.support.fixture.PostFixtures;
+import daybyquest.support.test.ServiceTest;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class GetCommentsByPostIdServiceTest extends ServiceTest {
+
+    @Autowired
+    private GetCommentsByPostIdService getCommentsByPostIdService;
+
+    @Test
+    void 게시물_ID를_통해_댓글_목록을_조회한다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long bobId = BOB을_저장한다();
+
+        final Long post1Id = posts.save(PostFixtures.POST_1.생성(aliceId)).getId();
+        final Long post2Id = posts.save(PostFixtures.POST_2.생성(aliceId)).getId();
+
+        final List<Long> expected = List.of(comments.save(댓글_1.생성(post1Id, aliceId)).getId(),
+                comments.save(댓글_1.생성(post1Id, bobId)).getId());
+        comments.save(댓글_1.생성(post2Id, aliceId));
+
+        // when
+        final PageCommentsResponse response = getCommentsByPostIdService.invoke(aliceId, post1Id, 페이지());
+        final List<Long> actual = response.comments().stream().map(CommentResponse::id).toList();
+
+        // then
+        assertThat(actual).containsExactlyInAnyOrderElementsOf(expected);
+    }
+}

src/test/java/daybyquest/comment/application/SaveCommentServiceTest.java

@@ -0,0 +1,44 @@
+package daybyquest.comment.application;
+
+import static daybyquest.support.fixture.CommentFixtures.댓글_1;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+import daybyquest.comment.domain.Comment;
+import daybyquest.comment.dto.request.SaveCommentRequest;
+import daybyquest.support.fixture.PostFixtures;
+import daybyquest.support.test.ServiceTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.util.ReflectionTestUtils;
+
+public class SaveCommentServiceTest extends ServiceTest {
+
+    @Autowired
+    private SaveCommentService saveCommentService;
+
+    @Test
+    void 댓글을_저장한다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long postId = posts.save(PostFixtures.POST_1.생성(aliceId)).getId();
+        final SaveCommentRequest request = 댓글_생성_요청(댓글_1.생성(postId, aliceId));
+
+        // when
+        final Long commentId = saveCommentService.invoke(aliceId, postId, request);
+        final Comment comment = comments.getById(commentId);
+
+        // then
+        assertAll(() -> {
+            assertThat(comment.getUserId()).isEqualTo(aliceId);
+            assertThat(comment.getPostId()).isEqualTo(postId);
+            assertThat(comment.getContent()).isEqualTo(댓글_1.content);
+        });
+    }
+
+    private SaveCommentRequest 댓글_생성_요청(final Comment comment) {
+        final SaveCommentRequest request = new SaveCommentRequest();
+        ReflectionTestUtils.setField(request, "content", comment.getContent());
+        return request;
+    }
+}

src/test/java/daybyquest/comment/domain/CommentsTest.java

@@ -35,7 +35,7 @@ public class CommentsTest {
         final Long postId = 2L;
 
         // when
-        comments.save(댓글_1.생성(userId, postId));
+        comments.save(댓글_1.생성(postId, userId));
 
         // then
         assertAll(() -> {

src/test/java/daybyquest/dislike/application/DeletePostDislikeServiceTest.java

@@ -0,0 +1,27 @@
+package daybyquest.dislike.application;
+
+import static daybyquest.support.fixture.PostFixtures.POST_1;
+import static org.assertj.core.api.Assertions.assertThatCode;
+
+import daybyquest.dislike.domain.PostDislike;
+import daybyquest.support.test.ServiceTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class DeletePostDislikeServiceTest extends ServiceTest {
+
+    @Autowired
+    private DeletePostDislikeService deletePostDislikeService;
+
+    @Test
+    void 관심_없음을_취소한다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long postId = posts.save(POST_1.생성(aliceId)).getId();
+        postDislikes.save(new PostDislike(aliceId, postId));
+
+        // when & then
+        assertThatCode(() -> deletePostDislikeService.invoke(aliceId, postId))
+                .doesNotThrowAnyException();
+    }
+}

src/test/java/daybyquest/dislike/application/SavePostDislikeServiceTest.java

@@ -0,0 +1,59 @@
+package daybyquest.dislike.application;
+
+import static daybyquest.global.error.ExceptionCode.ALREADY_DISLIKED_POST;
+import static daybyquest.support.fixture.PostFixtures.POST_1;
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import daybyquest.dislike.domain.PostDislike;
+import daybyquest.global.error.exception.InvalidDomainException;
+import daybyquest.like.domain.PostLike;
+import daybyquest.support.test.ServiceTest;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+public class SavePostDislikeServiceTest extends ServiceTest {
+
+    @Autowired
+    private SavePostDislikeService savePostDislikeService;
+
+    @Test
+    void 관심_없음을_저장한다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long postId = posts.save(POST_1.생성(aliceId)).getId();
+
+        // when
+        savePostDislikeService.invoke(aliceId, postId);
+
+        // then
+        assertThatThrownBy(() -> postDislikes.save(new PostDislike(aliceId, postId)))
+                .isInstanceOf(InvalidDomainException.class)
+                .hasMessageContaining(ALREADY_DISLIKED_POST.getMessage());
+    }
+
+    @Test
+    void 이미_관심_없음을_눌렀으면_저장할_수_없다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long postId = posts.save(POST_1.생성(aliceId)).getId();
+        postDislikes.save(new PostDislike(aliceId, postId));
+
+        // when & then
+        assertThatThrownBy(() -> savePostDislikeService.invoke(aliceId, postId))
+                .isInstanceOf(InvalidDomainException.class)
+                .hasMessageContaining(ALREADY_DISLIKED_POST.getMessage());
+    }
+
+    @Test
+    void 관심_없음을_누르면_좋아요가_취소된다() {
+        // given
+        final Long aliceId = ALICE를_저장한다();
+        final Long postId = posts.save(POST_1.생성(aliceId)).getId();
+        postLikes.save(new PostLike(aliceId, postId));
+
+        // when & then
+        assertThatCode(() -> savePostDislikeService.invoke(aliceId, postId))
+                .doesNotThrowAnyException();
+    }
+}