fix: replace runBlocking with runTest for better coroutine handling

Author: chock-cho

src/test/kotlin/com/dobby/backend/application/usecase/member/email/SendEmailCodeUseCaseTest.kt

@@ -2,24 +2,16 @@ package com.dobby.backend.application.usecase.member.email
 
 import com.dobby.backend.application.service.CoroutineDispatcherProvider
 import com.dobby.backend.application.service.TransactionExecutor
-import com.dobby.backend.domain.exception.EmailAlreadyVerifiedException
 import com.dobby.backend.domain.exception.EmailDomainNotFoundException
 import com.dobby.backend.domain.exception.EmailNotUnivException
 import com.dobby.backend.domain.IdGenerator
 import com.dobby.backend.domain.gateway.email.EmailGateway
 import com.dobby.backend.domain.gateway.email.VerificationGateway
-import com.dobby.backend.domain.model.Verification
-import com.dobby.backend.infrastructure.database.entity.enums.VerificationStatus
 import com.dobby.backend.util.EmailUtils
-import io.kotest.assertions.any
 import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.BehaviorSpec
-import io.kotest.matchers.shouldBe
 import io.mockk.*
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
 
 class SendEmailCodeUseCaseTest : BehaviorSpec({
 
@@ -35,32 +27,36 @@ class SendEmailCodeUseCaseTest : BehaviorSpec({
         mockkObject(EmailUtils)
     }
 
-        given("유효하지 않은 도메인의 이메일이 주어졌을 때") {
-            val invalidEmail = "invalid@unknown.com"
-            every { EmailUtils.isDomainExists(invalidEmail) } returns false
+    given("유효하지 않은 도메인의 이메일이 주어졌을 때") {
+        val invalidEmail = "invalid@unknown.com"
+        every { EmailUtils.isDomainExists(invalidEmail) } returns false
 
-            `when`("이메일 인증 코드 전송을 실행하면") {
-                then("EmailDomainNotFoundException 예외가 발생해야 한다") {
+        `when`("이메일 인증 코드 전송을 실행하면") {
+            then("EmailDomainNotFoundException 예외가 발생해야 한다") {
+                runTest {
                     shouldThrow<EmailDomainNotFoundException> {
-                        runBlocking { sendEmailCodeUseCase.execute(SendEmailCodeUseCase.Input(invalidEmail)) }
+                        sendEmailCodeUseCase.execute(SendEmailCodeUseCase.Input(invalidEmail))
                     }
                 }
             }
         }
+    }
 
-        given("대학 이메일이 아닌 일반 이메일이 주어졌을 때") {
-            val personalEmail = "christer10@naver.com"
-            every { EmailUtils.isDomainExists(personalEmail) } returns true
-            every { EmailUtils.isUnivMail(personalEmail) } returns false
+    given("대학 이메일이 아닌 일반 이메일이 주어졌을 때") {
+        val personalEmail = "christer10@naver.com"
+        every { EmailUtils.isDomainExists(personalEmail) } returns true
+        every { EmailUtils.isUnivMail(personalEmail) } returns false
 
-            `when`("이메일 인증 코드 전송을 실행하면") {
-                then("EmailNotUnivException 예외가 발생해야 한다") {
+        `when`("이메일 인증 코드 전송을 실행하면") {
+            then("EmailNotUnivException 예외가 발생해야 한다") {
+                runTest {
                     shouldThrow<EmailNotUnivException> {
-                        runBlocking { sendEmailCodeUseCase.execute(SendEmailCodeUseCase.Input(personalEmail)) }
+                        sendEmailCodeUseCase.execute(SendEmailCodeUseCase.Input(personalEmail))
                     }
                 }
             }
         }
+    }
 })
 
 

src/test/kotlin/com/dobby/backend/application/usecase/member/email/SendMatchingEmailUseCaseTest.kt

@@ -22,6 +22,7 @@ import io.kotest.matchers.shouldBe
 import io.kotest.assertions.throwables.shouldThrow
 import io.mockk.*
 import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.test.runTest
 import java.time.LocalDate
 import java.time.LocalDateTime
 
@@ -91,11 +92,13 @@ class SendMatchingEmailUseCaseTest : BehaviorSpec({
 
             coEvery { emailGateway.sendEmail(any(), any(), any()) } just Runs
 
-            then("이메일 전송이 성공해야 한다") {
-                val output = runBlocking { sendMatchingEmailUseCase.execute(input) }
-
-                output.isSuccess shouldBe true
-                coVerify(exactly = 1) { emailGateway.sendEmail(contactEmail, any(), any()) }
+            then("이메일 전송이 성공해야 한다")  {
+                runTest {
+                    val output = sendMatchingEmailUseCase.execute(input)
+                    output.isSuccess shouldBe true
+                    coVerify(exactly = 1) { emailGateway.sendEmail(contactEmail, any(), any())
+                    }
+                }
             }
         }
 
@@ -155,11 +158,12 @@ class SendMatchingEmailUseCaseTest : BehaviorSpec({
             val input = SendMatchingEmailUseCase.Input(invalidEmail, experimentPosts, LocalDateTime.now())
 
             then("EmailDomainNotFoundException 예외가 발생해야 한다") {
-                val exception = shouldThrow<EmailDomainNotFoundException> {
-                    runBlocking { sendMatchingEmailUseCase.execute(input) }
+                runTest {
+                    val exception = shouldThrow<EmailDomainNotFoundException> {
+                        runBlocking { sendMatchingEmailUseCase.execute(input) }
+                    }
+                    exception shouldBe EmailDomainNotFoundException
                 }
-
-                exception shouldBe EmailDomainNotFoundException
             }
         }
     }