refactor: User controller, service 계층 리팩토링/테스트 코드 추가

src/main/java/com/Alchive/backend/controller/UserController.java

@@ -34,10 +34,7 @@ public ResponseEntity<ResultResponse> createUser(@RequestBody UserCreateRequest
     @Operation(summary = "username 중복 확인 메서드", description = "username 중복을 검사하는 메서드입니다.")
     @GetMapping("/username/{name}")
     public ResponseEntity<ResultResponse> isDuplicateUsername(@PathVariable String name) {
-        if (userService.isDuplicateUsername(name)) {
-            return ResponseEntity.ok(ResultResponse.of(USER_USERNAME_DUPLICATED, true));
-        }
-        return ResponseEntity.ok(ResultResponse.of(USER_USERNAME_NOT_DUPLICATED, false));
+        return ResponseEntity.ok(ResultResponse.of(USER_USERNAME_NOT_DUPLICATED, userService.isDuplicatedUsername(name)));
     }
 
     @Operation(summary = "프로필 조회 메서드", description = "특정 사용자의 프로필 정보를 조회하는 메서드입니다.")

src/main/java/com/Alchive/backend/dto/response/UserResponseDTO.java

@@ -13,9 +13,9 @@ public class UserResponseDTO {
     private String accessToken;
 
     public UserResponseDTO(User user, String accessToken) {
-        this.userId=user.getId();
-        this.userEmail=user.getEmail();
-        this.userName=user.getName();
-        this.accessToken=accessToken;
+        this.userId = user.getId();
+        this.userEmail = user.getEmail();
+        this.userName = user.getName();
+        this.accessToken = accessToken;
     }
 }

src/main/java/com/Alchive/backend/service/UserService.java

@@ -28,26 +28,41 @@ public class UserService {
     public UserResponseDTO createUser(UserCreateRequest request) {
         String email = request.getEmail();
         String username = request.getName();
-        // 중복 이메일 검사
-        if (userRepository.existsByEmail(email)) {
+
+        isDuplicatedEmailUsername(email, username);
+        User savedUser = createSaveUser(email, username);
+        String accessToken = createUserTokens(email);
+
+        return new UserResponseDTO(savedUser, accessToken);
+    }
+
+    private void isDuplicatedEmailUsername(String email, String username) {
+        if (isDuplicatedEmail(email)) {
             throw new UserEmailExistException();
         }
-        // 중복 유저 이름 검사
-        if (userRepository.existsByName(username)) {
+        if (isDuplicatedUsername(username)) {
             throw new UserNameExistException();
         }
-        // db에 유저 저장 - 회원 가입
+    }
+
+    private boolean isDuplicatedEmail(String email) {
+        return userRepository.existsByEmail(email);
+    }
+
+    public boolean isDuplicatedUsername(String name) {
+        return userRepository.existsByName(name);
+    }
+
+    private User createSaveUser(String email, String username) {
         User user = new User(email, username);
-        user = userRepository.save(user);
-        // 토큰 생성 후 전달
+        return userRepository.save(user);
+    }
+
+    public String createUserTokens(String email) {
         String accessToken = jwtTokenProvider.createAccessToken(email);
         String refreshToken = refreshTokenService.createRefreshToken(email);
         refreshTokenService.saveRefreshToken(email, refreshToken);
-        return new UserResponseDTO(user, accessToken);
-    }
-
-    public boolean isDuplicateUsername(String name) {
-        return userRepository.existsByName(name);
+        return accessToken;
     }
 
     public User getUserDetail(Long userId) {

src/test/java/com/Alchive/backend/controller/UserControllerTest.java

@@ -0,0 +1,44 @@
+package com.Alchive.backend.controller;
+
+import com.Alchive.backend.config.result.ResultResponse;
+import com.Alchive.backend.service.UserService;
+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.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.ResponseEntity;
+
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class UserControllerTest {
+    @InjectMocks
+    private UserController sut;
+    @Mock
+    private UserService userService;
+    @BeforeEach
+    public void setUp() {
+    }
+    @DisplayName("UserController 유저네임 중복 - 성공")
+    @Test
+    public void isDuplicateUsernameSuccess() {
+        when(userService.isDuplicatedUsername("testNameUnique")).thenReturn(true);
+
+        ResponseEntity<ResultResponse> result = sut.isDuplicateUsername("testNameUnique");
+
+        Assertions.assertEquals(true, result.getBody().getData());
+    }
+    @DisplayName("UserController 유저네임 중복 - 실패")
+    @Test
+    public void isDuplicateUsernameFail() {
+        when(userService.isDuplicatedUsername("testNameDuplicated")).thenReturn(false);
+
+        ResponseEntity<ResultResponse> result = sut.isDuplicateUsername("testNameDuplicated");
+
+        Assertions.assertEquals(false, result.getBody().getData());
+    }
+}

src/test/java/com/Alchive/backend/service/UserServiceTest.java

@@ -1,175 +1,93 @@
-//package com.Alchive.backend.service;
-//
-//import com.Alchive.backend.config.error.exception.user.NoSuchUserIdException;
-//import com.Alchive.backend.config.error.exception.user.UserEmailExistException;
-//import com.Alchive.backend.domain.user.User;
-//import com.Alchive.backend.dto.request.UserCreateRequest;
-//import com.Alchive.backend.dto.request.UserUpdateRequest;
-//import com.Alchive.backend.dto.response.UserResponseDTO;
-//import com.Alchive.backend.repository.UserRepository;
-//import jakarta.servlet.http.HttpServletRequest;
-//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 org.springframework.security.core.token.TokenService;
-//
-//import java.util.Optional;
-//
-//import static org.junit.jupiter.api.Assertions.*;
-//import static org.mockito.ArgumentMatchers.any;
-//import static org.mockito.Mockito.doNothing;
-//import static org.mockito.Mockito.when;
-//
-//public class UserServiceTest {
-//    @InjectMocks
-//    private UserService userService;
-//
-//    @Mock
-//    private UserRepository userRepository;
-//
-//    @Mock
-//    private TokenService tokenService;
-//
-//    @Mock
-//    private HttpServletRequest request;
-//
-//    private User user;
-//
-//    @BeforeEach
-//    void setUp() {
-//        // Mockito 초기화
-//        MockitoAnnotations.openMocks(this);
-//
-//        // 테스트용 Builder 패턴을 이용해 userId까지 직접 입력
-//        user = User.userTestBuilder()
-//                .id(1L)
-//                .email("[email protected]")
-//                .name("user1")
-//                .build();
-//    }
-//
-//    @DisplayName("사용자 생성 - 성공")
-//    @Test
-//    void createUser_success() {
-//        // given
-//        UserCreateRequest createRequest = UserCreateRequest.builder()
-//                .email(user.getEmail())
-//                .name(user.getName())
-//                .build();
-//
-//        when(userRepository.existsByEmail(createRequest.getEmail())).thenReturn(false);
-//        when(userRepository.save(any(User.class))).thenReturn(user);
-//        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
-//        doNothing().when(tokenService).validateAccessToken(request);
-//        when(tokenService.validateAccessToken(request)).thenReturn(user.getId());
-//
-//        // when
-//        UserResponseDTO returnedUser = userService.createUser(createRequest);
-//
-//        // then
-//        assertNotNull(returnedUser);
-//        assertEquals(user.getId(), returnedUser.getUserId());
-//        assertEquals(user.getName(), returnedUser.getUserName());
-//        assertEquals(user.getEmail(), returnedUser.getUserEmail());
-//    }
-//
-//    @DisplayName("사용자 생성 - 유저 닉네임 중복")
-//    @Test
-//    void createUser_username_exists() {
-//        // given
-//        UserCreateRequest createRequest = UserCreateRequest.builder()
-//                .email("[email protected]")
-//                .name("duplicatedUserName")
-//                .build();
-//        when(userService.isDuplicateUsername(createRequest.getName())).thenReturn(true);
-//
-//        // when
-//        boolean returnedAnswer = userService.isDuplicateUsername(createRequest.getName());
-//
-//        // then
-//        assertTrue(returnedAnswer);
-//    }
-//
-//    @DisplayName("사용자 생성 - 유저 이메일 중복")
-//    @Test
-//    void createUser_userEmail_exists() {
-//        // given
-//        UserCreateRequest createRequest = UserCreateRequest.builder()
-//                .email("[email protected]")
-//                .name("user1")
-//                .build();
-//        when(userRepository.existsByEmail(createRequest.getEmail())).thenReturn(true);
-//
-//        // when, then
-//        assertThrows(UserEmailExistException.class, () -> userService.createUser(createRequest));
-//    }
-//
-//    @DisplayName("프로필 조회 - 성공")
-//    @Test
-//    void getUser_success() {
-//        // given
-//        doNothing().when(tokenService).validateAccessToken(request);
-//        when(tokenService.validateAccessToken(request)).thenReturn(user.getId());
-//        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
-//
-//        // when
-//        User returnedUser = userService.getUserDetail(request);
-//
-//        // then
-//        assertNotNull(returnedUser);
-//        assertEquals(user.getId(), returnedUser.getId());
-//        assertEquals(user.getEmail(), returnedUser.getEmail());
-//        assertEquals(user.getName(), returnedUser.getName());
-//    }
-//
-//    @DisplayName("프로필 조회 - 존재하지 않는 유저 아이디")
-//    @Test
-//    void getUser_userNotFound() {
-//        // given
-//        doNothing().when(tokenService).validateAccessToken(request);
-//        when(tokenService.validateAccessToken(request)).thenReturn(user.getId());
-//        when(userRepository.findById(user.getId())).thenReturn(Optional.empty());
-//
-//        // when, then
-//        assertThrows(NoSuchUserIdException.class, () -> userService.getUserDetail(request));
-//    }
-//
-//    @DisplayName("프로필 수정 - 성공")
-//    @Test
-//    void updateUser_success() {
-//        // given
-//        UserUpdateRequest updateRequest = UserUpdateRequest.builder()
-//                .description("updatedUserDescription")
-//                .build();
-//        doNothing().when(tokenService).validateAccessToken(request);
-//        when(tokenService.validateAccessToken(request)).thenReturn(user.getId());
-//        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
-//        when(userRepository.save(any(User.class))).thenReturn(user);
-//
-//        // when
-//        userService.updateUserDetail(request, updateRequest);
-//
-//        // then
-//        assertNotNull(user);
-//        assertEquals(user.getDescription(), "updatedUserDescription");
-//    }
-//
-//    @DisplayName("사용자 삭제 - 성공")
-//    @Test
-//    void deleteUser_success() {
-//        // given
-//        doNothing().when(tokenService).validateAccessToken(request);
-//        when(tokenService.validateAccessToken(request)).thenReturn(user.getId());
-//        when(userRepository.findById(user.getId())).thenReturn(Optional.of(user));
-//
-//        // when
-//        userService.deleteUserDetail(request);
-//        when(userRepository.findById(user.getId())).thenReturn(Optional.empty());
-//
-//        // then
-//        assertThrows(NoSuchUserIdException.class, () -> userService.getUserDetail(request));
-//    }
-//}
+package com.Alchive.backend.service;
+
+import com.Alchive.backend.config.error.exception.user.UserEmailExistException;
+import com.Alchive.backend.config.error.exception.user.UserNameExistException;
+import com.Alchive.backend.config.jwt.JwtTokenProvider;
+import com.Alchive.backend.config.redis.RefreshTokenService;
+import com.Alchive.backend.domain.user.User;
+import com.Alchive.backend.dto.request.UserCreateRequest;
+import com.Alchive.backend.dto.request.UserUpdateRequest;
+import com.Alchive.backend.dto.response.UserResponseDTO;
+import com.Alchive.backend.repository.UserRepository;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import java.util.Optional;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+public class UserServiceTest {
+    @InjectMocks
+    private UserService sut;
+    @Mock
+    private UserRepository userRepository;
+    @Mock
+    private JwtTokenProvider jwtTokenProvider;
+    @Mock
+    private RefreshTokenService refreshTokenService;
+
+    String email = "[email protected]";
+    String name = "testName";
+    String accessToken = "testAccessToken";
+    String refreshToken = "testRefreshToken";
+    User user = new User(email, name);
+
+    @DisplayName("UserService 사용자 생성 - 성공")
+    @Test
+    public void createUserSuccess() {
+        UserCreateRequest request = new UserCreateRequest(email, name);
+        when(userRepository.save(any(User.class))).thenReturn(new User(email, name));
+        when(userRepository.existsByEmail(email)).thenReturn(false);
+        when(userRepository.existsByName(name)).thenReturn(false);
+        when(jwtTokenProvider.createAccessToken(email)).thenReturn(accessToken);
+        when(refreshTokenService.createRefreshToken(email)).thenReturn(refreshToken);
+        doNothing().when(refreshTokenService).saveRefreshToken(email, refreshToken);
+
+        UserResponseDTO result = sut.createUser(request);
+
+        Assertions.assertEquals(email, result.getUserEmail());
+        Assertions.assertEquals(name, result.getUserName());
+        Assertions.assertEquals(accessToken, result.getAccessToken());
+    }
+
+    @DisplayName("UserService 사용자 생성 - 이메일 중복 실패")
+    @Test
+    public void createUserFailByEmailDuplicated() {
+        UserCreateRequest request = new UserCreateRequest(email, name);
+        when(userRepository.existsByEmail(email)).thenReturn(true);
+
+        Assertions.assertThrows(UserEmailExistException.class, () -> sut.createUser(request));
+    }
+
+    @DisplayName("UserService 사용자 생성 - 유저네임 중복 실패")
+    @Test
+    public void createUserFailByUsernameDuplicated() {
+        UserCreateRequest request = new UserCreateRequest(email, name);
+        when(userRepository.existsByEmail(email)).thenReturn(false);
+        when(userRepository.existsByName(name)).thenReturn(true);
+
+        Assertions.assertThrows(UserNameExistException.class, () -> sut.createUser(request));
+    }
+
+    @DisplayName("UserService 사용자 정보 수정 - 성공")
+    @Test
+    public void updateUserDetailSuccess() {
+        String description = "updatedDescription";
+        UserUpdateRequest request = UserUpdateRequest.builder()
+                .description(description).build();
+        when(userRepository.findById(nullable(Long.class))).thenReturn(Optional.ofNullable(user));
+
+        User result = sut.updateUserDetail(user, request);
+
+        Assertions.assertEquals(description, result.getDescription());
+    }
+}