feature: 프로필 수정 API 구현

src/main/kotlin/com/petqua/application/member/MemberService.kt

@@ -2,6 +2,7 @@ package com.petqua.application.member
 
 import com.petqua.application.member.dto.MemberAddProfileCommand
 import com.petqua.application.member.dto.MemberSignUpCommand
+import com.petqua.application.member.dto.UpdateProfileCommand
 import com.petqua.application.token.AuthTokenInfo
 import com.petqua.application.token.TokenService
 import com.petqua.common.domain.findActiveByIdOrThrow
@@ -19,6 +20,8 @@ import com.petqua.domain.member.nickname.NicknameWordRepository
 import com.petqua.domain.policy.bannedword.BannedWordRepository
 import com.petqua.domain.policy.bannedword.BannedWords
 import com.petqua.exception.member.MemberException
+import com.petqua.exception.member.MemberExceptionType
+import com.petqua.exception.member.MemberExceptionType.ALREADY_EXIST_NICKNAME
 import com.petqua.exception.member.MemberExceptionType.FAILED_NICKNAME_GENERATION
 import com.petqua.exception.member.MemberExceptionType.HAS_SIGNED_UP_MEMBER
 import com.petqua.exception.member.MemberExceptionType.NOT_FOUND_MEMBER
@@ -88,4 +91,19 @@ class MemberService(
         val bannedWords = BannedWords(bannedWordRepository.findAll())
         bannedWords.validateContainingBannedWord(name)
     }
+
+    fun updateProfile(command: UpdateProfileCommand) {
+        validateNickname(command.nickname)
+        val member = memberRepository.findActiveByIdOrThrow(command.memberId) {
+            MemberException(NOT_FOUND_MEMBER)
+        }
+        member.updateNickname(Nickname.from(command.nickname))
+    }
+
+    private fun validateNickname(nickname: String) {
+        validateContainingBannedWord(nickname)
+        throwExceptionWhen(memberRepository.existsMemberByNickname(Nickname.from(nickname))) {
+            MemberException(ALREADY_EXIST_NICKNAME)
+        }
+    }
 }

src/main/kotlin/com/petqua/application/member/dto/MemberDtos.kt

@@ -51,3 +51,8 @@ data class PetFishAddCommand(
         )
     }
 }
+
+data class UpdateProfileCommand(
+    val memberId: Long,
+    val nickname: String
+)

src/main/kotlin/com/petqua/exception/member/MemberExceptionType.kt

@@ -25,6 +25,7 @@ enum class MemberExceptionType(
     INVALID_MEMBER_NICKNAME(BAD_REQUEST, "M16", "유효하지 않은 회원 닉네임입니다."),
 
     CONTAINING_BANNED_WORD_NAME(BAD_REQUEST, "M20", "이름에 금지 단어를 포함할 수 없습니다."),
+    ALREADY_EXIST_NICKNAME(BAD_REQUEST, "M21", "이미 사용 중인 닉네임입니다."),
 
     INVALID_MEMBER_STATE(INTERNAL_SERVER_ERROR, "M90", "유효하지 않은 회원 상태입니다."),
     FAILED_NICKNAME_GENERATION(LOOP_DETECTED, "M91", "서버에서 회원 닉네임을 생성하지 못했습니다.")

src/main/kotlin/com/petqua/presentation/member/MemberController.kt

@@ -8,6 +8,7 @@ import com.petqua.domain.auth.LoginMember
 import com.petqua.domain.auth.SignUpGuest
 import com.petqua.presentation.member.dto.MemberAddProfileRequest
 import com.petqua.presentation.member.dto.MemberSignUpRequest
+import com.petqua.presentation.member.dto.UpdateProfileRequest
 import io.swagger.v3.oas.annotations.Operation
 import io.swagger.v3.oas.annotations.responses.ApiResponse
 import io.swagger.v3.oas.annotations.security.SecurityRequirement
@@ -19,6 +20,7 @@ import org.springframework.http.HttpStatus.CREATED
 import org.springframework.http.ResponseCookie
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
+import org.springframework.web.bind.annotation.PatchMapping
 import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
@@ -81,4 +83,17 @@ class MemberController(
         memberService.addProfile(command)
         return ResponseEntity.noContent().build()
     }
+
+    @Operation(summary = "회원 프로필 수정 API", description = "회원의 프로필 정보를 수정합니다")
+    @ApiResponse(responseCode = "204", description = "회원 프로필 수정 성공")
+    @SecurityRequirement(name = ACCESS_TOKEN_SECURITY_SCHEME_KEY)
+    @PatchMapping("/profiles")
+    fun updateProfile(
+        @Auth loginMember: LoginMember,
+        @RequestBody request: UpdateProfileRequest,
+    ): ResponseEntity<Unit> {
+        val command = request.toCommand(loginMember.memberId)
+        memberService.updateProfile(command)
+        return ResponseEntity.noContent().build()
+    }
 }

