feat: application 모듈 단위 테스트 작성 및 CI 테스트 자동화 (#33)

* setting: Fixture Monkey 의존성 추가 (#32)

- libs.versions.toml에 fixture-monkey 1.1.11 버전 추가
- test-implementation 번들에 fixture-monkey-starter-kotlin 포함

* test: application 모듈 테스트 픽스처 및 video 도메인 테스트 작성 (#32)

- Fixtures.kt: Fixture Monkey 기반 공통 픽스처 팩토리 작성
- VideoAnalyzeServiceTest: 신규/중복/FAILED URL 분석 요청 시나리오 검증
- VideoAnalyzeEventListenerTest: 분석 성공/실패 시 상태 업데이트 및 일정 저장 검증
- VideoAnalysisResultSaverTest: 분석 결과 저장 시 스케줄 아이템 변환 검증
- VideoScheduleServiceTest: 일정 조회 시 Place 조인 및 도메인 매핑 검증
- VideoScheduleItemTest: 도메인 모델 isRetryable 판정 로직 검증
- PlaceEnrichServiceTest: Google Places 장소 보강 성공/실패/재시도 검증

* test: youtube 도메인 테스트 작성 (#32)

- YouTubeCollectServiceTest: 영상 수집 시 중복 제거 및 키워드별 수집 검증
- YouTubeChannelCollectServiceTest: 구독자 필터링, 방송사 제외, 중복 제거 검증
- DiscoverVideoServiceTest: Discover API 영상 조회 및 상태별 필터링 검증
- DiscoverChannelServiceTest: Discover API 채널 조회 검증
- SearchKeywordTest: 키워드 랜덤 선택 로직 검증

* test: member, notification, log 도메인 테스트 작성 (#32)

- AuthServiceTest: 소셜 로그인 신규/기존 회원 토큰 발급 검증
- ExceptionAlertEventListenerTest: 알림 전송, InterruptedException 플래그 복원, RuntimeException 격리 검증
- AccessLogEventListenerTest: 접근 로그 이벤트 저장 검증

* ci: PR 생성 시 ktlint + test 자동 검증 추가 (#32)

- ci-pull-request.yml에 pull_request 트리거 및 auto-check job 추가
- PR 생성/업데이트 시 ktlint check + gradle test 자동 실행
- 기존 '빌드검증' 댓글 트리거 방식은 유지

* refactor: ktlintformat (#32)

* refactor: CodeRabbit 리뷰 반영 - 테스트 검증 강화 (#32)

- PlaceEnrichServiceTest: 테스트 이름에 맞게 실제 DB 오류 시뮬레이션 추가
- VideoAnalyzeEventListenerTest: assert() → assertEquals()로 변경 (-ea 플래그 무관하게 동작)
- YouTubeCollectServiceTest: verify(times(5)) 추가하여 5개 키워드 전부 호출 검증
- SearchKeywordTest: isNotEmpty() → size >= 5로 pickRandom() 계약 반영

Author: toychip

.github/ISSUE_TEMPLATE/linktrip-issue-template.md

@@ -1,7 +1,7 @@
 ---
 name: LinkTrip Issue
 about: 기능 개발 및 버그 수정을 위한 이슈 템플릿
-title: "[Feature] "
+title: "[Feat] "
 labels: ''
 assignees: toychip
 ---

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,7 +1,7 @@
 ## 관련 이슈
 
 <!-- 연관된 이슈 번호가 있다면 태그 -->
-
+-
 ---
 
 ## 변경 내용

.github/workflows/ci-pull-request.yml

@@ -1,6 +1,8 @@
 name: CI - Pull request
 
 on:
+  pull_request:
+    branches: [ main ]
   issue_comment:
     types: [ created ]
 
@@ -10,6 +12,39 @@ permissions:
   pull-requests: write
 
 jobs:
+  auto-check:
+    name: 자동 검증 (ktlint + test)
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'pull_request' }}
+    steps:
+      - name: Repository 접근
+        uses: actions/checkout@v4
+
+      - name: JDK 21 셋팅
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: 'temurin'
+
+      - name: Gradle 의존성 캐싱
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.gradle/caches
+            ~/.gradle/wrapper
+          key: ${{ runner.os }}-gradle-${{ hashFiles('**/*.gradle*', '**/gradle-wrapper.properties') }}
+          restore-keys: |
+            ${{ runner.os }}-gradle-
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: ktlint check
+        run: ./gradlew ktlintCheck
+
+      - name: 테스트 실행
+        run: ./gradlew test
+
   build:
     name: ready for launch (CI)
     runs-on: ubuntu-latest
@@ -51,7 +86,7 @@ jobs:
       - name: ktlint check
         run: ./gradlew ktlintCheck
 
-      - name: 프로젝트 빌드
+      - name: 프로젝트 빌드 (테스트 포함)
         run: ./gradlew build
 
       - name: Set build status output

gradle/libs.versions.toml

@@ -7,6 +7,7 @@ querydsl = "5.1.0"
 ktLintPlugin = "12.1.1"
 gradleBuildScanPlugin = "3.18.1"
 javaVersion = "21"
+fixture-monkey = "1.1.11"
 
 [plugins]
 spring-boot = { id = "org.springframework.boot", version.ref = "springBoot" }
@@ -68,12 +69,13 @@ spring-boot-starter-test = { group = "org.springframework.boot", name = "spring-
 kotlin-junit5 = { group = "org.jetbrains.kotlin", name = "kotlin-test-junit5" }
 junit = { group = "org.junit.platform", name = "junit-platform-launcher" }
 mockito-kotlin = { group = "org.mockito.kotlin", name = "mockito-kotlin", version = "5.4.0" }
+fixture-monkey-starter-kotlin = { group = "com.navercorp.fixturemonkey", name = "fixture-monkey-starter-kotlin", version.ref = "fixture-monkey" }
 
 [bundles]
 # 공통 (convention에서 사용)
 spring-common = ["spring-boot-starter-autoconfigure"]
 kotlin-spring = ["kotlin-reflect", "kotlin-jackson", "kotlin-logging"]
-test-implementation = ["spring-boot-starter-test", "kotlin-junit5", "mockito-kotlin"]
+test-implementation = ["spring-boot-starter-test", "kotlin-junit5", "mockito-kotlin", "fixture-monkey-starter-kotlin"]
 test-runtime = ["junit"]
 
 # 모듈별

linktrip-application/src/test/kotlin/com/linktrip/application/Fixtures.kt

@@ -0,0 +1,11 @@
+package com.linktrip.application
+
+import com.navercorp.fixturemonkey.FixtureMonkey
+import com.navercorp.fixturemonkey.kotlin.KotlinPlugin
+
+object Fixtures {
+    val monkey: FixtureMonkey =
+        FixtureMonkey.builder()
+            .plugin(KotlinPlugin())
+            .build()
+}

linktrip-application/src/test/kotlin/com/linktrip/application/domain/log/AccessLogEventListenerTest.kt

@@ -0,0 +1,66 @@
+package com.linktrip.application.domain.log
+
+import com.linktrip.application.port.output.log.AccessLogPort
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@ExtendWith(MockitoExtension::class)
+class AccessLogEventListenerTest {
+    @Test
+    fun `AccessLog 이벤트가 발생하면_등록된 모든 AccessLogPort에 로그를 저장한다`() {
+        // given - 2개의 AccessLogPort가 등록된 상태
+        val port1 = mock<AccessLogPort>()
+        val port2 = mock<AccessLogPort>()
+        val listener = AccessLogEventListener(listOf(port1, port2))
+
+        val accessLog =
+            AccessLog(
+                requestId = "req-1",
+                method = "GET",
+                uri = "/api/test",
+                clientIp = "127.0.0.1",
+                statusCode = 200,
+                durationMs = 50,
+            )
+        val event = AccessLogEvent(accessLog)
+
+        // when - 이벤트를 처리한다
+        listener.handle(event)
+
+        // then - 모든 port에 로그가 저장된다
+        verify(port1).save(accessLog)
+        verify(port2).save(accessLog)
+    }
+
+    @Test
+    fun `하나의 AccessLogPort에서 저장 실패해도_나머지 port에는 정상적으로 저장한다`() {
+        // given - port1에서 저장 시 예외가 발생하는 상태
+        val port1 = mock<AccessLogPort>()
+        val port2 = mock<AccessLogPort>()
+        val listener = AccessLogEventListener(listOf(port1, port2))
+
+        val accessLog =
+            AccessLog(
+                requestId = "req-1",
+                method = "POST",
+                uri = "/api/data",
+                clientIp = "10.0.0.1",
+                statusCode = 500,
+                durationMs = 100,
+            )
+        val event = AccessLogEvent(accessLog)
+
+        whenever(port1.save(accessLog)).thenThrow(RuntimeException("저장 실패"))
+
+        // when - 이벤트를 처리한다
+        listener.handle(event)
+
+        // then - port1이 실패해도 port2에는 정상적으로 저장된다
+        verify(port1).save(accessLog)
+        verify(port2).save(accessLog)
+    }
+}

linktrip-application/src/test/kotlin/com/linktrip/application/domain/member/AuthServiceTest.kt

@@ -0,0 +1,77 @@
+package com.linktrip.application.domain.member
+
+import com.linktrip.application.port.output.auth.TokenProvider
+import com.linktrip.application.port.output.persistence.MemberPort
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertFalse
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import org.mockito.InjectMocks
+import org.mockito.Mock
+import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.any
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@ExtendWith(MockitoExtension::class)
+class AuthServiceTest {
+    @Mock
+    lateinit var memberPort: MemberPort
+
+    @Mock
+    lateinit var tokenProvider: TokenProvider
+
+    @InjectMocks
+    lateinit var service: AuthService
+
+    @Test
+    fun `이미 가입된 시리얼 번호로 인증하면_기존 회원 정보를 조회하고_새로 저장하지 않으며_isNewMember가 false이다`() {
+        // given - 이미 가입된 시리얼 번호의 회원
+        val existingMember = Member(id = "member-1", serialNumber = "serial-123")
+        whenever(memberPort.findBySerialNumber("serial-123")).thenReturn(existingMember)
+        whenever(tokenProvider.create("member-1")).thenReturn("token-abc")
+
+        // when - 기존 시리얼 번호로 인증한다
+        val result = service.authenticateBySerial("serial-123")
+
+        // then - 기존 회원 정보를 반환하고, 새로 저장하지 않으며, isNewMember가 false이다
+        assertEquals("member-1", result.memberId)
+        assertEquals("token-abc", result.accessToken)
+        assertFalse(result.isNewMember)
+        verify(memberPort, never()).save(any())
+    }
+
+    @Test
+    fun `처음 보는 시리얼 번호로 인증하면_새 회원을 생성하여 저장하고_isNewMember가 true이다`() {
+        // given - DB에 존재하지 않는 신규 시리얼 번호
+        whenever(memberPort.findBySerialNumber("new-serial")).thenReturn(null)
+        val savedMember = Member(id = "new-member-1", serialNumber = "new-serial")
+        whenever(memberPort.save(any())).thenReturn(savedMember)
+        whenever(tokenProvider.create("new-member-1")).thenReturn("new-token")
+
+        // when - 신규 시리얼 번호로 인증한다
+        val result = service.authenticateBySerial("new-serial")
+
+        // then - 새 회원이 저장되고, isNewMember가 true이다
+        assertEquals("new-member-1", result.memberId)
+        assertEquals("new-token", result.accessToken)
+        assertTrue(result.isNewMember)
+        verify(memberPort).save(any())
+    }
+
+    @Test
+    fun `기존 회원이든 신규 회원이든_인증 시 항상 memberId 기반의 JWT 토큰이 생성된다`() {
+        // given - 기존 회원
+        val member = Member(id = "m1", serialNumber = "s1")
+        whenever(memberPort.findBySerialNumber("s1")).thenReturn(member)
+        whenever(tokenProvider.create("m1")).thenReturn("token")
+
+        // when - 인증을 수행한다
+        service.authenticateBySerial("s1")
+
+        // then - memberId 기반으로 토큰이 생성된다
+        verify(tokenProvider).create("m1")
+    }
+}

linktrip-application/src/test/kotlin/com/linktrip/application/domain/notification/ExceptionAlertEventListenerTest.kt

@@ -0,0 +1,100 @@
+package com.linktrip.application.domain.notification
+
+import com.linktrip.application.port.output.notification.NotificationPort
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.extension.ExtendWith
+import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@ExtendWith(MockitoExtension::class)
+class ExceptionAlertEventListenerTest {
+    @Test
+    fun `예외 알림 이벤트가 발생하면_등록된 모든 NotificationPort에 알림을 전송한다`() {
+        // given - 2개의 NotificationPort가 등록된 상태
+        val port1 = mock<NotificationPort>()
+        val port2 = mock<NotificationPort>()
+        val listener = ExceptionAlertEventListener(listOf(port1, port2))
+
+        val event =
+            ExceptionAlertEvent(
+                message = "에러 발생",
+                cause = "NullPointerException",
+                statusCode = 500,
+                stackTrace = "at com.linktrip...",
+            )
+
+        // when - 이벤트를 처리한다
+        listener.handle(event)
+
+        // then - 모든 port에 알림이 전송된다
+        verify(port1).sendExceptionAlert(event)
+        verify(port2).sendExceptionAlert(event)
+    }
+
+    @Test
+    fun `첫 번째 port에서 InterruptedException 발생 시_이후 port 호출을 중단하고_스레드 인터럽트 플래그를 복원한다`() {
+        // given - port1에서 InterruptedException이 발생하는 상태
+        val port1 = mock<NotificationPort>()
+        val port2 = mock<NotificationPort>()
+        val listener = ExceptionAlertEventListener(listOf(port1, port2))
+
+        val event =
+            ExceptionAlertEvent(
+                message = "에러",
+                cause = null,
+                statusCode = 500,
+                stackTrace = null,
+            )
+
+        doAnswer { throw InterruptedException("중단") }.whenever(port1).sendExceptionAlert(event)
+
+        // when - 이벤트를 처리한다
+        listener.handle(event)
+
+        // then - port2는 호출되지 않는다 (return으로 즉시 중단)
+        verify(port1).sendExceptionAlert(event)
+        verify(port2, never()).sendExceptionAlert(event)
+
+        // then - 스레드 인터럽트 플래그가 복원되어 있다
+        //   프로덕션 코드에서 Thread.currentThread().interrupt()를 제거하면 이 검증이 실패한다
+        assertTrue(Thread.currentThread().isInterrupted) {
+            "InterruptedException 발생 후 Thread.interrupt()로 플래그가 복원되어야 한다"
+        }
+
+        // cleanup - 다른 테스트에 영향 주지 않도록 인터럽트 플래그 클리어
+        Thread.interrupted()
+    }
+
+    @Test
+    fun `두 번째 port에서 RuntimeException 발생 시_해당 port만 건너뛰고_나머지 port는 정상적으로 알림을 전송한다`() {
+        // given - port2에서 RuntimeException이 발생하는 상태
+        val port1 = mock<NotificationPort>()
+        val port2 = mock<NotificationPort>()
+        val port3 = mock<NotificationPort>()
+        val listener = ExceptionAlertEventListener(listOf(port1, port2, port3))
+
+        val event =
+            ExceptionAlertEvent(
+                message = "에러",
+                cause = null,
+                statusCode = 500,
+                stackTrace = null,
+            )
+
+        whenever(port2.sendExceptionAlert(event)).thenThrow(RuntimeException("전송 실패"))
+
+        // when - 이벤트를 처리한다
+        listener.handle(event)
+
+        // then - port2만 실패하고, port1과 port3은 정상적으로 알림이 전송된다
+        //   RuntimeException은 catch 후 continue하므로 port3까지 도달한다
+        verify(port1).sendExceptionAlert(event)
+        verify(port2).sendExceptionAlert(event)
+        verify(port3).sendExceptionAlert(event)
+    }
+}