테스트 기록 초기화 API를 구현한다. (#104)

feat: implement exam history delete API

Author: earlgrey02

api/src/main/kotlin/com/gotchai/api/presentation/v1/admin/AdminController.kt

@@ -4,7 +4,9 @@ import com.gotchai.api.global.annotation.ApiV1Controller
 import com.gotchai.api.presentation.v1.admin.request.CreateExamRequest
 import com.gotchai.api.presentation.v1.exam.response.ExamResponse
 import com.gotchai.domain.admin.port.`in`.AdminCommandUseCase
+import org.springframework.web.bind.annotation.DeleteMapping
 import org.springframework.web.bind.annotation.ModelAttribute
+import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.PostMapping
 
 @ApiV1Controller
@@ -19,4 +21,14 @@ class AdminController(
         adminCommandUseCase
             .createExam(request.toCommand())
             .let { ExamResponse.from(it) }
+
+    @DeleteMapping("/admin/users/{userId}/exams/{examId}/histories")
+    fun deleteExamHistory(
+        @PathVariable
+        userId: Long,
+        @PathVariable
+        examId: Long
+    ) {
+        adminCommandUseCase.deleteExamHistoryByExamIdAndUserId(examId, userId)
+    }
 }

api/src/test/kotlin/com/gotchai/api/presentation/v1/admin/AdminControllerTest.kt

@@ -0,0 +1,95 @@
+package com.gotchai.api.presentation.v1.admin
+
+import com.gotchai.api.common.ControllerTest
+import com.gotchai.api.docs.createExamRequestFields
+import com.gotchai.api.docs.examResponseFields
+import com.gotchai.api.fixture.createCreateExamRequest
+import com.gotchai.api.global.dto.ApiResponse
+import com.gotchai.api.presentation.v1.exam.response.ExamResponse
+import com.gotchai.api.util.bodyForm
+import com.gotchai.api.util.desc
+import com.gotchai.api.util.document
+import com.gotchai.api.util.expectError
+import com.gotchai.domain.admin.port.`in`.AdminCommandUseCase
+import com.gotchai.domain.exam.exception.ExamHistoryNotFoundException
+import com.gotchai.domain.fixture.ID
+import com.gotchai.domain.fixture.createExam
+import com.ninjasquad.springmockk.MockkBean
+import io.mockk.every
+import io.mockk.just
+import io.mockk.runs
+import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
+import org.springframework.test.web.reactive.server.expectBody
+
+@WebMvcTest(AdminController::class)
+class AdminControllerTest : ControllerTest() {
+    @MockkBean
+    private lateinit var adminCommandUseCase: AdminCommandUseCase
+
+    init {
+        describe("createExam()은") {
+            val request =
+                createCreateExamRequest()
+                    .also {
+                        every { adminCommandUseCase.createExam(any()) } returns createExam()
+                    }
+
+            it("상태 코드 200과 ExamResponse를 반환한다.") {
+                webClient
+                    .post()
+                    .uri("/api/v1/admin/exams")
+                    .bodyForm(request)
+                    .exchange()
+                    .expectStatus()
+                    .isOk
+                    .expectBody<ApiResponse<ExamResponse>>()
+                    .document("테스트 생성 성공(200)") {
+                        requestForm(createExamRequestFields)
+                        responseBody(examResponseFields)
+                    }
+            }
+        }
+
+        describe("deleteExamHistory()는") {
+            context("테스트 기록이 존재하는 경우") {
+                every { adminCommandUseCase.deleteExamHistoryByExamIdAndUserId(ID, ID) } just runs
+
+                it("상태 코드 200을 반환한다.") {
+                    webClient
+                        .delete()
+                        .uri("/api/v1/admin/users/{userId}/exams/{examId}/histories", ID, ID)
+                        .exchange()
+                        .expectStatus()
+                        .isOk
+                        .expectBody<Void>()
+                        .document("테스트 기록 삭제 성공(200)") {
+                            pathParams(
+                                "userId" desc "유저 식별자",
+                                "examId" desc "테스트 식별자"
+                            )
+                        }
+                }
+            }
+
+            context("테스트 기록이 존재하지 않는 경우") {
+                every { adminCommandUseCase.deleteExamHistoryByExamIdAndUserId(ID, ID) } throws ExamHistoryNotFoundException()
+
+                it("상태 코드 404를 반환한다.") {
+                    webClient
+                        .delete()
+                        .uri("/api/v1/admin/users/{userId}/exams/{examId}/histories", ID, ID)
+                        .exchange()
+                        .expectStatus()
+                        .isNotFound
+                        .expectError()
+                        .document("테스트 기록 삭제 실패(404)") {
+                            pathParams(
+                                "userId" desc "유저 식별자",
+                                "examId" desc "테스트 식별자"
+                            )
+                        }
+                }
+            }
+        }
+    }
+}

domain/src/main/kotlin/com/gotchai/domain/admin/adapter/in/AdminCommandService.kt

@@ -4,15 +4,22 @@ import com.gotchai.domain.admin.dto.command.CreateExamCommand
 import com.gotchai.domain.admin.exception.InvalidFileException
 import com.gotchai.domain.admin.port.`in`.AdminCommandUseCase
 import com.gotchai.domain.exam.entity.Exam
+import com.gotchai.domain.exam.exception.ExamHistoryNotFoundException
 import com.gotchai.domain.exam.port.out.ExamCommandPort
+import com.gotchai.domain.exam.port.out.ExamHistoryCommandPort
+import com.gotchai.domain.exam.port.out.ExamHistoryQueryPort
 import com.gotchai.domain.global.provider.ObjectStorageProvider
+import com.gotchai.domain.quiz.port.out.QuizHistoryCommandPort
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import java.util.*
 
 @Service
 class AdminCommandService(
     private val examCommandPort: ExamCommandPort,
+    private val examHistoryQueryPort: ExamHistoryQueryPort,
+    private val examHistoryCommandPort: ExamHistoryCommandPort,
+    private val quizHistoryCommandPort: QuizHistoryCommandPort,
     private val objectStorageProvider: ObjectStorageProvider
 ) : AdminCommandUseCase {
     @Transactional
@@ -36,4 +43,16 @@ class AdminCommandService(
                 )
             )
         }