src/main/kotlin/com/petqua/presentation/member/dto/MemberDtos.kt

@@ -3,6 +3,7 @@ package com.petqua.presentation.member.dto
 import com.petqua.application.member.dto.MemberAddProfileCommand
 import com.petqua.application.member.dto.MemberSignUpCommand
 import com.petqua.application.member.dto.PetFishAddCommand
+import com.petqua.application.member.dto.UpdateProfileCommand
 import io.swagger.v3.oas.annotations.media.Schema
 import java.time.YearMonth
 
@@ -89,3 +90,19 @@ data class PetFishAddRequest(
     )
     val count: Int,
 )
+
+data class UpdateProfileRequest(
+    @Schema(
+        description = "닉네임",
+        example = "펫쿠아"
+    )
+    val nickname: String,
+) {
+
+    fun toCommand(memberId: Long): UpdateProfileCommand {
+        return UpdateProfileCommand(
+            memberId = memberId,
+            nickname = nickname,
+        )
+    }
+}

src/test/kotlin/com/petqua/application/member/MemberServiceTest.kt

@@ -4,6 +4,7 @@ import com.ninjasquad.springmockk.SpykBean
 import com.petqua.application.member.dto.MemberAddProfileCommand
 import com.petqua.application.member.dto.MemberSignUpCommand
 import com.petqua.application.member.dto.PetFishAddCommand
+import com.petqua.application.member.dto.UpdateProfileCommand
 import com.petqua.domain.auth.AuthCredentialsRepository
 import com.petqua.domain.fish.FishRepository
 import com.petqua.domain.member.FishTankRepository
@@ -20,6 +21,7 @@ import com.petqua.domain.member.nickname.NicknameWordRepository
 import com.petqua.domain.policy.bannedword.BannedWord
 import com.petqua.domain.policy.bannedword.BannedWordRepository
 import com.petqua.exception.member.MemberException
+import com.petqua.exception.member.MemberExceptionType.ALREADY_EXIST_NICKNAME
 import com.petqua.exception.member.MemberExceptionType.CONTAINING_BANNED_WORD_NAME
 import com.petqua.exception.member.MemberExceptionType.FAILED_NICKNAME_GENERATION
 import com.petqua.exception.member.MemberExceptionType.HAS_SIGNED_UP_MEMBER
@@ -30,6 +32,7 @@ import com.petqua.exception.member.MemberExceptionType.INVALID_MEMBER_FISH_TANK_
 import com.petqua.exception.member.MemberExceptionType.INVALID_MEMBER_PET_FISH
 import com.petqua.exception.member.MemberExceptionType.INVALID_MEMBER_PET_FISH_COUNT
 import com.petqua.exception.member.MemberExceptionType.NOT_FOUND_MEMBER
+import com.petqua.test.DataCleaner
 import com.petqua.test.fixture.authCredentials
 import com.petqua.test.fixture.fish
 import com.petqua.test.fixture.member
@@ -57,6 +60,7 @@ class MemberServiceTest(
     private val fishRepository: FishRepository,
     private val petFishRepository: PetFishRepository,
     private val fishTankRepository: FishTankRepository,
+    private val dataCleaner: DataCleaner,
 
     @SpykBean private val nicknameGenerator: NicknameGenerator,
 ) : BehaviorSpec({
@@ -444,4 +448,69 @@ class MemberServiceTest(
             }
         }
     }
