fix: solve user update error

src/main/kotlin/uoslife/servermeeting/user/command/UserCommand.kt

@@ -2,7 +2,6 @@ package uoslife.servermeeting.user.command
 
 import uoslife.servermeeting.user.entity.enums.AppearanceType
 import uoslife.servermeeting.user.entity.enums.EyelidType
-import uoslife.servermeeting.user.entity.enums.GenderType
 import uoslife.servermeeting.user.entity.enums.SmokingType
 
 class UserCommand {
@@ -24,7 +23,6 @@ class UserCommand {
         val userId: Long,
         val name: String?,
         val phoneNumber: String?,
-        val gender: GenderType?,
         val kakaoTalkId: String?,
     )
 }

src/main/kotlin/uoslife/servermeeting/user/dao/UserDao.kt

@@ -5,7 +5,6 @@ import org.springframework.stereotype.Repository
 import uoslife.servermeeting.payment.entity.Payment
 import uoslife.servermeeting.payment.entity.QPayment.payment
 import uoslife.servermeeting.payment.entity.enums.PaymentStatus
-import uoslife.servermeeting.user.command.UserCommand
 import uoslife.servermeeting.user.entity.QUser.user
 import uoslife.servermeeting.user.entity.QUserInformation.userInformation
 import uoslife.servermeeting.user.entity.User
@@ -27,36 +26,9 @@ class UserDao(
     fun findUserProfile(userId: Long): User? {
         return queryFactory
             .selectFrom(user)
-            .join(userInformation)
-            .on(userInformation.user.eq(user))
-            .where(user.id.eq(userId))
+            .leftJoin(user.userInformation, userInformation)
             .fetchJoin()
+            .where(user.id.eq(userId))
             .fetchOne()
     }
-
-    fun updateUserInformation(command: UserCommand.UpdateUserInformation): Long {
-
-        val jpaClause =
-            queryFactory.update(userInformation).where(userInformation.user.id.eq(command.userId))
-
-        command.smoking?.let { jpaClause.set(userInformation.smoking, it) }
-        command.mbti?.let { jpaClause.set(userInformation.mbti, it) }
-        command.interest?.let { jpaClause.set(userInformation.interest, it) }
-        command.height?.let { jpaClause.set(userInformation.height, it) }
-        command.age?.let { jpaClause.set(userInformation.age, it) }
-        command.studentNumber?.let { jpaClause.set(userInformation.studentNumber, it) }
-        command.department?.let { jpaClause.set(userInformation.department, it) }
-        command.eyelidType?.let { jpaClause.set(userInformation.eyelidType, it) }
-        command.appearanceType?.let { jpaClause.set(userInformation.appearanceType, it) }
-        return jpaClause.execute()
-    }
-
-    fun updateUserPersonalInformation(command: UserCommand.UpdateUserPersonalInformation): Long {
-        val jpaClause = queryFactory.update(user).where(user.id.eq(command.userId))
-        command.name?.let { jpaClause.set(user.name, it) }
-        command.phoneNumber?.let { jpaClause.set(user.phoneNumber, it) }
-        command.gender?.let { jpaClause.set(user.gender, it) }
-        command.kakaoTalkId?.let { jpaClause.set(user.kakaoTalkId, it) }
-        return jpaClause.execute()
-    }
 }

src/main/kotlin/uoslife/servermeeting/user/dto/request/UserPersonalInformationUpdateRequest.kt

@@ -22,7 +22,6 @@ data class UserPersonalInformationUpdateRequest(
             name = this.name,
             phoneNumber = this.phoneNumber,
             kakaoTalkId = this.kakaoTalkId,
-            gender = this.genderType,
         )
     }
 }

src/main/kotlin/uoslife/servermeeting/user/service/UserService.kt

@@ -18,8 +18,10 @@ import uoslife.servermeeting.user.command.UserCommand
 import uoslife.servermeeting.user.dao.UserDao
 import uoslife.servermeeting.user.dto.response.UserBranchResponse
 import uoslife.servermeeting.user.entity.User
+import uoslife.servermeeting.user.entity.UserInformation
 import uoslife.servermeeting.user.exception.KakaoTalkIdDuplicationException
 import uoslife.servermeeting.user.exception.UserNotFoundException
+import uoslife.servermeeting.user.repository.UserInformationRepository
 import uoslife.servermeeting.user.repository.UserRepository
 
 @Service