+
+    @Transactional
+    override fun deleteExamHistoryByExamIdAndUserId(
+        examId: Long,
+        userId: Long
+    ) {
+        val examHistory =
+            examHistoryQueryPort.getExamHistoryByExamIdAndUserId(examId, userId) ?: throw ExamHistoryNotFoundException()
+
+        quizHistoryCommandPort.deleteQuizHistoriesByExamHistoryId(examHistory.id)
+        examHistoryCommandPort.deleteExamHistoryByExamIdAndUserId(examId, userId)
+    }
 }

domain/src/main/kotlin/com/gotchai/domain/admin/port/in/AdminCommandUseCase.kt

@@ -5,4 +5,9 @@ import com.gotchai.domain.exam.entity.Exam
 
 interface AdminCommandUseCase {
     fun createExam(command: CreateExamCommand): Exam
+
+    fun deleteExamHistoryByExamIdAndUserId(
+        examId: Long,
+        userId: Long
+    )
 }

domain/src/main/kotlin/com/gotchai/domain/exam/adapter/in/ExamCommandService.kt

@@ -16,6 +16,7 @@ import com.gotchai.domain.exam.port.`in`.ExamCommandUseCase
 import com.gotchai.domain.exam.port.out.ExamHistoryCommandPort
 import com.gotchai.domain.exam.port.out.ExamHistoryQueryPort
 import com.gotchai.domain.exam.port.out.ExamQueryPort
+import com.gotchai.domain.quiz.port.out.QuizHistoryCommandPort
 import com.gotchai.domain.quiz.port.out.QuizHistoryQueryPort
 import com.gotchai.domain.quiz.port.out.QuizQueryPort
 import org.springframework.stereotype.Service