+
+    Given("프로필 수정을 할 때") {
+        val member = memberRepository.save(member(nickname = "닉네임"))
+        bannedWordRepository.save(BannedWord(word = "금지 단어"))
+
+        When("닉네임을 입력하면") {
+            val command = UpdateProfileCommand(
+                memberId = member.id,
+                nickname = "변경된 닉네임",
+            )
+            memberService.updateProfile(command)
+
+            Then("닉네임을 수정한다") {
+                val updatedMember = memberRepository.findById(member.id).get()
+
+                assertSoftly {
+                    updatedMember.nickname.value shouldBe "변경된 닉네임"
+                }
+            }
+        }
+
+        When("닉네임에 부적절한 단어가 들어가면") {
+            val command = UpdateProfileCommand(
+                memberId = member.id,
+                nickname = "금지 단어",
+            )
+
+            Then("예외를 던진다") {
+                shouldThrow<MemberException> {
+                    memberService.updateProfile(command)
+                }.exceptionType() shouldBe CONTAINING_BANNED_WORD_NAME
+            }
+        }
+
+        When("이미 다른 회원이 사용중인 닉네임이라면") {
+            memberRepository.save(member(nickname = "변경된 닉네임"))
+            val command = UpdateProfileCommand(
+                memberId = member.id,
+                nickname = "변경된 닉네임",
+            )
+
+            Then("예외를 던진다") {
+                shouldThrow<MemberException> {
+                    memberService.updateProfile(command)
+                }.exceptionType() shouldBe ALREADY_EXIST_NICKNAME
+            }
+        }
+
+        When("회원이 존재하지 않으면") {
+            val command = UpdateProfileCommand(
+                memberId = Long.MAX_VALUE,
+                nickname = "변경된 닉네임",
+            )
+
+            Then("예외를 던진다") {
+                shouldThrow<MemberException> {
+                    memberService.updateProfile(command)
+                }.exceptionType() shouldBe NOT_FOUND_MEMBER
+            }
+        }
+    }
+
+    afterContainer {
+        dataCleaner.clean()
+    }
 })

src/test/kotlin/com/petqua/presentation/member/MemberControllerSteps.kt

@@ -2,6 +2,7 @@ package com.petqua.presentation.member
 
 import com.petqua.presentation.member.dto.MemberAddProfileRequest
 import com.petqua.presentation.member.dto.MemberSignUpRequest
+import com.petqua.presentation.member.dto.UpdateProfileRequest
 import io.restassured.module.kotlin.extensions.Extract
 import io.restassured.module.kotlin.extensions.Given
 import io.restassured.module.kotlin.extensions.Then
@@ -59,3 +60,21 @@ fun requestAddProfile(
         response()
     }
 }
+
+fun requestUpdateProfile(
+    request: UpdateProfileRequest,
+    accessToken: String,
+): Response {
+    return Given {
+        log().all()
+        contentType(APPLICATION_JSON_VALUE)
+        body(request)
+        auth().preemptive().oauth2(accessToken)
+    } When {
+        patch("/members/profiles")
+    } Then {
+        log().all()
+    } Extract {
+        response()
+    }
+}

src/test/kotlin/com/petqua/presentation/member/MemberControllerTest.kt

@@ -2,6 +2,8 @@ package com.petqua.presentation.member
 
 import com.petqua.common.domain.findByIdOrThrow
 import com.petqua.common.exception.ExceptionResponse
+import com.petqua.domain.auth.Authority
+import com.petqua.domain.auth.token.AuthTokenProvider
 import com.petqua.domain.fish.FishRepository
 import com.petqua.domain.member.FishTankRepository
 import com.petqua.domain.member.MemberRepository
@@ -15,11 +17,14 @@ import com.petqua.domain.policy.bannedword.BannedWordRepository
 import com.petqua.exception.member.MemberExceptionType
 import com.petqua.exception.member.MemberExceptionType.CONTAINING_BANNED_WORD_NAME
 import com.petqua.exception.member.MemberExceptionType.HAS_SIGNED_UP_MEMBER
+import com.petqua.exception.member.MemberExceptionType.NOT_FOUND_MEMBER
 import com.petqua.presentation.member.dto.MemberAddProfileRequest
 import com.petqua.presentation.member.dto.MemberSignUpRequest
 import com.petqua.presentation.member.dto.PetFishAddRequest
