refactor: repository 테스트 코드 추가 구현

module-infrastructure/persistence-db/src/test/kotlin/site/yourevents/guest/repository/GuestRepositoryTest.kt

@@ -1,6 +1,7 @@
 package site.yourevents.guest.repository
 
 import io.kotest.core.spec.style.DescribeSpec
+import io.kotest.matchers.nulls.shouldNotBeNull
 import io.kotest.matchers.shouldBe
 import org.springframework.beans.factory.annotation.Autowired
 import org.springframework.boot.jdbc.EmbeddedDatabaseConnection
@@ -13,6 +14,7 @@ import site.yourevents.invitation.repository.InvitationJPARepository
 import site.yourevents.member.domain.MemberVO
 import site.yourevents.member.entity.MemberEntity
 import site.yourevents.member.repository.MemberJPARepository
+import java.util.*
 
 @ActiveProfiles("test")
 @DataJpaTest
@@ -61,7 +63,7 @@ class GuestRepositoryTest(
     }
 
     describe("GuestRepository") {
-        context("save() 메서드에서") {
+        context("save(GuestVo) 메서드에서") {
             it("GuestVO를 저장하고 반환해야 한다") {
                 val savedGuest = guestRepository.save(guestVO)
 
@@ -73,6 +75,212 @@ class GuestRepositoryTest(
             }
         }
 
+        context("save(Guest) 메서드에서") {
+            it("Guest를 저장한 후 findById로 조회 가능해야 한다") {
+                val savedGuest = guestRepository.save(guestVO)
+                guestRepository.save(savedGuest)
+
+                val foundGuest = guestRepository.findById(savedGuest.id)
+                foundGuest.shouldNotBeNull()
+                foundGuest.id shouldBe savedGuest.id
+            }
+        }
+
+        context("findById() 메서드에서") {
+            it("저장된 Guest의 id로 조회 시 Guest를 반환해야 한다") {
+                val savedGuest = guestRepository.save(guestVO)
+                val foundGuest = guestRepository.findById(savedGuest.id)
+                foundGuest.shouldNotBeNull()
+                foundGuest.id shouldBe savedGuest.id
+            }
+
+            it("존재하지 않는 id로 조회 시 null을 반환해야 한다") {
+                val nothing = UUID.randomUUID()
+                val foundGuest = guestRepository.findById(nothing)
+                foundGuest shouldBe null
+            }
+        }
+
+        context("getReceivedInvitationCount() 메서드에서") {
+            it("member가 받은 초대 수를 반환해야 한다") {
+                val guestMemberEntity = MemberEntity.from(
+                    MemberVO(
+                        socialId = "6316",
+                        nickname = "seunghyun",
+                        email = "seunghyun@example.com"
+                    )
+                )
+                memberJPARepository.save(guestMemberEntity)
+
+                val guestVOForCount = GuestVO(
+                    member = guestMemberEntity.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "nickname",
+                    attendance = true
+                )
+                guestRepository.save(guestVOForCount)
+
+                val count = guestRepository.getReceivedInvitationCount(guestMemberEntity.toDomain())
+                count shouldBe 1
+            }
+
+            it("member가 받은 초대가 없으면 0을 반환해야 한다") {
+                val otherMemberEntity = MemberEntity.from(
+                    MemberVO(
+                        socialId = "2002",
+                        nickname = "otherUser",
+                        email = "other@example.com"
+                    )
+                )
+                memberJPARepository.save(otherMemberEntity)
+                val count = guestRepository.getReceivedInvitationCount(otherMemberEntity.toDomain())
+                count shouldBe 0
+            }
+        }
+
+        context("getReceivedInvitations() 메서드에서") {
+            it("member가 받은 초대 목록을 반환해야 한다") {
+                val guestMemberEntity = MemberEntity.from(
+                    MemberVO(
+                        socialId = "6316",
+                        nickname = "seunghyun",
+                        email = "seunghyun@example.com"
+                    )
+                )
+                memberJPARepository.save(guestMemberEntity)
+
+                val guestVOForInvitation = GuestVO(
+                    member = guestMemberEntity.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "nickname",
+                    attendance = true
+                )
+                guestRepository.save(guestVOForInvitation)
+
+                val invitations = guestRepository.getReceivedInvitations(guestMemberEntity.toDomain())
+                invitations.size shouldBe 1
+                invitations.first().id shouldBe invitationEntity.id
+            }
+        }
+
+        context("findAttendGuestsByInvitation() 메서드에서") {
+            it("초대에 참석하는 Guest 목록을 반환해야 한다") {
+                val guestMember1 = MemberEntity.from(
+                    MemberVO("1", "1", "1")
+                )
+                val guestMember2 = MemberEntity.from(
+                    MemberVO("2", "2", "2")
+                )
+                memberJPARepository.save(guestMember1)
+                memberJPARepository.save(guestMember2)
+
+                val guestVO1 = GuestVO(
+                    member = guestMember1.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "1",
+                    attendance = true
+                )
+                val guestVO2 = GuestVO(
+                    member = guestMember2.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "2",
+                    attendance = true
+                )
+                val guestVO3 = GuestVO(
+                    member = memberEntity.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "not",
+                    attendance = false
+                )
+                guestRepository.save(guestVO1)
+                guestRepository.save(guestVO2)
+                guestRepository.save(guestVO3)
+
+                val attendGuests = guestRepository.findAttendGuestsByInvitation(invitationEntity.toDomain())
+                attendGuests.size shouldBe 2
+                attendGuests.all { it.attendance } shouldBe true
+            }
+        }
+
+        context("findNotAttendGuestsByInvitation() 메서드에서") {
+            it("초대에 참석하지 않는 Guest 목록을 반환해야 한다") {
+                val guestMember1 = MemberEntity.from(
+                    MemberVO("1", "1", "1")
+                )
+                val guestMember2 = MemberEntity.from(
+                    MemberVO("2", "2", "2")
+                )
+                memberJPARepository.save(guestMember1)
+                memberJPARepository.save(guestMember2)
+
+                val guestVO1 = GuestVO(
+                    member = guestMember1.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "1",
+                    attendance = false
+                )
+                val guestVO2 = GuestVO(
+                    member = guestMember2.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "2",
+                    attendance = false
+                )
+                val guestVO3 = GuestVO(
+                    member = memberEntity.toDomain(),
+                    invitation = invitationEntity.toDomain(),
+                    nickname = "yes",
+                    attendance = true
+                )
+                guestRepository.save(guestVO1)
+                guestRepository.save(guestVO2)
+                guestRepository.save(guestVO3)
+
+                val notAttendGuests = guestRepository.findNotAttendGuestsByInvitation(invitationEntity.toDomain())
+                notAttendGuests.size shouldBe 2
+                notAttendGuests.all { !it.attendance } shouldBe true
+            }
+        }
+
+        context("findAttendanceByMemberIdAndInvitationId() 메서드에서") {
+            it("Guest가 존재하면 attendance 값을 반환해야 한다") {
+                val savedGuest = guestRepository.save(guestVO)
+                val attendance = guestRepository.findAttendanceByMemberIdAndInvitationId(
+                    savedGuest.member.id,
+                    savedGuest.invitation.id
+                )
+                attendance.shouldNotBeNull()
+                attendance shouldBe savedGuest.attendance
+            }
+
+            it("Guest가 존재하지 않으면 null을 반환해야 한다") {
+                val attendance = guestRepository.findAttendanceByMemberIdAndInvitationId(
+                    UUID.randomUUID(),
+                    UUID.randomUUID()
+                )
+                attendance shouldBe null
+            }
+        }
+
+        context("findNicknameByInvitationIdAndMemberId() 메서드에서") {
+            it("Guest가 존재하면 nickname을 반환해야 한다") {
+                val savedGuest = guestRepository.save(guestVO)
+                val nickname = guestRepository.findNicknameByInvitationIdAndMemberId(
+                    savedGuest.invitation.id,
+                    savedGuest.member.id
+                )
+                nickname.shouldNotBeNull()
+                nickname shouldBe savedGuest.nickname
+            }
+
+            it("Guest가 존재하지 않으면 null을 반환해야 한다") {
+                val nickname = guestRepository.findNicknameByInvitationIdAndMemberId(
+                    invitationEntity.id!!,
+                    memberEntity.id!!
+                )
+                nickname shouldBe null
+            }
+        }
+
         context("findIdByMemberIdAndInvitationId() 메서드에서") {
             it("Guest가 존재하면 guestId를 반환해야 한다.") {
                 val savedGuest = guestRepository.save(guestVO)

module-infrastructure/persistence-db/src/test/kotlin/site/yourevents/invitation/repository/InvitationRepositoryTest.kt

@@ -8,6 +8,7 @@ import org.springframework.boot.jdbc.EmbeddedDatabaseConnection
 import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
 import org.springframework.test.context.ActiveProfiles
+import site.yourevents.invitation.domain.InvitationVO
 import site.yourevents.invitation.entity.InvitationEntity
 import site.yourevents.member.domain.MemberVO
 import site.yourevents.member.entity.MemberEntity
@@ -19,7 +20,7 @@ import java.util.*
 @AutoConfigureTestDatabase(connection = EmbeddedDatabaseConnection.H2, replace = AutoConfigureTestDatabase.Replace.NONE)
 class InvitationRepositoryTest(
     @Autowired private val invitationJPARepository: InvitationJPARepository,
-    @Autowired private val memberJPARepository: MemberJPARepository
+    @Autowired private val memberJPARepository: MemberJPARepository,
 ) : DescribeSpec({
     val invitationRepository = InvitationRepository(invitationJPARepository)
 
@@ -79,6 +80,87 @@ class InvitationRepositoryTest(
             }
         }
 
+        context("save(invitationVO) 메서드에서") {
+            it("InvitationVO를 받아 Invitation을 저장해야 한다") {
+                val newQrUrl = "http://new-example.com"
+                val newTemplateKey = "newTemplate"
+                val invitationVO = InvitationVO.of(
+                    member = memberEntity.toDomain(),
+                    qrUrl = newQrUrl,
+                    templateKey = newTemplateKey,
+                    deleted = false
+                )
+
+                val savedInvitation = invitationRepository.save(invitationVO)
+                savedInvitation shouldNotBe null
+                savedInvitation.qrUrl shouldBe newQrUrl
+                savedInvitation.templateKey shouldBe newTemplateKey
+                savedInvitation.deleted shouldBe false
+            }
+        }
+
+        context("save(invitation) 메서드에서") {
+            it("Invitation 객체를 받아 저장 및 업데이트가 가능해야 한다") {
+                val invitation = invitationRepository.findById(invitationId)
+                invitation shouldNotBe null
+
+                val updatedQrUrl = "http://updated.com"
+                invitation!!.updateQrCode(updatedQrUrl)
+                val updatedInvitation = invitationRepository.save(invitation)
+                updatedInvitation.qrUrl shouldBe updatedQrUrl
+            }
+        }
+
+        context("findByMember() 메서드에서") {
+            it("주어진 member에 해당하는 Invitation 목록을 반환해야 한다") {
+                val invitations = invitationRepository.findByMember(memberEntity.toDomain())
+                invitations.size shouldBe 2
+
+                val newInvitationVO = InvitationVO.of(
+                    member = memberEntity.toDomain(),
+                    qrUrl = "http://new-example.com",
+                    templateKey = "newTemplate",
+                    deleted = false
+                )
+                invitationRepository.save(newInvitationVO)
+
+                val updatedInvitations = invitationRepository.findByMember(memberEntity.toDomain())
+                updatedInvitations.size shouldBe 3
+            }
+        }
+
+        context("countByMember() 메서드에서") {
+            it("주어진 member에 해당하는 Invitation 개수를 반환해야 한다") {
+                val countBefore = invitationRepository.countByMember(memberEntity.toDomain())
+
+                val newInvitationVO = InvitationVO.of(
+                    member = memberEntity.toDomain(),
+                    qrUrl = "http://count-example.com",
+                    templateKey = "countTemplate",
+                    deleted = false
+                )
+                invitationRepository.save(newInvitationVO)
+
+                val countAfter = invitationRepository.countByMember(memberEntity.toDomain())
+                countAfter shouldBe (countBefore + 1)
+            }
+        }
+
+        context("getOwnerId() 메서드에서") {
+            it("주어진 invitationId에 대해 올바른 ownerId(memberId)를 반환해야 한다") {
+                val invitationVO = InvitationVO.of(
+                    member = memberEntity.toDomain(),
+                    qrUrl = "http://owner-example.com",
+                    templateKey = "ownerTemplate",
+                    deleted = false
+                )
+                val savedInvitation = invitationRepository.save(invitationVO)
+
+                val ownerId = invitationRepository.getOwnerId(savedInvitation.id)
+                ownerId shouldBe memberEntity.id
+            }
+        }
+
         context("delete() 메서드에서") {
             it("존재하는 Invitation을 삭제(soft delete)해야 한다") {
                 val invitationBeforeDelete = invitationRepository.findById(invitationId)