diff --git a/src/test/java/com/rabbitmqprac/service/AuthServiceTest.java b/src/test/java/com/rabbitmqprac/service/AuthServiceTest.java index 07e2585..e96c96c 100644 --- a/src/test/java/com/rabbitmqprac/service/AuthServiceTest.java +++ b/src/test/java/com/rabbitmqprac/service/AuthServiceTest.java @@ -25,7 +25,6 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertThrows; import static org.mockito.BDDMockito.any; -import static org.mockito.BDDMockito.anyLong; import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.mock; import static org.mockito.BDDMockito.never; @@ -44,145 +43,148 @@ public class AuthServiceTest { @InjectMocks private AuthService authService; - private static User user = UserFixture.FIRST_USER.toEntity(); + private static final User USER = UserFixture.FIRST_USER.toEntity(); + private static final Jwts JWTS = mock(Jwts.class); @Nested - @DisplayName("회원가입 성공 시나리오") - class SignUpSuccessScenarios { - @Test - @DisplayName("회원가입 성공") - void signUp() { - // given - final String nickname = "nickname"; - final String username = "nickname"; - final String password = "password_123"; - final String confirmPassword = "password_123"; - AuthSignUpReq req = new AuthSignUpReq(nickname, username, password, confirmPassword); - Jwts jwts = mock(Jwts.class); - - given(userService.saveUserWithEncryptedPassword(any(UserCreateReq.class))) - .willReturn(user); - given(jwtHelper.createToken(user)).willReturn(jwts); - - // when - Pair result = authService.signUp(req); - - // then - assertThat(result.getLeft()).isEqualTo(user.getId()); - assertThat(result.getRight()).isEqualTo(jwts); - verify(userService).saveUserWithEncryptedPassword(any(UserCreateReq.class)); - verify(jwtHelper).createToken(user); + @DisplayName("회원가입 시나리오") + class SignUpScenario { + private final String nickname = "nickname"; + private final String username = "nickname"; + private final String password = "password_123"; + private final String confirmPassword = "password_123"; + private final AuthSignUpReq req = new AuthSignUpReq(nickname, username, password, confirmPassword); + + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("회원가입 성공") + void signUpSuccess() { + // given + given(userService.saveUserWithEncryptedPassword(any(UserCreateReq.class))).willReturn(USER); + given(jwtHelper.createToken(USER)).willReturn(JWTS); + + // when + Pair result = authService.signUp(req); + + // then + assertThat(result.getLeft()).isEqualTo(USER.getId()); + assertThat(result.getRight()).isEqualTo(JWTS); + verify(userService).saveUserWithEncryptedPassword(any(UserCreateReq.class)); + verify(jwtHelper).createToken(USER); + } } - } - @Nested - @DisplayName("회원가입 실패 시나리오") - class SignUpFailScenarios { - @Test - @DisplayName("password와 confirmPassword가 다른 경우 회원 가입에 실패") - void signUpWhenInvalidPassword() { - // given - final String nickname = "nickname"; - final String username = "nickname"; - final String password = "password"; - final String confirmPassword = "invalid_password"; - AuthSignUpReq req = new AuthSignUpReq(nickname, username, password, confirmPassword); - - // when - AuthErrorException errorException = assertThrows(AuthErrorException.class, () -> authService.signUp(req)); - - // then - assertThat(errorException.getErrorCode()).isEqualTo(AuthErrorCode.PASSWORD_CONFIRM_MISMATCH); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("password와 confirmPassword가 다르면 회원가입 실패") + void signUpFailWhenPasswordMismatch() { + // given + AuthSignUpReq invalidReq = new AuthSignUpReq(nickname, username, password, "wrong"); + + // when + AuthErrorException ex = assertThrows(AuthErrorException.class, () -> authService.signUp(invalidReq)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(AuthErrorCode.PASSWORD_CONFIRM_MISMATCH); + } } } @Nested - @DisplayName("로그인 성공 시나리오") - class SignInSuccessScenarios { - @Test - @DisplayName("로그인 성공") - void signIn() { - // given - final String username = "nickname"; - final String password = "password"; - AuthSignInReq req = new AuthSignInReq(username, password); - Jwts jwts = mock(Jwts.class); - - given(userService.readUserByUsername(username)).willReturn(user); - given(jwtHelper.createToken(user)).willReturn(jwts); - given(bCryptPasswordEncoder.matches(password, user.getPassword())).willReturn(Boolean.TRUE); - - // when - Pair result = authService.signIn(req); - - // then - assertThat(result.getLeft()).isEqualTo(user.getId()); - assertThat(result.getRight()).isEqualTo(jwts); - verify(jwtHelper).createToken(user); + @DisplayName("로그인 시나리오") + class SignInScenario { + private final String username = "nickname"; + private final String password = "password"; + private final AuthSignInReq req = new AuthSignInReq(username, password); + + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("로그인 성공") + void signInSuccess() { + // given + given(userService.readUserByUsername(username)).willReturn(USER); + given(jwtHelper.createToken(USER)).willReturn(JWTS); + given(bCryptPasswordEncoder.matches(password, USER.getPassword())).willReturn(true); + + // when + Pair result = authService.signIn(req); + + // then + assertThat(result.getLeft()).isEqualTo(USER.getId()); + assertThat(result.getRight()).isEqualTo(JWTS); + verify(jwtHelper).createToken(USER); + } } - } - @Nested - @DisplayName("로그인 실패 시나리오") - class SignInFailScenarios { - @Test - @DisplayName("로그인 유저의 패스워드가 올바르지 않다면 로그인 실패") - void signInWhenInvalidPassword() { - // given - final String username = "nickname"; - final String password = "password"; - AuthSignInReq req = new AuthSignInReq(username, password); - given(userService.readUserByUsername(username)).willReturn(user); - given(bCryptPasswordEncoder.matches(password, user.getPassword())).willReturn(Boolean.FALSE); - - // when - AuthErrorException errorException = assertThrows(AuthErrorException.class, () -> authService.signIn(req)); - - // then - assertThat(errorException.getErrorCode()).isEqualTo(AuthErrorCode.INVALID_PASSWORD); - verify(jwtHelper, never()).createToken(user); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("패스워드가 올바르지 않으면 로그인 실패") + void signInFailWhenInvalidPassword() { + // given + given(userService.readUserByUsername(username)).willReturn(USER); + given(bCryptPasswordEncoder.matches(password, USER.getPassword())).willReturn(false); + + // when + AuthErrorException ex = assertThrows(AuthErrorException.class, () -> authService.signIn(req)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(AuthErrorCode.INVALID_PASSWORD); + verify(jwtHelper, never()).createToken(USER); + } } } @Nested - @DisplayName("패스워드 변경 성공 시나리오") - class UpdatePasswordScenarios { - @Test - @DisplayName("패스워드 변경 성공") - void updatePasswordSuccess() { - // given - final Long userId = anyLong(); - final String oldPassword = "oldPassword"; - final String newPassword = "newPassword"; - AuthUpdatePasswordReq req = new AuthUpdatePasswordReq(oldPassword, newPassword); - - given(userService.readUser(userId)).willReturn(user); - given(bCryptPasswordEncoder.matches(req.oldPassword(), user.getPassword())).willReturn(true); - given(req.newPassword(bCryptPasswordEncoder)).willReturn(newPassword); - - // when - authService.updatePassword(userId, req); - - // then - assertThat(user.getPassword()).isEqualTo(newPassword); + @DisplayName("패스워드 변경 시나리오") + class UpdatePasswordScenario { + private final Long userId = 1L; + private final String oldPassword = "oldPassword"; + private final String newPassword = "newPassword"; + private final AuthUpdatePasswordReq req = new AuthUpdatePasswordReq(oldPassword, newPassword); + + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("패스워드 변경 성공") + void updatePasswordSuccess() { + // given + given(userService.readUser(userId)).willReturn(USER); + given(bCryptPasswordEncoder.matches(oldPassword, USER.getPassword())).willReturn(true); + given(req.newPassword(bCryptPasswordEncoder)).willReturn(newPassword); + + // when + authService.updatePassword(userId, req); + + // then + assertThat(USER.getPassword()).isEqualTo(newPassword); + } } - @Test - @DisplayName("기존 패스워드가 틀리면 변경 실패") - void updatePasswordFailWhenInvalidOldPassword() { - // given - final Long userId = anyLong(); - final String oldPassword = "oldPassword"; - final String newPassword = "newPassword"; - AuthUpdatePasswordReq req = new AuthUpdatePasswordReq(oldPassword, newPassword); - given(userService.readUser(userId)).willReturn(user); - given(bCryptPasswordEncoder.matches(oldPassword, user.getPassword())).willReturn(false); - - // when - AuthErrorException errorException = assertThrows(AuthErrorException.class, () -> authService.updatePassword(userId, req)); - - // then - assertThat(errorException.getErrorCode()).isEqualTo(AuthErrorCode.INVALID_PASSWORD); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("기존 패스워드가 틀리면 변경 실패") + void updatePasswordFailWhenInvalidOldPassword() { + // given + given(userService.readUser(userId)).willReturn(USER); + given(bCryptPasswordEncoder.matches(oldPassword, USER.getPassword())).willReturn(false); + + // when + AuthErrorException ex = assertThrows(AuthErrorException.class, () -> authService.updatePassword(userId, req)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(AuthErrorCode.INVALID_PASSWORD); + } } } } diff --git a/src/test/java/com/rabbitmqprac/service/ChatMessageServiceTest.java b/src/test/java/com/rabbitmqprac/service/ChatMessageServiceTest.java index a7a924b..713bf3a 100644 --- a/src/test/java/com/rabbitmqprac/service/ChatMessageServiceTest.java +++ b/src/test/java/com/rabbitmqprac/service/ChatMessageServiceTest.java @@ -55,37 +55,37 @@ public class ChatMessageServiceTest { private static final ChatRoomFixture CHAT_ROOM_FIXTURE = ChatRoomFixture.FIRST_CHAT_ROOM; private static final ChatMessageFixture CHAT_MESSAGE_FIXTURE = ChatMessageFixture.FIRST_CHAT_MESSAGE; - private User user = mock(User.class); - private ChatRoom chatRoom = mock(ChatRoom.class); - private ChatMessage chatMessage = mock(ChatMessage.class); + private static final User USER = mock(User.class); + private static final ChatRoom CHAT_ROOM = mock(ChatRoom.class); + private static final ChatMessage CHAT_MESSAGE = mock(ChatMessage.class); @BeforeEach void setUp() { - given(user.getId()).willReturn(USER_FIXTURE.getId()); - given(chatRoom.getId()).willReturn(CHAT_ROOM_FIXTURE.getId()); - - given(chatMessage.getId()).willReturn(CHAT_MESSAGE_FIXTURE.getId()); - given(chatMessage.getUser()).willReturn(user); - given(chatMessage.getChatRoom()).willReturn(chatRoom); + given(USER.getId()).willReturn(USER_FIXTURE.getId()); + given(CHAT_ROOM.getId()).willReturn(CHAT_ROOM_FIXTURE.getId()); + given(CHAT_MESSAGE.getId()).willReturn(CHAT_MESSAGE_FIXTURE.getId()); + given(CHAT_MESSAGE.getUser()).willReturn(USER); + given(CHAT_MESSAGE.getChatRoom()).willReturn(CHAT_ROOM); } @Nested @DisplayName("채팅 메시지 전송 시나리오") class SendMessageScenario { + private final ChatMessageReq req = new ChatMessageReq("content"); + @Nested - @DisplayName("채팅 메시지 전송 성공 시나리오") - class SendMessageSuccessScenario { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test - @DisplayName("성공") + @DisplayName("채팅 메시지 전송 성공") void sendMessageSuccess() { // given - ChatMessageReq req = new ChatMessageReq("content"); - given(entityFacade.readUser(user.getId())).willReturn(user); - given(entityFacade.readChatRoom(chatRoom.getId())).willReturn(chatRoom); - given(chatMessageRepository.save(any(ChatMessage.class))).willReturn(chatMessage); + given(entityFacade.readUser(USER.getId())).willReturn(USER); + given(entityFacade.readChatRoom(CHAT_ROOM.getId())).willReturn(CHAT_ROOM); + given(chatMessageRepository.save(any(ChatMessage.class))).willReturn(CHAT_MESSAGE); // when - chatMessageService.sendMessage(user.getId(), chatRoom.getId(), req); + chatMessageService.sendMessage(USER.getId(), CHAT_ROOM.getId(), req); // then verify(rabbitPublisher).publish(any(Long.class), any(ChatMessageRes.class)); @@ -96,24 +96,24 @@ void sendMessageSuccess() { @Nested @DisplayName("채팅 메시지 범위 조회 시나리오") class ReadMessageBetweenScenario { + private final Long from = 2L; + private final Long to = 10L; + @Nested - @DisplayName("채팅 메시지 범위 조회 성공 시나리오") - class ReadMessageBetweenSuccessScenario { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test @DisplayName("안 읽은 메시지가 존재하는 경우") void readMessageBetweenSuccessWhenExistsUnReadMessage() { // given - final Long from = 2L; - final Long to = 10L; - given(chatMessageRepository.findByChatRoomIdAndIdBetween(user.getId(), from, to)) - .willReturn(List.of(chatMessage)); - - long lastMessageId = chatRoom.getId() - 1; // chatRoomId보다 작은 값 - given(chatMessageStatusService.readLastReadMessageId(user.getId(), chatRoom.getId())) + given(chatMessageRepository.findByChatRoomIdAndIdBetween(CHAT_ROOM.getId(), from, to)) + .willReturn(List.of(CHAT_MESSAGE)); + long lastMessageId = CHAT_ROOM.getId() - 1; + given(chatMessageStatusService.readLastReadMessageId(USER.getId(), CHAT_ROOM.getId())) .willReturn(lastMessageId); // when - chatMessageService.readChatMessagesBetween(user.getId(), chatRoom.getId(), from, to); + chatMessageService.readChatMessagesBetween(USER.getId(), CHAT_ROOM.getId(), from, to); // then verify(chatMessageStatusService).saveLastReadMessageId(any(Long.class), any(Long.class), any(Long.class)); @@ -123,17 +123,14 @@ void readMessageBetweenSuccessWhenExistsUnReadMessage() { @DisplayName("안 읽은 메시지가 존재하지 않는 경우") void readMessageBetweenSuccessWhenNotExistsUnReadMessage() { // given - final Long from = 2L; - final Long to = 10L; - given(chatMessageRepository.findByChatRoomIdAndIdBetween(user.getId(), from, to)) - .willReturn(List.of(chatMessage)); - - long lastMessageId = chatRoom.getId() + 1; // chatRoomId보다 큰 값 - given(chatMessageStatusService.readLastReadMessageId(user.getId(), chatRoom.getId())) + given(chatMessageRepository.findByChatRoomIdAndIdBetween(CHAT_ROOM.getId(), from, to)) + .willReturn(List.of(CHAT_MESSAGE)); + long lastMessageId = CHAT_ROOM.getId() + 1; + given(chatMessageStatusService.readLastReadMessageId(USER.getId(), CHAT_ROOM.getId())) .willReturn(lastMessageId); // when - chatMessageService.readChatMessagesBetween(user.getId(), chatRoom.getId(), from, to); + chatMessageService.readChatMessagesBetween(USER.getId(), CHAT_ROOM.getId(), from, to); // then verify(chatMessageStatusService, never()).saveLastReadMessageId(any(Long.class), any(Long.class), any(Long.class)); diff --git a/src/test/java/com/rabbitmqprac/service/ChatRoomMemberServiceTest.java b/src/test/java/com/rabbitmqprac/service/ChatRoomMemberServiceTest.java index 34ba020..08fa11e 100644 --- a/src/test/java/com/rabbitmqprac/service/ChatRoomMemberServiceTest.java +++ b/src/test/java/com/rabbitmqprac/service/ChatRoomMemberServiceTest.java @@ -38,41 +38,46 @@ class ChatRoomMemberServiceTest { @InjectMocks private ChatRoomMemberService chatRoomMemberService; - private static final User user = UserFixture.FIRST_USER.toEntity(); - private static final ChatRoom chatRoom = ChatRoomFixture.FIRST_CHAT_ROOM.toEntity(); - private static final ChatRoomMember chatRoomAdmin = ChatRoomMemberFixture.ADMIN.toEntity(chatRoom, user); - private static final ChatRoomMember chatRoomMember = ChatRoomMemberFixture.MEMBER.toEntity(chatRoom, user); + private static final UserFixture USER_FIXTURE = UserFixture.FIRST_USER; + private static final ChatRoomFixture CHAT_ROOM_FIXTURE = ChatRoomFixture.FIRST_CHAT_ROOM; + private static final ChatRoomMemberFixture ADMIN_FIXTURE = ChatRoomMemberFixture.ADMIN; + private static final ChatRoomMemberFixture MEMBER_FIXTURE = ChatRoomMemberFixture.MEMBER; + + private static final User USER = USER_FIXTURE.toEntity(); + private static final ChatRoom CHAT_ROOM = CHAT_ROOM_FIXTURE.toEntity(); + private static final ChatRoomMember CHAT_ROOM_ADMIN = ADMIN_FIXTURE.toEntity(CHAT_ROOM, USER); + private static final ChatRoomMember CHAT_ROOM_MEMBER = MEMBER_FIXTURE.toEntity(CHAT_ROOM, USER); @Nested @DisplayName("채팅방 어드민 생성 시나리오") - class CreateAdminScenarios { + class CreateAdminScenario { @Nested - @DisplayName("채팅방 어드민 생성 성공 시나리오") - class CreateAdminSuccessScenarios { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test - @DisplayName("성공") + @DisplayName("어드민 생성 성공") void createAdminSuccess() { // given - given(chatRoomMemberRepository.existsByChatRoomAndUser(chatRoom, user)).willReturn(Boolean.FALSE); + given(chatRoomMemberRepository.existsByChatRoomAndUser(CHAT_ROOM, USER)).willReturn(false); // when - chatRoomMemberService.createAdmin(user, chatRoom); + chatRoomMemberService.createAdmin(USER, CHAT_ROOM); // then verify(chatRoomMemberRepository).save(any(ChatRoomMember.class)); } } @Nested - @DisplayName("채팅방 어드민 생성 실패 시나리오") - class CreateAdminFailScenarios { + @DisplayName("실패 시나리오") + class FailScenario { @Test - @DisplayName("이미 가입한 유저가 가입 요청 시 CONFLICT 예외") + @DisplayName("이미 가입한 유저가 어드민 생성 요청 시 CONFLICT 예외") void createAdminFailByAlreadyJoined() { // given - given(chatRoomMemberRepository.existsByChatRoomAndUser(chatRoom, user)).willReturn(true); + given(chatRoomMemberRepository.existsByChatRoomAndUser(CHAT_ROOM, USER)).willReturn(true); // when - ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomMemberService.createAdmin(user, chatRoom)); + ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomMemberService.createAdmin(USER, CHAT_ROOM)); // then assertThat(ex.getErrorCode()).isEqualTo(ChatRoomErrorCode.CONFLICT); @@ -82,39 +87,39 @@ void createAdminFailByAlreadyJoined() { @Nested @DisplayName("채팅방 가입 시나리오") - class JoinChatRoomScenarios { + class JoinChatRoomScenario { @Nested - @DisplayName("채팅방 가입 성공 시나리오") - class JoinChatRoomSuccessScenarios { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test - @DisplayName("성공") + @DisplayName("채팅방 가입 성공") void joinChatRoomSuccess() { // given - given(entityFacade.readUser(user.getId())).willReturn(user); - given(entityFacade.readChatRoom(chatRoom.getId())).willReturn(chatRoom); - given(chatRoomMemberRepository.existsByChatRoomAndUser(chatRoom, user)).willReturn(false); - given(chatRoomMemberRepository.save(any(ChatRoomMember.class))).willReturn(chatRoomMember); + given(entityFacade.readUser(USER.getId())).willReturn(USER); + given(entityFacade.readChatRoom(CHAT_ROOM.getId())).willReturn(CHAT_ROOM); + given(chatRoomMemberRepository.existsByChatRoomAndUser(CHAT_ROOM, USER)).willReturn(false); + given(chatRoomMemberRepository.save(any(ChatRoomMember.class))).willReturn(CHAT_ROOM_MEMBER); // when - chatRoomMemberService.joinChatRoom(user.getId(), chatRoom.getId()); + chatRoomMemberService.joinChatRoom(USER.getId(), CHAT_ROOM.getId()); // then verify(chatRoomMemberRepository).save(any(ChatRoomMember.class)); } } @Nested - @DisplayName("채팅방 가입 실패 시나리오") - class JoinChatRoomFailScenarios { + @DisplayName("실패 시나리오") + class FailScenario { @Test @DisplayName("이미 가입한 유저가 채팅방 가입 시도 시 CONFLICT 예외") void joinChatRoomFailByAlreadyJoined() { // given - given(entityFacade.readUser(user.getId())).willReturn(user); - given(entityFacade.readChatRoom(chatRoom.getId())).willReturn(chatRoom); - given(chatRoomMemberRepository.existsByChatRoomAndUser(chatRoom, user)).willReturn(true); + given(entityFacade.readUser(USER.getId())).willReturn(USER); + given(entityFacade.readChatRoom(CHAT_ROOM.getId())).willReturn(CHAT_ROOM); + given(chatRoomMemberRepository.existsByChatRoomAndUser(CHAT_ROOM, USER)).willReturn(true); // when - ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomMemberService.joinChatRoom(user.getId(), chatRoom.getId())); + ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomMemberService.joinChatRoom(USER.getId(), CHAT_ROOM.getId())); // then assertThat(ex.getErrorCode()).isEqualTo(ChatRoomErrorCode.CONFLICT); @@ -124,19 +129,19 @@ void joinChatRoomFailByAlreadyJoined() { @Nested @DisplayName("채팅방 멤버 조회 시나리오") - class GetChatRoomMembersScenarios { + class GetChatRoomMembersScenario { @Nested - @DisplayName("채팅방 멤버 조회 성공 시나리오") - class GetChatRoomMembersSuccessScenarios { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test - @DisplayName("성공") + @DisplayName("채팅방 멤버 조회 성공") void getChatRoomMembersSuccess() { // given - given(entityFacade.readChatRoom(chatRoom.getId())).willReturn(chatRoom); - given(chatRoomMemberRepository.findAllWithUserByChatRoomId(chatRoom.getId())).willReturn(List.of(chatRoomAdmin, chatRoomMember)); + given(entityFacade.readChatRoom(CHAT_ROOM.getId())).willReturn(CHAT_ROOM); + given(chatRoomMemberRepository.findAllWithUserByChatRoomId(CHAT_ROOM.getId())).willReturn(List.of(CHAT_ROOM_ADMIN, CHAT_ROOM_MEMBER)); // when - var result = chatRoomMemberService.getChatRoomMembers(chatRoom.getId()); + var result = chatRoomMemberService.getChatRoomMembers(CHAT_ROOM.getId()); // then assertThat(result).isNotNull(); @@ -147,18 +152,18 @@ void getChatRoomMembersSuccess() { @Nested @DisplayName("User ID로 채팅방 멤버 조회 시나리오") - class ReadChatRoomMembersByUserIdScenarios { + class ReadChatRoomMembersByUserIdScenario { @Nested - @DisplayName("User ID로 채팅방 멤버 조회 성공 시나리오") - class ReadChatRoomMembersByUserIdSuccessScenarios { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test - @DisplayName("성공") + @DisplayName("User ID로 채팅방 멤버 조회 성공") void readChatRoomMembersByUserIdSuccess() { // given - given(chatRoomMemberRepository.findAllByUserId(user.getId())).willReturn(List.of(chatRoomAdmin, chatRoomMember)); + given(chatRoomMemberRepository.findAllByUserId(USER.getId())).willReturn(List.of(CHAT_ROOM_ADMIN, CHAT_ROOM_MEMBER)); // when - List result = chatRoomMemberService.readChatRoomMembersByUserId(user.getId()); + List result = chatRoomMemberService.readChatRoomMembersByUserId(USER.getId()); // then assertThat(result).hasSize(2); @@ -168,18 +173,18 @@ void readChatRoomMembersByUserIdSuccess() { @Nested @DisplayName("채팅방 인원 조회 시나리오") - class CountChatRoomMembersScenarios { + class CountChatRoomMembersScenario { @Nested - @DisplayName("채팅방 인원 조회 성공 시나리오") - class CountChatRoomMembersSuccessScenarios { + @DisplayName("성공 시나리오") + class SuccessScenario { @Test - @DisplayName("성공") + @DisplayName("채팅방 인원 조회 성공") void countChatRoomMembersSuccess() { // given - given(chatRoomMemberRepository.countByChatRoomId(chatRoom.getId())).willReturn(2); + given(chatRoomMemberRepository.countByChatRoomId(CHAT_ROOM.getId())).willReturn(2); // when - int count = chatRoomMemberService.countChatRoomMembers(chatRoom.getId()); + int count = chatRoomMemberService.countChatRoomMembers(CHAT_ROOM.getId()); // then assertThat(count).isEqualTo(2); diff --git a/src/test/java/com/rabbitmqprac/service/ChatRoomServiceTest.java b/src/test/java/com/rabbitmqprac/service/ChatRoomServiceTest.java index 86956e9..5b7a3a1 100644 --- a/src/test/java/com/rabbitmqprac/service/ChatRoomServiceTest.java +++ b/src/test/java/com/rabbitmqprac/service/ChatRoomServiceTest.java @@ -6,6 +6,7 @@ import com.rabbitmqprac.common.fixture.ChatRoomFixture; import com.rabbitmqprac.common.fixture.UserFixture; import com.rabbitmqprac.domain.context.chatmessage.service.ChatMessageService; +import com.rabbitmqprac.domain.context.chatmessagestatus.service.ChatMessageStatusService; import com.rabbitmqprac.domain.context.chatroom.exception.ChatRoomErrorCode; import com.rabbitmqprac.domain.context.chatroom.exception.ChatRoomErrorException; import com.rabbitmqprac.domain.context.chatroom.service.ChatRoomService; @@ -42,6 +43,8 @@ class ChatRoomServiceTest { @Mock private ChatRoomMemberService chatRoomMemberService; @Mock + private ChatMessageStatusService chatMessageStatusService; + @Mock private ChatRoomRepository chatRoomRepository; @InjectMocks @@ -49,125 +52,136 @@ class ChatRoomServiceTest { private static final UserFixture USER_FIXTURE = UserFixture.FIRST_USER; private static final ChatRoomFixture CHAT_ROOM_FIXTURE = ChatRoomFixture.FIRST_CHAT_ROOM; - - private User user = mock(User.class); - private ChatRoom chatRoom = mock(ChatRoom.class); + private static final User USER = mock(User.class); + private static final ChatRoom CHAT_ROOM = mock(ChatRoom.class); @BeforeEach void setUp() { - given(user.getId()).willReturn(USER_FIXTURE.getId()); - given(chatRoom.getId()).willReturn(CHAT_ROOM_FIXTURE.getId()); + given(USER.getId()).willReturn(USER_FIXTURE.getId()); + given(CHAT_ROOM.getId()).willReturn(CHAT_ROOM_FIXTURE.getId()); + given(CHAT_ROOM.getTitle()).willReturn(CHAT_ROOM_FIXTURE.getTitle()); + given(CHAT_ROOM.getMaxCapacity()).willReturn(CHAT_ROOM_FIXTURE.getMaxCapacity()); } @Nested - @DisplayName("채팅방 생성 성공 시나리오") - class CreateChatRoomSuccessScenarios { - @Test - @DisplayName("채팅방 생성 성공") - void createChatRoom() { - // given - ChatRoomCreateReq req = new ChatRoomCreateReq(chatRoom.getTitle(), chatRoom.getMaxCapacity()); - given(entityFacade.readUser(user.getId())).willReturn(user); - given(chatRoomRepository.save(any(ChatRoom.class))).willReturn(chatRoom); - - // when - ChatRoomDetailRes result = chatRoomService.create(user.getId(), req); - - // then - assertThat(result.title()).isEqualTo(chatRoom.getTitle()); - assertThat(result.maxCapacity()).isEqualTo(chatRoom.getMaxCapacity()); + @DisplayName("채팅방 생성 시나리오") + class CreateChatRoomScenario { + private final ChatRoomCreateReq req = new ChatRoomCreateReq(CHAT_ROOM.getTitle(), CHAT_ROOM.getMaxCapacity()); + + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("채팅방 생성 성공") + void createChatRoomSuccess() { + // given + given(entityFacade.readUser(USER.getId())).willReturn(USER); + given(chatRoomRepository.save(any(ChatRoom.class))).willReturn(CHAT_ROOM); + + // when + ChatRoomDetailRes result = chatRoomService.create(USER.getId(), req); + + // then + assertThat(result.title()).isEqualTo(CHAT_ROOM.getTitle()); + assertThat(result.maxCapacity()).isEqualTo(CHAT_ROOM.getMaxCapacity()); + } } - } - @Nested - @DisplayName("채팅방 생성 실패 시나리오") - class CreateChatRoomFailScenarios { - @Test - @DisplayName("존재하지 않는 유저로 채팅방 생성") - void createChatRoomWhenUserNotFound() { - // given - ChatRoomCreateReq req = new ChatRoomCreateReq(chatRoom.getTitle(), chatRoom.getMaxCapacity()); - given(entityFacade.readUser(user.getId())).willThrow(new ChatRoomErrorException(ChatRoomErrorCode.NOT_FOUND)); - - // when - ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomService.create(user.getId(), req)); - - // then - assertThat(ex.getErrorCode()).isEqualTo(ChatRoomErrorCode.NOT_FOUND); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("존재하지 않는 유저로 채팅방 생성 시 실패") + void createChatRoomFailWhenUserNotFound() { + // given + given(entityFacade.readUser(USER.getId())).willThrow(new ChatRoomErrorException(ChatRoomErrorCode.NOT_FOUND)); + + // when + ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomService.create(USER.getId(), req)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(ChatRoomErrorCode.NOT_FOUND); + } } } @Nested - @DisplayName("내 채팅방 목록 조회 성공 시나리오") - class GetMyChatRoomsSuccessScenarios { - @Test - @DisplayName("내 채팅방 목록 조회 성공") - void getMyChatRooms() { - // given - given(entityFacade.readUser(user.getId())).willReturn(user); - given(chatRoomMemberService.readChatRoomMembersByUserId(user.getId())).willReturn(List.of()); - - // when - List result = chatRoomService.getMyChatRooms(user.getId()); - - // then - assertThat(result).isNotNull(); + @DisplayName("내 채팅방 목록 조회 시나리오") + class GetMyChatRoomsScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("내 채팅방 목록 조회 성공") + void getMyChatRoomsSuccess() { + // given + given(entityFacade.readUser(USER.getId())).willReturn(USER); + given(chatRoomMemberService.readChatRoomMembersByUserId(USER.getId())).willReturn(List.of()); + + // when + List result = chatRoomService.getMyChatRooms(USER.getId()); + + // then + assertThat(result).isNotNull(); + } } - } - @Nested - @DisplayName("내 채팅방 목록 조회 실패 시나리오") - class GetMyChatRoomsFailScenarios { - @Test - @DisplayName("존재하지 않는 유저의 채팅방 목록 조회") - void getMyChatRoomsWhenUserNotFound() { - // given - given(entityFacade.readUser(user.getId())).willThrow(new ChatRoomErrorException(ChatRoomErrorCode.NOT_FOUND)); - - // when - ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomService.getMyChatRooms(user.getId())); - - // then - assertThat(ex.getErrorCode()).isEqualTo(ChatRoomErrorCode.NOT_FOUND); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("존재하지 않는 유저의 채팅방 목록 조회 시 실패") + void getMyChatRoomsFailWhenUserNotFound() { + // given + given(entityFacade.readUser(USER.getId())).willThrow(new ChatRoomErrorException(ChatRoomErrorCode.NOT_FOUND)); + + // when + ChatRoomErrorException ex = assertThrows(ChatRoomErrorException.class, () -> chatRoomService.getMyChatRooms(USER.getId())); + + // then + assertThat(ex.getErrorCode()).isEqualTo(ChatRoomErrorCode.NOT_FOUND); + } } } @Nested - @DisplayName("전체 채팅방 목록 조회 성공 시나리오") - class GetChatRoomsSuccessScenarios { - @Test - @DisplayName("비로그인 유저의 전체 채팅방 목록 조회 성공") - void getChatRoomsWhenNotLoggedIn() { - // given - given(chatRoomRepository.findAll()).willReturn(List.of(chatRoom)); - - // when - List result = chatRoomService.getChatRooms(Optional.ofNullable(null)); - - // then - assertThat(result).isNotNull(); - assertThat(result.size()).isEqualTo(1); - - ChatRoomSummaryRes res = result.getFirst(); - assertThat(res.isJoined()).isFalse(); - } - - @Test - @DisplayName("로그인 유저의 전체 채팅방 목록 조회 성공") - void getChatRoomsWhenLoggedIn() { - // given - given(chatRoomRepository.findAll()).willReturn(List.of(chatRoom)); - given(chatRoomMemberService.isExists(chatRoom.getId(), user.getId())).willReturn(true); - - // when - List result = chatRoomService.getChatRooms(Optional.of(user.getId())); - - // then - assertThat(result).isNotNull(); - assertThat(result.size()).isEqualTo(1); - - ChatRoomSummaryRes res = result.getFirst(); - assertThat(res.isJoined()).isTrue(); + @DisplayName("전체 채팅방 목록 조회 시나리오") + class GetChatRoomsScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("비로그인 유저의 전체 채팅방 목록 조회 성공") + void getChatRoomsSuccessWhenNotLoggedIn() { + // given + given(chatRoomRepository.findAll()).willReturn(List.of(CHAT_ROOM)); + + // when + List result = chatRoomService.getChatRooms(Optional.ofNullable(null)); + + // then + assertThat(result).isNotNull(); + assertThat(result.size()).isEqualTo(1); + ChatRoomSummaryRes res = result.getFirst(); + assertThat(res.isJoined()).isFalse(); + } + + @Test + @DisplayName("로그인 유저의 전체 채팅방 목록 조회 성공") + void getChatRoomsSuccessWhenLoggedIn() { + // given + given(chatRoomRepository.findAll()).willReturn(List.of(CHAT_ROOM)); + given(chatRoomMemberService.isExists(CHAT_ROOM.getId(), USER.getId())).willReturn(true); + + // when + List result = chatRoomService.getChatRooms(Optional.of(USER.getId())); + + // then + assertThat(result).isNotNull(); + assertThat(result.size()).isEqualTo(1); + ChatRoomSummaryRes res = result.getFirst(); + assertThat(res.isJoined()).isTrue(); + } } } } diff --git a/src/test/java/com/rabbitmqprac/service/UserServiceTest.java b/src/test/java/com/rabbitmqprac/service/UserServiceTest.java index f928f74..00a7eee 100644 --- a/src/test/java/com/rabbitmqprac/service/UserServiceTest.java +++ b/src/test/java/com/rabbitmqprac/service/UserServiceTest.java @@ -37,285 +37,311 @@ class UserServiceTest { @InjectMocks private UserService userService; - private static User user = UserFixture.FIRST_USER.toEntity(); + private static final User USER = UserFixture.FIRST_USER.toEntity(); @Nested - @DisplayName("유저 저장 성공 시나리오") - class UserSaveSuccessScenarios { - @Test - @DisplayName("유저 저장 성공") - void saveUser() { - // given - UserCreateReq req = new UserCreateReq(user.getNickname(), user.getUsername(), user.getPassword()); - given(userRepository.save(any(User.class))).willReturn(user); - given(userRepository.existsByUsername(user.getUsername())).willReturn(Boolean.FALSE); - - // when - User savedUser = userService.saveUserWithEncryptedPassword(req); - - // then - assertThat(savedUser.getUsername()).isEqualTo(user.getUsername()); - assertThat(savedUser.getPassword()).isEqualTo(user.getPassword()); + @DisplayName("유저 저장 시나리오") + class SaveUserScenario { + private final UserCreateReq req = new UserCreateReq(USER.getNickname(), USER.getUsername(), USER.getPassword()); + + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("유저 저장 성공") + void saveUserSuccess() { + // given + given(userRepository.existsByUsername(USER.getUsername())).willReturn(false); + given(userRepository.save(any(User.class))).willReturn(USER); + + // when + User saved = userService.saveUserWithEncryptedPassword(req); + + // then + assertThat(saved.getUsername()).isEqualTo(USER.getUsername()); + assertThat(saved.getPassword()).isEqualTo(USER.getPassword()); + } } - } - @Nested - @DisplayName("유저 저장 실패 시나리오") - class UserSaveFailScenarios { - @Test - @DisplayName("nickname 중복") - void saveUserWhenExistingUserByUsername() { - // given - UserCreateReq req = new UserCreateReq(user.getNickname(), user.getUsername(), user.getPassword()); - given(userRepository.existsByUsername(user.getUsername())).willReturn(Boolean.TRUE); - - // when - UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.saveUserWithEncryptedPassword(req)); - - // then - assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.CONFLICT_USERNAME); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("username 중복") + void saveUserFailByDuplicateUsername() { + // given + given(userRepository.existsByUsername(USER.getUsername())).willReturn(true); + + // when + UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.saveUserWithEncryptedPassword(req)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.CONFLICT_USERNAME); + } } } @Nested - @DisplayName("유저 조회 성공 시나리오") - class UserReadSuccessScenarios { - @Test - @DisplayName("유저 조회 성공") - void readUser() { - // given - given(userRepository.findById(user.getId())).willReturn(Optional.of(user)); - - // when - User foundUser = userService.readUser(user.getId()); - - // then - assertThat(foundUser.getUsername()).isEqualTo(user.getUsername()); + @DisplayName("유저 조회 시나리오") + class ReadUserScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("유저 조회 성공") + void readUserSuccess() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.of(USER)); + + // when + User found = userService.readUser(USER.getId()); + + // then + assertThat(found.getUsername()).isEqualTo(USER.getUsername()); + } } - } - @Nested - @DisplayName("유저 조회 실패 시나리오") - class UserReadFailScenarios { - @Test - @DisplayName("존재하지 않는 userId") - void readUserWhenNotFoundedUserId() { - // given - given(userRepository.findById(user.getId())).willReturn(Optional.empty()); - - // when - UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.readUser(user.getId())); - - // then - assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("존재하지 않는 userId") + void readUserFailByNotFound() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.empty()); + // when + UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.readUser(USER.getId())); + // then + assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + } } } - @Nested - @DisplayName("유저 리스트 조회 성공 시나리오") - class UserListScenarios { - @Test - @DisplayName("유저 리스트 조회 성공") - void getUserDetails() { - // given - given(userRepository.findAll()).willReturn(List.of(user)); - - // when - List details = userService.getUserDetails(); - - // then - assertThat(details).hasSize(1); - assertThat(details.get(0).nickname()).isEqualTo(user.getUsername()); + @DisplayName("유저 리스트 조회 시나리오") + class GetUserDetailsScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("유저 리스트 조회 성공") + void getUserDetailsSuccess() { + // given + given(userRepository.findAll()).willReturn(List.of(USER)); + + // when + List details = userService.getUserDetails(); + + // then + assertThat(details).hasSize(1); + assertThat(details.get(0).nickname()).isEqualTo(USER.getUsername()); + } } } - @Nested - @DisplayName("단일 유저 상세 조회 성공 시나리오") - class UserDetailSuccessScenarios { - @Test - @DisplayName("유저 상세 조회 성공") - void getUserDetail() { - // given - given(userRepository.findById(user.getId())).willReturn(Optional.of(user)); - - // when - UserDetailRes detail = userService.getUserDetail(user.getId()); - - // then - assertThat(detail.nickname()).isEqualTo(user.getUsername()); + @DisplayName("단일 유저 상세 조회 시나리오") + class GetUserDetailScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("유저 상세 조회 성공") + void getUserDetailSuccess() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.of(USER)); + + // when + UserDetailRes detail = userService.getUserDetail(USER.getId()); + + // then + assertThat(detail.nickname()).isEqualTo(USER.getUsername()); + } } - } - @Nested - @DisplayName("단일 유저 상세 조회 실패 시나리오") - class UserDetailFailScenarios { - @Test - @DisplayName("존재하지 않는 userId") - void getUserDetailWhenNotFoundedUserId() { - // given - given(userRepository.findById(user.getId())).willReturn(Optional.empty()); - - // when - UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.getUserDetail(user.getId())); - - // then - assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("존재하지 않는 userId") + void getUserDetailFailByNotFound() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.empty()); + + // when + UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.getUserDetail(USER.getId())); + + // then + assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + } } } @Nested - @DisplayName("username으로 유저 조회 성공 시나리오") - class UserReadByUsernameSuccessScenarios { - @Test - @DisplayName("username으로 유저 조회 성공") - void readUserByUsername() { - // given - given(userRepository.findByUsername(user.getUsername())).willReturn(java.util.Optional.of(user)); - - // when - User foundUser = userService.readUserByUsername(user.getUsername()); - - // then - assertThat(foundUser.getUsername()).isEqualTo(user.getUsername()); + @DisplayName("username으로 유저 조회 시나리오") + class ReadUserByUsernameScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("username으로 유저 조회 성공") + void readUserByUsernameSuccess() { + // given + given(userRepository.findByUsername(USER.getUsername())).willReturn(Optional.of(USER)); + + // when + User found = userService.readUserByUsername(USER.getUsername()); + + // then + assertThat(found.getUsername()).isEqualTo(USER.getUsername()); + } } - } - @Nested - @DisplayName("username으로 유저 조회 실패 시나리오") - class UserReadByUsernameFailScenarios { - @Test - @DisplayName("존재하지 않는 nickname") - void readUserByUsernameWhenNotFoundedUser() { - // given - given(userRepository.findByUsername(user.getUsername())).willReturn(Optional.empty()); - - // when - UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.readUserByUsername(user.getUsername())); - - // then - assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("존재하지 않는 username") + void readUserByUsernameFailByNotFound() { + // given + given(userRepository.findByUsername(USER.getUsername())).willReturn(Optional.empty()); + + // when + UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.readUserByUsername(USER.getUsername())); + + // then + assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + } } } @Nested - @DisplayName("닉네임 변경 성공 시나리오") - class UpdateNicknameSuccessScenarios { - @Test - @DisplayName("닉네임 변경 성공") - void updateNicknameSuccess() { - // given - NicknameUpdateReq req = new NicknameUpdateReq("newNickname"); - given(userRepository.findById(user.getId())).willReturn(Optional.of(user)); - given(userRepository.existsByNickname(req.nickname())).willReturn(Boolean.FALSE); - - // when - userService.updateNickname(user.getId(), req); - - // then - assertThat(user.getNickname()).isEqualTo(req.nickname()); + @DisplayName("닉네임 변경 시나리오") + class UpdateNicknameScenario { + private final NicknameUpdateReq req = new NicknameUpdateReq("newNickname"); + + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("닉네임 변경 성공") + void updateNicknameSuccess() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.of(USER)); + given(userRepository.existsByNickname(req.nickname())).willReturn(false); + + // when + userService.updateNickname(USER.getId(), req); + + // then + assertThat(USER.getNickname()).isEqualTo(req.nickname()); + } } - } - @Nested - @DisplayName("닉네임 변경 실패 시나리오") - class UpdateNicknameFailScenarios { - @Test - @DisplayName("존재하지 않은 유저") - void updateNicknameFailWhenNotFoundedUser() { - // given - NicknameUpdateReq req = mock(NicknameUpdateReq.class); - given(userRepository.findById(user.getId())).willReturn(Optional.empty()); - - // when - UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.updateNickname(user.getId(), req)); - - // then - assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); - } - - @Test - @DisplayName("닉네임 중복") - void updateNicknameFailByDuplicate() { - // given - NicknameUpdateReq req = new NicknameUpdateReq("newNickname"); - given(userRepository.findById(user.getId())).willReturn(Optional.of(user)); - given(userRepository.existsByNickname(req.nickname())).willReturn(Boolean.TRUE); - - // when - UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.updateNickname(user.getId(), req)); - - // then - assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.CONFLICT_USERNAME); + @Nested + @DisplayName("실패 시나리오") + class FailScenario { + @Test + @DisplayName("존재하지 않은 유저") + void updateNicknameFailByNotFound() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.empty()); + + // when + UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.updateNickname(USER.getId(), req)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.NOT_FOUND); + } + + @Test + @DisplayName("닉네임 중복") + void updateNicknameFailByDuplicate() { + // given + given(userRepository.findById(USER.getId())).willReturn(Optional.of(USER)); + given(userRepository.existsByNickname(req.nickname())).willReturn(true); + + // when + UserErrorException ex = assertThrows(UserErrorException.class, () -> userService.updateNickname(USER.getId(), req)); + + // then + assertThat(ex.getErrorCode()).isEqualTo(UserErrorCode.CONFLICT_USERNAME); + } } } @Nested - @DisplayName("nickname 중복 체크 성공 시나리오") - class UsernameDuplicateCheckSuccessScenarios { - @Test - @DisplayName("nickname 중복 체크 - 중복") - void isDuplicatedUsernameTrue() { - // given - given(userRepository.existsByUsername(user.getUsername())).willReturn(Boolean.TRUE); - - // when - Boolean result = userService.isDuplicatedUsername(user.getUsername()); - - // then - assertThat(result).isTrue(); - } - - @Test - @DisplayName("nickname 중복 체크 - 중복 아님") - void isDuplicatedUsernameFalse() { - // given - given(userRepository.existsByUsername(user.getUsername())).willReturn(Boolean.FALSE); - - // when - Boolean result = userService.isDuplicatedUsername(user.getUsername()); - - // then - assertThat(result).isFalse(); + @DisplayName("username 중복 체크 시나리오") + class UsernameDuplicateCheckScenario { + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("username 중복 체크 - 중복") + void isDuplicatedUsernameTrue() { + // given + given(userRepository.existsByUsername(USER.getUsername())).willReturn(true); + + // when + Boolean result = userService.isDuplicatedUsername(USER.getUsername()); + + // then + assertThat(result).isTrue(); + } + + @Test + @DisplayName("username 중복 체크 - 중복 아님") + void isDuplicatedUsernameFalse() { + // given + given(userRepository.existsByUsername(USER.getUsername())).willReturn(false); + + // when + Boolean result = userService.isDuplicatedUsername(USER.getUsername()); + + // then + assertThat(result).isFalse(); + } } } @Nested - @DisplayName("닉네임 중복 체크 성공 시나리오") - class NicknameDuplicateCheckSuccessScenarios { - private static NicknameCheckReq req = mock(NicknameCheckReq.class); + @DisplayName("닉네임 중복 체크 시나리오") + class NicknameDuplicateCheckScenario { + private final NicknameCheckReq req = mock(NicknameCheckReq.class); @BeforeEach void setUp() { - given(req.nickname()).willReturn(user.getNickname()); + given(req.nickname()).willReturn(USER.getNickname()); } - @Test - @DisplayName("닉네임 중복 체크 - 중복") - void isDuplicatedNicknameTrue() { - // given - given(userRepository.existsByNickname(user.getNickname())).willReturn(Boolean.TRUE); - - // when - Boolean result = userService.isDuplicatedNickname(req); - - // then - assertThat(result).isTrue(); - } - - @Test - @DisplayName("닉네임 중복 체크 - 중복 아님") - void isDuplicatedNicknameFalse() { - // given - given(userRepository.existsByNickname(user.getNickname())).willReturn(Boolean.FALSE); - - // when - Boolean result = userService.isDuplicatedNickname(req); - - // then - assertThat(result).isFalse(); + @Nested + @DisplayName("성공 시나리오") + class SuccessScenario { + @Test + @DisplayName("닉네임 중복 체크 - 중복") + void isDuplicatedNicknameTrue() { + // given + given(userRepository.existsByNickname(USER.getNickname())).willReturn(true); + + // when + Boolean result = userService.isDuplicatedNickname(req); + + // then + assertThat(result).isTrue(); + } + + @Test + @DisplayName("닉네임 중복 체크 - 중복 아님") + void isDuplicatedNicknameFalse() { + // given + given(userRepository.existsByNickname(USER.getNickname())).willReturn(false); + + // when + Boolean result = userService.isDuplicatedNickname(req); + + // then + assertThat(result).isFalse(); + } } } - }