+import com.petqua.presentation.member.dto.UpdateProfileRequest
 import com.petqua.test.ApiTestConfig
 import com.petqua.test.fixture.fish
+import com.petqua.test.fixture.member
 import com.petqua.test.fixture.memberAddProfileRequest
 import io.kotest.assertions.assertSoftly
 import io.kotest.matchers.shouldBe
@@ -29,9 +34,11 @@ import org.springframework.http.HttpHeaders
 import org.springframework.http.HttpHeaders.AUTHORIZATION
 import org.springframework.http.HttpStatus.BAD_REQUEST
 import org.springframework.http.HttpStatus.CREATED
+import org.springframework.http.HttpStatus.NOT_FOUND
 import org.springframework.http.HttpStatus.NO_CONTENT
 import java.time.LocalDate
 import java.time.YearMonth
+import java.util.Date
 import kotlin.Long.Companion.MIN_VALUE
 
 class MemberControllerTest(
@@ -41,6 +48,7 @@ class MemberControllerTest(
     private val fishRepository: FishRepository,
     private val petFishRepository: PetFishRepository,
     private val fishTankRepository: FishTankRepository,
+    private val authTokenProvider: AuthTokenProvider,
 ) : ApiTestConfig() {
 
     init {
@@ -307,5 +315,73 @@ class MemberControllerTest(
                 }
             }
         }
+
+        Given("회원 프로필을 수정할 때") {
+            val accessToken = signInAsMember().accessToken
+            bannedWordRepository.saveAll(
+                listOf(
+                    BannedWord(word = "금지 단어"),
+                )
+            )
+
+            When("닉네임을 입력하면") {
+                val request = UpdateProfileRequest(nickname = "변경된 닉네임")
+                val response = requestUpdateProfile(request, accessToken)
+
+                Then("회원의 닉네임을 수정한다") {
+                    assertSoftly {
+                        response.statusCode shouldBe NO_CONTENT.value()
+
+                        val updatedMember = memberRepository.findByIdOrThrow(1L)
+                        updatedMember.nickname.value shouldBe "변경된 닉네임"
+                    }
+                }
+            }
+
+            When("닉네임에 부적절한 단어가 들어가면") {
+                val request = UpdateProfileRequest(nickname = "금지 단어")
+                val response = requestUpdateProfile(request, accessToken)
+
+                Then("예외를 응답한다") {
+                    val errorResponse = response.`as`(ExceptionResponse::class.java)
+                    assertSoftly(response) {
+                        statusCode shouldBe BAD_REQUEST.value()
+                        errorResponse.message shouldBe CONTAINING_BANNED_WORD_NAME.errorMessage()
+                    }
+                }
+            }
+
+            When("이미 다른 회원이 사용중인 닉네임이라면") {
+                memberRepository.save(member(nickname = "변경된 닉네임"))
+                val request = UpdateProfileRequest(nickname = "변경된 닉네임")
+                val response = requestUpdateProfile(request, accessToken)
+
+                Then("예외를 응답한다") {
+                    val errorResponse = response.`as`(ExceptionResponse::class.java)
+                    assertSoftly(response) {
+                        statusCode shouldBe BAD_REQUEST.value()
+                        errorResponse.message shouldBe MemberExceptionType.ALREADY_EXIST_NICKNAME.errorMessage()
+                    }
+                }
+            }
+
+            When("회원이 존재하지 않으면") {
+                val request = UpdateProfileRequest(nickname = "변경된 닉네임")
+                val accessTokenOfNoExistMember = authTokenProvider.createLoginAuthToken(
+                    memberId = Long.MAX_VALUE,
+                    authority = Authority.MEMBER,
+                    issuedDate = Date()
+                ).getAccessToken()
+                val response = requestUpdateProfile(request, accessTokenOfNoExistMember)
+
+                Then("예외를 응답한다") {
+                    val errorResponse = response.`as`(ExceptionResponse::class.java)
+                    assertSoftly(response) {
+                        statusCode shouldBe NOT_FOUND.value()
+                        errorResponse.message shouldBe NOT_FOUND_MEMBER.errorMessage()
+                    }
+                }
+            }
+        }
     }
 }