@@ -28,6 +30,7 @@ class UserService(
     private val userRepository: UserRepository,
     @Qualifier("portOneService") private val paymentService: PaymentService,
     private val userTeamRepository: UserTeamRepository,
+    private val userInformationRepository: UserInformationRepository,
     private val userDao: UserDao,
     private val userTeamDao: UserTeamDao,
     private val validator: Validator,
@@ -58,17 +61,17 @@ class UserService(
     @Transactional
     fun updateUserInformation(command: UserCommand.UpdateUserInformation): User {
         command.mbti = validator.setValidMBTI(command.mbti)
-        val updated: Long = userDao.updateUserInformation(command)
-        return userDao.findUserProfile(command.userId) ?: throw UserNotFoundException()
+        val user = userRepository.findByIdOrNull(command.userId) ?: throw UserNotFoundException()
+        return upsertUserInformation(user, command)
     }
 
     @Transactional
     fun updateUserPersonalInformation(command: UserCommand.UpdateUserPersonalInformation): User {
         if (command.kakaoTalkId != null) {
             isDuplicatedKakaoTalkId(command.kakaoTalkId)
         }
-        val updateUserPersonalInformation = userDao.updateUserPersonalInformation(command)
-        return userRepository.findByIdOrNull(command.userId) ?: throw UserNotFoundException()
+        val user = userRepository.findByIdOrNull(command.userId) ?: throw UserNotFoundException()
+        return updateUserProfile(user, command)
     }
 
     /**
@@ -113,6 +116,41 @@ class UserService(
         return true
     }
 
+    private fun upsertUserInformation(
+        user: User,
+        command: UserCommand.UpdateUserInformation
+    ): User {
+        val existingUserInfo =
+            if (user.userInformation == null) {
+                user.userInformation = userInformationRepository.save(UserInformation(user = user))
+                user.userInformation
+            } else {
+                user.userInformation
+            }
+
+        existingUserInfo?.smoking = command.smoking ?: existingUserInfo?.smoking
+        existingUserInfo?.mbti = command.mbti ?: existingUserInfo?.mbti
+        existingUserInfo?.interest = command.interest ?: existingUserInfo?.interest
+        existingUserInfo?.height = command.height ?: existingUserInfo?.height
+        existingUserInfo?.age = command.age ?: existingUserInfo?.age
+        existingUserInfo?.studentNumber = command.studentNumber ?: existingUserInfo?.studentNumber
+        existingUserInfo?.department = command.department ?: existingUserInfo?.department
+        existingUserInfo?.eyelidType = command.eyelidType ?: existingUserInfo?.eyelidType
+        existingUserInfo?.appearanceType =
+            command.appearanceType ?: existingUserInfo?.appearanceType
+        return user
+    }
+
+    private fun updateUserProfile(
+        user: User,
+        command: UserCommand.UpdateUserPersonalInformation
+    ): User {
+        user.name = command.name ?: user.name
+        user.phoneNumber = command.phoneNumber ?: user.phoneNumber
+        user.kakaoTalkId = command.kakaoTalkId ?: user.kakaoTalkId
+        return user
+    }
+
     fun getUserMeetingTeamBranch(userId: Long): UserBranchResponse {
         val user = userRepository.findByIdOrNull(userId) ?: throw UserNotFoundException()
 

src/test/kotlin/uoslife/servermeeting/domain/user/service/UserIntegrationTest.kt

@@ -0,0 +1,168 @@
+package uoslife.servermeeting.domain.user.service
+
+import com.querydsl.jpa.impl.JPAQueryFactory
+import io.kotest.core.spec.style.BehaviorSpec
+import io.kotest.extensions.spring.SpringExtension
+import io.kotest.matchers.shouldBe
+import io.mockk.mockk
+import jakarta.persistence.EntityManager
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
+import org.springframework.test.annotation.Rollback
+import uoslife.servermeeting.meetingteam.dao.UserTeamDao
+import uoslife.servermeeting.meetingteam.repository.UserTeamRepository
+import uoslife.servermeeting.meetingteam.service.BaseMeetingService
+import uoslife.servermeeting.meetingteam.util.Validator
+import uoslife.servermeeting.payment.service.PaymentService
+import uoslife.servermeeting.user.command.UserCommand
+import uoslife.servermeeting.user.dao.UserDao
+import uoslife.servermeeting.user.entity.User
+import uoslife.servermeeting.user.entity.enums.AppearanceType
+import uoslife.servermeeting.user.entity.enums.EyelidType
+import uoslife.servermeeting.user.entity.enums.SmokingType
+import uoslife.servermeeting.user.repository.UserInformationRepository
+import uoslife.servermeeting.user.repository.UserRepository
+import uoslife.servermeeting.user.service.UserService
+
+@DataJpaTest(showSql = true)
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+@Rollback(true)
+internal class UserIntegrationTest
+@Autowired
+constructor(
+    private val userRepository: UserRepository,
+    private val userTeamRepository: UserTeamRepository,
+    private val userInformationRepository: UserInformationRepository,
+    private val entityManager: EntityManager
+) : BehaviorSpec() {
+
+    override fun extensions() = listOf(SpringExtension)
+    init {
+        val jpaQueryFactory = JPAQueryFactory(entityManager)
+        val userDao = UserDao(jpaQueryFactory)
+        val paymentService = mockk<PaymentService>()
+        val userTeamDao = mockk<UserTeamDao>()
+        val meetingService = mockk<BaseMeetingService>()
+        val userService =
+            UserService(
+                userRepository = userRepository,
+                userInformationRepository = userInformationRepository,
+                paymentService = paymentService,
+                userTeamRepository = userTeamRepository,
+                userDao = userDao,
+                validator = Validator(),
+                userTeamDao = userTeamDao,
+                singleMeetingService = meetingService,
+                tripleMeetingService = meetingService
+            )
+
+        given("유저가 생성되었을때") {
+            val savedUser = userRepository.saveAllAndFlush(users)
+
+            `when`("유저 info 업데이트 정보 요청이 들어오면") {
+                then("업데이트를 한다") {
+                    val firstUser = userService.updateUserInformation(initUserInformationCommand)
+                    entityManager.flush()
+
+                    firstUser.userInformation?.mbti shouldBe "INTJ"
+                    firstUser.userInformation?.interest shouldBe listOf("운동", "독서")
+                    firstUser.userInformation?.height shouldBe 180
+                    firstUser.userInformation?.age shouldBe 25
+                    firstUser.userInformation?.studentNumber shouldBe 2020830018
+                    firstUser.userInformation?.department shouldBe "컴퓨터공학과"
+                    firstUser.userInformation?.eyelidType shouldBe EyelidType.DOUBLE
+                    firstUser.userInformation?.appearanceType shouldBe AppearanceType.ARAB
+                }
+            }
+            `when`("유저 프로파일 업데이트 요청이 들어오면") {
+                then("업데이트를 한다") {
+                    val firstUser =
+                        userService.updateUserPersonalInformation(initUserProfileCommand)
+                    entityManager.flush()
+
+                    firstUser.name shouldBe "석우진"
+                    firstUser.phoneNumber shouldBe "010-1234-5678"
+                    firstUser.kakaoTalkId shouldBe "seok"
+                }
+            }
+            `when`("유저 정보가 이미 있을때") {
+                userService.updateUserPersonalInformation(initUserProfileCommand)
+                userService.updateUserInformation(initUserInformationCommand)
+
+                then("userInformation을 업데이트한다") {
+                    val firstUser =
+                        userService.updateUserInformation(updateUserPersonalInformationCommand)
+                    entityManager.flush()
+
+                    firstUser.userInformation?.smoking shouldBe SmokingType.E_CIGARETTE
+                    firstUser.userInformation?.mbti shouldBe "ENTP"
+                    firstUser.userInformation?.interest shouldBe listOf("수영", "코딩")
+                    firstUser.userInformation?.height shouldBe 185
+                    firstUser.userInformation?.age shouldBe 23
+                    firstUser.userInformation?.studentNumber shouldBe 2023830018
+                    firstUser.userInformation?.department shouldBe "전자전기컴퓨터공학부"
+                    firstUser.userInformation?.eyelidType shouldBe EyelidType.SINGLE
+                    firstUser.userInformation?.appearanceType shouldBe AppearanceType.TOFU
+                }
+                then("userProfile을 업데이트한다") {
+                    val firstUser =
+                        userService.updateUserPersonalInformation(initUserProfileCommand)
+                    entityManager.flush()
+
+                    firstUser.name shouldBe "석우진"
+                    firstUser.phoneNumber shouldBe "010-1234-5678"
+                    firstUser.kakaoTalkId shouldBe "seok"
+                }
+            }
+        }
+    }
+
+    companion object {
+        private val users =
+            listOf(
+                User(name = "석우진", email = "[email protected]"),
+                User(name = "최동준", email = "[email protected]"),
+            )
+        private val initUserInformationCommand =
+            UserCommand.UpdateUserInformation(
+                userId = 1L,
+                smoking = SmokingType.FALSE,
+                mbti = "INTJ",
+                interest = listOf("운동", "독서"),
+                height = 180,
+                age = 25,
+                studentNumber = 2020830018,
+                department = "컴퓨터공학과",
+                eyelidType = EyelidType.DOUBLE,
+                appearanceType = AppearanceType.ARAB,
+            )
+        private val initUserProfileCommand =
+            UserCommand.UpdateUserPersonalInformation(
+                userId = 1L,
+                name = "석우진",
+                phoneNumber = "010-1234-5678",
+                kakaoTalkId = "seok"
+            )
+        private val updateUserPersonalInformationCommand =
+            UserCommand.UpdateUserInformation(
+                userId = 1L,
+                smoking = SmokingType.E_CIGARETTE,
+                mbti = "ENTP",
+                interest = listOf("수영", "코딩"),
+                height = 185,
+                age = 23,
+                studentNumber = 2023830018,
+                department = "전자전기컴퓨터공학부",
+                eyelidType = EyelidType.SINGLE,
+                appearanceType = AppearanceType.TOFU,
+            )
+        private val updateUserProfileCommand =
+            UserCommand.UpdateUserPersonalInformation(
+                userId = 1L,
+                name = "석우진",
+                phoneNumber = "010-9006-8420",
+                kakaoTalkId = "seok"
+            )
+    }
+}