✨ 사용자 아이디/이름 수정 API

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/users/api/UserAccountApi.java

@@ -13,6 +13,7 @@
 import jakarta.validation.constraints.NotBlank;
 import kr.co.pennyway.api.apis.users.dto.DeviceDto;
 import kr.co.pennyway.api.apis.users.dto.UserProfileDto;
+import kr.co.pennyway.api.apis.users.dto.UserProfileUpdateDto;
 import kr.co.pennyway.api.common.security.authentication.SecurityUserDetails;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
@@ -60,4 +61,10 @@ public interface UserAccountApi {
     @Operation(summary = "사용자 계정 조회", description = "사용자 본인의 계정 정보를 조회합니다.")
     @ApiResponse(responseCode = "200", content = @Content(schemaProperties = @SchemaProperty(name = "user", schema = @Schema(implementation = UserProfileDto.class))))
     ResponseEntity<?> getMyAccount(@AuthenticationPrincipal SecurityUserDetails user);
+
+    @Operation(summary = "사용자 이름 수정")
+    ResponseEntity<?> putName(@RequestBody @Validated UserProfileUpdateDto.NameReq request, @AuthenticationPrincipal SecurityUserDetails user);
+
+    @Operation(summary = "사용자 아이디 수정")
+    ResponseEntity<?> putUsername(@RequestBody @Validated UserProfileUpdateDto.UsernameReq request, @AuthenticationPrincipal SecurityUserDetails user);
 }

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/users/controller/UserAccountController.java

@@ -3,6 +3,7 @@
 import jakarta.validation.constraints.NotBlank;
 import kr.co.pennyway.api.apis.users.api.UserAccountApi;
 import kr.co.pennyway.api.apis.users.dto.DeviceDto;
+import kr.co.pennyway.api.apis.users.dto.UserProfileUpdateDto;
 import kr.co.pennyway.api.apis.users.usecase.UserAccountUseCase;
 import kr.co.pennyway.api.common.response.SuccessResponse;
 import kr.co.pennyway.api.common.security.authentication.SecurityUserDetails;
@@ -21,22 +22,41 @@
 public class UserAccountController implements UserAccountApi {
     private final UserAccountUseCase userAccountUseCase;
 
+    @Override
     @PutMapping("/devices")
     @PreAuthorize("isAuthenticated()")
     public ResponseEntity<?> putDevice(@RequestBody @Validated DeviceDto.RegisterReq request, @AuthenticationPrincipal SecurityUserDetails user) {
         return ResponseEntity.ok(SuccessResponse.from("device", userAccountUseCase.registerDevice(user.getUserId(), request)));
     }
 
+    @Override
     @DeleteMapping("/devices")
     @PreAuthorize("isAuthenticated()")
     public ResponseEntity<?> deleteDevice(@RequestParam("token") @Validated @NotBlank String token, @AuthenticationPrincipal SecurityUserDetails user) {
         userAccountUseCase.unregisterDevice(user.getUserId(), token);
         return ResponseEntity.ok(SuccessResponse.noContent());
     }
 
+    @Override
     @GetMapping("")
     @PreAuthorize("isAuthenticated()")
     public ResponseEntity<?> getMyAccount(@AuthenticationPrincipal SecurityUserDetails user) {
         return ResponseEntity.ok(SuccessResponse.from("user", userAccountUseCase.getMyAccount(user.getUserId())));
     }
+
+    @Override
+    @PutMapping("/name")
+    @PreAuthorize("isAuthenticated()")
+    public ResponseEntity<?> putName(UserProfileUpdateDto.NameReq request, SecurityUserDetails user) {
+        userAccountUseCase.updateName(user.getUserId(), request.name());
+        return ResponseEntity.ok(SuccessResponse.noContent());
+    }
+
+    @Override
+    @PutMapping("/username")
+    @PreAuthorize("isAuthenticated()")
+    public ResponseEntity<?> putUsername(UserProfileUpdateDto.UsernameReq request, SecurityUserDetails user) {
+        userAccountUseCase.updateUsername(user.getUserId(), request.username());
+        return ResponseEntity.ok(SuccessResponse.noContent());
+    }
 }

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/users/dto/UserProfileUpdateDto.java

