[YS-299] feat: 지역별 공고 개수 조회 UseCase Output 캐싱 적용 및 Redis 테스트 컨테이너 추가

.github/workflows/ci-backend.yml → .github/workflows/ci-dev.yml

@@ -12,6 +12,12 @@ jobs:
   build:
     runs-on: ubuntu-latest
 
+    services:
+      redis:
+        image: redis:7.0.8-alpine
+        ports:
+          - 6379:6379
+
     steps:
       - uses: actions/checkout@v4
 
@@ -24,5 +30,8 @@ jobs:
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
 
-      - name: Build with Gradle
-        run: ./gradlew clean build
+      - name: Run tests with Gradle
+        run: ./gradlew clean test
+        env:
+          SPRING_REDIS_HOST: localhost
+          SPRING_REDIS_PORT: 6379

build.gradle.kts

@@ -79,6 +79,9 @@ dependencies {
 	testImplementation("io.kotest.extensions:kotest-extensions-spring:1.1.2")
 
 	testImplementation("io.mockk:mockk:1.13.10")
+
+	testImplementation("org.testcontainers:testcontainers:1.19.3")
+	testImplementation("org.testcontainers:junit-jupiter:1.19.3")
 }
 
 dependencyManagement {

src/main/kotlin/com/dobby/backend/application/service/ExperimentPostService.kt

@@ -10,7 +10,10 @@ import com.dobby.backend.application.usecase.experiment.GetMyExperimentPostsUseC
 import com.dobby.backend.domain.exception.ExperimentAreaInCorrectException
 import com.dobby.backend.domain.exception.ExperimentAreaOverflowException
 import com.dobby.backend.domain.exception.InvalidRequestValueException
+import com.dobby.backend.domain.gateway.CacheGateway
 import com.dobby.backend.infrastructure.database.entity.enums.areaInfo.Area
+import com.dobby.backend.infrastructure.database.entity.enums.experiment.RecruitStatus
+import com.fasterxml.jackson.databind.ObjectMapper
 import jakarta.transaction.Transactional
 import org.springframework.stereotype.Service
 
@@ -30,9 +33,13 @@ class ExperimentPostService(
     private val getExperimentPostTotalCountByCustomFilterUseCase: GetExperimentPostTotalCountByCustomFilterUseCase,
     private val getMyExperimentPostsUseCase: GetMyExperimentPostsUseCase,
     private val getMyExperimentPostTotalCountUseCase: GetMyExperimentPostTotalCountUseCase,
+    private val cacheGateway: CacheGateway,
+    private val objectMapper: ObjectMapper,
 ) {
     @Transactional
     fun createNewExperimentPost(input: CreateExperimentPostUseCase.Input): CreateExperimentPostUseCase.Output {
+        cacheGateway.evict("experimentPostCounts:ALL")
+        cacheGateway.evict("experimentPostCounts:OPEN")
         return createExperimentPostUseCase.execute(input)
     }
 
@@ -69,14 +76,36 @@ class ExperimentPostService(
     }
 
     fun getExperimentPostCounts(input: Any): Any {
-        return when (input) {
+        if (input is GetExperimentPostCountsByRegionUseCase.Input && input.region == null) {
+            getCachedExperimentPostCounts(input.recruitStatus)?.let { return it }
+        }
+
+        val output = when (input) {
             is GetExperimentPostCountsByRegionUseCase.Input -> getExperimentPostCountsByRegionUseCase.execute(input)
             is GetExperimentPostCountsByAreaUseCase.Input -> getExperimentPostCountsByAreaUseCase.execute(input)
             else -> throw IllegalArgumentException("Invalid input type: ${input::class.java.simpleName}")
         }
+
+        if (input is GetExperimentPostCountsByRegionUseCase.Input && input.region == null) {
+            cacheExperimentPostCounts(input.recruitStatus, output)
+        }
+
+        return output
+    }
+
+    private fun getCachedExperimentPostCounts(recruitStatus: RecruitStatus): GetExperimentPostCountsByRegionUseCase.Output? {
+        val cacheKey = "experimentPostCounts:$recruitStatus"
+        return cacheGateway.get(cacheKey)?.let {
+            objectMapper.readValue(it, GetExperimentPostCountsByRegionUseCase.Output::class.java)
+        }
+    }
+
+    private fun cacheExperimentPostCounts(recruitStatus: RecruitStatus, output: Any) {
+        val cacheKey = "experimentPostCounts:$recruitStatus"
+        cacheGateway.set(cacheKey, objectMapper.writeValueAsString(output))
     }
 
-    fun validateFilter(input: GetExperimentPostsUseCase.Input) {
+    private fun validateFilter(input: GetExperimentPostsUseCase.Input) {
         val locationInfo = input.customFilter.locationTarget ?: return
 
         locationInfo.areas?.let { validateLocationAreaCount(it) }

src/main/kotlin/com/dobby/backend/domain/gateway/CacheGateway.kt

@@ -0,0 +1,7 @@
+package com.dobby.backend.domain.gateway
+
+interface CacheGateway {
+    fun get(key: String): String?
+    fun set(key: String, value: String)
+    fun evict(key: String)
+}

src/main/kotlin/com/dobby/backend/infrastructure/gateway/cache/RedisCacheGatewayImpl.kt

@@ -0,0 +1,33 @@
+package com.dobby.backend.infrastructure.gateway.cache
+
+import com.dobby.backend.domain.gateway.CacheGateway
+import org.springframework.core.env.Environment
+import org.springframework.data.redis.core.RedisTemplate
+import org.springframework.stereotype.Component
+import java.util.concurrent.TimeUnit
+
+@Component
+class RedisCacheGatewayImpl(
+    private val redisTemplate: RedisTemplate<String, String>,
+    private val environment: Environment
+) : CacheGateway {
+
+    private val cacheTimeout = 300L
+
+    override fun get(key: String): String? {
+        return redisTemplate.opsForValue().get(getCacheKey(key))
+    }
+
+    override fun set(key: String, value: String) {
+        redisTemplate.opsForValue().set(getCacheKey(key), value, cacheTimeout, TimeUnit.MINUTES)
+    }
+
+    override fun evict(key: String) {
+        redisTemplate.delete(getCacheKey(key))
+    }
+
+    private fun getCacheKey(key: String): String {
+        val activeProfile = environment.activeProfiles.firstOrNull() ?: "local"
+        return "$activeProfile:$key"
+    }
+}

src/test/kotlin/com/dobby/backend/application/service/ExperimentPostServiceTest.kt

@@ -0,0 +1,131 @@
+package com.dobby.backend.application.service
+
+import com.dobby.backend.application.usecase.experiment.CreateExperimentPostUseCase
+import com.dobby.backend.application.usecase.experiment.GetExperimentPostCountsByRegionUseCase
+import com.dobby.backend.domain.gateway.CacheGateway
+import com.dobby.backend.infrastructure.database.entity.enums.MatchType
+import com.dobby.backend.infrastructure.database.entity.enums.areaInfo.Area
+import com.dobby.backend.infrastructure.database.entity.enums.areaInfo.Region
+import com.dobby.backend.infrastructure.database.entity.enums.experiment.RecruitStatus
+import com.dobby.backend.infrastructure.database.entity.enums.experiment.TimeSlot
+import com.dobby.backend.infrastructure.database.entity.enums.member.GenderType
+import com.dobby.backend.infrastructure.database.entity.enums.member.MemberStatus
+import com.dobby.backend.infrastructure.database.entity.enums.member.ProviderType
+import com.dobby.backend.infrastructure.database.entity.enums.member.RoleType
+import com.dobby.backend.infrastructure.database.entity.member.MemberEntity
+import com.dobby.backend.infrastructure.database.repository.MemberRepository
+import com.fasterxml.jackson.databind.ObjectMapper
+import io.kotest.core.spec.style.BehaviorSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.nulls.shouldBeNull
+import io.mockk.*
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.boot.test.context.SpringBootTest
+import org.springframework.test.context.ActiveProfiles
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+@SpringBootTest
+@ActiveProfiles("test")
+class ExperimentPostServiceTest @Autowired constructor(
+    private val experimentPostService: ExperimentPostService,
+    private val memberRepository: MemberRepository,
+    private val cacheGateway: CacheGateway,
+    private val objectMapper: ObjectMapper
+) : BehaviorSpec({
+
+    val getExperimentPostCountsByRegionUseCase = mockk<GetExperimentPostCountsByRegionUseCase>()
+    val createExperimentPostUseCase = mockk<CreateExperimentPostUseCase>()
+
+    lateinit var memberId: String
+
+    beforeSpec {
+        clearAllMocks()
+
+        val savedMember = memberRepository.save(
+            MemberEntity(
+                id = "1",
+                oauthEmail = "test@gmail.com",
+                contactEmail = "test@gmail.com",
+                provider = ProviderType.GOOGLE,
+                status = MemberStatus.ACTIVE,
+                role = RoleType.RESEARCHER,
+                name = "테스트",
+                createdAt = LocalDateTime.now(),
+                updatedAt = LocalDateTime.now(),
+                deletedAt = null
+            )
+        )
+        memberId = savedMember.id
+    }
+
+    given("Redis 캐시에 게시글 개수를 저장할 때") {
+        val input = GetExperimentPostCountsByRegionUseCase.Input(region = null, recruitStatus = RecruitStatus.ALL)
+        val output = GetExperimentPostCountsByRegionUseCase.Output(total = 100, area = emptyList())
+
+        val cacheKey = "experimentPostCounts:ALL"
+
+        `when`("캐시에 데이터를 저장하고 조회하면") {
+            cacheGateway.set(cacheKey, objectMapper.writeValueAsString(output))
+            val cachedData = cacheGateway.get(cacheKey)
+
+            then("저장된 데이터가 올바르게 반환되어야 한다") {
+                cachedData shouldBe objectMapper.writeValueAsString(output)
+            }
+        }
+    }
+
+    given("새로운 게시글을 생성할 때") {
+        val cacheKey = "experimentPostCounts:ALL"
+        cacheGateway.set(cacheKey, objectMapper.writeValueAsString(GetExperimentPostCountsByRegionUseCase.Output(100, emptyList())))
+
+        val mockInput = mockk<CreateExperimentPostUseCase.Input>(relaxed = true)
+
+        every { mockInput.memberId } returns memberId
+        every { mockInput.leadResearcher } returns "야뿌 연구 리더"
+        every { mockInput.univName } returns "야뿌대학교"
+        every { mockInput.region } returns Region.SEOUL
+        every { mockInput.area } returns Area.GWANAKGU
+        every { mockInput.detailedAddress } returns "야뿌 연구소"
+        every { mockInput.reward } returns "Gift Card"
+        every { mockInput.title } returns "새로운 실험"
+        every { mockInput.content } returns "참여해 참여해"
+        every { mockInput.alarmAgree } returns true
+        every { mockInput.startDate } returns LocalDate.of(2024, 6, 1)
+        every { mockInput.endDate } returns LocalDate.of(2024, 6, 30)
+        every { mockInput.matchType } returns MatchType.OFFLINE
+        every { mockInput.count } returns 3
+        every { mockInput.timeRequired } returns TimeSlot.ABOUT_1H
+
+        val mockTargetGroupInfo = mockk<CreateExperimentPostUseCase.TargetGroupInfo>(relaxed = true)
+        every { mockTargetGroupInfo.startAge } returns 20
+        every { mockTargetGroupInfo.endAge } returns 30
+        every { mockTargetGroupInfo.genderType } returns GenderType.MALE
+        every { mockTargetGroupInfo.otherCondition } returns "Healthy"
+
+        every { mockInput.targetGroupInfo } returns mockTargetGroupInfo
+
+        val mockApplyMethodInfo = mockk<CreateExperimentPostUseCase.ApplyMethodInfo>(relaxed = true)
+        every { mockApplyMethodInfo.content } returns "이메일로 연락주세요"
+        every { mockApplyMethodInfo.formUrl } returns "https://test.com/apply"
+        every { mockApplyMethodInfo.phoneNum } returns "010-1234-5678"
+
+        every { mockInput.applyMethodInfo } returns mockApplyMethodInfo
+
+        val mockImageListInfo = mockk<CreateExperimentPostUseCase.ImageListInfo>(relaxed = true)
+        every { mockImageListInfo.images } returns listOf("https://test.com/image1.jpg", "https://test.com/image2.jpg")
+
+        every { mockInput.imageListInfo } returns mockImageListInfo
+
+        every { createExperimentPostUseCase.execute(any()) } returns mockk()
+
+        `when`("게시글을 생성하면") {
+            experimentPostService.createNewExperimentPost(mockInput)
+
+            then("캐시가 삭제되어야 한다") {
+                val cachedData = cacheGateway.get(cacheKey)
+                cachedData.shouldBeNull()
+            }
+        }
+    }
+})

src/test/kotlin/com/dobby/backend/config/RedisTestContainerConfig.kt

@@ -0,0 +1,24 @@
+package com.dobby.backend.config
+
+import org.junit.jupiter.api.extension.BeforeAllCallback
+import org.junit.jupiter.api.extension.ExtensionContext
+import org.testcontainers.containers.GenericContainer
+import org.testcontainers.utility.DockerImageName
+
+object RedisTestContainerConfig : BeforeAllCallback {
+
+    private const val REDIS_IMAGE = "redis:7.0.8-alpine"
+    private const val REDIS_PORT = 6379
+
+    private val redisContainer: GenericContainer<out GenericContainer<*>> = GenericContainer(DockerImageName.parse(REDIS_IMAGE))
+        .apply {
+            withExposedPorts(REDIS_PORT)
+            withReuse(true) // 컨테이너 재사용 설정
+            if (!isRunning) start()
+        }
+
+    override fun beforeAll(context: ExtensionContext?) {
+        System.setProperty("spring.data.redis.host", redisContainer.host)
+        System.setProperty("spring.data.redis.port", redisContainer.getMappedPort(REDIS_PORT).toString())
+    }
+}