diff --git a/docs/20261109_감지번역공급자공통화/provider-guide.md b/docs/20261109_감지번역공급자공통화/provider-guide.md index c5d5a67d..1e768cd3 100644 --- a/docs/20261109_감지번역공급자공통화/provider-guide.md +++ b/docs/20261109_감지번역공급자공통화/provider-guide.md @@ -4,7 +4,7 @@ 감지 구현체는 `PapagoLanguageDetectionProvider`와 `AwsLanguageDetectionProvider`, 번역 구현체는 `PapagoTranslationService`와 `AwsTranslationService`다. -두 기능의 production 기본 순서는 모두 `PAPAGO → AWS`다. AWS는 기존 자격 증명과 리전 설정을 재사용한다. +production 기본 순서는 감지와 번역 모두 `AWS → PAPAGO`다. AWS는 기존 자격 증명과 리전 설정을 재사용한다. 감지와 번역은 별도 capability다. 감지만 또는 번역만 제공하는 공급자도 등록할 수 있다. 두 capability에서 같은 `providerId`를 쓰는 것은 가능하지만, 한 capability 안의 ID 중복은 시작 시 거부한다. @@ -47,12 +47,12 @@ ko/en/ja 서비스 정책은 `TranslationLanguages`에 있으며 공급자를 production 순서의 유일한 편집 지점은 `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`다. -목록의 왼쪽부터 사용하며 기본값은 두 기능 모두 `listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)`다. +목록의 왼쪽부터 사용하며 감지와 번역의 기본 순서는 다음과 같다. ```kotlin object LanguageProviderOrder { - val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) - val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) + val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) + val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) } ``` @@ -61,11 +61,11 @@ Spring은 `@Autowired` 기본 생성자로 위 목록을 읽는다. 문자열 테스트에서는 전역 목록을 변경하지 않고 `LanguageProviderProperties(List, List)`로 만든 테스트 bean을 주입한다. -다음은 감지만 AWS 우선으로 바꾸는 예시다. 현재 기본 순서를 뜻하지 않는다. +다음은 감지만 Papago 우선으로 바꾸는 예시다. 현재 기본 순서를 뜻하지 않는다. ```kotlin -val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) -val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) +val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) +val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) ``` 감지만 순서를 바꾸어도 번역 순서는 바뀌지 않는다. 반대로 번역만 바꿀 수도 있다. @@ -123,7 +123,7 @@ adapter 예외·null 감지·빈 감지·번역 결과 개수 불일치·blank | 테스트 | 검증 내용 | |---|---| -| `LanguageProviderSpringConfigurationTest` | production 기본 생성자와 PAPAGO 우선 성공, 과거 property/env 무시, 독립 순서와 잘못된 목록의 시작 실패; fake AWS context와 실제 adapter + SDK mock context 분리 | +| `LanguageProviderSpringConfigurationTest` | production 기본 생성자와 AWS 우선 성공, 과거 property/env 무시, 독립 순서와 잘못된 목록의 시작 실패; fake AWS context와 실제 adapter + SDK mock context 분리 | | `LanguageProviderIdTest` | 런타임 enum getter 계약, 안정적인 papago/aws code, production 기본값과 실제 adapter ID | | `LanguageProviderPropertiesTest` | 순서 검증 및 선택되지 않은 bean을 포함한 capability 내 중복 ID 거부 | | `LanguageDetectionProviderTest` / `TranslationCoordinatorTest` | 전체 요청 폴백, 첫 성공 중단, cache-first, 안전한 전체 실패, DB 오류 전파 | diff --git a/docs/20261116_메타데이터번역신속반영/plan-task.md b/docs/20261116_메타데이터번역신속반영/plan-task.md new file mode 100644 index 00000000..9342fb41 --- /dev/null +++ b/docs/20261116_메타데이터번역신속반영/plan-task.md @@ -0,0 +1,177 @@ +# 메타데이터 자동 번역 신속 반영 구현 계획 + +| 항목 | 내용 | +|---|---| +| 상태 | 구현·기능 검증·독립 리뷰 완료 | +| 작성일 | 2026-11-16 | +| 요구사항 | [prd.md](prd.md) | +| 현재 활성 Goal | 없음 | +| 다음 Goal | 없음 | + +## 목표와 제약 + +기존 DB 큐에서 감지 후 작업 등록, 최초+5회 재시도, 요청 시 실패 재개, AWS 번역 우선과 1초 워커를 제공한다. +Kotlin 1.6.21, Java 17, Spring Boot 2.7.14와 기존 패키지/스키마/API/캐시를 유지한다. +새 worktree, 커밋, 배포, 외부 유료 호출은 만들지 않는다. 시작 작업 트리는 깨끗했고 현재 브랜치는 test다. +단일 구현 Goal 안에서 파일이 겹치지 않는 작업을 분담하며, Gradle 실행은 부모가 직렬로 관리한다. +전체 테스트는 사용자 실행 `./gradlew test`이며 에이전트는 기능별 테스트, ktlintCheck, bootJar만 실행한다. + +## Phase 1: 번역 수명주기와 요청 연결 + +- [x] **Task 1.1: 순서·재시도·신속 처리 구현** + +**Goal P1-T1:** 감지 성공부터 실패 소진 후 재요청까지 번역 상태가 요구사항대로 이어진다. + +- 시작 조건: MT-001~007 확정, PRD와 이 계획 준비. +- 완료 증거: 아래 RED/GREEN, 트랜잭션 저장/롤백과 재개 검증, 기능별 회귀 통과. +- 범위 밖: 감지 자체 새 재시도, 외부 API/브로커 추가, 운영 데이터 일괄 변경, 응답 스키마 변경. + +### 작업 A: 공통 큐와 워커 + +파일: +- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRepository.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt` +- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobSchedulerTest.kt` +- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorkerTest.kt` +- 같은 테스트 패키지의 DB 재시도 통합 테스트. + +계약: 기존 scheduleMissingTranslation 시그니처를 유지한다. 기존 FAILED 행만 원자적으로 재개하고 현재 원문 해시를 사용한다. +진행 중 작업과 완료 작업은 요청으로 초기화하지 않는다. 워커는 최초 실행 뒤 5회 재시도하며 1/5/15/15/15분 지연을 사용한다. +기본 fixedDelay는 1000ms이며 5개 그룹 처리와 SKIP LOCKED claim을 유지한다. + +재개 DB 경계는 `TranslationJobRepository.restartFailedJob(jobId: Long, now: LocalDateTime): Int` 조건부 update다. +id와 FAILED 조건으로 4개 필드를 함께 변경하며 persistence context를 자동 clear하지 않는다. + +- [x] **RED:** 기존 행의 상태별 재개, 동시 재개, 5회 재시도 경계와 1초 설정의 실패 테스트 작성. +- [x] **RED 확인:** `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest'`에서 의도한 assertion 실패 확인. +- [x] **GREEN:** 기존 상태 전이와 DB 경합 경계에서 최소 구현. +- [x] **GREEN 확인:** 동일 focused 테스트와 추가 DB 통합 테스트 통과. +- [x] **REFACTOR:** 새 중복만 정리하고 캐시/부분 실패 회귀를 기능별 실행. + +### 작업 B: 언어 감지와 콘텐츠 수정 + +파일: +- `src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentService.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/creator/admin/content/CreatorAdminContentService.kt` +- 직접 생성자를 쓰는 해당 기능의 테스트 fixture. +- `src/test/kotlin/kr/co/vividnext/sodalive/content/`의 감지 트랜잭션 통합 테스트 및 관련 관리자 수정 테스트. + +계약: 일반 메타데이터 감지 성공 후 ResourceTranslationJobScheduler를 같은 트랜잭션에서 직접 호출한다. +커뮤니티의 기존 revision/hash 검증과 after-commit 경로는 보존한다. +관리자 제목/설명 변경과 크리에이터 관리자 태그 없는 제목/설명 변경도 커밋 후 번역 이벤트를 발행한다. + +- [x] **RED:** 실제 DB로 감지 후 작업 존재/롤백, 태그 없는 관리자 텍스트 수정의 작업 요청 누락을 재현. +- [x] **RED 확인:** 해당 신규 감지 테스트와 관련 관리자 기능 테스트에서 의도한 실패 확인. +- [x] **GREEN:** 기존 서비스/리스너에 최소 연결 수정. +- [x] **GREEN 확인:** 감지·관리자 수정 focused 테스트 통과. +- [x] **REFACTOR:** 커뮤니티 감지/동시성 기능 회귀를 별도 실행하고 기존 보호 확인. + +### 작업 C: 공급자 기본 순서 + +파일: +- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt` +- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt` +- 필요한 production 기본값 소유 테스트. +- `docs/20261109_감지번역공급자공통화/provider-guide.md` + +계약: 번역 AWS/Papago, 감지 Papago/AWS. 기존 캐시와 fallback 유지. + +- [x] **RED:** 기본 Spring 설정에서 실제 coordinator가 AWS 번역을 선택하고 감지는 Papago를 선택하는 실패 테스트. +- [x] **RED 확인:** `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderSpringConfigurationTest'`의 선택 결과 실패 확인. +- [x] **GREEN:** production 순서와 현재 가이드 변경. +- [x] **GREEN 확인:** 같은 테스트 및 provider/coordinator 관련 기능 회귀 통과. +- [x] **REFACTOR:** 과거 이력은 보존하고 현재 실행 안내만 정합성 확인. + +### 작업 D: 조회 시 실패 재개 + +파일: +- `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt` +- `src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt` +- 해당 기능의 기존/신규 focused 테스트. + +최종 HTTP/DB 연결 확인 파일: +`src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt`. +실제 관리자 controller multipart 요청과 Spring 서비스/이벤트/DB를 실행하고 동일 FAILED 행 재개와 필드별 작업 저장을 검증한다. +외부 공급자는 호출하지 않고 비동기 executor를 테스트에서 동기 실행하여 커밋 후 동작을 결정적으로 확인한다. + +계약: 기존 번역 요청 진입점에서 현재 원문과 대상 locale의 FAILED를 재개한다. 이전 번역 행이 있어도 요청이 전달된다. +원문 fallback과 기존 번역 응답을 유지하고, 관계없는 목록 전체에 번역 요청을 추가하지 않는다. + +추가 공통 파일: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt`. +읽기 전용 상위 트랜잭션에서도 저장 가능한 `restartFailedResourceTranslations(resourceType, resourceIds: Collection, targetLanguage)` +REQUIRES_NEW 진입점을 사용한다. FAILED 후보가 없으면 원문을 불필요하게 추출하지 않으며, 현재 원문에 해당하는 작업만 재개한다. +커뮤니티 쓰기 잠금 안에서는 이 REQUIRES_NEW 읽기 진입점을 호출하지 않고 기존 REQUIRED 예약으로 처리한다. +계획 검토에서 제안된 모든 projection/list의 광범위한 변경은 채택하지 않고 PRD의 기존 번역 요청 경계로 한정한다. + +- [x] **RED:** 이전 번역이 존재하는 상태에서도 조회가 현재 원문의 FAILED를 재개하는 실패 테스트. +- [x] **RED 확인:** 변경 기능의 focused 테스트에서 의도한 실패 확인. +- [x] **GREEN:** 기존 요청 분기의 예약 위치를 조정한다. +- [x] **GREEN 확인:** 각 기능 focused 테스트 통과. +- [x] **REFACTOR:** 실제 DB 재개 주기와 기존 응답 유지 확인. + +### Phase 1 Gate + +**Goal P1-GATE:** MT-001~007과 직접 영향 기능의 검증/리뷰 증거를 판정한다. + +- 시작 조건: P1-T1의 구현과 focused RED/GREEN 완료. +- TDD 예외 사유: Gate는 기존 구현 검증/리뷰이며 새 동작을 추가하지 않는다. +- 완료 증거: 기능별 테스트, lint/bootJar, DB 동작 QA, 단일 독립 리뷰와 문서 갱신. +- 범위 밖: 전체 테스트, 실 AWS/Papago/IAM 및 운영 MySQL/배포 검증. + +- [x] 번역 공통 패키지 및 언어 감지 캐시 기능 회귀. +- [x] 콘텐츠/관리자 수정·시리즈·테마·카테고리·캐릭터/원작·커뮤니티의 직접 영향 기능별 회귀. +- [x] `./gradlew --no-daemon ktlintCheck bootJar` 통과. +- [x] 실제 트랜잭션의 저장/롤백, 실패 소진 후 조회/수정 재개, 캐시 재사용 QA. +- [x] 한 명의 리뷰어가 요구사항/동시성/테스트 증거 검토, 지적 사항 해결. +- [x] PRD/계획 완료 상태와 미검증 범위 기록. + +## 검증 기록 + +### 후속 Goal P1-T2: 감지도 AWS 우선으로 전환 + +- 시작 조건: 사용자가 기존 감지 캐시 유지와 AWS/Papago 순서를 승인했다. +- 완료 증거: Spring 기본 감지 AWS 선택, 실제 AWS adapter SDK 응답 처리, AWS 실패 시 Papago, 기존 Papago 캐시 무호출 재사용. +- 범위 밖: 감지 알고리즘/confidence/지원 언어/캐시 무효화/번역·재시도 재설계. +- production 파일: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`. +- 테스트 파일: 같은 i18n/translation 테스트 패키지의 `LanguageProviderSpringConfigurationTest.kt`, `LanguageProviderIdTest.kt`, `LanguageDetectionProviderTest.kt`, `LanguageProviderCacheEndToEndTest.kt`. +- 문서: 기존 PRD 및 `docs/20261109_감지번역공급자공통화/provider-guide.md`. +- [x] **RED:** 기본 설정의 AWS 감지와 fallback/cache 회귀 기대를 작성하고 의도한 실패 확인. +- [x] **GREEN:** detectionOrder만 AWS/Papago로 변경하고 관련 감지·설정·캐시 테스트 통과. +- [x] **REFACTOR:** 현재 가이드 갱신, ktlintCheck/bootJar, 후속 delta 리뷰와 임시 자원 정리. +- 검증 명령: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProvider*Test' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageDetectionProviderTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageDetectionProviderTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.PapagoLanguageDetectionProviderTest' --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest'`. + +### 후속 회귀 Goal P1-R1: 다른 원문 언어의 FAILED 보존 + +- 시작 조건: gate reviewer가 MT-003의 현재 원문 한정 재개 누락을 확인했다. +- 완료 증거: 같은 해시/다른 원문 언어 작업은 직접 예약과 번역 행 없는 조회 모두에서 재개되지 않는다. +- 범위 밖: 작업 고유 키/스키마 변경, 이전 언어 데이터 변환, materializer 재설계. +- 파일: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt`, + `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRetryIntegrationTest.kt`, + `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt`. +- [x] **RED:** 두 경로의 다른 원문 언어 FAILED 보존 회귀 테스트 추가. +- [x] **RED 확인:** 두 테스트 클래스에서 FAILED 기대/PENDING 실제 실패 확인. +- [x] **GREEN:** FAILED 재개 조건에 정규화된 현재 원문 언어 일치 추가. +- [x] **GREEN 확인:** 두 테스트 클래스 및 직접 영향 scheduler/read/HTTP 테스트 통과. +- [x] **REFACTOR:** lint/build 및 차단 사항 delta 재검토 완료. + +- 2026-11-16 기준 상태: Java 17.0.15, 작업 트리 깨끗함, 기존 브랜치 test에서 작업한다. +- 구현 전 `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderSpringConfigurationTest'`: exit 0, 16초. 기존 Gradle 9 호환성 deprecation 안내가 출력됐다. +- 전체 테스트는 미실행이며 사용자 실행 명령은 `./gradlew test`다. +- 2026-11-16 RED: worker/scheduler/retry DB/provider Spring/provider ID/coordinator 43건 중 14건이 의도한 assertion으로 실패했다. 기본 600000ms, 조기 FAILED, 기존 FAILED 미재개, Papago 우선이 각 실패 원인이며 컴파일은 성공했다. +- 2026-11-16 공급자 GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderSpringConfigurationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderIdTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinatorTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderCacheEndToEndTest'`: exit 0, 37초. 기본 AWS 선택, Papago 감지 유지, fallback와 실제 H2 캐시/조회 결과 보존을 확인했다. +- 2026-11-16 연결 RED와 큐 GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*' --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest'`: exit 1, 감지 10건·조회 10건·관리자 수정 8건이 의도한 assertion으로 실패했다. 같은 실행의 worker 13건/scheduler 3건/retry DB 9건은 모두 통과했다. H2에서 기존 FAILED 재개, 동시 요청, RUNNING 선점 뒤 오래된 요청 보호, 자동 재개 금지를 확인했다. H2 claim은 운영 쿼리의 SKIP LOCKED 옵션만 제거한 테스트이며 MySQL 잠금 동작 검증이 아니다. +- 2026-11-16 연결 GREEN: 감지 10건, 조회 15건, 관리자 수정 8건, HTTP 1건 통과. 이후 번역/감지 회귀 191건과 직접 영향 기능 회귀 67건(HTTP 1건 중복)을 실행해 총 257개 고유 사례에서 실패/오류/skip 0을 확인했다. +- 2026-11-16 최종 lint/build: 첫 main/test 인자 줄바꿈 위반을 변경 부분에서 수정한 뒤 ktlintCheck/bootJar 및 직접 수정 기능 49건을 함께 실행해 exit 0을 확인했다. HTTP test는 이벤트 발행을 끊는 변이로 DB assertion RED도 확인하고 원상 복구했다. +- 정확한 회귀 명령·QA 관찰값·원본 증거 경로·H2/Redis 로그 한계는 [검증 기록](reviews/verification.md)에 보존한다. 현재 단일 독립 reviewer 판정 대기다. +- 2026-11-16 P1-R1: reviewer가 일반 예약 경로에서 이전 원문 언어의 FAILED도 재개하는 누락을 확인했다. 직접 scheduler와 번역 행 없는 원작 조회 2건의 RED를 확인하고 원문 언어 일치 guard를 추가했다. 직접 영향 74건과 ktlintCheck/bootJar는 exit 0이며 추가 2건을 포함한 고유 검증 사례는 259건이다. delta 재검토 대기. +- 2026-11-16 최종 Gate: 동일 독립 reviewer가 P1-R1 수정과 RED/GREEN/XML 74건 및 lint/build 증거를 대조해 APPROVE했다. 차단 사항 없음. 전체 테스트와 운영 MySQL/외부 공급자 검증은 별도이며 커밋·배포는 하지 않았다. +- 2026-11-16 P1-T2: 감지 AWS 우선 변경 전 기본값/실제 SDK adapter/기존 캐시 관련 7개 assertion RED를 확인했다. detectionOrder 한 줄 변경 후 명시된 감지·공급자·캐시 기능 테스트 49건(8개 클래스, 실패/오류/skip 0) 및 ktlintCheck/bootJar가 exit 0이다. 후속 delta 리뷰 대기. +- 2026-11-16 P1-T2 최종: 독립 reviewer APPROVE. 현재 가이드의 잔여 PAPAGO 우선 테스트 설명도 AWS로 정정했다. 이전 기능 검증 기록과 완료 상태를 보존하며, 후속 감지 변경까지 완료했다. +- 2026-11-16 커밋 전 검증: 사용자 커밋 요청에 따라 번역·감지 및 직접 영향 기능을 함께 재실행했다. 33개 클래스 261건의 실패/오류/skip 0, ktlintCheck/bootJar는 UP-TO-DATE, 전체 명령은 exit 0(2분 3초)이다. 정확한 명령은 [검증 기록](reviews/verification.md)의 커밋 전 재검증 절에 남긴다. 전체 테스트는 미실행이며 사용자 실행 명령은 `./gradlew test`다. diff --git a/docs/20261116_메타데이터번역신속반영/prd.md b/docs/20261116_메타데이터번역신속반영/prd.md new file mode 100644 index 00000000..2b80ac87 --- /dev/null +++ b/docs/20261116_메타데이터번역신속반영/prd.md @@ -0,0 +1,49 @@ +# 메타데이터 자동 번역 신속 반영 PRD + +| 항목 | 내용 | +|---|---| +| 작성일 | 2026-11-16 | +| 상태 | 구현·기능 검증·독립 리뷰 완료 | +| 구현 계획 | [plan-task.md](plan-task.md) | +| 결정권자 | 사용자 | + +## 목적과 현재 문제 + +콘텐츠, 시리즈, 테마 등 기존 메타데이터 번역의 작업 등록 누락과 10분 대기를 줄인다. +언어 감지 결과 저장 전 별도 비동기 번역 이벤트가 실행될 수 있고, 관리자 콘텐츠 수정에는 이벤트 미발행 경로가 있다. +기존 FAILED 작업은 같은 원문으로 요청해도 재개되지 않으며, 워커는 기본 10분 간격이다. + +## 확정 요구사항 + +| ID | 요구사항 | 수용 기준 | +|---|---|---| +| MT-001 | 언어 감지 성공 후 번역 작업을 등록한다. | 기존 일반 메타데이터 감지 경로는 감지된 languageCode와 translation_job을 같은 트랜잭션에 저장한다. 작업 등록 실패 시 언어 저장도 롤백한다. 커뮤니티의 기존 revision/hash 검증은 보존한다. | +| MT-002 | 최초 번역 후 최대 5회 재시도한다. | 한 주기는 최초 시도 1회와 재시도 5회, 총 6회다. 6번째 실패 후 FAILED로 멈춘다. 자동 재시도 지연은 1분, 5분, 이후 15분이다. | +| MT-003 | 소진 후 조회/수정 요청으로 다시 최대 5회 재시도한다. | 현재 원문에 해당하는 기존 FAILED 행을 PENDING, retryCount=0, lastErrorMessage=null, nextRetryAt=요청 시각으로 재개한다. PENDING/RUNNING/COMPLETED는 요청으로 초기화하지 않는다. 중복 요청이 실행 중 재시도 예산을 늘리지 않는다. | +| MT-004 | AWS 감지와 번역을 먼저 사용한다. | 새 외부 감지·번역은 모두 AWS 다음 Papago다. 기존 Papago 포함 유효 캐시를 우선 재사용한다. | +| MT-005 | 번역을 빠르게 반영한다. | 워커 기본 fixedDelay는 1000ms, 실행당 최대 5개 그룹을 유지한다. 실제 완료 시간은 대기량과 외부 API 처리 시간에 좌우된다. | +| MT-006 | 콘텐츠 수정과 기존 조회 흐름을 연결한다. | 일반 관리자 제목/상세 수정과 크리에이터 관리자 태그 없는 제목/상세 수정도 작업을 요청한다. 기존 번역 응답이 남아 있어도 관련 조회 요청은 현재 원문의 FAILED 작업을 재개할 수 있다. | +| MT-007 | 기존 계약과 경쟁 처리를 유지한다. | ko/en/ja, 공개 API/원문 fallback, provider별 캐시, SKIP LOCKED 작업 claim, 커뮤니티 revision 보호를 유지한다. job 등록/재개와 워커의 상태 경쟁을 DB 조건 또는 잠금으로 보호한다. | + +## 구현 결정 + +- 새 메시지 브로커, 외부 API, 의존성, DB 스키마를 추가하지 않고 기존 scheduler/worker를 사용한다. +- 최초 시도와 별도로 재시도 5회를 부여하는 것으로 사용자 문구를 해석한다. 이 해석은 실행 시작 시 사용자에게 명시했다. +- 감지 실패 시 번역은 실행하지 않는다. 감지 자체의 새 재시도 시스템과 운영 데이터 일괄 복구는 이번 범위가 아니다. +- 기존 번역을 즉시 삭제하지 않고 작업 완료 시 교체한다. 원문 변경 후 조회 fallback 계약은 유지한다. +- 조회/수정은 기존 번역 기능 진입점에서 처리한다. 관계없는 모든 목록 API에 새 번역 작업 생성을 강제하지 않는다. +- 주기적 워커는 FAILED를 자동으로 되살리지 않는다. 현재 원문에 대한 명시적인 조회/수정 요청만 새 주기를 연다. + +## 검증 + +- 재시도 경계, 소진 후 요청 재개, 진행 중 작업 예산 보존, 동시 요청, 1초 설정과 AWS 우선/fallback/cache를 검증한다. +- 실제 DB 트랜잭션으로 언어 감지 이후 job 저장과 실패 시 롤백을 검증한다. +- 관련 콘텐츠/시리즈/테마 및 직접 영향받는 번역 조회 기능을 기능별로 검증한다. +- 실제 유료 AWS/Papago 호출, 운영 DB/배포, 전체 테스트는 실행하지 않는다. 전체 테스트는 사용자 명령 `./gradlew test`로 구분한다. + +## 결정 기록 + +- 2026-11-16: 사용자가 언어 감지 후 번역, FAILED 재시도, AWS 번역 우선, 빠른 반영을 요청했다. +- 2026-11-16: 기존 DB 큐와 1초 워커, 동일 트랜잭션 작업 등록안을 제시했다. 사용자가 재시도는 5회로 제한하고 소진 후 조회/수정 요청 때 다시 5회로 재개하도록 확정했다. +- 2026-11-16: 구현 후 기능별 고유 사례 259건, ktlintCheck/bootJar를 검증했다. 독립 리뷰의 원문 언어 일치 누락을 회귀 테스트로 보완한 뒤 APPROVE 판정을 받았다. 상세 명령과 미검증 범위는 [검증 기록](reviews/verification.md)에 있다. +- 2026-11-16 후속 승인: 사용자가 감지도 AWS 우선으로 변경하는 데 동의했다. 초기의 Papago 우선 감지 정책을 정정하고, 기존 감지 캐시는 그대로 재사용한다. P1-T2로 검증한다. diff --git a/docs/20261116_메타데이터번역신속반영/reviews/verification.md b/docs/20261116_메타데이터번역신속반영/reviews/verification.md new file mode 100644 index 00000000..b0aa0ee2 --- /dev/null +++ b/docs/20261116_메타데이터번역신속반영/reviews/verification.md @@ -0,0 +1,166 @@ +# 메타데이터 번역 검증 기록 + +## 환경과 범위 + +- 2026-11-16, macOS x64, Java 17.0.15, Gradle Wrapper 8.1.1. +- 커밋하지 않은 작업 트리의 구현을 부모 세션에서 검증했다. +- 실제 Spring/JPA/H2 및 MockMvc controller 요청을 실행했다. 외부 AWS/Papago 호출은 SDK/공급자 경계의 테스트 대역으로 대체했다. +- 실제 운영 DB, 배포 환경변수, IAM, 외부 공급자의 지연/품질/과금은 미검증이다. +- LSP 도구가 없어 Kotlin 컴파일과 ktlint로 진단했다. 전체 테스트는 저장소 정책대로 사용자 실행 `./gradlew test`다. + +## QA 결과 + +| 시나리오 | 실행 경계 | 기대 결과 | 관찰 결과 | +|---|---|---|---| +| 감지 후 작업 등록 | MetadataLanguageDetectTransactionTest, Spring/JPA | 콘텐츠/캐릭터/시리즈/원작/카테고리의 languageCode와 en/ja 필드 작업이 함께 저장 | 5개 대상 모두 커밋 전/후 저장 일치 | +| 작업 저장 실패 | 같은 테스트, H2 CHECK로 ja INSERT 거부 | 선행 en 작업과 languageCode 함께 롤백 | 5개 대상 모두 null 언어/작업 0개 | +| 최초+5회 재시도 | TranslationJobWorkerTest | 실패 1~5회 PENDING, 1/5/15/15/15분, 실패 6회 FAILED | 경계 6사례 및 마지막 재시도 성공 사례 통과 | +| FAILED 요청 재개 | TranslationJobRetryIntegrationTest, H2 | 동일 ID 재개, count 0/error null/due now, active/completed 보호 | 기존 3회/6회 FAILED 및 동시 요청/오래된 조회 후 RUNNING 보호 통과 | +| 조회 응답 유지 | 6개 ReadRetryTest 클래스, H2 | 기존 번역/원문 fallback 유지하며 현재 원문의 FAILED만 재개 | 15건 통과, 이전 해시/다른 언어/다른 대상 locale/제외 테마 보호 | +| 관리자 HTTP 수정 | MetadataTranslationHttpIntegrationTest, MockMvc + 실제 서비스/이벤트/JPA | HTTP 200, 커밋 후 동일 FAILED 행 재개와 4개 필드 작업 | 아래 실제 출력, PENDING/count 0/error null 및 title/detail × en/ja 4개 확인 | +| 공급자 기본값 | LanguageProviderSpringConfigurationTest/TranslationCoordinatorTest | 감지 Papago 우선, 번역 AWS 우선, 실패 시 Papago, 기존 캐시 재사용 | 실제 Spring 기본 설정과 공급자 선택/캐시 모두 통과 | +| 워커 주기 | TranslationJobWorkerTest | 기본 1000ms, 실행당 최대 5개 그룹 | 기본 스케줄 계약과 실행 상한 통과 | + +HTTP QA 출력: + +```text +HTTP QA: status=200, body={"success":true,"message":null,"data":{},"errorProperty":null}, contentId=1, restartedJobId=1 +``` + +HTTP 증거 파일은 `build/test-results/test/TEST-kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest.xml`이다. +MockMvc standalone controller는 인증 필터 검증이 아니라 multipart 입력부터 실제 서비스/커밋 이벤트/DB까지의 연결 검증이다. +동기 테스트 executor로 커밋 후 실행을 결정적으로 검증했으며 실제 스레드 스케줄링 지연은 측정하지 않았다. +H2 worker claim 검증은 운영 SQL에서 SKIP LOCKED 옵션만 제거했으므로 MySQL 잠금 동시성 검증으로 해석하지 않는다. + +## 실패를 잡는 증거 + +- 변경 전 기준 worker/scheduler/provider 테스트는 통과했다. +- 최초 RED: 43건 중 14건 실패. 기존 10분 기본값, 3회 실패 종료, FAILED 미재개, Papago 우선이 예상 assertion 실패로 나타났다. +- 연결 RED: 감지 10건, 조회 10건, 관리자 수정 8건이 예상 assertion으로 실패했고 컴파일은 성공했다. +- HTTP 테스트 추가 검증: 관리자 이벤트 발행 조건만 일시적으로 false로 바꾸자 HTTP 요청은 성공하더라도 `PENDING` 기대에서 실패했다. 조건을 원래 수정본으로 복원한 뒤 같은 테스트가 통과했다. 변이는 남기지 않았다. + +## 통과한 실행 + +### 번역·언어 감지 회귀: 191건 + +```bash +./gradlew --no-daemon test \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.*' \ + --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' \ + --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' +``` + +25개 클래스, failures/errors/skipped 모두 0. 공급자 adapter/캐시, retry, read, HTTP, 감지 원자성 포함. + +### 직접 영향 기능 회귀: 67건 + +```bash +./gradlew --no-daemon test \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \ + --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' \ + --tests 'kr.co.vividnext.sodalive.admin.content.AdminContentServiceTest' \ + --tests 'kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterControllerTest' \ + --tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectTest' \ + --tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectionCacheConcurrencyTest' \ + --tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \ + --tests 'kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityTranslationEndToEndTest' \ + --tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*' +``` + +9개 클래스, failures/errors/skipped 모두 0. 위 191건과 HTTP 1건이 중복되므로 합계는 257개 고유 사례다. + +### 포맷 수정 후 최종 체크: 49건 + lint/build + +```bash +./gradlew --no-daemon ktlintCheck bootJar test \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \ + --tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \ + --tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*' +``` + +exit 0. 앞선 lint 실행에서 새 호출의 인자 줄바꿈과 테스트 한 줄 길이 위반을 발견해 변경 줄만 수정했다. +운영/테스트 Kotlin 컴파일, ktlintCheck, bootJar 및 수정된 기능 49건이 통과했다. Gradle 9 호환성 deprecation 안내는 기존 상태다. + +기능 회귀의 전체 Spring context에서는 기존 MySQL 전용 SKIP LOCKED 쿼리를 H2 스케줄러가 실행해 SQL 구문 오류가 로그에 남았다. +테스트 assertion 실패는 없지만 이 실행을 운영 MySQL 워커 claim 검증으로 간주하지 않는다. 쿼리는 이번 변경에서 수정하지 않았다. +embedded Redis 종료 시 기존 연결의 재접속 WARN도 출력됐다. 실행 후 Gradle test worker/redis-server 잔존 프로세스는 없었다. +별도의 기존 Gradle daemon PID 1396은 이번 --no-daemon 실행의 소유 프로세스가 아니므로 종료하지 않았다. + +## P1-R1 리뷰 후 회귀 보완 + +reviewer는 공통 예약 경로에서 이전 원문 언어의 FAILED도 재개하는 누락을 확인했다. +직접 예약 및 기존 번역 행 없는 원작 조회의 2개 테스트가 FAILED 기대/PENDING 실제로 실패하는 것을 확인했다. +`TranslationJobScheduler`의 FAILED 재개 조건에 `existingJob.sourceLanguage == normalizedSourceLanguage`를 추가했다. + +```bash +./gradlew --no-daemon ktlintCheck bootJar test \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \ + --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' \ + --tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectTest' \ + --tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectionCacheConcurrencyTest' \ + --tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \ + --tests 'kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityTranslationEndToEndTest' +``` + +14개 클래스 74건, failures/errors/skipped 모두 0, lint/build exit 0. +원문 언어 불일치 직접 예약/번역 없는 조회 2건이 추가되어 이번 작업의 고유 검증 사례는 259건이다. +마지막 XML에서도 HTTP 200과 동일 ID FAILED 재개를 재확인했다. 차단 사항 delta 재검토 대기. + +## 최종 판정과 운영 확인 범위 + +- 독립 gate reviewer의 첫 판정은 원문 언어 불일치 재개의 P1 차단 사항으로 REJECT였다. 두 회귀 테스트와 guard 추가 후 delta 재검토는 APPROVE다. 최종 차단 사항 없음. +- 운영의 `sodalive.translation-job.fixed-delay-ms` override가 있으면 새 기본값을 덮어쓴다. 운영 설정과 실제 공급자 지연/쿼터는 배포 시 확인 대상이다. +- 큐가 비어 있을 때의 1초 polling 기준을 바꿨으며 번역 완료 1초 SLA를 주장하지 않는다. +- 정리 완료: 독립 리뷰가 원본 로그를 읽고 승인한 후 이번 실행의 임시 디렉터리 `translation-ulw.jWBKaK`와 하위 로그/메모를 삭제하고 경로 부재를 확인했다. 영속 검증 기록은 이 문서와 계획에 남겼다. 소유 test worker/Redis 프로세스는 남아 있지 않으며 공유 캐시와 기존 Gradle daemon은 건드리지 않았다. 최종 `git diff --check`도 통과했다. + +## 후속 P1-T2: 감지 AWS 우선 + +사용자 후속 승인에 따라 감지도 AWS/Papago 순서로 정정했다. 이전 절의 Papago 감지 유지 검증은 초기 요구사항에 대한 이력이다. +새 기본값의 Spring 감지 선택, 실제 AWS adapter의 SDK 응답 사용, AWS 예외/null/blank 뒤 Papago 전환, +기존 Papago 감지 캐시의 외부 호출 없는 재사용을 검증했다. 번역 우선순위와 명시적 테스트 순서 설정은 유지했다. + +```bash +./gradlew --no-daemon ktlintCheck bootJar test \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProvider*Test' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageDetectionProviderTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageDetectionProviderTest' \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.PapagoLanguageDetectionProviderTest' \ + --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' +``` + +변경 전 7개 assertion RED, 변경 후 8개 클래스 49건의 실패/오류/skip 0 및 lint/build exit 0. +H2 E2E는 전체 원문별 AWS 감지 캐시 2개 저장 및 반복 요청의 SDK 무호출을 검증한다. +실제 외부 API 호출/정확도 비교/IAM과 전체 테스트는 실행하지 않았다. 후속 delta 리뷰 대기. + +후속 delta 최종 판정은 APPROVE다. reviewer가 코드·Spring/SDK 경계·H2 캐시·RED/GREEN과 49건 XML을 확인했다. +비차단 지적이었던 현재 가이드의 테스트 설명도 AWS 우선으로 정정했다. +승인 후 `detection-aws.4a18xV` 임시 루트와 로그/메모를 삭제하고 경로 부재를 확인했다. +소유 test worker/Redis 프로세스는 없으며, 공유 캐시는 보존했다. 후속 `git diff --check`도 통과했다. + +## 커밋 전 재검증 + +2026-11-16 사용자 커밋 요청에 따라 최종 변경 상태에서 다음 명령을 실행했다. + +```bash +./gradlew --no-daemon ktlintCheck bootJar test \ + --tests 'kr.co.vividnext.sodalive.i18n.translation.*' \ + --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' \ + --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' \ + --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' \ + --tests 'kr.co.vividnext.sodalive.admin.content.AdminContentServiceTest' \ + --tests 'kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterControllerTest' \ + --tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectTest' \ + --tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectionCacheConcurrencyTest' \ + --tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \ + --tests 'kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityTranslationEndToEndTest' \ + --tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*' +``` + +- exit 0, `BUILD SUCCESSFUL in 2m 3s`. 테스트를 새로 실행했고 ktlintCheck/bootJar는 UP-TO-DATE다. +- `build/test-results/test/TEST-*.xml` 33개 클래스 261건에서 failures/errors/skipped 모두 0을 확인했다. +- 전체 테스트와 운영 MySQL/외부 공급자 검증은 미실행이다. 전체 테스트 사용자 실행 명령은 `./gradlew test`다. diff --git a/docs/agent-guides/실행명령어.md b/docs/agent-guides/실행명령어.md index 91509019..29282bbb 100644 --- a/docs/agent-guides/실행명령어.md +++ b/docs/agent-guides/실행명령어.md @@ -22,6 +22,9 @@ ./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageDetectionProviderTest' ./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsTranslationServiceTest' ./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageProviderConfigurationTest' +./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest' +./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' +./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' ./gradlew bootJar ./gradlew ktlintCheck ./gradlew ktlintFormat diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentService.kt index b903c420..8ebb0756 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentService.kt @@ -9,8 +9,11 @@ import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront import kr.co.vividnext.sodalive.aws.s3.S3Uploader import kr.co.vividnext.sodalive.common.SodaException import kr.co.vividnext.sodalive.content.main.tab.GetContentMainTabItem +import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent +import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType import kr.co.vividnext.sodalive.utils.generateFileName import org.springframework.beans.factory.annotation.Value +import org.springframework.context.ApplicationEventPublisher import org.springframework.data.domain.Pageable import org.springframework.data.repository.findByIdOrNull import org.springframework.stereotype.Service @@ -26,6 +29,7 @@ class AdminContentService( private val contentMainTabRepository: AdminContentMainTabRepository, private val objectMapper: ObjectMapper, private val s3Uploader: S3Uploader, + private val applicationEventPublisher: ApplicationEventPublisher, @Value("\${cloud.aws.s3.bucket}") private val bucket: String ) { @@ -158,6 +162,16 @@ class AdminContentService( } audioContent.settlementRatio = request.settlementRatio } + + if (request.title != null || request.detail != null) { + applicationEventPublisher.publishEvent( + LanguageTranslationEvent( + id = request.id, + targetType = LanguageTranslationTargetType.CONTENT, + waitTransactionCommit = true + ) + ) + } } fun getContentMainTabList(): List { diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt b/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt index e1fc899e..a8db80d7 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt @@ -186,6 +186,11 @@ class ChatCharacterController( var translated: TranslatedAiCharacterDetail? = null if (langContext.lang.code != character.languageCode) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CHARACTER, + listOf(characterId), + langContext.lang.code + ) val existing = aiCharacterTranslationRepository .findByCharacterIdAndLocale(character.id!!, langContext.lang.code) diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt index 41fdcc75..ab6fc5ad 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt @@ -28,8 +28,15 @@ class OriginalWorkTranslationService( return null } + val originalWorkId = requireNotNull(originalWork.id) + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.ORIGINAL_WORK, + listOf(originalWorkId), + target + ) + // 기존 번역 조회 - val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWork.id!!, target) + val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWorkId, target) val existedPayload = existed?.renderedPayload if (existedPayload != null) { val t = existedPayload.title.trim() @@ -51,7 +58,7 @@ class OriginalWorkTranslationService( resourceTranslationJobScheduler.scheduleResourceTranslation( resourceType = LanguageTranslationTargetType.ORIGINAL_WORK, - resourceId = originalWork.id!!, + resourceId = originalWorkId, targetLanguage = target ) return null diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt index 5be729a1..6276963f 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt @@ -896,6 +896,11 @@ class AudioContentService( audioContent.languageCode!!.isNotBlank() && audioContent.languageCode != langContext.lang.code ) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CONTENT, + listOf(id), + langContext.lang.code + ) val existing = contentTranslationRepository .findByContentIdAndLocale(audioContent.id!!, langContext.lang.code) diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt index 2ea6e6f0..f64a658e 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt @@ -8,12 +8,11 @@ import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository import kr.co.vividnext.sodalive.explorer.profile.CreatorCheersRepository import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository -import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType +import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService import org.slf4j.LoggerFactory -import org.springframework.context.ApplicationEventPublisher import org.springframework.data.repository.findByIdOrNull import org.springframework.scheduling.annotation.Async import org.springframework.stereotype.Component @@ -64,8 +63,7 @@ class LanguageDetectListener( private val languageDetectionCacheService: LanguageDetectionCacheService, private val creatorCommunityTranslationService: CreatorCommunityTranslationService, private val entityManager: EntityManager, - - private val applicationEventPublisher: ApplicationEventPublisher + private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler ) { private val log = LoggerFactory.getLogger(LanguageDetectListener::class.java) @@ -116,11 +114,9 @@ class LanguageDetectListener( character.languageCode = langCode chatCharacterRepository.save(character) - applicationEventPublisher.publishEvent( - LanguageTranslationEvent( - id = characterId, - targetType = LanguageTranslationTargetType.CHARACTER - ) + resourceTranslationJobScheduler.scheduleResourceTranslations( + resourceType = LanguageTranslationTargetType.CHARACTER, + resourceId = characterId ) log.info( @@ -156,11 +152,9 @@ class LanguageDetectListener( // REQUIRES_NEW 트랜잭션 내에서 변경 내용을 저장한다. audioContentRepository.save(audioContent) - applicationEventPublisher.publishEvent( - LanguageTranslationEvent( - id = contentId, - targetType = LanguageTranslationTargetType.CONTENT - ) + resourceTranslationJobScheduler.scheduleResourceTranslations( + resourceType = LanguageTranslationTargetType.CONTENT, + resourceId = contentId ) log.info( @@ -288,11 +282,9 @@ class LanguageDetectListener( series.languageCode = langCode seriesRepository.save(series) - applicationEventPublisher.publishEvent( - LanguageTranslationEvent( - id = seriesId, - targetType = LanguageTranslationTargetType.SERIES - ) + resourceTranslationJobScheduler.scheduleResourceTranslations( + resourceType = LanguageTranslationTargetType.SERIES, + resourceId = seriesId ) log.info( @@ -326,12 +318,9 @@ class LanguageDetectListener( originalWork.languageCode = langCode originalWorkRepository.save(originalWork) - // 언어 감지가 완료된 후 언어 번역 이벤트 호출 - applicationEventPublisher.publishEvent( - LanguageTranslationEvent( - id = originalWorkId, - targetType = LanguageTranslationTargetType.ORIGINAL_WORK - ) + resourceTranslationJobScheduler.scheduleResourceTranslations( + resourceType = LanguageTranslationTargetType.ORIGINAL_WORK, + resourceId = originalWorkId ) log.info( @@ -352,11 +341,9 @@ class LanguageDetectListener( category.languageCode = langCode categoryRepository.save(category) - applicationEventPublisher.publishEvent( - LanguageTranslationEvent( - id = categoryId, - targetType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY - ) + resourceTranslationJobScheduler.scheduleResourceTranslations( + resourceType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY, + resourceId = categoryId ) } diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt index 4a83f966..b743fbbc 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt @@ -141,6 +141,11 @@ class CategoryService( val categoryIds = baseList.map { it.categoryId } val entities = repository.findAllById(categoryIds) val entityMap = entities.associateBy { it.id!! } + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY, + categoryIds, + locale + ) // 요청 로케일로 이미 저장된 번역 일괄 조회 val translations = categoryTranslationRepository diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt index 2ead853c..4ad4f917 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt @@ -98,6 +98,11 @@ class ContentSeriesService( if (currentLang == Lang.EN || currentLang == Lang.JA) { val targetLocale = currentLang.code val ids = genres.map { it.id } + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.SERIES_GENRE, + ids, + targetLocale + ) // 기존 번역 일괄 조회 val existing = if (ids.isNotEmpty()) { @@ -278,6 +283,11 @@ class ContentSeriesService( val languageCode = series.languageCode // 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리 if (!languageCode.isNullOrBlank() && languageCode != locale) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.SERIES, + listOf(seriesId), + locale + ) val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale) if (existing != null) { val payload = existing.renderedPayload diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt index ece624e8..36c1408a 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt @@ -58,6 +58,11 @@ class AudioContentThemeService( val targetLocale = currentLang.code // 1) 기존 번역을 한 번에 조회 val ids = themesWithIds.map { it.id } + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CONTENT_THEME, + ids, + targetLocale + ) val existingTranslations = if (ids.isNotEmpty()) { contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale) } else { diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/creator/admin/content/CreatorAdminContentService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/creator/admin/content/CreatorAdminContentService.kt index e502fd88..8625fd0a 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/creator/admin/content/CreatorAdminContentService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/creator/admin/content/CreatorAdminContentService.kt @@ -199,7 +199,9 @@ class CreatorAdminContentService( } audioContent.audioContentHashTags.addAll(newAudioContentHashTagList) + } + if (request.title != null || request.detail != null || !request.tags.isNullOrBlank()) { applicationEventPublisher.publishEvent( LanguageTranslationEvent( id = request.id, diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt index 2c89e06c..f9f792f9 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt @@ -1,6 +1,6 @@ package kr.co.vividnext.sodalive.i18n.translation object LanguageProviderOrder { - val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) - val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) + val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) + val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) } diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt index 5c5013b4..f141efb8 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt @@ -2,12 +2,15 @@ package kr.co.vividnext.sodalive.i18n.translation import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes import org.springframework.stereotype.Service +import org.springframework.transaction.annotation.Propagation import org.springframework.transaction.annotation.Transactional +import java.time.LocalDateTime @Service class ResourceTranslationJobScheduler( private val sourceExtractor: TranslationSourceExtractor, - private val translationJobScheduler: TranslationJobScheduler + private val translationJobScheduler: TranslationJobScheduler, + private val translationJobRepository: TranslationJobRepository ) { @Transactional fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) { @@ -27,6 +30,45 @@ class ResourceTranslationJobScheduler( scheduleSource(source, targetLanguage) } + @Transactional(propagation = Propagation.REQUIRES_NEW) + fun restartFailedResourceTranslations( + resourceType: LanguageTranslationTargetType, + resourceIds: Collection, + targetLanguage: String + ) { + restartFailedResourceTranslationsInCurrentTransaction(resourceType, resourceIds, targetLanguage) + } + + @Transactional + fun restartFailedResourceTranslationsInCurrentTransaction( + resourceType: LanguageTranslationTargetType, + resourceIds: Collection, + targetLanguage: String + ) { + if (resourceIds.isEmpty()) return + + val target = targetLanguage.lowercase() + val candidates = translationJobRepository.findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus( + resourceType, + resourceIds, + target, + TranslationJobStatus.FAILED + ) + val now = LocalDateTime.now() + candidates.groupBy { it.resourceId }.forEach { (resourceId, failedJobs) -> + val source = sourceExtractor.extract(resourceType, resourceId) ?: return@forEach + val sourceLanguage = source.sourceLanguage.lowercase() + if (!TranslationLanguages.isSupported(sourceLanguage) || sourceLanguage == target) return@forEach + + val sourceHashes = source.fields.associate { it.fieldKey to SourceTextNormalizer.hash(it.sourceText) } + failedJobs.filter { job -> + job.sourceLanguage == sourceLanguage && job.sourceHash == sourceHashes[job.fieldKey] + }.forEach { job -> + translationJobRepository.restartFailedJob(requireNotNull(job.id), now) + } + } + } + private fun scheduleSource(source: TranslationSource, targetLanguage: String) { source.fields.forEach { field -> translationJobScheduler.scheduleMissingTranslation( diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRepository.kt b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRepository.kt index 06ce0b09..d803f13d 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRepository.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRepository.kt @@ -1,6 +1,7 @@ package kr.co.vividnext.sodalive.i18n.translation import org.springframework.data.jpa.repository.JpaRepository +import org.springframework.data.jpa.repository.Modifying import org.springframework.data.jpa.repository.Query import org.springframework.data.repository.query.Param import java.time.LocalDateTime @@ -14,6 +15,27 @@ interface TranslationJobRepository : JpaRepository { sourceHash: String ): TranslationJob? + fun findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus( + resourceType: LanguageTranslationTargetType, + resourceIds: Collection, + targetLanguage: String, + status: TranslationJobStatus + ): List + + @Modifying + @Query( + """ + update TranslationJob j + set j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.PENDING, + j.retryCount = 0, + j.lastErrorMessage = null, + j.nextRetryAt = :now + where j.id = :jobId + and j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.FAILED + """ + ) + fun restartFailedJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int + @Query( """ select j from TranslationJob j diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt index 5f8f849a..4b2c1ff7 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt @@ -34,7 +34,12 @@ class TranslationJobScheduler( targetLanguage = normalizedTargetLanguage, sourceHash = sourceHash ) - if (existingJob != null) return + if (existingJob != null) { + if (existingJob.status == TranslationJobStatus.FAILED && existingJob.sourceLanguage == normalizedSourceLanguage) { + translationJobRepository.restartFailedJob(existingJob.id!!, LocalDateTime.now()) + } + return + } translationJobRepository.save( TranslationJob( diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt index 5ea1d74e..d1f17db0 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt @@ -18,7 +18,7 @@ class TranslationJobWorker( private val log = LoggerFactory.getLogger(javaClass) private val transactionTemplate = TransactionTemplate(transactionManager) - @Scheduled(fixedDelayString = "\${sodalive.translation-job.fixed-delay-ms:600000}") + @Scheduled(fixedDelayString = "\${sodalive.translation-job.fixed-delay-ms:1000}") fun runPendingJobs() { repeat(MAX_GROUPS_PER_TICK) { if (!processNextGroup()) return @@ -121,7 +121,7 @@ class TranslationJobWorker( val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult job.retryCount += 1 job.lastErrorMessage = ex.message?.take(MAX_ERROR_LENGTH) - if (job.retryCount >= MAX_RETRY_COUNT) { + if (job.retryCount >= MAX_ATTEMPTS) { job.status = TranslationJobStatus.FAILED } else { job.status = TranslationJobStatus.PENDING @@ -142,6 +142,6 @@ class TranslationJobWorker( companion object { private const val MAX_GROUPS_PER_TICK = 5 private const val MAX_ERROR_LENGTH = 1000 - private const val MAX_RETRY_COUNT = 3 + private const val MAX_ATTEMPTS = 6 } } diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt index 7c1b4972..f001caea 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt @@ -35,6 +35,17 @@ class CreatorCommunityTranslationService( val normalizedLocale = locale.lowercase() val posts = creatorCommunityRepository.findAllById(postIds).filter { it.isActive } + val translationPostIds = posts.filter { post -> + val sourceLanguage = post.languageCode?.lowercase() + !sourceLanguage.isNullOrBlank() && sourceLanguage != normalizedLocale + }.mapNotNull { it.id } + if (translationPostIds.isNotEmpty()) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + translationPostIds, + normalizedLocale + ) + } val translations = creatorCommunityTranslationRepository .findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale) .associateBy { it.creatorCommunityId } @@ -62,6 +73,11 @@ class CreatorCommunityTranslationService( targetLanguages .filter { it != sourceLanguage } .forEach { language -> + resourceTranslationJobScheduler.restartFailedResourceTranslationsInCurrentTransaction( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + listOf(postId), + language + ) if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) { resourceTranslationJobScheduler.scheduleResourceTranslation( resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY, diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentServiceTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentServiceTest.kt index 027bd62b..7d766624 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentServiceTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentServiceTest.kt @@ -15,6 +15,7 @@ import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test import org.mockito.Mockito +import org.springframework.context.ApplicationEventPublisher import java.util.Optional class AdminContentServiceTest { @@ -43,6 +44,7 @@ class AdminContentServiceTest { contentMainTabRepository = contentMainTabRepository, objectMapper = jacksonObjectMapper(), s3Uploader = s3Uploader, + applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java), bucket = "test-bucket" ) } diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/content/MetadataLanguageDetectTransactionTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/content/MetadataLanguageDetectTransactionTest.kt new file mode 100644 index 00000000..8533e712 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/content/MetadataLanguageDetectTransactionTest.kt @@ -0,0 +1,199 @@ +package kr.co.vividnext.sodalive.content + +import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre +import kr.co.vividnext.sodalive.chat.character.ChatCharacter +import kr.co.vividnext.sodalive.chat.original.OriginalWork +import kr.co.vividnext.sodalive.common.BaseEntity +import kr.co.vividnext.sodalive.configs.QueryDslConfig +import kr.co.vividnext.sodalive.content.category.Category +import kr.co.vividnext.sodalive.content.theme.AudioContentTheme +import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository +import kr.co.vividnext.sodalive.creator.admin.content.series.Series +import kr.co.vividnext.sodalive.i18n.translation.DetectedLanguage +import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId +import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType +import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler +import kr.co.vividnext.sodalive.i18n.translation.TranslationJob +import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository +import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler +import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus +import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor +import kr.co.vividnext.sodalive.member.Member +import kr.co.vividnext.sodalive.member.MemberRole +import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService +import org.junit.jupiter.api.AfterEach +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNull +import org.junit.jupiter.api.Assertions.assertThrows +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.EnumSource +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.boot.test.mock.mockito.MockBean +import org.springframework.context.annotation.Import +import org.springframework.dao.DataIntegrityViolationException +import org.springframework.jdbc.core.JdbcTemplate +import org.springframework.test.util.AopTestUtils +import org.springframework.transaction.PlatformTransactionManager +import org.springframework.transaction.annotation.Propagation +import org.springframework.transaction.annotation.Transactional +import org.springframework.transaction.support.TransactionTemplate +import javax.persistence.EntityManager + +@DataJpaTest( + properties = [ + "spring.cache.type=none", + "spring.datasource.url=jdbc:h2:mem:metadata-language-detect;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE" + ] +) +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +@Import( + QueryDslConfig::class, + AudioContentThemeQueryRepository::class, + LanguageDetectListener::class, + TranslationSourceExtractor::class, + ResourceTranslationJobScheduler::class, + TranslationJobScheduler::class +) +@Transactional(propagation = Propagation.NOT_SUPPORTED) +class MetadataLanguageDetectTransactionTest @Autowired constructor( + private val languageDetectListener: LanguageDetectListener, + private val jobRepository: TranslationJobRepository, + private val entityManager: EntityManager, + private val jdbcTemplate: JdbcTemplate, + transactionManager: PlatformTransactionManager +) { + private val transaction = TransactionTemplate(transactionManager) + private val fixtures = mutableListOf() + + @MockBean + private lateinit var detectionCache: LanguageDetectionCacheService + + @MockBean + private lateinit var communityTranslationService: CreatorCommunityTranslationService + + @AfterEach + fun cleanUp() { + transaction.executeWithoutResult { + jobRepository.deleteAll() + fixtures.asReversed().forEach { entity -> + entityManager.remove(entityManager.find(entity.javaClass, entity.id)) + } + } + } + + @ParameterizedTest + @EnumSource(MetadataTarget::class) + @DisplayName("메타데이터 감지는 언어와 전체 번역 작업을 커밋 전 같은 트랜잭션에 저장한다") + fun shouldPersistDetectedLanguageAndJobsInSameTransaction(target: MetadataTarget) { + val event = prepareDetection(target) + // 비동기 어댑터를 제외한 실제 리스너와 Spring scheduler를 하나의 DB 트랜잭션에서 실행한다. + val listener: LanguageDetectListener = AopTestUtils.getTargetObject(languageDetectListener) + + val beforeCommit = transaction.execute { + listener.detectLanguage(event) + readState(target, event.id) + }!! + val afterCommit = transaction.execute { readState(target, event.id) }!! + + val expectedJobs = target.fields.flatMap { (field, text) -> + listOf(Triple(field, "en", text), Triple(field, "ja", text)) + }.toSet() + listOf(beforeCommit, afterCommit).forEach { (languageCode, jobs) -> + assertEquals("ko", languageCode) + assertEquals(expectedJobs.size, jobs.size) + assertEquals(expectedJobs, jobs.map { Triple(it.fieldKey, it.targetLanguage, it.sourceText) }.toSet()) + assertEquals(setOf("ko"), jobs.map { it.sourceLanguage }.toSet()) + assertEquals(setOf(TranslationJobStatus.PENDING), jobs.map { it.status }.toSet()) + } + } + + @ParameterizedTest + @EnumSource(MetadataTarget::class) + @DisplayName("번역 작업 INSERT 실패는 감지 언어와 먼저 저장한 작업을 모두 롤백한다") + fun shouldRollBackDetectedLanguageAndJobsWhenJobInsertFails(target: MetadataTarget) { + val event = prepareDetection(target) + val listener: LanguageDetectListener = AopTestUtils.getTargetObject(languageDetectListener) + // H2 전용 일시 제약으로 en INSERT 이후 ja INSERT를 실제 DB에서 실패시킨다. + jdbcTemplate.execute( + "ALTER TABLE translation_job ADD CONSTRAINT metadata_reject_ja CHECK (target_language <> 'ja')" + ) + try { + assertThrows(DataIntegrityViolationException::class.java) { + transaction.executeWithoutResult { listener.detectLanguage(event) } + } + + val (languageCode, jobs) = transaction.execute { readState(target, event.id) }!! + assertNull(languageCode) + assertEquals(emptyList(), jobs) + } finally { + jdbcTemplate.execute("ALTER TABLE translation_job DROP CONSTRAINT metadata_reject_ja") + } + } + + private fun prepareDetection(target: MetadataTarget): LanguageDetectEvent { + Mockito.`when`(detectionCache.detectWithCache("원문 제목")) + .thenReturn(DetectedLanguage("ko", LanguageProviderId.PAPAGO)) + val id = transaction.execute { + val owner = persist(Member(password = "password", nickname = "metadata-owner", role = MemberRole.CREATOR)) + val metadata = when (target) { + MetadataTarget.CONTENT -> AudioContent("원문 제목", "원문 설명", null).apply { + member = owner + theme = persist(AudioContentTheme("theme", "theme.png")) + } + MetadataTarget.CHARACTER -> ChatCharacter( + characterUUID = "metadata-character", + name = "원문 제목", + description = "원문 설명", + systemPrompt = "system prompt" + ).apply { creatorMember = owner } + MetadataTarget.SERIES -> Series("원문 제목", "원문 설명").apply { + member = owner + genre = persist(SeriesGenre("genre")) + } + MetadataTarget.ORIGINAL_WORK -> OriginalWork( + title = "원문 제목", + contentType = "소설", + category = "판타지", + description = "원문 설명" + ) + MetadataTarget.CREATOR_CONTENT_CATEGORY -> Category("원문 제목").apply { member = owner } + } + requireNotNull(persist(metadata).id) + }!! + return LanguageDetectEvent(id, "원문 제목", LanguageDetectTargetType.valueOf(target.name)) + } + + private fun persist(entity: T): T { + entityManager.persist(entity) + fixtures.add(entity) + return entity + } + + private fun readState(target: MetadataTarget, id: Long): Pair> { + entityManager.flush() + entityManager.clear() + val languageCode = entityManager.createQuery( + "select metadata.languageCode from ${target.entityClass.simpleName} metadata where metadata.id = :id", + String::class.java + ).setParameter("id", id).singleResult + val jobs = jobRepository.findAll().filter { + it.resourceType == LanguageTranslationTargetType.valueOf(target.name) && it.resourceId == id + } + return languageCode to jobs + } + + enum class MetadataTarget(val entityClass: Class, val fields: Map) { + CONTENT(AudioContent::class.java, mapOf("title" to "원문 제목", "detail" to "원문 설명")), + CHARACTER(ChatCharacter::class.java, mapOf("name" to "원문 제목", "description" to "원문 설명")), + SERIES(Series::class.java, mapOf("title" to "원문 제목", "introduction" to "원문 설명")), + ORIGINAL_WORK( + OriginalWork::class.java, + mapOf("title" to "원문 제목", "contentType" to "소설", "category" to "판타지", "description" to "원문 설명") + ), + CREATOR_CONTENT_CATEGORY(Category::class.java, mapOf("category" to "원문 제목")) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt new file mode 100644 index 00000000..5b194151 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt @@ -0,0 +1,113 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import com.fasterxml.jackson.databind.ObjectMapper +import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront +import kr.co.vividnext.sodalive.aws.s3.S3Uploader +import kr.co.vividnext.sodalive.content.AudioContent +import kr.co.vividnext.sodalive.content.AudioContentRepository +import kr.co.vividnext.sodalive.content.AudioContentService +import kr.co.vividnext.sodalive.content.PlaybackTrackingRepository +import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository +import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository +import kr.co.vividnext.sodalive.content.like.AudioContentLikeRepository +import kr.co.vividnext.sodalive.content.order.LimitedEditionOrderRepository +import kr.co.vividnext.sodalive.content.order.OrderRepository +import kr.co.vividnext.sodalive.content.pin.PinContentRepository +import kr.co.vividnext.sodalive.content.theme.AudioContentTheme +import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository +import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository +import kr.co.vividnext.sodalive.content.translation.ContentTranslation +import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload +import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository +import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository +import kr.co.vividnext.sodalive.i18n.SodaMessageSource +import kr.co.vividnext.sodalive.member.Member +import kr.co.vividnext.sodalive.member.MemberRepository +import kr.co.vividnext.sodalive.member.block.BlockMemberRepository +import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService +import kr.co.vividnext.sodalive.support.originalLocalizedNameService +import kr.co.vividnext.sodalive.v2.home.following.application.HomeFollowingNewsPublishService +import kr.co.vividnext.sodalive.v2.recommendation.application.CreatorContentViewHistoryService +import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.context.ApplicationEventPublisher +import java.util.Optional + +class AudioContentReadRetryTest : MetadataReadRetryTestSupport() { + @Autowired + private lateinit var translations: ContentTranslationRepository + + @Test + @DisplayName("오디오 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다") + fun shouldRestartFailedContentWhilePreservingRenderedDetail() { + val source = givenSource(LanguageTranslationTargetType.CONTENT, "title", "현재 제목") + val job = failedJob(source) + persistRendered( + ContentTranslation(10L, "en", ContentTranslationPayload("Old title", "Old detail", "old tags")), + "content_translation", + """{"title":"Old title","detail":"Old detail","tags":"old tags"}""" + ) + val member = Member(password = "password", nickname = "creator").apply { id = 100L } + val content = AudioContent("현재 제목", "현재 설명", "ko", isCommentAvailable = false).apply { + id = 10L + this.member = member + theme = AudioContentTheme("테마", "theme.png").apply { id = 20L } + this.content = "output/audio.mp3" + coverImage = "cover.png" + duration = "00:01:00" + isActive = true + } + val repository = Mockito.mock(AudioContentRepository::class.java) + val explorer = Mockito.mock(ExplorerQueryRepository::class.java) + val orders = Mockito.mock(OrderRepository::class.java) + val cloudFront = Mockito.mock(AudioContentCloudFront::class.java) + Mockito.`when`(repository.findById(10L)).thenReturn(Optional.of(content)) + Mockito.`when`(explorer.getMember(100L)).thenReturn(member) + Mockito.`when`(orders.isExistOrderedAndOrderType(100L, 10L)).thenReturn(false to null) + Mockito.`when`(cloudFront.generateSignedURL("output/audio.mp3", 7_200_000L)).thenReturn("https://signed.test/audio") + val service = AudioContentService( + repository = repository, + explorerQueryRepository = explorer, + blockMemberRepository = Mockito.mock(BlockMemberRepository::class.java), + hashTagRepository = Mockito.mock(HashTagRepository::class.java), + orderRepository = orders, + limitedEditionOrderRepository = Mockito.mock(LimitedEditionOrderRepository::class.java), + themeQueryRepository = Mockito.mock(AudioContentThemeQueryRepository::class.java), + playbackTrackingRepository = Mockito.mock(PlaybackTrackingRepository::class.java), + creatorContentViewHistoryService = Mockito.mock(CreatorContentViewHistoryService::class.java), + commentRepository = Mockito.mock(AudioContentCommentRepository::class.java), + audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java), + pinContentRepository = Mockito.mock(PinContentRepository::class.java), + memberRepository = Mockito.mock(MemberRepository::class.java), + resourceTranslationJobScheduler = scheduler, + contentTranslationRepository = translations, + s3Uploader = Mockito.mock(S3Uploader::class.java), + objectMapper = ObjectMapper(), + audioContentCloudFront = cloudFront, + applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java), + messageSource = SodaMessageSource(), + langContext = langContext, + localizedNameService = originalLocalizedNameService(), + contentThemeTranslationRepository = Mockito.mock(ContentThemeTranslationRepository::class.java), + homeFollowingNewsPublishService = Mockito.mock(HomeFollowingNewsPublishService::class.java), + memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java), + subtitleJobService = Mockito.mock(SubtitleJobService::class.java), + transactionManager = transactionManager, + audioContentBucket = "audio-bucket", + coverImageBucket = "cover-bucket", + coverImageHost = "https://cdn.test" + ) + + val response = service.getDetail(10L, member, false, "Asia/Seoul") + + assertEquals("현재 제목", response.title) + assertEquals("Old title", response.translated?.title) + assertEquals("Old detail", response.translated?.detail) + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt new file mode 100644 index 00000000..c0751e3b --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt @@ -0,0 +1,78 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.chat.character.ChatCharacter +import kr.co.vividnext.sodalive.chat.character.comment.CharacterCommentService +import kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterController +import kr.co.vividnext.sodalive.chat.character.curation.CharacterCurationQueryService +import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterBannerService +import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService +import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslation +import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationRenderedPayload +import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationRepository +import kr.co.vividnext.sodalive.chat.room.service.ChatRoomService +import kr.co.vividnext.sodalive.content.ContentType +import kr.co.vividnext.sodalive.member.Member +import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService +import kr.co.vividnext.sodalive.member.contentpreference.ViewerContentPreference +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired + +class CharacterReadRetryTest : MetadataReadRetryTestSupport() { + @Autowired + private lateinit var translations: AiCharacterTranslationRepository + + @Test + @DisplayName("캐릭터 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다") + fun shouldRestartFailedCharacterWhilePreservingRenderedDetail() { + val source = givenSource(LanguageTranslationTargetType.CHARACTER, "name", "현재 이름") + val job = failedJob(source) + persistRendered( + AiCharacterTranslation( + 10L, + "en", + AiCharacterTranslationRenderedPayload("Old name", "Old description", "", "", "", "", "", "") + ), + "ai_character_translation", + """ + {"name":"Old name","description":"Old description","gender":"","personalityTrait":"", + "personalityDescription":"","backgroundTopic":"","backgroundDescription":"","tags":""} + """.trimIndent() + ) + val member = Member(password = "password", nickname = "viewer").apply { id = 100L } + val character = ChatCharacter( + characterUUID = "character-10", + name = "현재 이름", + description = "현재 설명", + systemPrompt = "prompt", + languageCode = "ko" + ).apply { id = 10L } + val characterService = Mockito.mock(ChatCharacterService::class.java) + val preferenceService = Mockito.mock(MemberContentPreferenceService::class.java) + Mockito.`when`(characterService.getCharacterDetail(10L)).thenReturn(character) + Mockito.`when`(preferenceService.getStoredPreference(member)) + .thenReturn(ViewerContentPreference("KR", true, ContentType.ALL, true)) + val controller = ChatCharacterController( + service = characterService, + bannerService = Mockito.mock(ChatCharacterBannerService::class.java), + chatRoomService = Mockito.mock(ChatRoomService::class.java), + characterCommentService = Mockito.mock(CharacterCommentService::class.java), + curationQueryService = Mockito.mock(CharacterCurationQueryService::class.java), + resourceTranslationJobScheduler = scheduler, + aiCharacterTranslationRepository = translations, + langContext = langContext, + memberContentPreferenceService = preferenceService, + imageHost = "https://cdn.test" + ) + + val response = controller.getCharacterDetail(10L, member) + + assertEquals("현재 이름", response.data?.name) + assertEquals("Old name", response.data?.translated?.name) + assertEquals("Old description", response.data?.translated?.description) + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt new file mode 100644 index 00000000..4502871d --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt @@ -0,0 +1,101 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre +import kr.co.vividnext.sodalive.content.ContentType +import kr.co.vividnext.sodalive.content.order.OrderRepository +import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository +import kr.co.vividnext.sodalive.content.series.ContentSeriesService +import kr.co.vividnext.sodalive.content.series.GetSeriesGenreListResponse +import kr.co.vividnext.sodalive.content.series.content.ContentSeriesContentRepository +import kr.co.vividnext.sodalive.content.series.content.GetSeriesContentMinMaxPriceResponse +import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslation +import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslationRepository +import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslation +import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationPayload +import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationRepository +import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository +import kr.co.vividnext.sodalive.creator.admin.content.series.Series +import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesSortType +import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository +import kr.co.vividnext.sodalive.member.Member +import kr.co.vividnext.sodalive.member.block.BlockMemberRepository +import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import java.time.LocalDateTime + +class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() { + @Autowired + private lateinit var seriesTranslations: SeriesTranslationRepository + + @Autowired + private lateinit var genreTranslations: SeriesGenreTranslationRepository + + private val repository = Mockito.mock(ContentSeriesRepository::class.java) + private val contents = Mockito.mock(ContentSeriesContentRepository::class.java) + + @Test + @DisplayName("시리즈 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다") + fun shouldRestartFailedSeriesWhilePreservingRenderedDetail() { + val source = givenSource(LanguageTranslationTargetType.SERIES, "title", "현재 제목") + val job = failedJob(source) + persistRendered( + SeriesTranslation(10L, "en", SeriesTranslationPayload("Old title", "Old introduction", listOf("old"))), + "series_translation", + """{"title":"Old title","introduction":"Old introduction","keywords":["old"]}""" + ) + val member = Member(password = "password", nickname = "viewer").apply { id = 100L } + val series = Series("현재 제목", "현재 소개", "ko").apply { + id = 10L + this.member = member + genre = SeriesGenre("현재 장르").apply { id = 20L } + createdAt = LocalDateTime.of(2026, 1, 1, 0, 0) + } + Mockito.`when`(repository.getSeriesDetail(10L, false, ContentType.ALL)).thenReturn(series) + Mockito.`when`(repository.getSeriesContentMinMaxPrice(10L)).thenReturn(GetSeriesContentMinMaxPriceResponse(0, 0)) + Mockito.`when`(contents.getContentList(10L, false, ContentType.ALL, "https://cdn.test", SeriesSortType.NEWEST, 0, 5)) + .thenReturn(emptyList()) + + val response = service().getSeriesDetail(10L, false, ContentType.ALL, member) + + assertEquals("현재 제목", response.title) + assertEquals("Old title", response.translated?.title) + assertEquals("Old introduction", response.translated?.introduction) + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + } + + @Test + @DisplayName("장르 목록은 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다") + fun shouldRestartFailedGenreWhilePreservingRenderedList() { + val source = givenSource(LanguageTranslationTargetType.SERIES_GENRE, "genre", "현재 장르") + val job = failedJob(source) + persist(SeriesGenreTranslation(10L, "en", "Old genre")) + Mockito.`when`(repository.getGenreList(false, 100L, ContentType.ALL)) + .thenReturn(listOf(GetSeriesGenreListResponse(10L, "현재 장르"))) + + val response = service().getGenreList(100L, false, ContentType.ALL) + + assertEquals(listOf(GetSeriesGenreListResponse(10L, "Old genre")), response) + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + } + + private fun service() = ContentSeriesService( + repository = repository, + orderRepository = Mockito.mock(OrderRepository::class.java), + blockMemberRepository = Mockito.mock(BlockMemberRepository::class.java), + explorerQueryRepository = Mockito.mock(ExplorerQueryRepository::class.java), + seriesContentRepository = contents, + langContext = langContext, + seriesTranslationRepository = seriesTranslations, + seriesGenreTranslationRepository = genreTranslations, + contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java), + resourceTranslationJobScheduler = scheduler, + memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java), + coverImageHost = "https://cdn.test" + ) +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt new file mode 100644 index 00000000..9ccc6851 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt @@ -0,0 +1,114 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunity +import kr.co.vividnext.sodalive.member.Member +import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslation +import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslationRepository +import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.ValueSource +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.mock.mockito.MockBean +import org.springframework.context.annotation.Import + +@Import(CreatorCommunityTranslationService::class) +class CreatorCommunityReadRetryTest : MetadataReadRetryTestSupport() { + @Autowired + private lateinit var service: CreatorCommunityTranslationService + + @MockBean + private lateinit var materializer: TranslationReadModelMaterializer + + @Autowired + private lateinit var translations: CreatorCommunityTranslationRepository + + private lateinit var post: CreatorCommunity + private lateinit var job: TranslationJob + + @BeforeEach + fun givenCurrentFailedPost() { + val creator = persist(Member(password = "password", nickname = "retry-creator")) + post = persist( + CreatorCommunity("현재 본문", 0, true, false, languageCode = "ko", contentRevision = 2).apply { + member = creator + } + ) + val source = TranslationSource( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + requireNotNull(post.id), + "ko", + listOf(TranslationSourceField("content", "현재 본문")), + sourceRevision = 2 + ) + Mockito.`when`(sourceExtractor.extract(source.resourceType, source.resourceId)).thenReturn(source) + job = failedJob(source) + } + + @ParameterizedTest + @ValueSource(booleans = [true, false]) + @DisplayName("커뮤니티 표시 조회는 현재 FAILED를 재개하고 개정에 따른 번역과 원문 fallback을 보존한다") + fun shouldRestartFailedDisplayReadWhilePreservingRevisionFallback(currentRevision: Boolean) { + val postId = requireNotNull(post.id) + persist( + CreatorCommunityTranslation( + creatorCommunityId = postId, + locale = "en", + content = "Rendered content", + sourceRevision = if (currentRevision) 2 else 1, + sourceHash = SourceTextNormalizer.hash("현재 본문"), + sourceLanguage = "ko" + ) + ) + + val response = service.findDisplayContents(listOf(postId), "EN") + + assertEquals(if (currentRevision) "Rendered content" else "현재 본문", response[postId]?.content) + assertEquals(currentRevision, response[postId]?.hasValidTranslation) + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + } + + @Test + @DisplayName("커뮤니티 표시 조회는 재개할 작업이 없으면 원문을 반환하고 누락 작업을 새로 만들지 않는다") + fun shouldPreserveOriginalWithoutCreatingMissingJobsFromDisplayRead() { + jobs.deleteById(requireNotNull(job.id)) + val postId = requireNotNull(post.id) + + val response = service.findDisplayContents(listOf(postId), "en") + + assertEquals("현재 본문", response[postId]?.content) + assertEquals(false, response[postId]?.hasValidTranslation) + assertEquals(emptyList(), jobs.findAll()) + } + + @Test + @DisplayName("커뮤니티 잠금 요청은 메모리 재료화에 성공해도 같은 트랜잭션에서 FAILED 작업을 재개한다") + fun shouldRestartFailedRequestEvenWhenMemoryMaterializesUnderPostLock() { + val postId = requireNotNull(post.id) + val rendered = persist( + CreatorCommunityTranslation( + creatorCommunityId = postId, + locale = "en", + content = "Rendered content", + sourceRevision = 2, + sourceHash = SourceTextNormalizer.hash("현재 본문"), + sourceLanguage = "ko" + ) + ) + Mockito.`when`(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en")) + .thenReturn(true) + + service.requestTranslations(postId, "EN") + + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + val preserved = translations.findByCreatorCommunityIdAndLocale(postId, "en") + assertEquals(rendered.id, preserved?.id) + assertEquals("Rendered content", preserved?.content) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageDetectionProviderTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageDetectionProviderTest.kt index 0e889ae1..2d79ff4d 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageDetectionProviderTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageDetectionProviderTest.kt @@ -18,6 +18,35 @@ class LanguageDetectionProviderTest { private val query = "original source" private val hash = SourceTextNormalizer.hash(query) + @Test + @DisplayName("기본 감지 순서에서 AWS 예외와 빈 결과는 Papago로 전환한다") + fun shouldFallbackToPapagoWithDefaultDetectionOrder() { + val failures: List<() -> String?> = listOf({ throw IllegalStateException("unavailable") }, { null }, { " " }) + failures.forEach { failure -> + val aws = RecordingDetectionProvider(AWS, failure) + val papago = RecordingDetectionProvider(PAPAGO) { "ko" } + Mockito.`when`(repository.findDetectedLanguageForUpdate(hash, "papago", "v1")).thenReturn("ko") + val detector = LanguageDetectionCacheService(repository, listOf(papago, aws), LanguageProviderProperties()) + + assertEquals(DetectedLanguage("ko", PAPAGO), detector.detectWithCache(query)) + assertEquals(listOf(query), aws.queries) + assertEquals(listOf(query), papago.queries) + } + } + + @Test + @DisplayName("AWS 우선 기본 설정도 기존 Papago 감지 캐시는 외부 호출 없이 재사용한다") + fun shouldReusePapagoCacheWithDefaultDetectionOrder() { + val aws = RecordingDetectionProvider(AWS) { "en" } + val papago = RecordingDetectionProvider(PAPAGO) { "ko" } + Mockito.`when`(repository.findBySourceHashAndProviderAndNormalizationVersion(hash, "papago", "v1")) + .thenReturn(LanguageDetectionResult(hash, "sample", "ja", "papago", null, "v1")) + val detector = LanguageDetectionCacheService(repository, listOf(papago, aws), LanguageProviderProperties()) + + assertEquals(DetectedLanguage("ja", PAPAGO), detector.detectWithCache(query)) + assertEquals(emptyList(), aws.queries + papago.queries) + } + @Test @DisplayName("감지 예외와 빈 결과는 다음 공급자로 넘기고 실제 공급자의 저장 승자를 반환한다") fun shouldFallbackAndReturnCanonicalWinnerWithActualProvider() { diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderCacheEndToEndTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderCacheEndToEndTest.kt index 14be1f68..c575d2b9 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderCacheEndToEndTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderCacheEndToEndTest.kt @@ -138,7 +138,7 @@ class LanguageProviderCacheEndToEndTest @Autowired constructor( assertEquals("v1", it.normalizationVersion) assertNotEquals(SourceTextNormalizer.hash(prefix), it.sourceHash) } - assertEquals(sources, papagoDetection.queries) + assertEquals(emptyList(), papagoDetection.queries) assertDetectionRequests(prefix, prefix) } @@ -203,8 +203,7 @@ class LanguageProviderCacheEndToEndTest @Autowired constructor( assertTrue(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en")) schedule(postId, source) assertTrue(worker.processNextGroup()) - assertEquals(1, papagoTranslation.requests.size) - assertEquals(listOf(source), papagoTranslation.requests.single().texts) + assertEquals(emptyList(), papagoTranslation.requests) assertTranslationRequests(first, tail) assertEquals(1L, transaction.execute { memoryRepository.count() }) assertEquals( diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderIdTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderIdTest.kt index e10110af..0eeae41f 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderIdTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderIdTest.kt @@ -42,20 +42,20 @@ class LanguageProviderIdTest { } @Test - @DisplayName("production 기본 순서는 PAPAGO 다음 AWS이며 실제 Papago adapter 식별자는 유지한다") - fun shouldUsePapagoEnumForProductionDefaultsAndAdapters() { + @DisplayName("production 감지와 번역은 AWS 다음 PAPAGO이며 Papago adapter 식별자는 유지한다") + fun shouldUseCapabilityDefaultsAndPreservePapagoAdapterIdentity() { assertAll( - { assertEquals(listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), LanguageProviderOrder.detectionOrder) }, - { assertEquals(listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), LanguageProviderOrder.translationOrder) }, + { assertEquals(listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderOrder.detectionOrder) }, + { assertEquals(listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderOrder.translationOrder) }, { assertEquals( - listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), + listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderProperties().detectionOrder ) }, { assertEquals( - listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), + listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderProperties().translationOrder ) } diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt index c652ac43..dc99b260 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt @@ -41,17 +41,17 @@ class LanguageProviderSpringConfigurationTest { assertNull(context.startupFailure) val properties = context.getBean(LanguageProviderProperties::class.java) assertAll( - { assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, - { assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } + { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) }, + { assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) } ) - assertEquals(PAPAGO, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId) + assertEquals(AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId) assertEquals( - PAPAGO, + AWS, context.getBean(TranslationCoordinator::class.java) .translate(TranslateRequest(listOf("source"), "ko", "en")).providerId ) - assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) - assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) + assertEquals(1, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) + assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) } } @@ -77,17 +77,17 @@ class LanguageProviderSpringConfigurationTest { assertEquals("secondary,papago", context.environment.getProperty("sodalive.language-providers.translation-order")) val properties = context.getBean(LanguageProviderProperties::class.java) assertAll( - { assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, - { assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } + { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) }, + { assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) } ) - assertEquals(PAPAGO, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId) + assertEquals(AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId) assertEquals( - PAPAGO, + AWS, context.getBean(TranslationCoordinator::class.java) .translate(TranslateRequest(listOf("source"), "ko", "en")).providerId ) - assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) - assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) + assertEquals(1, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) + assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) } } @@ -133,36 +133,47 @@ class LanguageProviderSpringConfigurationTest { } @Test - @DisplayName("Spring 기본 생성자는 두 기능 모두 PAPAGO 다음 AWS를 등록하고 첫 PAPAGO 성공 뒤 멈춘다") - fun shouldDefaultToPapago() { + @DisplayName("Spring 기본 설정은 감지와 번역에 AWS를 먼저 사용하고 첫 성공 뒤 멈춘다") + fun shouldDefaultToAwsForDetectionAndTranslation() { defaultRunner.run { context -> assertNull(context.startupFailure) - val properties = context.getBean(LanguageProviderProperties::class.java) - assertAll( - { assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, - { assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } - ) assertEquals( - PAPAGO, + AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId ) - assertEquals( - PAPAGO, - context.getBean(TranslationCoordinator::class.java) - .translate(TranslateRequest(listOf("source"), "ko", "en")).providerId + val result = context.getBean(TranslationCoordinator::class.java) + .translate(TranslateRequest(listOf("source"), "ko", "en")) + assertEquals(AWS, result.providerId) + assertEquals("AWS-v1", result.providerVersion) + assertEquals(listOf("AWS:0"), result.result.translatedText) + val properties = context.getBean(LanguageProviderProperties::class.java) + assertAll( + { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) }, + { assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) } ) - assertEquals(listOf("source"), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries) - assertEquals(1, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size) - assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) - assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) + assertEquals(emptyList(), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries) + assertEquals(0, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size) + assertEquals(listOf("source"), context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries) + assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) } } @Test - @DisplayName("실제 AWS adapter와 SDK client만 등록한 context도 기본 순서에서 PAPAGO 첫 성공 뒤 SDK를 호출하지 않는다") + @DisplayName("실제 AWS adapter를 등록한 기본 context는 감지와 번역에 AWS SDK를 사용한다") fun shouldWireActualAwsAdaptersWithoutDuplicateIds() { actualRunner.withUserConfiguration(LanguageProviderProperties::class.java).run { context -> assertNull(context.startupFailure) + val translationRequest = TranslateTextRequest.builder() + .text("source").sourceLanguageCode("ko").targetLanguageCode("en").build() + val client = context.getBean(TranslateClient::class.java) + val detectionRequest = DetectDominantLanguageRequest.builder().text("source").build() + val detector = context.getBean(ComprehendClient::class.java) + Mockito.`when`(detector.detectDominantLanguage(detectionRequest)).thenReturn( + DetectDominantLanguageResponse.builder() + .languages(DominantLanguage.builder().languageCode("ko").build()).build() + ) + Mockito.`when`(client.translateText(translationRequest)) + .thenReturn(TranslateTextResponse.builder().translatedText("translated").build()) assertEquals(2, context.getBeansOfType(LanguageDetectionProvider::class.java).size) assertEquals(2, context.getBeansOfType(TranslationProvider::class.java).size) assertEquals(AWS, context.getBean(AwsLanguageDetectionProvider::class.java).providerId) @@ -171,19 +182,19 @@ class LanguageProviderSpringConfigurationTest { assertEquals("translate-2017-07-01", translator.providerVersion) val properties = context.getBean(LanguageProviderProperties::class.java) assertAll( - { assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, - { assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } - ) - assertEquals(PAPAGO, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId) - assertEquals( - PAPAGO, - context.getBean(TranslationCoordinator::class.java) - .translate(TranslateRequest(listOf("source"), "ko", "en")).providerId - ) - Mockito.verifyNoInteractions( - context.getBean(ComprehendClient::class.java), - context.getBean(TranslateClient::class.java) + { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) }, + { assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) } ) + assertEquals(AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId) + val result = context.getBean(TranslationCoordinator::class.java) + .translate(TranslateRequest(listOf("source"), "ko", "en")) + assertEquals(AWS, result.providerId) + assertEquals("translate-2017-07-01", result.providerVersion) + assertEquals(listOf("translated"), result.result.translatedText) + assertEquals(0, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size) + assertEquals(emptyList(), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries) + Mockito.verify(detector).detectDominantLanguage(detectionRequest) + Mockito.verify(client).translateText(translationRequest) } } diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt new file mode 100644 index 00000000..aa41e8e5 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt @@ -0,0 +1,92 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.content.AudioContentRepository +import kr.co.vividnext.sodalive.content.ContentType +import kr.co.vividnext.sodalive.content.category.Category +import kr.co.vividnext.sodalive.content.category.CategoryContentRepository +import kr.co.vividnext.sodalive.content.category.CategoryRepository +import kr.co.vividnext.sodalive.content.category.CategoryService +import kr.co.vividnext.sodalive.content.category.CategoryTranslation +import kr.co.vividnext.sodalive.content.category.CategoryTranslationRepository +import kr.co.vividnext.sodalive.content.category.GetCategoryListResponse +import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository +import kr.co.vividnext.sodalive.content.theme.AudioContentThemeService +import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslation +import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository +import kr.co.vividnext.sodalive.member.block.BlockMemberRepository +import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.context.ApplicationEventPublisher + +class MetadataListReadRetryTest : MetadataReadRetryTestSupport() { + @Autowired + private lateinit var themeTranslations: ContentThemeTranslationRepository + + @Autowired + private lateinit var categoryTranslations: CategoryTranslationRepository + + @Test + @DisplayName("활성 테마 목록은 이전 번역을 반환하면서 제외되지 않은 현재 FAILED 작업을 재개한다") + fun shouldRestartFailedThemeWhilePreservingRenderedListAndExclusions() { + val source = givenSource(LanguageTranslationTargetType.CONTENT_THEME, "theme", "현재 테마") + val job = failedJob(source) + val excludedSource = source.copy(resourceId = 20L, fields = listOf(TranslationSourceField("theme", "제외 테마"))) + val excluded = failedJob(excludedSource) + Mockito.`when`(sourceExtractor.extract(excludedSource.resourceType, excludedSource.resourceId)).thenReturn(excludedSource) + persist(ContentThemeTranslation(10L, "en", "Old theme")) + val query = Mockito.mock(AudioContentThemeQueryRepository::class.java) + Mockito.`when`(query.getActiveThemeWithIdsOfContent(false, false, false, ContentType.ALL)).thenReturn( + listOf( + AudioContentThemeQueryRepository.ThemeIdAndName(10L, "현재 테마"), + AudioContentThemeQueryRepository.ThemeIdAndName(20L, "제외 테마") + ) + ) + val service = AudioContentThemeService( + query, + Mockito.mock(AudioContentRepository::class.java), + themeTranslations, + scheduler, + langContext, + Mockito.mock(MemberContentPreferenceService::class.java) + ) + + val response = service.getActiveThemeOfContent(contentType = ContentType.ALL, excludeThemes = listOf("제외 테마")) + + assertEquals(listOf("Old theme"), response) + assertRestarted(job) + assertEquals(TranslationJobStatus.FAILED, jobs.findById(requireNotNull(excluded.id)).orElseThrow().status) + assertEquals(setOf(job.id, excluded.id), jobs.findAll().map { it.id }.toSet()) + } + + @Test + @DisplayName("카테고리 목록은 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다") + fun shouldRestartFailedCategoryWhilePreservingRenderedList() { + val source = givenSource(LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY, "category", "현재 분류") + val job = failedJob(source) + persist(CategoryTranslation(10L, "en", "Old category")) + val repository = Mockito.mock(CategoryRepository::class.java) + val category = Category("현재 분류", languageCode = "ko").apply { id = 10L } + Mockito.`when`(repository.findByCreatorId(100L)).thenReturn(listOf(GetCategoryListResponse(10L, "현재 분류"))) + Mockito.`when`(repository.findAllById(listOf(10L))).thenReturn(listOf(category)) + val service = CategoryService( + repository, + Mockito.mock(AudioContentRepository::class.java), + Mockito.mock(BlockMemberRepository::class.java), + Mockito.mock(CategoryContentRepository::class.java), + categoryTranslations, + langContext, + Mockito.mock(ApplicationEventPublisher::class.java), + scheduler + ) + + val response = service.getCategoryList(100L, 200L) + + assertEquals(listOf(GetCategoryListResponse(10L, "Old category")), response) + assertRestarted(job) + assertEquals(listOf(job.id), jobs.findAll().map { it.id }) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt new file mode 100644 index 00000000..a98b1a1e --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt @@ -0,0 +1,111 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.common.BaseEntity +import kr.co.vividnext.sodalive.configs.QueryDslConfig +import kr.co.vividnext.sodalive.i18n.Lang +import kr.co.vividnext.sodalive.i18n.LangContext +import org.junit.jupiter.api.AfterEach +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNull +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.boot.test.mock.mockito.MockBean +import org.springframework.context.annotation.Import +import org.springframework.transaction.PlatformTransactionManager +import org.springframework.transaction.annotation.Propagation +import org.springframework.transaction.annotation.Transactional +import org.springframework.transaction.support.TransactionTemplate +import java.time.LocalDateTime +import javax.persistence.EntityManager + +@DataJpaTest( + properties = [ + "spring.cache.type=none", + "spring.datasource.url=jdbc:h2:mem:metadata-read-retry;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE" + ] +) +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +@Import(QueryDslConfig::class, ResourceTranslationJobScheduler::class, TranslationJobScheduler::class) +@Transactional(propagation = Propagation.NOT_SUPPORTED) +abstract class MetadataReadRetryTestSupport { + @Autowired + protected lateinit var scheduler: ResourceTranslationJobScheduler + + @Autowired + protected lateinit var jobs: TranslationJobRepository + + @Autowired + protected lateinit var transactionManager: PlatformTransactionManager + + @Autowired + protected lateinit var entityManager: EntityManager + + @MockBean + protected lateinit var sourceExtractor: TranslationSourceExtractor + + protected val langContext = LangContext().apply { setLang(Lang.EN) } + protected val previousRetryAt = LocalDateTime.of(2040, 1, 1, 0, 0) + private val fixtures = mutableListOf() + + protected fun givenSource(type: LanguageTranslationTargetType, fieldKey: String, text: String): TranslationSource { + val source = TranslationSource(type, 10L, "ko", listOf(TranslationSourceField(fieldKey, text))) + Mockito.`when`(sourceExtractor.extract(type, source.resourceId)).thenReturn(source) + return source + } + + protected fun failedJob(source: TranslationSource, targetLanguage: String = "en"): TranslationJob { + val field = source.fields.first() + return persist( + TranslationJob( + resourceType = source.resourceType, + resourceId = source.resourceId, + fieldKey = field.fieldKey, + sourceHash = SourceTextNormalizer.hash(field.sourceText), + sourceText = field.sourceText, + sourceLanguage = source.sourceLanguage, + targetLanguage = targetLanguage, + status = TranslationJobStatus.FAILED, + retryCount = 6, + lastErrorMessage = "exhausted", + nextRetryAt = previousRetryAt + ) + ) + } + + protected fun persist(entity: T): T { + TransactionTemplate(transactionManager).executeWithoutResult { entityManager.persist(entity) } + fixtures.add(entity) + return entity + } + + protected fun persistRendered(entity: T, table: String, payload: String): T { + persist(entity) + TransactionTemplate(transactionManager).executeWithoutResult { + // H2 JSON 컬럼에는 문자열 대신 JSON 객체를 적재한다. + entityManager.createNativeQuery("update $table set rendered_payload = :payload format json where id = :id") + .setParameter("payload", payload) + .setParameter("id", entity.id) + .executeUpdate() + } + return entity + } + + protected fun assertRestarted(job: TranslationJob) { + val restarted = jobs.findById(requireNotNull(job.id)).orElseThrow() + assertEquals(TranslationJobStatus.PENDING, restarted.status) + assertEquals(0, restarted.retryCount) + assertNull(restarted.lastErrorMessage) + } + + @AfterEach + fun removeFixtures() { + TransactionTemplate(transactionManager).executeWithoutResult { + jobs.deleteAllInBatch() + fixtures.asReversed().filterNot { it is TranslationJob }.forEach { fixture -> + entityManager.remove(entityManager.find(fixture.javaClass, fixture.id)) + } + } + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt new file mode 100644 index 00000000..240a7992 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt @@ -0,0 +1,137 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import com.fasterxml.jackson.databind.ObjectMapper +import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper +import kr.co.vividnext.sodalive.admin.content.AdminContentController +import kr.co.vividnext.sodalive.admin.content.AdminContentService +import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront +import kr.co.vividnext.sodalive.aws.s3.S3Uploader +import kr.co.vividnext.sodalive.configs.QueryDslConfig +import kr.co.vividnext.sodalive.content.AudioContent +import kr.co.vividnext.sodalive.content.theme.AudioContentTheme +import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository +import kr.co.vividnext.sodalive.member.Member +import kr.co.vividnext.sodalive.member.MemberRole +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNull +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.boot.test.context.TestConfiguration +import org.springframework.boot.test.mock.mockito.MockBean +import org.springframework.context.annotation.Bean +import org.springframework.context.annotation.Import +import org.springframework.core.task.SyncTaskExecutor +import org.springframework.mock.web.MockMultipartFile +import org.springframework.scheduling.annotation.EnableAsync +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart +import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status +import org.springframework.test.web.servlet.setup.MockMvcBuilders +import org.springframework.transaction.PlatformTransactionManager +import org.springframework.transaction.annotation.Propagation +import org.springframework.transaction.annotation.Transactional +import org.springframework.transaction.support.TransactionTemplate +import java.time.LocalDateTime +import java.util.concurrent.Executor +import javax.persistence.EntityManager + +@DataJpaTest( + properties = [ + "spring.cache.type=none", + "spring.datasource.url=jdbc:h2:mem:metadata-translation-http;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE" + ] +) +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +@Import( + QueryDslConfig::class, + AdminContentService::class, + AudioContentThemeQueryRepository::class, + TranslationSourceExtractor::class, + ResourceTranslationJobScheduler::class, + TranslationJobScheduler::class, + LanguageTranslationListener::class, + MetadataTranslationHttpIntegrationTest.Configuration::class +) +@Transactional(propagation = Propagation.NOT_SUPPORTED) +class MetadataTranslationHttpIntegrationTest @Autowired constructor( + private val service: AdminContentService, + private val jobs: TranslationJobRepository, + private val entityManager: EntityManager, + transactionManager: PlatformTransactionManager +) { + private val transaction = TransactionTemplate(transactionManager) + + @MockBean + private lateinit var uploader: S3Uploader + + @MockBean + private lateinit var cloudFront: AudioContentCloudFront + + @Test + @DisplayName("관리자 multipart 수정 HTTP 요청은 커밋 후 같은 FAILED 행을 재개하고 번역 작업을 저장한다") + fun shouldRestartFailedTranslationAfterAdminHttpUpdateCommits() { + val (contentId, failedId) = transaction.execute { + val member = Member(password = "test", nickname = "http-translation", role = MemberRole.CREATOR) + val theme = AudioContentTheme("테마", "theme.png") + entityManager.persist(member) + entityManager.persist(theme) + val content = AudioContent("원문 제목", "원문 설명", "ko").apply { + this.member = member + this.theme = theme + } + entityManager.persist(content) + val failed = jobs.saveAndFlush( + TranslationJob( + LanguageTranslationTargetType.CONTENT, content.id!!, "title", SourceTextNormalizer.hash("원문 제목"), + "원문 제목", "ko", "en", TranslationJobStatus.FAILED, 6, "exhausted", LocalDateTime.of(2040, 1, 1, 0, 0) + ) + ) + content.id!! to failed.id!! + }!! + + val response = MockMvcBuilders.standaloneSetup(AdminContentController(service)).build() + .perform( + multipart("/admin/audio-content") + .file( + MockMultipartFile( + "request", + "", + "application/json", + """{"id":$contentId,"title":"원문 제목","isDefaultCoverImage":false}""".toByteArray() + ) + ) + .with { request -> request.apply { method = "PUT" } } + ) + .andExpect(status().isOk) + .andReturn().response + + transaction.executeWithoutResult { + val restarted = jobs.findById(failedId).orElseThrow() + assertEquals(TranslationJobStatus.PENDING, restarted.status) + assertEquals(0, restarted.retryCount) + assertNull(restarted.lastErrorMessage) + val stored = jobs.findAll().filter { it.resourceId == contentId } + assertEquals( + setOf("title" to "en", "title" to "ja", "detail" to "en", "detail" to "ja"), + stored.map { it.fieldKey to it.targetLanguage }.toSet() + ) + assertEquals(4, stored.size) + } + println( + "HTTP QA: status=${response.status}, body=${response.contentAsString}, " + + "contentId=$contentId, restartedJobId=$failedId" + ) + } + + @TestConfiguration + @EnableAsync + class Configuration { + @Bean + fun objectMapper(): ObjectMapper = jacksonObjectMapper() + + @Bean + fun taskExecutor(): Executor = SyncTaskExecutor() + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt new file mode 100644 index 00000000..222ff496 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt @@ -0,0 +1,124 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.chat.original.OriginalWork +import kr.co.vividnext.sodalive.chat.original.service.OriginalWorkTranslationService +import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslation +import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationPayload +import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationRepository +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNotEquals +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.EnumSource +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.transaction.support.TransactionTemplate + +class OriginalWorkReadRetryTest : MetadataReadRetryTestSupport() { + @Autowired + private lateinit var translations: OriginalWorkTranslationRepository + + @Test + @DisplayName("이전 원작 번역을 반환해도 읽기 전용 트랜잭션과 별도로 현재 FAILED 작업만 재개한다") + fun shouldRestartOnlyCurrentFailedJobDespiteRenderedTranslationAndReadOnlyRollback() { + val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목") + val current = failedJob(source) + val stale = failedJob(source.copy(fields = listOf(TranslationSourceField("title", "이전 제목")))) + val otherTarget = failedJob(source, targetLanguage = "ja") + val otherLanguage = failedJob( + source.copy(sourceLanguage = "ja", fields = listOf(TranslationSourceField("category", "장르"))) + ) + val currentSource = source.copy( + fields = source.fields + listOf( + TranslationSourceField("category", "장르"), + TranslationSourceField("description", "현재 설명") + ) + ) + Mockito.`when`(sourceExtractor.extract(source.resourceType, source.resourceId)).thenReturn(currentSource) + val rendered = givenRenderedTranslation() + val original = OriginalWork("현재 제목", "소설", "장르", description = "현재 설명", languageCode = "ko").apply { id = 10L } + val service = OriginalWorkTranslationService(translations, scheduler) + + val response = TransactionTemplate(transactionManager).apply { isReadOnly = true }.execute { transaction -> + service.ensureTranslated(original, "EN").also { transaction.setRollbackOnly() } + } + + assertEquals("Old title", response?.title) + assertEquals("Old description", response?.description) + assertRestarted(current) + assertNotEquals(previousRetryAt, jobs.findById(requireNotNull(current.id)).orElseThrow().nextRetryAt) + val preserved = jobs.findAll().filter { it.id != current.id } + assertEquals(setOf(stale.id, otherTarget.id, otherLanguage.id), preserved.map { it.id }.toSet()) + preserved.forEach { + assertEquals(TranslationJobStatus.FAILED, it.status) + assertEquals(6, it.retryCount) + assertEquals("exhausted", it.lastErrorMessage) + assertEquals(previousRetryAt, it.nextRetryAt) + } + assertEquals(rendered.id, translations.findByOriginalWorkIdAndLocale(10L, "en")?.id) + } + + @ParameterizedTest + @EnumSource(TranslationJobStatus::class, names = ["PENDING", "RUNNING", "COMPLETED"]) + @DisplayName("이전 원작 번역 조회는 진행 중이거나 완료된 작업의 재시도 예산을 보존한다") + fun shouldPreserveActiveOrCompletedJobWhenRenderedTranslationExists(status: TranslationJobStatus) { + val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목") + val job = failedJob(source) + TransactionTemplate(transactionManager).executeWithoutResult { + jobs.findById(requireNotNull(job.id)).orElseThrow().status = status + } + givenRenderedTranslation() + val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L } + + OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en") + + val preserved = jobs.findAll().single() + assertEquals(job.id, preserved.id) + assertEquals(status, preserved.status) + assertEquals(6, preserved.retryCount) + assertEquals("exhausted", preserved.lastErrorMessage) + assertEquals(previousRetryAt, preserved.nextRetryAt) + } + + @Test + @DisplayName("번역이 없는 원작 조회도 다른 원문 언어의 FAILED 작업을 재개하지 않는다") + fun shouldPreserveOtherSourceLanguageWithoutRenderedTranslation() { + val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목") + val job = failedJob(source.copy(sourceLanguage = "ja")) + val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L } + + val response = OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en") + + assertEquals(null, response) + val preserved = jobs.findAll().single() + assertEquals(job.id, preserved.id) + assertEquals(TranslationJobStatus.FAILED, preserved.status) + assertEquals(6, preserved.retryCount) + assertEquals("exhausted", preserved.lastErrorMessage) + assertEquals(previousRetryAt, preserved.nextRetryAt) + } + + @Test + @DisplayName("번역이 있는 원작 조회는 존재하지 않는 다른 필드 작업을 새로 만들지 않는다") + fun shouldNotCreateMissingJobsWhenRenderedTranslationExists() { + givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목") + givenRenderedTranslation() + val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L } + + val response = OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en") + + assertEquals("Old title", response?.title) + assertEquals(emptyList(), jobs.findAll()) + } + + private fun givenRenderedTranslation() = persistRendered( + OriginalWorkTranslation( + 10L, + "en", + OriginalWorkTranslationPayload("Old title", "Novel", "Drama", "Old description", emptyList()) + ), + "original_work_translation", + """{"title":"Old title","contentType":"Novel","category":"Drama","description":"Old description","tags":[]}""" + ) +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationCoordinatorTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationCoordinatorTest.kt index b23dc76c..b1eb2679 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationCoordinatorTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationCoordinatorTest.kt @@ -30,6 +30,22 @@ class TranslationCoordinatorTest { assertEquals(emptyList(), first.requests) } + @Test + @DisplayName("기본 순서에서 AWS 번역 실패 뒤 전체 요청을 PAPAGO로 넘겨 성공 결과를 반환한다") + fun shouldFallbackToPapagoAfterAwsFailureWithDefaultOrder() { + val papago = RecordingTranslationProvider(PAPAGO) + val aws = RecordingTranslationProvider(AWS) { throw IllegalStateException("provider unavailable") } + val coordinator = TranslationCoordinator(listOf(papago, aws), LanguageProviderProperties(), repository) + + val result = coordinator.translate(request) + + assertEquals(PAPAGO, result.providerId) + assertEquals("PAPAGO-v1", result.providerVersion) + assertEquals(listOf("PAPAGO:0", "PAPAGO:1"), result.result.translatedText) + assertEquals(listOf(request), aws.requests) + assertEquals(listOf(request), papago.requests) + } + @Test @DisplayName("예외와 부분 결과와 공백 결과 뒤에는 전체 요청을 다음 공급자로 넘긴다") fun shouldFallbackWholeRequestAfterExceptionsOrInvalidResults() { @@ -102,6 +118,24 @@ class TranslationCoordinatorTest { assertEquals(emptyList(), first.requests + second.requests) } + @Test + @DisplayName("기본 순서는 기존 PAPAGO 캐시를 재사용하고 두 캐시가 유효하면 AWS 캐시를 먼저 선택한다") + fun shouldReusePapagoCacheAndPreferValidAwsCacheWithDefaultOrder() { + val papago = RecordingTranslationProvider(PAPAGO) + val aws = RecordingTranslationProvider(AWS) + val coordinator = TranslationCoordinator(listOf(papago, aws), LanguageProviderProperties(), repository) + val papagoMemory = memory("papago", "cached papago") + givenMemory("papago", papagoMemory) + + assertSame(papagoMemory, coordinator.findCached("hash", "ko", "en")) + givenMemory("aws", memory("aws", " ")) + assertSame(papagoMemory, coordinator.findCached("hash", "ko", "en")) + val awsMemory = memory("aws", "cached aws") + givenMemory("aws", awsMemory) + assertSame(awsMemory, coordinator.findCached("hash", "ko", "en")) + assertEquals(emptyList(), papago.requests + aws.requests) + } + @Test @DisplayName("캐시 저장소 오류는 공급자 실패로 숨기지 않는다") fun shouldPropagateCacheRepositoryFailure() { diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRetryIntegrationTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRetryIntegrationTest.kt new file mode 100644 index 00000000..4764bd42 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRetryIntegrationTest.kt @@ -0,0 +1,294 @@ +package kr.co.vividnext.sodalive.i18n.translation + +import kr.co.vividnext.sodalive.configs.QueryDslConfig +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertFalse +import org.junit.jupiter.api.Assertions.assertNull +import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.DisplayName +import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.EnumSource +import org.junit.jupiter.params.provider.ValueSource +import org.mockito.AdditionalAnswers +import org.mockito.Mockito +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest +import org.springframework.context.annotation.Import +import org.springframework.data.jpa.repository.Query +import org.springframework.transaction.PlatformTransactionManager +import org.springframework.transaction.annotation.Propagation +import org.springframework.transaction.annotation.Transactional +import org.springframework.transaction.support.TransactionTemplate +import java.time.LocalDateTime +import java.util.concurrent.CountDownLatch +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit +import javax.persistence.EntityManager + +@DataJpaTest( + properties = [ + "spring.cache.type=none", + "spring.datasource.url=jdbc:h2:mem:translation-job-retry;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE" + ] +) +@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) +@Import(QueryDslConfig::class, TranslationJobScheduler::class) +class TranslationJobRetryIntegrationTest @Autowired constructor( + private val repository: TranslationJobRepository, + private val scheduler: TranslationJobScheduler, + private val entityManager: EntityManager, + private val transactionManager: PlatformTransactionManager +) { + private val transaction = TransactionTemplate(transactionManager) + private val requiresNewTransaction = TransactionTemplate(transactionManager).apply { + propagationBehavior = Propagation.REQUIRES_NEW.value() + } + private val previousRetryAt = LocalDateTime.of(2040, 1, 1, 0, 0) + + @ParameterizedTest + @ValueSource(ints = [3, 6]) + @DisplayName("기존 실패 횟수가 3회 또는 6회인 FAILED 행을 같은 원문 요청으로 즉시 재개한다") + fun shouldResetSameFailedRowForCurrentNormalizedSource(previousFailures: Int) { + val original = persistJob(retryCount = previousFailures) + val requestStartedAt = LocalDateTime.now().withNano(0) + + schedule() + + val requestFinishedAt = LocalDateTime.now().plusSeconds(1).withNano(0) + entityManager.flush() + entityManager.clear() + val resumed = repository.findAll().single() + assertEquals(original.id, resumed.id) + assertEquals("제목", resumed.sourceText) + assertEquals(SourceTextNormalizer.hash("제목"), resumed.sourceHash) + assertEquals(TranslationJobStatus.PENDING, resumed.status) + assertEquals(0, resumed.retryCount) + assertNull(resumed.lastErrorMessage) + assertTrue(!resumed.nextRetryAt.isBefore(requestStartedAt)) + assertTrue(resumed.nextRetryAt.isBefore(requestFinishedAt)) + } + + @ParameterizedTest + @EnumSource(TranslationJobStatus::class, names = ["PENDING", "RUNNING", "COMPLETED"]) + @DisplayName("반복 요청은 진행 중이거나 완료된 행의 상태와 재시도 예산을 바꾸지 않는다") + fun shouldPreserveExistingRowOutsideFailedStatus(status: TranslationJobStatus) { + val original = persistJob(status = status, retryCount = 4) + + repeat(2) { schedule() } + + entityManager.flush() + entityManager.clear() + val preserved = repository.findAll().single() + assertEquals(original.id, preserved.id) + assertEquals(status, preserved.status) + assertEquals(4, preserved.retryCount) + assertEquals("previous failure", preserved.lastErrorMessage) + assertEquals(previousRetryAt, preserved.nextRetryAt) + } + + @Test + @DisplayName("같은 원문 해시라도 원문 언어가 다른 FAILED 행은 재개하지 않는다") + fun shouldNotRestartFailedJobForDifferentSourceLanguage() { + val original = persistJob(sourceLanguage = "ja") + + schedule() + + entityManager.flush() + entityManager.clear() + val preserved = repository.findAll().single() + assertEquals(original.id, preserved.id) + assertEquals("ja", preserved.sourceLanguage) + assertEquals(TranslationJobStatus.FAILED, preserved.status) + assertEquals(6, preserved.retryCount) + assertEquals("previous failure", preserved.lastErrorMessage) + assertEquals(previousRetryAt, preserved.nextRetryAt) + } + + @Test + @DisplayName("현재 원문 요청은 이전 원문의 FAILED 행을 재개하지 않고 현재 해시의 작업을 생성한다") + fun shouldLeaveFailedRowForPreviousSourceUntouched() { + val previous = persistJob(sourceText = "이전 제목") + + schedule() + + entityManager.flush() + entityManager.clear() + val jobs = repository.findAll() + assertEquals(2, jobs.size) + val unchanged = jobs.single { it.id == previous.id } + assertEquals(TranslationJobStatus.FAILED, unchanged.status) + assertEquals(6, unchanged.retryCount) + assertEquals("previous failure", unchanged.lastErrorMessage) + assertEquals(previousRetryAt, unchanged.nextRetryAt) + val current = jobs.single { it.sourceHash == SourceTextNormalizer.hash("제목") } + assertEquals(TranslationJobStatus.PENDING, current.status) + assertEquals(0, current.retryCount) + assertNull(current.lastErrorMessage) + } + + @Test + @DisplayName("재시도 시각이 지난 FAILED 행도 요청 없이 워커가 자동 선점하지 않는다") + fun shouldNotPollFailedRowWithoutNewRequest() { + val original = persistJob().apply { nextRetryAt = LocalDateTime.of(2000, 1, 1, 0, 0) } + entityManager.flush() + val claimSql = TranslationJobRepository::class.java + .getMethod("findNextPendingGroupJobIdsForUpdate", LocalDateTime::class.java) + .getAnnotation(Query::class.java).value + .replace("skip locked", "") // H2에서는 잠금 옵션만 제외하고 실제 운영 쿼리의 선점 조건을 실행한다. + val claimRepository = Mockito.mock( + TranslationJobRepository::class.java, + AdditionalAnswers.delegatesTo(repository) + ) + Mockito.doAnswer { call -> + entityManager.createNativeQuery(claimSql) + .setParameter("now", call.getArgument(0)) + .resultList.map { (it as Number).toLong() } + }.`when`(claimRepository).findNextPendingGroupJobIdsForUpdate( + Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now() + ) + val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java) + val provider = object : TranslationProvider { + override val providerId = LanguageProviderId.PAPAGO + override val providerVersion = "test" + override fun translate(request: TranslateRequest): TranslateResult = + throw IllegalStateException("unexpected translation") + } + val worker = TranslationJobWorker( + claimRepository, + memoryRepository, + TranslationCoordinator( + listOf(provider), + LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)), + memoryRepository + ), + Mockito.mock(TranslationReadModelMaterializer::class.java), + transactionManager + ) + + assertFalse(worker.processNextGroup()) + + entityManager.flush() + entityManager.clear() + val untouched = repository.findAll().single() + assertEquals(original.id, untouched.id) + assertEquals(TranslationJobStatus.FAILED, untouched.status) + assertEquals(6, untouched.retryCount) + assertEquals("previous failure", untouched.lastErrorMessage) + assertEquals(LocalDateTime.of(2000, 1, 1, 0, 0), untouched.nextRetryAt) + } + + @Test + @Transactional(propagation = Propagation.NOT_SUPPORTED) + @DisplayName("같은 FAILED 행의 동시 재개 요청은 중복 행 없이 하나의 새 주기만 연다") + fun shouldResumeSameFailedRowFromConcurrentRequests() { + val original = persistJob() + val originalId = requireNotNull(original.id) + val executor = Executors.newFixedThreadPool(2) + val ready = CountDownLatch(2) + val start = CountDownLatch(1) + try { + val requests = (1..2).map { + executor.submit { + ready.countDown() + check(start.await(5, TimeUnit.SECONDS)) { "concurrent request start timed out" } + schedule() + } + } + assertTrue(ready.await(5, TimeUnit.SECONDS)) + start.countDown() + requests.forEach { it.get(5, TimeUnit.SECONDS) } + + val resumed = repository.findAll().single() + assertEquals(originalId, resumed.id) + assertEquals(TranslationJobStatus.PENDING, resumed.status) + assertEquals(0, resumed.retryCount) + assertNull(resumed.lastErrorMessage) + } finally { + start.countDown() + executor.shutdownNow() + check(executor.awaitTermination(5, TimeUnit.SECONDS)) { "concurrent requests did not stop" } + repository.deleteById(originalId) + } + } + + @Test + @Transactional(propagation = Propagation.NOT_SUPPORTED) + @DisplayName("FAILED 조회 뒤 다른 트랜잭션이 RUNNING으로 선점하면 오래된 재개 요청은 예산을 초기화하지 않는다") + fun shouldPreserveClaimCommittedAfterFailedSnapshotWasRead() { + val originalId = requireNotNull(persistJob().id) + val interleavingRepository = Mockito.mock( + TranslationJobRepository::class.java, + AdditionalAnswers.delegatesTo(repository) + ) + Mockito.doAnswer { + val snapshot = repository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash( + LanguageTranslationTargetType.CONTENT, + 10L, + "title", + "en", + SourceTextNormalizer.hash("제목") + ) + requiresNewTransaction.executeWithoutResult { + val claimed = repository.findById(originalId).orElseThrow() + claimed.status = TranslationJobStatus.RUNNING + claimed.retryCount = 4 + repository.saveAndFlush(claimed) + } + snapshot + }.`when`(interleavingRepository).findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash( + LanguageTranslationTargetType.CONTENT, + 10L, + "title", + "en", + SourceTextNormalizer.hash("제목") + ) + try { + transaction.executeWithoutResult { + schedule(TranslationJobScheduler(interleavingRepository)) + } + + val claimed = repository.findAll().single() + assertEquals(originalId, claimed.id) + assertEquals(TranslationJobStatus.RUNNING, claimed.status) + assertEquals(4, claimed.retryCount) + assertEquals("previous failure", claimed.lastErrorMessage) + assertEquals(previousRetryAt, claimed.nextRetryAt) + } finally { + repository.deleteById(originalId) + } + } + + private fun schedule(scheduler: TranslationJobScheduler = this.scheduler) { + scheduler.scheduleMissingTranslation( + resourceType = LanguageTranslationTargetType.CONTENT, + resourceId = 10L, + fieldKey = "title", + sourceText = " 제목\n", + sourceLanguage = "ko", + targetLanguage = "EN" + ) + } + + private fun persistJob( + status: TranslationJobStatus = TranslationJobStatus.FAILED, + sourceText: String = "제목", + retryCount: Int = 6, + sourceLanguage: String = "ko" + ): TranslationJob = repository.saveAndFlush( + TranslationJob( + resourceType = LanguageTranslationTargetType.CONTENT, + resourceId = 10L, + fieldKey = "title", + sourceHash = SourceTextNormalizer.hash(sourceText), + sourceText = sourceText, + sourceLanguage = sourceLanguage, + targetLanguage = "en", + status = status, + retryCount = retryCount, + lastErrorMessage = "previous failure", + nextRetryAt = previousRetryAt + ) + ) +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorkerTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorkerTest.kt index f5bb3916..488d1178 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorkerTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorkerTest.kt @@ -2,8 +2,12 @@ package kr.co.vividnext.sodalive.i18n.translation import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId.PAPAGO import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.CsvSource import org.mockito.ArgumentCaptor import org.mockito.Mockito import org.springframework.scheduling.annotation.Scheduled @@ -14,12 +18,13 @@ import java.util.Optional class TranslationJobWorkerTest { @Test - fun shouldRunEveryTenMinutesByDefault() { + @DisplayName("번역 워커의 기본 실행 간격은 1초다") + fun shouldRunEverySecondByDefault() { val scheduled = TranslationJobWorker::class.java .getDeclaredMethod("runPendingJobs") .getAnnotation(Scheduled::class.java) - assertEquals("\${sodalive.translation-job.fixed-delay-ms:600000}", scheduled.fixedDelayString) + assertEquals("\${sodalive.translation-job.fixed-delay-ms:1000}", scheduled.fixedDelayString) } @Test @@ -210,8 +215,14 @@ class TranslationJobWorkerTest { assertEquals(setOf(1L, 2L, 3L, 4L, 5L), completedResourceIds) } - @Test - fun shouldRetryFailedJobWithBackoff() { + @ParameterizedTest(name = "기존 실패 {0}회 뒤 실패하면 {1}, 대기 {2}분") + @CsvSource("0, PENDING, 1", "1, PENDING, 5", "2, PENDING, 15", "3, PENDING, 15", "4, PENDING, 15", "5, FAILED, 0") + @DisplayName("최초 시도와 재시도 5회의 실패 횟수를 누적하고 여섯 번째 실패에 종료한다") + fun shouldScheduleFiveRetriesBeforeFailingOnSixthAttempt( + failuresBeforeAttempt: Int, + expectedStatus: TranslationJobStatus, + delayMinutes: Long + ) { val jobRepository = Mockito.mock(TranslationJobRepository::class.java) val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java) val provider = failingProvider() @@ -229,17 +240,54 @@ class TranslationJobWorkerTest { ) val job = translationJob() job.id = 200L - val beforeRetryAt = job.nextRetryAt + job.retryCount = failuresBeforeAttempt Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L)) Mockito.`when`(jobRepository.findById(200L)).thenReturn(Optional.of(job)) - worker.processNextGroup() + val attemptStartedAt = LocalDateTime.now() + assertTrue(worker.processNextGroup()) + val attemptFinishedAt = LocalDateTime.now() - assertEquals(TranslationJobStatus.PENDING, job.status) - assertEquals(1, job.retryCount) + assertEquals(expectedStatus, job.status, "failure #${failuresBeforeAttempt + 1}") + assertEquals(failuresBeforeAttempt + 1, job.retryCount) assertEquals("all translation providers failed", job.lastErrorMessage) - assertTrue(job.nextRetryAt.isAfter(beforeRetryAt)) + if (expectedStatus == TranslationJobStatus.PENDING) { + assertTrue(!job.nextRetryAt.isBefore(attemptStartedAt.plusMinutes(delayMinutes))) + assertTrue(!job.nextRetryAt.isAfter(attemptFinishedAt.plusMinutes(delayMinutes))) + } + } + + @Test + @DisplayName("다섯 번 실패한 작업도 여섯 번째 시도가 성공하면 완료된다") + fun shouldCompleteSixthAttemptAfterFiveFailures() { + val jobRepository = Mockito.mock(TranslationJobRepository::class.java) + val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java) + val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) + val worker = TranslationJobWorker( + translationJobRepository = jobRepository, + translationMemoryRepository = memoryRepository, + translationCoordinator = TranslationCoordinator( + listOf(successfulProvider()), + LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)), + memoryRepository + ), + materializer = materializer, + transactionManager = TestTransactionManager() + ) + val job = translationJob().also { + it.id = 200L + it.retryCount = 5 + it.lastErrorMessage = "previous failure" + } + Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L)) + Mockito.`when`(jobRepository.findById(200L)).thenReturn(Optional.of(job)) + + assertTrue(worker.processNextGroup()) + + assertEquals(TranslationJobStatus.COMPLETED, job.status) + assertEquals(5, job.retryCount) + assertNull(job.lastErrorMessage) } private fun translationJob( diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/LegacyCreatorAdminAudioContentCharacterizationTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/LegacyCreatorAdminAudioContentCharacterizationTest.kt index 7a72e73d..1d2f4dca 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/LegacyCreatorAdminAudioContentCharacterizationTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/LegacyCreatorAdminAudioContentCharacterizationTest.kt @@ -2,6 +2,7 @@ package kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content import com.amazonaws.services.s3.AmazonS3Client import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper +import kr.co.vividnext.sodalive.admin.content.AdminContentService import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront import kr.co.vividnext.sodalive.aws.s3.S3Uploader import kr.co.vividnext.sodalive.common.SodaException @@ -26,6 +27,8 @@ import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.Test +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.CsvSource import org.mockito.ArgumentCaptor import org.mockito.Mockito import org.springframework.beans.factory.annotation.Autowired @@ -35,6 +38,8 @@ import org.springframework.context.ApplicationEventPublisher import org.springframework.data.domain.PageRequest import org.springframework.mock.web.MockMultipartFile import org.springframework.test.context.ContextConfiguration +import org.springframework.test.context.event.ApplicationEvents +import org.springframework.test.context.event.RecordApplicationEvents import org.springframework.transaction.annotation.Propagation import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.support.TransactionTemplate @@ -45,6 +50,7 @@ import javax.persistence.EntityManager @SpringBootTest @Transactional @ContextConfiguration(initializers = [EmbeddedRedisInitializer::class]) +@RecordApplicationEvents class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor( private val audioContentService: AudioContentService, private val repository: CreatorAdminContentRepository, @@ -53,6 +59,15 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor( private val entityManager: EntityManager, private val transactionTemplate: TransactionTemplate ) { + @Autowired + private lateinit var adminContentService: AdminContentService + + @Autowired + private lateinit var creatorAdminContentService: CreatorAdminContentService + + @Autowired + private lateinit var applicationEvents: ApplicationEvents + private lateinit var audioContentCloudFront: AudioContentCloudFront @MockBean @@ -224,6 +239,42 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor( return member } + @ParameterizedTest + @CsvSource( + "true,title,", + "true,detail,", + "false,title,", + "false,detail,", + "false,title,''", + "false,detail,''", + "false,title,' '", + "false,detail,' '" + ) + @DisplayName("관리자와 크리에이터 관리자의 제목 또는 상세 수정은 태그 없이도 커밋 후 번역을 요청한다") + fun shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags(asAdmin: Boolean, field: String, tags: String?) { + val owner = saveMember("metadata-update-owner") + val content = saveAudioContent(owner, "before title", "00:10:00") + entityManager.flush() + val tagsField = tags?.let { ",\"tags\":\"$it\"" }.orEmpty() + val coverField = if (asAdmin) ",\"isDefaultCoverImage\":false" else "" + val request = """{"id":${content.id},"$field":"updated text"$tagsField$coverField}""" + + if (asAdmin) { + adminContentService.updateAudioContent(null, request) + } else { + creatorAdminContentService.updateAudioContent(null, request, owner) + } + + entityManager.flush() + entityManager.clear() + val updated = entityManager.find(AudioContent::class.java, content.id) + assertEquals("updated text", if (field == "title") updated.title else updated.detail) + val events = applicationEvents.stream(LanguageTranslationEvent::class.java).filter { it.id == content.id }.toList() + assertEquals(1, events.size) + assertEquals(LanguageTranslationTargetType.CONTENT, events.single().targetType) + assertTrue(events.single().waitTransactionCommit) + } + private fun saveAudioContent(owner: Member, title: String, duration: String): AudioContent { val theme = AudioContentTheme(theme = "theme-$title", image = "theme.png") entityManager.persist(theme) diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt index 77856bae..2a4110e5 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt @@ -146,7 +146,13 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor( assertEquals("original", contents[3L]?.content) assertTrue(contents[3L]?.hasValidTranslation == false) assertTrue(4L !in contents) - Mockito.verifyNoInteractions(sourceExtractor, materializer, scheduler) + Mockito.verifyNoInteractions(sourceExtractor, materializer) + Mockito.verify(scheduler).restartFailedResourceTranslations( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + listOf(1L, 2L), + "en" + ) + Mockito.verifyNoMoreInteractions(scheduler) } @Test @@ -231,7 +237,12 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor( service.requestTranslations(1L, "EN") Mockito.verify(materializer).materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, 1L, "en") - Mockito.verifyNoInteractions(scheduler) + Mockito.verify(scheduler).restartFailedResourceTranslationsInCurrentTransaction( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + listOf(1L), + "en" + ) + Mockito.verifyNoMoreInteractions(scheduler) } @Test @@ -718,7 +729,8 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor( materializer = persistentMaterializer(sourceExtractor), resourceTranslationJobScheduler = ResourceTranslationJobScheduler( sourceExtractor, - TranslationJobScheduler(translationJobRepository) + TranslationJobScheduler(translationJobRepository), + translationJobRepository ), applicationEventPublisher = applicationEventPublisher, entityManager = entityManager