@@ -0,0 +1,25 @@
+package kr.co.pennyway.api.apis.users.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Pattern;
+
+public class UserProfileUpdateDto {
+    @Schema(title = "이름 변경 요청 DTO")
+    public record NameReq(
+            @Schema(description = "이름", example = "페니웨이")
+            @NotBlank(message = "이름을 입력해주세요")
+            @Pattern(regexp = "^[가-힣a-z]{2,8}$", message = "2~8자의 한글, 영문 소문자만 사용 가능합니다.")
+            String name
+    ) {
+    }
+
+    @Schema(title = "아이디 변경 요청 DTO")
+    public record UsernameReq(
+            @Schema(description = "아이디", example = "pennyway")
+            @NotBlank(message = "아이디를 입력해주세요")
+            @Pattern(regexp = "^[a-z-_.]{5,20}$", message = "5~20자의 영문 소문자, -, _, . 만 사용 가능합니다.")
+            String username
+    ) {
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/users/service/UserProfileUpdateService.java

@@ -0,0 +1,22 @@
+package kr.co.pennyway.api.apis.users.service;
+
+import kr.co.pennyway.domain.domains.user.domain.User;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class UserProfileUpdateService {
+    @Transactional
+    public void updateName(User user, String newName) {
+        user.updateName(newName);
+    }
+
+    @Transactional
+    public void updateUsername(User user, String newUsername) {
+        user.updateUsername(newUsername);
+    }
+}

pennyway-app-external-api/src/main/java/kr/co/pennyway/api/apis/users/usecase/UserAccountUseCase.java

@@ -3,6 +3,7 @@
 import kr.co.pennyway.api.apis.users.dto.DeviceDto;
 import kr.co.pennyway.api.apis.users.dto.UserProfileDto;
 import kr.co.pennyway.api.apis.users.service.DeviceRegisterService;
+import kr.co.pennyway.api.apis.users.service.UserProfileUpdateService;
 import kr.co.pennyway.common.annotation.UseCase;
 import kr.co.pennyway.domain.domains.device.domain.Device;
 import kr.co.pennyway.domain.domains.device.exception.DeviceErrorCode;
@@ -23,6 +24,8 @@ public class UserAccountUseCase {
     private final UserService userService;
     private final DeviceService deviceService;
 
+    private final UserProfileUpdateService userProfileUpdateService;
+
     private final DeviceRegisterService deviceRegisterService;
 
     @Transactional
@@ -57,4 +60,22 @@ public UserProfileDto getMyAccount(Long userId) {
 
         return UserProfileDto.from(user);
     }
+
+    @Transactional
+    public void updateName(Long userId, String newName) {
+        User user = userService.readUser(userId).orElseThrow(
+                () -> new UserErrorException(UserErrorCode.NOT_FOUND)
+        );
+
+        userProfileUpdateService.updateName(user, newName);
+    }
+
+    @Transactional
+    public void updateUsername(Long userId, String newUsername) {
+        User user = userService.readUser(userId).orElseThrow(
+                () -> new UserErrorException(UserErrorCode.NOT_FOUND)
+        );
+
+        userProfileUpdateService.updateUsername(user, newUsername);
+    }
 }

pennyway-app-external-api/src/test/java/kr/co/pennyway/api/apis/users/controller/UserAccountControllerUnitTest.java

@@ -2,11 +2,13 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 import kr.co.pennyway.api.apis.users.dto.DeviceDto;
+import kr.co.pennyway.api.apis.users.dto.UserProfileUpdateDto;
 import kr.co.pennyway.api.apis.users.usecase.UserAccountUseCase;
 import kr.co.pennyway.api.config.supporter.WithSecurityMockUser;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
+import kr.co.pennyway.common.exception.StatusCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
+import org.junit.jupiter.api.*;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
 import org.springframework.boot.test.mock.mockito.MockBean;
@@ -16,7 +18,9 @@
 import org.springframework.test.web.servlet.setup.MockMvcBuilders;
 import org.springframework.web.context.WebApplicationContext;
 
+import static kr.co.pennyway.common.exception.ReasonCode.REQUIRED_PARAMETERS_MISSING_IN_REQUEST_BODY;
 import static org.mockito.BDDMockito.given;
+import static org.mockito.BDDMockito.willThrow;
 import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
 import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
@@ -26,6 +30,7 @@
 
 @WebMvcTest(controllers = {UserAccountController.class})
 @ActiveProfiles("local")
+@TestClassOrder(ClassOrderer.OrderAnnotation.class)
 public class UserAccountControllerUnitTest {
     @Autowired
     private MockMvc mockMvc;
@@ -45,25 +50,186 @@ void setUp(WebApplicationContext webApplicationContext) {
                 .build();
     }
 
-    @DisplayName("[1] 디바이스가 정상적으로 저장되었을 때, 디바이스 pk와 등록된 토큰을 반환한다.")
-    @Test
-    @WithSecurityMockUser
-    void putDeviceSuccess() throws Exception {
-        // given
-        DeviceDto.RegisterReq request = new DeviceDto.RegisterReq("newToken", "newToken", "modelA", "Windows");
-        DeviceDto.RegisterRes expectedResponse = new DeviceDto.RegisterRes(2L, "newToken");
-        given(userAccountUseCase.registerDevice(1L, request)).willReturn(expectedResponse);
-
-        // when
-        ResultActions result = mockMvc.perform(put("/v2/users/me/devices")
-                .contentType("application/json")
-                .content(objectMapper.writeValueAsString(request)));
-
-        // then
-        result.andExpect(status().isOk())
-                .andExpect(jsonPath("$.code").value("2000"))
-                .andExpect(jsonPath("$.data.device.id").value(expectedResponse.id()))
-                .andExpect(jsonPath("$.data.device.token").value(expectedResponse.token()))
-                .andDo(print());
+    @Nested
+    @Order(1)
+    @DisplayName("[1] 디바이스 요청 테스트")
+    class DeviceRequestTest {
+        @DisplayName("디바이스가 정상적으로 저장되었을 때, 디바이스 pk와 등록된 토큰을 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void putDevice() throws Exception {
+            // given
+            DeviceDto.RegisterReq request = new DeviceDto.RegisterReq("newToken", "newToken", "modelA", "Windows");
+            DeviceDto.RegisterRes expectedResponse = new DeviceDto.RegisterRes(2L, "newToken");
+            given(userAccountUseCase.registerDevice(1L, request)).willReturn(expectedResponse);
+
+            // when
+            ResultActions result = mockMvc.perform(put("/v2/users/me/devices")
+                    .contentType("application/json")
+                    .content(objectMapper.writeValueAsString(request)));
+
+            // then
+            result.andExpect(status().isOk())
+                    .andExpect(jsonPath("$.code").value("2000"))
+                    .andExpect(jsonPath("$.data.device.id").value(expectedResponse.id()))
+                    .andExpect(jsonPath("$.data.device.token").value(expectedResponse.token()))
+                    .andDo(print());
+        }
+    }
+
+    @Nested
+    @Order(2)
+    @DisplayName("[2] 사용자 이름 수정 테스트")
+    class UpdateNameTest {
+        @DisplayName("사용자 이름 수정 요청 시, 유효성 검사에 실패하면 422 에러를 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void updateNameValidationFail() throws Exception {
+            // given
+            String newNameWithBlank = " ";
+            String newNameWithOverLength = "안녕하세요장페르센입니다";
+            String newNameWithSpecialCharacter = "hello!";
+            String expectedErrorCode = String.valueOf(StatusCode.UNPROCESSABLE_CONTENT.getCode() * 10 + REQUIRED_PARAMETERS_MISSING_IN_REQUEST_BODY.getCode());
+
+            // when
+            ResultActions result1 = performUpdateNameRequest(newNameWithBlank);
+            ResultActions result2 = performUpdateNameRequest(newNameWithOverLength);
+            ResultActions result3 = performUpdateNameRequest(newNameWithSpecialCharacter);
+
+            // then
+            result1.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+            result2.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+            result3.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+        }
+
+        @DisplayName("사용자 이름 수정 요청 시, 삭제된 사용자인 경우 404 에러를 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void updateNameDeletedUser() throws Exception {
+            // given
+            String newName = "양재서";
+            willThrow(new UserErrorException(UserErrorCode.NOT_FOUND)).given(userAccountUseCase).updateName(1L, newName);
+
+            // when
+            ResultActions result = performUpdateNameRequest(newName);
+
+            // then
+            result.andExpect(status().isNotFound())
+                    .andExpect(jsonPath("$.code").value(UserErrorCode.NOT_FOUND.causedBy().getCode()))
+                    .andExpect(jsonPath("$.message").value(UserErrorCode.NOT_FOUND.getExplainError()))
+                    .andDo(print());
+        }
+
+        @DisplayName("사용자 이름 수정 요청 시, 사용자 이름이 정상적으로 수정되면 200 코드를 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void updateNameSuccess() throws Exception {
+            // given
+            String newName = "양재서";
+
+            // when
+            ResultActions result = performUpdateNameRequest(newName);
+
+            // then
+            result.andExpect(status().isOk())
+                    .andExpect(jsonPath("$.code").value("2000"))
+                    .andDo(print());
+        }
+
+        private ResultActions performUpdateNameRequest(String newName) throws Exception {
+            UserProfileUpdateDto.NameReq request = new UserProfileUpdateDto.NameReq(newName);
+            return mockMvc.perform(put("/v2/users/me/name")
+                    .contentType("application/json")
+                    .content(objectMapper.writeValueAsString(request)));
+        }
+    }
+
+    @Nested
+    @Order(3)
+    @DisplayName("[3] 사용자 닉네임 수정 테스트")
+    class UpdateNicknameTest {
+        @DisplayName("사용자 닉네임 수정 요청 시, 유효성 검사에 실패하면 422 에러를 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void updateNicknameValidationFail() throws Exception {
+            // given
+            String newNicknameWithBlank = " ";
+            String newNicknameWithOverLength = "한글이름";
+            String newNicknameWithSpecialCharacter = "hello!";
+            String newNicknameWithWhiteSpace = "jay ang";
+            String newNicknameWithOverLengthAndWhiteSpace = "myNameisJayangHello";
+            String expectedErrorCode = String.valueOf(StatusCode.UNPROCESSABLE_CONTENT.getCode() * 10 + REQUIRED_PARAMETERS_MISSING_IN_REQUEST_BODY.getCode());
+
+            // when
+            ResultActions result1 = performUpdateNicknameRequest(newNicknameWithBlank);
+            ResultActions result2 = performUpdateNicknameRequest(newNicknameWithOverLength);
+            ResultActions result3 = performUpdateNicknameRequest(newNicknameWithSpecialCharacter);
+            ResultActions result4 = performUpdateNicknameRequest(newNicknameWithWhiteSpace);
+            ResultActions result5 = performUpdateNicknameRequest(newNicknameWithOverLengthAndWhiteSpace);
+
+            // then
+            result1.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+            result2.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+            result3.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+            result4.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+            result5.andExpect(status().isUnprocessableEntity())
+                    .andExpect(jsonPath("$.code").value(expectedErrorCode))
+                    .andDo(print());
+        }
+
+        @DisplayName("사용자 닉네임 수정 요청 시, 삭제된 사용자인 경우 404 에러를 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void updateNicknameDeletedUser() throws Exception {
+            // given
+            String newNickname = "jayang._.";
+            willThrow(new UserErrorException(UserErrorCode.NOT_FOUND)).given(userAccountUseCase).updateUsername(1L, newNickname);
+
+            // when
+            ResultActions result = performUpdateNicknameRequest(newNickname);
+
+            // then
+            result.andExpect(status().isNotFound())
+                    .andExpect(jsonPath("$.code").value(UserErrorCode.NOT_FOUND.causedBy().getCode()))
+                    .andExpect(jsonPath("$.message").value(UserErrorCode.NOT_FOUND.getExplainError()))
+                    .andDo(print());
+        }
+
+        @DisplayName("사용자 닉네임 수정 요청 시, 사용자 닉네임이 정상적으로 수정되면 200 코드를 반환한다.")
+        @Test
+        @WithSecurityMockUser
+        void updateNicknameSuccess() throws Exception {
+            // given
+            String newNickname = "jayang._.";
+
+            // when
+            ResultActions result = performUpdateNicknameRequest(newNickname);
+
+            // then
+            result.andExpect(status().isOk())
+                    .andExpect(jsonPath("$.code").value("2000"))
+                    .andDo(print());
+        }
+
+        private ResultActions performUpdateNicknameRequest(String newNickname) throws Exception {
+            UserProfileUpdateDto.UsernameReq request = new UserProfileUpdateDto.UsernameReq(newNickname);
+            return mockMvc.perform(put("/v2/users/me/username")
+                    .contentType("application/json")
+                    .content(objectMapper.writeValueAsString(request)));
+        }
     }
 }