@@ -28,6 +29,7 @@ class ExamCommandService(
     private val examHistoryQueryPort: ExamHistoryQueryPort,
     private val examHistoryCommandPort: ExamHistoryCommandPort,
     private val quizHistoryQueryPort: QuizHistoryQueryPort,
+    private val quizHistoryCommandPort: QuizHistoryCommandPort,
     private val userBadgeCommandPort: UserBadgeCommandPort,
     private val badgeQueryPort: BadgeQueryPort
 ) : ExamCommandUseCase {
@@ -54,7 +56,7 @@ class ExamCommandService(
         } else {
             if (examHistory.isSolved) throw ExamAlreadySolvedException()
 
-            quizHistoryQueryPort.deleteQuizHistoriesByExamHistoryId(examHistory.id)
+            quizHistoryCommandPort.deleteQuizHistoriesByExamHistoryId(examHistory.id)
             examHistoryCommandPort.updateExamHistory(
                 examHistory.copy(
                     quizIds = quizIds,

domain/src/main/kotlin/com/gotchai/domain/exam/port/out/ExamHistoryCommandPort.kt

@@ -6,4 +6,9 @@ interface ExamHistoryCommandPort {
     fun createExamHistory(creation: ExamHistory.Creation): ExamHistory
 
     fun updateExamHistory(examHistory: ExamHistory): ExamHistory
+
+    fun deleteExamHistoryByExamIdAndUserId(
+        examId: Long,
+        userId: Long
+    )
 }

domain/src/main/kotlin/com/gotchai/domain/quiz/port/out/QuizHistoryCommandPort.kt

@@ -4,4 +4,6 @@ import com.gotchai.domain.quiz.entity.QuizHistory
 
 interface QuizHistoryCommandPort {
     fun createQuizHistory(creation: QuizHistory.Creation): QuizHistory
+
+    fun deleteQuizHistoriesByExamHistoryId(examHistoryId: Long)
 }

domain/src/main/kotlin/com/gotchai/domain/quiz/port/out/QuizHistoryQueryPort.kt

@@ -4,6 +4,4 @@ import com.gotchai.domain.quiz.entity.QuizHistory
 
 interface QuizHistoryQueryPort {
     fun getQuizHistoriesByExamHistoryId(examHistoryId: Long): List<QuizHistory>
-
-    fun deleteQuizHistoriesByExamHistoryId(examHistoryId: Long)
 }

storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/adapter/out/ExamHistoryCommandAdapter.kt

@@ -6,7 +6,6 @@ import com.gotchai.storage.rdb.exam.entity.ExamHistoryEntity
 import com.gotchai.storage.rdb.exam.repository.ExamHistoryJpaRepository
 import com.gotchai.storage.rdb.global.annotation.Adapter
 import com.gotchai.storage.rdb.global.util.findByIdOrElseThrow
-import org.springframework.transaction.annotation.Transactional
 
 @Adapter
 class ExamHistoryCommandAdapter(
@@ -17,7 +16,6 @@ class ExamHistoryCommandAdapter(
             .save(ExamHistoryEntity.from(creation))
             .toExamHistory()
 
-    @Transactional
     override fun updateExamHistory(examHistory: ExamHistory): ExamHistory =
         with(examHistory) {
             val examHistoryEntity = examHistoryJpaRepository.findByIdOrElseThrow(id)
@@ -32,4 +30,11 @@ class ExamHistoryCommandAdapter(
                 .save(examHistoryEntity)
                 .toExamHistory()
         }
+
+    override fun deleteExamHistoryByExamIdAndUserId(
+        examId: Long,
+        userId: Long
+    ) {
+        examHistoryJpaRepository.deleteByExamIdAndUserId(examId, userId)
+    }
 }

storage/rdb/src/main/kotlin/com/gotchai/storage/rdb/exam/repository/ExamHistoryJpaRepository.kt

@@ -13,16 +13,25 @@ interface ExamHistoryJpaRepository : JpaRepository<ExamHistoryEntity, Long> {
 
     @Query("SELECT e FROM ExamHistoryEntity e WHERE e.examId = :examId AND e.isSolved = :isSolved")
     fun findAllByExamIdAndIsSolved(
-        @Param("examId") examId: Long,
-        @Param("isSolved") isSolved: Boolean
+        @Param("examId")
+        examId: Long,
+        @Param("isSolved")
+        isSolved: Boolean
     ): List<ExamHistoryEntity>
 
     @Query("SELECT e FROM ExamHistoryEntity e WHERE e.userId = :userId AND e.isSolved = :isSolved")
     fun findAllByUserIdAndIsSolved(
-        @Param("userId") userId: Long,
-        @Param("isSolved") isSolved: Boolean
+        @Param("userId")
+        userId: Long,
+        @Param("isSolved")
+        isSolved: Boolean
     ): List<ExamHistoryEntity>
 
     @Query("SELECT e FROM ExamHistoryEntity e JOIN FETCH e.quizIds")
     fun findAllWithQuizIds(): List<ExamHistoryEntity>
+
+    fun deleteByExamIdAndUserId(
+        examId: Long,
+        userId: Long
+    ): List<ExamHistoryEntity>
 }