Merge pull request #110 from NMNB-Team/v1/feat/#109-report-block-duplication-check

88dldl · web-flow · commit c17233893116 · 2025-08-14T19:59:31.000+09:00
[refactor] 신고/차단 중복 검증을 DB제약으로 변경
diff --git a/nmnb-application/src/main/kotlin/nmnb/application/domain/block/controller/BlockController.kt b/nmnb-application/src/main/kotlin/nmnb/application/domain/block/controller/BlockController.kt
@@ -27,7 +27,10 @@ class BlockController(
         summary = "사용자 차단 API",
         description = "사용자를 차단합니다. 차단한 사용자는 페이지에 조회되지 않습니다._숙희",
     )
-    @ApiResponses(ApiResponse(responseCode = "COMMON200", description = "성공입니다."))
+    @ApiResponses(
+        ApiResponse(responseCode = "COMMON200", description = "성공입니다."),
+        ApiResponse(responseCode = "BLOCK400", description = "이미 차단한적이 있습니다."),
+    )
     @PostMapping("/users/blocks")
     fun blockUser(
         @Parameter(name = "user", hidden = true) @AuthUser user: User,
diff --git a/nmnb-application/src/main/kotlin/nmnb/application/domain/block/service/UserBlockService.kt b/nmnb-application/src/main/kotlin/nmnb/application/domain/block/service/UserBlockService.kt
@@ -1,12 +1,14 @@
 package nmnb.application.domain.block.service
 
 import nmnb.application.domain.block.service.dto.request.UserBlockServiceRequest
+import nmnb.common.response.exception.BlockException
 import nmnb.common.response.exception.UserException
 import nmnb.common.response.status.ErrorStatus
 import nmnb.domain.block.Block
 import nmnb.domain.block.repository.BlockRepository
 import nmnb.domain.user.User
 import nmnb.domain.user.repository.UserRepository
+import org.springframework.dao.DataIntegrityViolationException
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 
@@ -18,20 +20,26 @@ class UserBlockService(
 ) {
     @Transactional
     fun block(user: User, request: UserBlockServiceRequest) {
-        val blockedUser = userRepository.findById(request.userId).orElseThrow {
-            UserException(ErrorStatus.USER_NOT_FOUND)
+        val blockedUser = getBlockedUser(request)
+
+        try {
+            blockRepository.save(Block(blocker = user, blockedUser = blockedUser))
+        } catch (e: DataIntegrityViolationException) {
+            throw BlockException(ErrorStatus.ALREADY_BLOCKED)
         }
-        blockRepository.save(Block(blocker = user, blockedUser = blockedUser))
     }
 
     @Transactional
     fun unBlock(user: User, request: UserBlockServiceRequest) {
-        val blockedUser = userRepository.findById(request.userId).orElseThrow {
-            UserException(ErrorStatus.USER_NOT_FOUND)
-        }
+        val blockedUser = getBlockedUser(request)
         blockRepository.findByBlockerAndBlockedUser(user, blockedUser)
             ?.let { block ->
                 blockRepository.delete(block)
             }
     }
+
+    private fun getBlockedUser(request: UserBlockServiceRequest): User =
+        userRepository.findById(request.userId).orElseThrow {
+            UserException(ErrorStatus.USER_NOT_FOUND)
+        }
 }
diff --git a/nmnb-application/src/main/kotlin/nmnb/application/domain/report/service/PostReportService.kt b/nmnb-application/src/main/kotlin/nmnb/application/domain/report/service/PostReportService.kt
@@ -21,7 +21,6 @@ class PostReportService(
     override fun validateReport(user: User, request: PostReportServiceRequest) {
         val post = fetchPost(request.targetId)
         validateNotSelfReport(user.id!!, post)
-        validateNotDuplicateReport(user, request.targetId)
     }
 
     private fun fetchPost(targetId: Long): Post {
@@ -39,15 +38,6 @@ class PostReportService(
         }
     }
 
-    private fun validateNotDuplicateReport(
-        reporter: User,
-        targetId: Long,
-    ) {
-        if (reportRepository.existsPostReport(reporter, targetId)) {
-            throw ReportException(ErrorStatus.ALREADY_REPORTED)
-        }
-    }
-
     override fun createReport(user: User, request: PostReportServiceRequest): PostReport {
         return PostReport(request.targetId, user, request.contentType)
     }
diff --git a/nmnb-application/src/main/kotlin/nmnb/application/domain/report/service/ReportService.kt b/nmnb-application/src/main/kotlin/nmnb/application/domain/report/service/ReportService.kt
@@ -1,14 +1,23 @@
 package nmnb.application.domain.report.service
 
+import nmnb.common.response.exception.ReportException
+import nmnb.common.response.status.ErrorStatus
 import nmnb.domain.report.Report
 import nmnb.domain.report.repository.ReportRepository
 import nmnb.domain.user.User
+import org.springframework.dao.DataIntegrityViolationException
 import org.springframework.transaction.annotation.Transactional
 
 abstract class ReportService<R : Report, Request>(
     private val reportRepository: ReportRepository,
 ) {
-    fun save(report: R) = reportRepository.save(report)
+    fun save(report: R) {
+        try {
+            reportRepository.save(report)
+        } catch (e: DataIntegrityViolationException) {
+            throw ReportException(ErrorStatus.ALREADY_REPORTED)
+        }
+    }
 
     @Transactional
     open fun report(user: User, request: Request) {
diff --git a/nmnb-application/src/main/kotlin/nmnb/application/domain/report/service/UserReportService.kt b/nmnb-application/src/main/kotlin/nmnb/application/domain/report/service/UserReportService.kt
@@ -20,7 +20,6 @@ class UserReportService(
     override fun validateReport(user: User, request: UserReportServiceRequest) {
         validateTarget(request.targetId)
         validateNotSelfReport(user.id!!, request.targetId)
-        validateNotDuplicateReport(user, request.targetId)
     }
 
     private fun validateTarget(targetId: String): User =
@@ -37,15 +36,6 @@ class UserReportService(
         }
     }
 
-    private fun validateNotDuplicateReport(
-        reporter: User,
-        targetId: String,
-    ) {
-        if (reportRepository.existsUserReport(reporter, targetId)) {
-            throw ReportException(ErrorStatus.ALREADY_REPORTED)
-        }
-    }
-
     override fun createReport(user: User, request: UserReportServiceRequest): UserReport =
         UserReport(request.targetId, user, request.contentType)
 }
diff --git a/nmnb-application/src/test/kotlin/nmnb/application/domain/report/service/PostReportServiceTest.kt b/nmnb-application/src/test/kotlin/nmnb/application/domain/report/service/PostReportServiceTest.kt
@@ -13,6 +13,7 @@ import nmnb.domain.user.User
 import nmnb.domain.user.repository.UserRepository
 import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
@@ -28,9 +29,13 @@ class PostReportServiceTest : IntegrationTestSupport() {
     @Autowired
     private lateinit var reportRepository: ReportRepository
 
-    @Autowired
     private lateinit var postReportService: PostReportService
 
+    @BeforeEach
+    fun setUp() {
+        postReportService = PostReportService(reportRepository, postRepository)
+    }
+
     @AfterEach
     fun tearDown() {
         reportRepository.deleteAllInBatch()
@@ -58,20 +63,16 @@ class PostReportServiceTest : IntegrationTestSupport() {
         assertThat(reportRepository.findAll()).hasSize(1)
     }
 
-    @DisplayName("중복 신고시 예외가 발생한다.")
+    @DisplayName("본인의 게시글을 신고할 시 예외가 발생한다.")
     @Test
-    fun postReportDuplicate() {
+    fun postReportSelf() {
         // given
-        val poster = User.fixture()
         val reporter = User.fixture()
-        userRepository.saveAll(listOf(poster, reporter))
+        userRepository.save(reporter)
 
-        val post = Post.fixture(user = poster)
+        val post = Post.fixture(user = reporter)
         postRepository.save(post)
 
-        val report = PostReport.fixture(post.id!!, reporter)
-        reportRepository.save(report)
-
         val request = PostReportServiceRequest(post.id!!, ContentType.SEXUAL)
 
         // when
@@ -80,28 +81,31 @@ class PostReportServiceTest : IntegrationTestSupport() {
         }
 
         // then
-        assertThat(exception.getCode()).isEqualTo(ErrorStatus.ALREADY_REPORTED)
-        assertThat(reportRepository.findAll()).hasSize(1)
+        assertThat(exception.getCode()).isEqualTo(ErrorStatus.CANNOT_REPORT_SELF)
     }
 
-    @DisplayName("본인의 게시글을 신고할 시 예외가 발생한다.")
+    @DisplayName("중복 신고시 예외가 발생한다.")
     @Test
-    fun postReportSelf() {
+    fun postReportDuplicate() {
         // given
+        val poster = User.fixture()
         val reporter = User.fixture()
-        userRepository.save(reporter)
+        userRepository.saveAll(listOf(poster, reporter))
 
-        val post = Post.fixture(user = reporter)
+        val post = Post.fixture(user = poster)
         postRepository.save(post)
 
-        val request = PostReportServiceRequest(post.id!!, ContentType.SEXUAL)
+        val report1 = PostReport.fixture(post.id!!, reporter)
+        val report2 = PostReport.fixture(post.id!!, reporter)
+        reportRepository.save(report1)
 
         // when
         val exception = assertThrows<ReportException> {
-            postReportService.validateReport(reporter, request)
+            postReportService.save(report2)
         }
 
         // then
-        assertThat(exception.getCode()).isEqualTo(ErrorStatus.CANNOT_REPORT_SELF)
+        assertThat(exception.getCode()).isEqualTo(ErrorStatus.ALREADY_REPORTED)
+        assertThat(reportRepository.findAll()).hasSize(1)
     }
 }
diff --git a/nmnb-application/src/test/kotlin/nmnb/application/domain/report/service/ReportServiceConcurrencyTest.kt b/nmnb-application/src/test/kotlin/nmnb/application/domain/report/service/ReportServiceConcurrencyTest.kt
@@ -0,0 +1,80 @@
+package nmnb.application.domain.report.service
+
+import nmnb.application.IntegrationTestSupport
+import nmnb.domain.post.Post
+import nmnb.domain.post.repository.PostRepository
+import nmnb.domain.report.PostReport
+import nmnb.domain.report.repository.ReportRepository
+import nmnb.domain.user.User
+import nmnb.domain.user.repository.UserRepository
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.DisplayName
+import org.junit.jupiter.api.Test
+import org.springframework.beans.factory.annotation.Autowired
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
+class ReportServiceConcurrencyTest : IntegrationTestSupport() {
+    @Autowired
+    private lateinit var userRepository: UserRepository
+
+    @Autowired
+    private lateinit var postRepository: PostRepository
+
+    @Autowired
+    private lateinit var reportRepository: ReportRepository
+
+    @Autowired
+    private lateinit var postReportService: PostReportService
+
+    @AfterEach
+    fun tearDown() {
+        reportRepository.deleteAllInBatch()
+        postRepository.deleteAllInBatch()
+        userRepository.deleteAllInBatch()
+    }
+
+    @DisplayName("동일 게시글 신고 요청 시 중복 등록되지 않는다.")
+    @Test
+    fun report() {
+        // given
+        val threadCount = 10
+
+        val poster = User.fixture()
+        val reporter = User.fixture()
+        userRepository.saveAll(listOf(poster, reporter))
+
+        val post = Post.fixture(user = poster)
+        postRepository.save(post)
+
+        val report = PostReport.fixture(post.id!!, reporter)
+        reportRepository.save(report)
+
+        // when
+        val executorService = Executors.newFixedThreadPool(threadCount)
+        val latch = CountDownLatch(threadCount)
+
+        try {
+            repeat(threadCount) {
+                executorService.submit {
+                    try {
+                        postReportService.save(report)
+                    } finally {
+                        latch.countDown()
+                    }
+                }
+            }
+
+            latch.await()
+        } finally {
+            executorService.shutdown()
+            executorService.awaitTermination(1, TimeUnit.MINUTES)
+        }
+
+        // then
+        val allReport = reportRepository.findAll()
+        assertThat(allReport).hasSize(1)
+    }
+}
diff --git a/nmnb-application/src/test/kotlin/nmnb/application/domain/report/service/UserReportServiceTest.kt b/nmnb-application/src/test/kotlin/nmnb/application/domain/report/service/UserReportServiceTest.kt
@@ -11,6 +11,7 @@ import nmnb.domain.user.User
 import nmnb.domain.user.repository.UserRepository
 import org.assertj.core.api.Assertions
 import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.api.DisplayName
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.assertThrows
@@ -23,9 +24,13 @@ class UserReportServiceTest : IntegrationTestSupport() {
     @Autowired
     private lateinit var reportRepository: ReportRepository
 
-    @Autowired
     private lateinit var userReportService: UserReportService
 
+    @BeforeEach
+    fun setUp() {
+        userReportService = UserReportService(reportRepository, userRepository)
+    }
+
     @AfterEach
     fun tearDown() {
         reportRepository.deleteAllInBatch()
@@ -70,20 +75,18 @@ class UserReportServiceTest : IntegrationTestSupport() {
     @DisplayName("사용자를 중복 신고할 시 예외가 발생한다.")
     @Test
     fun userReportDuplicate() {
-        // given
         // given
         val poster = User.fixture()
         val reporter = User.fixture()
         userRepository.saveAll(listOf(poster, reporter))
 
-        val report = UserReport.fixture(poster.id!!, reporter)
-        reportRepository.save(report)
-
-        val request = UserReportServiceRequest(poster.id!!, ContentType.SEXUAL)
+        val report1 = UserReport.fixture(poster.id!!, reporter)
+        val report2 = UserReport.fixture(poster.id!!, reporter)
+        reportRepository.save(report1)
 
         // when
         val exception = assertThrows<ReportException> {
-            userReportService.validateReport(reporter, request)
+            userReportService.save(report2)
         }
 
         // then
diff --git a/nmnb-common/src/main/kotlin/nmnb/common/response/exception/BlockException.kt b/nmnb-common/src/main/kotlin/nmnb/common/response/exception/BlockException.kt
@@ -0,0 +1,5 @@
+package nmnb.common.response.exception
+
+import nmnb.common.response.base.BaseErrorCode
+
+class BlockException(code: BaseErrorCode) : GeneralException(code)
diff --git a/nmnb-common/src/main/kotlin/nmnb/common/response/status/ErrorStatus.kt b/nmnb-common/src/main/kotlin/nmnb/common/response/status/ErrorStatus.kt
@@ -47,6 +47,9 @@ enum class ErrorStatus(
     INVALID_POST_TARGET_ID(HttpStatus.NOT_FOUND, "REPORT401", "유효한 Post 아이디가 아닙니다."),
     CANNOT_REPORT_SELF(HttpStatus.BAD_REQUEST, "REPORT402", "본인을 신고할 수 없습니다."),
     ALREADY_REPORTED(HttpStatus.BAD_REQUEST, "REPORT403", "이미 신고한적이 있습니다."),
+
+    // BLOCK
+    ALREADY_BLOCKED(HttpStatus.BAD_REQUEST, "BLOCK400", "이미 차단한적이 있습니다."),
     ;
 
     override fun getReasonHttpStatus(): ErrorReasonDTO {
diff --git a/nmnb-domain/src/main/kotlin/nmnb/domain/report/Report.kt b/nmnb-domain/src/main/kotlin/nmnb/domain/report/Report.kt
@@ -15,11 +15,18 @@ import jakarta.persistence.InheritanceType
 import jakarta.persistence.JoinColumn
 import jakarta.persistence.ManyToOne
 import jakarta.persistence.Table
+import jakarta.persistence.UniqueConstraint
 import nmnb.domain.JpaBaseEntity
 import nmnb.domain.user.User
 
 @Entity
-@Table(name = "reports")
+@Table(
+    name = "reports",
+    uniqueConstraints = [
+        UniqueConstraint(columnNames = ["user_id", "target_post_id"]),
+        UniqueConstraint(columnNames = ["user_id", "target_user_id"]),
+    ],
+)
 @Inheritance(strategy = InheritanceType.SINGLE_TABLE)
 @DiscriminatorColumn(name = "report_type", discriminatorType = DiscriminatorType.STRING)
 abstract class Report(
diff --git a/nmnb-domain/src/main/kotlin/nmnb/domain/report/repository/ReportRepository.kt b/nmnb-domain/src/main/kotlin/nmnb/domain/report/repository/ReportRepository.kt

Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,6 @@ class PostReportService(`
`21`	`21`	`override fun validateReport(user: User, request: PostReportServiceRequest) {`
`22`	`22`	`val post = fetchPost(request.targetId)`
`23`	`23`	`validateNotSelfReport(user.id!!, post)`
`24`		`- validateNotDuplicateReport(user, request.targetId)`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`private fun fetchPost(targetId: Long): Post {`
`@@ -39,15 +38,6 @@ class PostReportService(`
`39`	`38`	`}`
`40`	`39`	`}`
`41`	`40`
`42`		`- private fun validateNotDuplicateReport(`
`43`		`- reporter: User,`
`44`		`- targetId: Long,`
`45`		`- ) {`
`46`		`- if (reportRepository.existsPostReport(reporter, targetId)) {`
`47`		`- throw ReportException(ErrorStatus.ALREADY_REPORTED)`
`48`		`- }`
`49`		`- }`
`50`		`-`
`51`	`41`	`override fun createReport(user: User, request: PostReportServiceRequest): PostReport {`
`52`	`42`	`return PostReport(request.targetId, user, request.contentType)`
`53`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@ class UserReportService(`
`20`	`20`	`override fun validateReport(user: User, request: UserReportServiceRequest) {`
`21`	`21`	`validateTarget(request.targetId)`
`22`	`22`	`validateNotSelfReport(user.id!!, request.targetId)`
`23`		`- validateNotDuplicateReport(user, request.targetId)`
`24`	`23`	`}`
`25`	`24`
`26`	`25`	`private fun validateTarget(targetId: String): User =`
`@@ -37,15 +36,6 @@ class UserReportService(`
`37`	`36`	`}`
`38`	`37`	`}`
`39`	`38`
`40`		`- private fun validateNotDuplicateReport(`
`41`		`- reporter: User,`
`42`		`- targetId: String,`
`43`		`- ) {`
`44`		`- if (reportRepository.existsUserReport(reporter, targetId)) {`
`45`		`- throw ReportException(ErrorStatus.ALREADY_REPORTED)`
`46`		`- }`
`47`		`- }`
`48`		`-`
`49`	`39`	`override fun createReport(user: User, request: UserReportServiceRequest): UserReport =`
`50`	`40`	`UserReport(request.targetId, user, request.contentType)`
`51`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,6 +47,9 @@ enum class ErrorStatus(`
`47`	`47`	`INVALID_POST_TARGET_ID(HttpStatus.NOT_FOUND, "REPORT401", "유효한 Post 아이디가 아닙니다."),`
`48`	`48`	`CANNOT_REPORT_SELF(HttpStatus.BAD_REQUEST, "REPORT402", "본인을 신고할 수 없습니다."),`
`49`	`49`	`ALREADY_REPORTED(HttpStatus.BAD_REQUEST, "REPORT403", "이미 신고한적이 있습니다."),`
	`50`	`+`
	`51`	`+ // BLOCK`
	`52`	`+ ALREADY_BLOCKED(HttpStatus.BAD_REQUEST, "BLOCK400", "이미 차단한적이 있습니다."),`
`50`	`53`	`;`
`51`	`54`
`52`	`55`	`override fun getReasonHttpStatus(): ErrorReasonDTO {`