Compare commits

...
6 Commits
39 changed files with 2178 additions and 109 deletions
@@ -4,7 +4,7 @@
감지 구현체는 `PapagoLanguageDetectionProvider`와 `AwsLanguageDetectionProvider`, 감지 구현체는 `PapagoLanguageDetectionProvider`와 `AwsLanguageDetectionProvider`,
번역 구현체는 `PapagoTranslationService`와 `AwsTranslationService`다. 번역 구현체는 `PapagoTranslationService`와 `AwsTranslationService`다.
두 기능의 production 기본 순서는 모두 `PAPAGO → AWS`다. AWS는 기존 자격 증명과 리전 설정을 재사용한다. production 기본 순서는 감지와 번역 모두 `AWS → PAPAGO`다. AWS는 기존 자격 증명과 리전 설정을 재사용한다.
감지와 번역은 별도 capability다. 감지만 또는 번역만 제공하는 공급자도 등록할 수 있다. 감지와 번역은 별도 capability다. 감지만 또는 번역만 제공하는 공급자도 등록할 수 있다.
두 capability에서 같은 `providerId`를 쓰는 것은 가능하지만, 한 capability 안의 ID 중복은 시작 시 거부한다. 두 capability에서 같은 `providerId`를 쓰는 것은 가능하지만, 한 capability 안의 ID 중복은 시작 시 거부한다.
@@ -47,12 +47,12 @@ ko/en/ja 서비스 정책은 `TranslationLanguages`에 있으며 공급자를
production 순서의 유일한 편집 지점은 production 순서의 유일한 편집 지점은
`src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`다. `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`다.
목록의 왼쪽부터 사용하며 기본값은 두 기능 모두 `listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)`다. 목록의 왼쪽부터 사용하며 감지와 번역의 기본 순서는 다음과 같다.
```kotlin ```kotlin
object LanguageProviderOrder { object LanguageProviderOrder {
val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
} }
``` ```
@@ -61,11 +61,11 @@ Spring은 `@Autowired` 기본 생성자로 위 목록을 읽는다. 문자열
테스트에서는 전역 목록을 변경하지 않고 테스트에서는 전역 목록을 변경하지 않고
`LanguageProviderProperties(List<LanguageProviderId>, List<LanguageProviderId>)`로 만든 테스트 bean을 주입한다. `LanguageProviderProperties(List<LanguageProviderId>, List<LanguageProviderId>)`로 만든 테스트 bean을 주입한다.
다음은 감지만 AWS 우선으로 바꾸는 예시다. 현재 기본 순서를 뜻하지 않는다. 다음은 감지만 Papago 우선으로 바꾸는 예시다. 현재 기본 순서를 뜻하지 않는다.
```kotlin ```kotlin
val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO) val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val translationOrder = 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 | | `LanguageProviderIdTest` | 런타임 enum getter 계약, 안정적인 papago/aws code, production 기본값과 실제 adapter ID |
| `LanguageProviderPropertiesTest` | 순서 검증 및 선택되지 않은 bean을 포함한 capability 내 중복 ID 거부 | | `LanguageProviderPropertiesTest` | 순서 검증 및 선택되지 않은 bean을 포함한 capability 내 중복 ID 거부 |
| `LanguageDetectionProviderTest` / `TranslationCoordinatorTest` | 전체 요청 폴백, 첫 성공 중단, cache-first, 안전한 전체 실패, DB 오류 전파 | | `LanguageDetectionProviderTest` / `TranslationCoordinatorTest` | 전체 요청 폴백, 첫 성공 중단, cache-first, 안전한 전체 실패, DB 오류 전파 |
@@ -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<Long>, 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`다.
@@ -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로 검증한다.
@@ -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`다.
+3
View File
@@ -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.AwsLanguageDetectionProviderTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsTranslationServiceTest' ./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.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 bootJar
./gradlew ktlintCheck ./gradlew ktlintCheck
./gradlew ktlintFormat ./gradlew ktlintFormat
@@ -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.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.common.SodaException import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.main.tab.GetContentMainTabItem 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 kr.co.vividnext.sodalive.utils.generateFileName
import org.springframework.beans.factory.annotation.Value import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.domain.Pageable import org.springframework.data.domain.Pageable
import org.springframework.data.repository.findByIdOrNull import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
@@ -26,6 +29,7 @@ class AdminContentService(
private val contentMainTabRepository: AdminContentMainTabRepository, private val contentMainTabRepository: AdminContentMainTabRepository,
private val objectMapper: ObjectMapper, private val objectMapper: ObjectMapper,
private val s3Uploader: S3Uploader, private val s3Uploader: S3Uploader,
private val applicationEventPublisher: ApplicationEventPublisher,
@Value("\${cloud.aws.s3.bucket}") @Value("\${cloud.aws.s3.bucket}")
private val bucket: String private val bucket: String
) { ) {
@@ -158,6 +162,16 @@ class AdminContentService(
} }
audioContent.settlementRatio = request.settlementRatio 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<GetContentMainTabItem> { fun getContentMainTabList(): List<GetContentMainTabItem> {
@@ -186,6 +186,11 @@ class ChatCharacterController(
var translated: TranslatedAiCharacterDetail? = null var translated: TranslatedAiCharacterDetail? = null
if (langContext.lang.code != character.languageCode) { if (langContext.lang.code != character.languageCode) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CHARACTER,
listOf(characterId),
langContext.lang.code
)
val existing = aiCharacterTranslationRepository val existing = aiCharacterTranslationRepository
.findByCharacterIdAndLocale(character.id!!, langContext.lang.code) .findByCharacterIdAndLocale(character.id!!, langContext.lang.code)
@@ -28,8 +28,15 @@ class OriginalWorkTranslationService(
return null 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 val existedPayload = existed?.renderedPayload
if (existedPayload != null) { if (existedPayload != null) {
val t = existedPayload.title.trim() val t = existedPayload.title.trim()
@@ -51,7 +58,7 @@ class OriginalWorkTranslationService(
resourceTranslationJobScheduler.scheduleResourceTranslation( resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.ORIGINAL_WORK, resourceType = LanguageTranslationTargetType.ORIGINAL_WORK,
resourceId = originalWork.id!!, resourceId = originalWorkId,
targetLanguage = target targetLanguage = target
) )
return null return null
@@ -896,6 +896,11 @@ class AudioContentService(
audioContent.languageCode!!.isNotBlank() && audioContent.languageCode!!.isNotBlank() &&
audioContent.languageCode != langContext.lang.code audioContent.languageCode != langContext.lang.code
) { ) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CONTENT,
listOf(id),
langContext.lang.code
)
val existing = contentTranslationRepository val existing = contentTranslationRepository
.findByContentIdAndLocale(audioContent.id!!, langContext.lang.code) .findByContentIdAndLocale(audioContent.id!!, langContext.lang.code)
@@ -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.content.series.ContentSeriesRepository
import kr.co.vividnext.sodalive.explorer.profile.CreatorCheersRepository import kr.co.vividnext.sodalive.explorer.profile.CreatorCheersRepository
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository 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.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.slf4j.LoggerFactory import org.slf4j.LoggerFactory
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.repository.findByIdOrNull import org.springframework.data.repository.findByIdOrNull
import org.springframework.scheduling.annotation.Async import org.springframework.scheduling.annotation.Async
import org.springframework.stereotype.Component import org.springframework.stereotype.Component
@@ -64,8 +63,7 @@ class LanguageDetectListener(
private val languageDetectionCacheService: LanguageDetectionCacheService, private val languageDetectionCacheService: LanguageDetectionCacheService,
private val creatorCommunityTranslationService: CreatorCommunityTranslationService, private val creatorCommunityTranslationService: CreatorCommunityTranslationService,
private val entityManager: EntityManager, private val entityManager: EntityManager,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler
private val applicationEventPublisher: ApplicationEventPublisher
) { ) {
private val log = LoggerFactory.getLogger(LanguageDetectListener::class.java) private val log = LoggerFactory.getLogger(LanguageDetectListener::class.java)
@@ -116,11 +114,9 @@ class LanguageDetectListener(
character.languageCode = langCode character.languageCode = langCode
chatCharacterRepository.save(character) chatCharacterRepository.save(character)
applicationEventPublisher.publishEvent( resourceTranslationJobScheduler.scheduleResourceTranslations(
LanguageTranslationEvent( resourceType = LanguageTranslationTargetType.CHARACTER,
id = characterId, resourceId = characterId
targetType = LanguageTranslationTargetType.CHARACTER
)
) )
log.info( log.info(
@@ -156,11 +152,9 @@ class LanguageDetectListener(
// REQUIRES_NEW 트랜잭션 내에서 변경 내용을 저장한다. // REQUIRES_NEW 트랜잭션 내에서 변경 내용을 저장한다.
audioContentRepository.save(audioContent) audioContentRepository.save(audioContent)
applicationEventPublisher.publishEvent( resourceTranslationJobScheduler.scheduleResourceTranslations(
LanguageTranslationEvent( resourceType = LanguageTranslationTargetType.CONTENT,
id = contentId, resourceId = contentId
targetType = LanguageTranslationTargetType.CONTENT
)
) )
log.info( log.info(
@@ -288,11 +282,9 @@ class LanguageDetectListener(
series.languageCode = langCode series.languageCode = langCode
seriesRepository.save(series) seriesRepository.save(series)
applicationEventPublisher.publishEvent( resourceTranslationJobScheduler.scheduleResourceTranslations(
LanguageTranslationEvent( resourceType = LanguageTranslationTargetType.SERIES,
id = seriesId, resourceId = seriesId
targetType = LanguageTranslationTargetType.SERIES
)
) )
log.info( log.info(
@@ -326,12 +318,9 @@ class LanguageDetectListener(
originalWork.languageCode = langCode originalWork.languageCode = langCode
originalWorkRepository.save(originalWork) originalWorkRepository.save(originalWork)
// 언어 감지가 완료된 후 언어 번역 이벤트 호출 resourceTranslationJobScheduler.scheduleResourceTranslations(
applicationEventPublisher.publishEvent( resourceType = LanguageTranslationTargetType.ORIGINAL_WORK,
LanguageTranslationEvent( resourceId = originalWorkId
id = originalWorkId,
targetType = LanguageTranslationTargetType.ORIGINAL_WORK
)
) )
log.info( log.info(
@@ -352,11 +341,9 @@ class LanguageDetectListener(
category.languageCode = langCode category.languageCode = langCode
categoryRepository.save(category) categoryRepository.save(category)
applicationEventPublisher.publishEvent( resourceTranslationJobScheduler.scheduleResourceTranslations(
LanguageTranslationEvent( resourceType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY,
id = categoryId, resourceId = categoryId
targetType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY
)
) )
} }
@@ -141,6 +141,11 @@ class CategoryService(
val categoryIds = baseList.map { it.categoryId } val categoryIds = baseList.map { it.categoryId }
val entities = repository.findAllById(categoryIds) val entities = repository.findAllById(categoryIds)
val entityMap = entities.associateBy { it.id!! } val entityMap = entities.associateBy { it.id!! }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY,
categoryIds,
locale
)
// 요청 로케일로 이미 저장된 번역 일괄 조회 // 요청 로케일로 이미 저장된 번역 일괄 조회
val translations = categoryTranslationRepository val translations = categoryTranslationRepository
@@ -98,6 +98,11 @@ class ContentSeriesService(
if (currentLang == Lang.EN || currentLang == Lang.JA) { if (currentLang == Lang.EN || currentLang == Lang.JA) {
val targetLocale = currentLang.code val targetLocale = currentLang.code
val ids = genres.map { it.id } val ids = genres.map { it.id }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.SERIES_GENRE,
ids,
targetLocale
)
// 기존 번역 일괄 조회 // 기존 번역 일괄 조회
val existing = if (ids.isNotEmpty()) { val existing = if (ids.isNotEmpty()) {
@@ -278,6 +283,11 @@ class ContentSeriesService(
val languageCode = series.languageCode val languageCode = series.languageCode
// 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리 // 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리
if (!languageCode.isNullOrBlank() && languageCode != locale) { if (!languageCode.isNullOrBlank() && languageCode != locale) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.SERIES,
listOf(seriesId),
locale
)
val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale) val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale)
if (existing != null) { if (existing != null) {
val payload = existing.renderedPayload val payload = existing.renderedPayload
@@ -58,6 +58,11 @@ class AudioContentThemeService(
val targetLocale = currentLang.code val targetLocale = currentLang.code
// 1) 기존 번역을 한 번에 조회 // 1) 기존 번역을 한 번에 조회
val ids = themesWithIds.map { it.id } val ids = themesWithIds.map { it.id }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CONTENT_THEME,
ids,
targetLocale
)
val existingTranslations = if (ids.isNotEmpty()) { val existingTranslations = if (ids.isNotEmpty()) {
contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale) contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale)
} else { } else {
@@ -199,7 +199,9 @@ class CreatorAdminContentService(
} }
audioContent.audioContentHashTags.addAll(newAudioContentHashTagList) audioContent.audioContentHashTags.addAll(newAudioContentHashTagList)
}
if (request.title != null || request.detail != null || !request.tags.isNullOrBlank()) {
applicationEventPublisher.publishEvent( applicationEventPublisher.publishEvent(
LanguageTranslationEvent( LanguageTranslationEvent(
id = request.id, id = request.id,
@@ -1,6 +1,6 @@
package kr.co.vividnext.sodalive.i18n.translation package kr.co.vividnext.sodalive.i18n.translation
object LanguageProviderOrder { object LanguageProviderOrder {
val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS) val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
} }
@@ -2,12 +2,15 @@ package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
@Service @Service
class ResourceTranslationJobScheduler( class ResourceTranslationJobScheduler(
private val sourceExtractor: TranslationSourceExtractor, private val sourceExtractor: TranslationSourceExtractor,
private val translationJobScheduler: TranslationJobScheduler private val translationJobScheduler: TranslationJobScheduler,
private val translationJobRepository: TranslationJobRepository
) { ) {
@Transactional @Transactional
fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) { fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) {
@@ -27,6 +30,45 @@ class ResourceTranslationJobScheduler(
scheduleSource(source, targetLanguage) scheduleSource(source, targetLanguage)
} }
@Transactional(propagation = Propagation.REQUIRES_NEW)
fun restartFailedResourceTranslations(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String
) {
restartFailedResourceTranslationsInCurrentTransaction(resourceType, resourceIds, targetLanguage)
}
@Transactional
fun restartFailedResourceTranslationsInCurrentTransaction(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
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) { private fun scheduleSource(source: TranslationSource, targetLanguage: String) {
source.fields.forEach { field -> source.fields.forEach { field ->
translationJobScheduler.scheduleMissingTranslation( translationJobScheduler.scheduleMissingTranslation(
@@ -1,6 +1,7 @@
package kr.co.vividnext.sodalive.i18n.translation package kr.co.vividnext.sodalive.i18n.translation
import org.springframework.data.jpa.repository.JpaRepository 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.jpa.repository.Query
import org.springframework.data.repository.query.Param import org.springframework.data.repository.query.Param
import java.time.LocalDateTime import java.time.LocalDateTime
@@ -14,6 +15,27 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
sourceHash: String sourceHash: String
): TranslationJob? ): TranslationJob?
fun findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String,
status: TranslationJobStatus
): List<TranslationJob>
@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( @Query(
""" """
select j from TranslationJob j select j from TranslationJob j
@@ -34,7 +34,12 @@ class TranslationJobScheduler(
targetLanguage = normalizedTargetLanguage, targetLanguage = normalizedTargetLanguage,
sourceHash = sourceHash 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( translationJobRepository.save(
TranslationJob( TranslationJob(
@@ -18,7 +18,7 @@ class TranslationJobWorker(
private val log = LoggerFactory.getLogger(javaClass) private val log = LoggerFactory.getLogger(javaClass)
private val transactionTemplate = TransactionTemplate(transactionManager) 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() { fun runPendingJobs() {
repeat(MAX_GROUPS_PER_TICK) { repeat(MAX_GROUPS_PER_TICK) {
if (!processNextGroup()) return if (!processNextGroup()) return
@@ -121,7 +121,7 @@ class TranslationJobWorker(
val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult
job.retryCount += 1 job.retryCount += 1
job.lastErrorMessage = ex.message?.take(MAX_ERROR_LENGTH) job.lastErrorMessage = ex.message?.take(MAX_ERROR_LENGTH)
if (job.retryCount >= MAX_RETRY_COUNT) { if (job.retryCount >= MAX_ATTEMPTS) {
job.status = TranslationJobStatus.FAILED job.status = TranslationJobStatus.FAILED
} else { } else {
job.status = TranslationJobStatus.PENDING job.status = TranslationJobStatus.PENDING
@@ -142,6 +142,6 @@ class TranslationJobWorker(
companion object { companion object {
private const val MAX_GROUPS_PER_TICK = 5 private const val MAX_GROUPS_PER_TICK = 5
private const val MAX_ERROR_LENGTH = 1000 private const val MAX_ERROR_LENGTH = 1000
private const val MAX_RETRY_COUNT = 3 private const val MAX_ATTEMPTS = 6
} }
} }
@@ -35,6 +35,17 @@ class CreatorCommunityTranslationService(
val normalizedLocale = locale.lowercase() val normalizedLocale = locale.lowercase()
val posts = creatorCommunityRepository.findAllById(postIds).filter { it.isActive } 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 val translations = creatorCommunityTranslationRepository
.findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale) .findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale)
.associateBy { it.creatorCommunityId } .associateBy { it.creatorCommunityId }
@@ -62,6 +73,11 @@ class CreatorCommunityTranslationService(
targetLanguages targetLanguages
.filter { it != sourceLanguage } .filter { it != sourceLanguage }
.forEach { language -> .forEach { language ->
resourceTranslationJobScheduler.restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(postId),
language
)
if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) { if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) {
resourceTranslationJobScheduler.scheduleResourceTranslation( resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY, resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY,
@@ -15,6 +15,7 @@ import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test import org.junit.jupiter.api.Test
import org.mockito.Mockito import org.mockito.Mockito
import org.springframework.context.ApplicationEventPublisher
import java.util.Optional import java.util.Optional
class AdminContentServiceTest { class AdminContentServiceTest {
@@ -43,6 +44,7 @@ class AdminContentServiceTest {
contentMainTabRepository = contentMainTabRepository, contentMainTabRepository = contentMainTabRepository,
objectMapper = jacksonObjectMapper(), objectMapper = jacksonObjectMapper(),
s3Uploader = s3Uploader, s3Uploader = s3Uploader,
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
bucket = "test-bucket" bucket = "test-bucket"
) )
} }
@@ -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<BaseEntity>()
@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<TranslationJob>(), 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 <T : BaseEntity> persist(entity: T): T {
entityManager.persist(entity)
fixtures.add(entity)
return entity
}
private fun readState(target: MetadataTarget, id: Long): Pair<String?, List<TranslationJob>> {
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<out BaseEntity>, val fields: Map<String, String>) {
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 "원문 제목"))
}
}
@@ -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 })
}
}
@@ -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 })
}
}
@@ -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"
)
}
@@ -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<TranslationJob>(), 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)
}
}
@@ -18,6 +18,35 @@ class LanguageDetectionProviderTest {
private val query = "original source" private val query = "original source"
private val hash = SourceTextNormalizer.hash(query) 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<String>(), aws.queries + papago.queries)
}
@Test @Test
@DisplayName("감지 예외와 빈 결과는 다음 공급자로 넘기고 실제 공급자의 저장 승자를 반환한다") @DisplayName("감지 예외와 빈 결과는 다음 공급자로 넘기고 실제 공급자의 저장 승자를 반환한다")
fun shouldFallbackAndReturnCanonicalWinnerWithActualProvider() { fun shouldFallbackAndReturnCanonicalWinnerWithActualProvider() {
@@ -138,7 +138,7 @@ class LanguageProviderCacheEndToEndTest @Autowired constructor(
assertEquals("v1", it.normalizationVersion) assertEquals("v1", it.normalizationVersion)
assertNotEquals(SourceTextNormalizer.hash(prefix), it.sourceHash) assertNotEquals(SourceTextNormalizer.hash(prefix), it.sourceHash)
} }
assertEquals(sources, papagoDetection.queries) assertEquals(emptyList<String>(), papagoDetection.queries)
assertDetectionRequests(prefix, prefix) assertDetectionRequests(prefix, prefix)
} }
@@ -203,8 +203,7 @@ class LanguageProviderCacheEndToEndTest @Autowired constructor(
assertTrue(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en")) assertTrue(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en"))
schedule(postId, source) schedule(postId, source)
assertTrue(worker.processNextGroup()) assertTrue(worker.processNextGroup())
assertEquals(1, papagoTranslation.requests.size) assertEquals(emptyList<TranslateRequest>(), papagoTranslation.requests)
assertEquals(listOf(source), papagoTranslation.requests.single().texts)
assertTranslationRequests(first, tail) assertTranslationRequests(first, tail)
assertEquals(1L, transaction.execute { memoryRepository.count() }) assertEquals(1L, transaction.execute { memoryRepository.count() })
assertEquals( assertEquals(
@@ -42,20 +42,20 @@ class LanguageProviderIdTest {
} }
@Test @Test
@DisplayName("production 기본 순서는 PAPAGO 다음 AWS이며 실제 Papago adapter 식별자는 유지한다") @DisplayName("production 감지와 번역은 AWS 다음 PAPAGO이며 Papago adapter 식별자는 유지한다")
fun shouldUsePapagoEnumForProductionDefaultsAndAdapters() { fun shouldUseCapabilityDefaultsAndPreservePapagoAdapterIdentity() {
assertAll( assertAll(
{ assertEquals(listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), LanguageProviderOrder.detectionOrder) }, { assertEquals(listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderOrder.detectionOrder) },
{ assertEquals(listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), LanguageProviderOrder.translationOrder) }, { assertEquals(listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderOrder.translationOrder) },
{ {
assertEquals( assertEquals(
listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO),
LanguageProviderProperties().detectionOrder LanguageProviderProperties().detectionOrder
) )
}, },
{ {
assertEquals( assertEquals(
listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO),
LanguageProviderProperties().translationOrder LanguageProviderProperties().translationOrder
) )
} }
@@ -41,17 +41,17 @@ class LanguageProviderSpringConfigurationTest {
assertNull(context.startupFailure) assertNull(context.startupFailure)
val properties = context.getBean(LanguageProviderProperties::class.java) val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll( assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } { 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( assertEquals(
PAPAGO, AWS,
context.getBean(TranslationCoordinator::class.java) context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en")).providerId .translate(TranslateRequest(listOf("source"), "ko", "en")).providerId
) )
assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) assertEquals(1, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.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")) assertEquals("secondary,papago", context.environment.getProperty("sodalive.language-providers.translation-order"))
val properties = context.getBean(LanguageProviderProperties::class.java) val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll( assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } { 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( assertEquals(
PAPAGO, AWS,
context.getBean(TranslationCoordinator::class.java) context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en")).providerId .translate(TranslateRequest(listOf("source"), "ko", "en")).providerId
) )
assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) assertEquals(1, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
} }
} }
@@ -133,36 +133,47 @@ class LanguageProviderSpringConfigurationTest {
} }
@Test @Test
@DisplayName("Spring 기본 생성자는 두 기능 모두 PAPAGO 다음 AWS를 등록하고 첫 PAPAGO 성공 뒤 멈춘다") @DisplayName("Spring 기본 설정은 감지와 번역에 AWS를 먼저 사용하고 첫 성공 뒤 멈춘다")
fun shouldDefaultToPapago() { fun shouldDefaultToAwsForDetectionAndTranslation() {
defaultRunner.run { context -> defaultRunner.run { context ->
assertNull(context.startupFailure) assertNull(context.startupFailure)
val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) }
)
assertEquals( assertEquals(
PAPAGO, AWS,
context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId
) )
assertEquals( val result = context.getBean(TranslationCoordinator::class.java)
PAPAGO, .translate(TranslateRequest(listOf("source"), "ko", "en"))
context.getBean(TranslationCoordinator::class.java) assertEquals(AWS, result.providerId)
.translate(TranslateRequest(listOf("source"), "ko", "en")).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(emptyList<String>(), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries)
assertEquals(1, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size) assertEquals(0, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size) assertEquals(listOf("source"), context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries)
assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size) assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
} }
} }
@Test @Test
@DisplayName("실제 AWS adapter와 SDK client만 등록한 context도 기본 순서에서 PAPAGO 첫 성공 뒤 SDK를 호출하지 않는다") @DisplayName("실제 AWS adapter를 등록한 기본 context는 감지와 번역에 AWS SDK를 사용한다")
fun shouldWireActualAwsAdaptersWithoutDuplicateIds() { fun shouldWireActualAwsAdaptersWithoutDuplicateIds() {
actualRunner.withUserConfiguration(LanguageProviderProperties::class.java).run { context -> actualRunner.withUserConfiguration(LanguageProviderProperties::class.java).run { context ->
assertNull(context.startupFailure) 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(LanguageDetectionProvider::class.java).size)
assertEquals(2, context.getBeansOfType(TranslationProvider::class.java).size) assertEquals(2, context.getBeansOfType(TranslationProvider::class.java).size)
assertEquals(AWS, context.getBean(AwsLanguageDetectionProvider::class.java).providerId) assertEquals(AWS, context.getBean(AwsLanguageDetectionProvider::class.java).providerId)
@@ -171,19 +182,19 @@ class LanguageProviderSpringConfigurationTest {
assertEquals("translate-2017-07-01", translator.providerVersion) assertEquals("translate-2017-07-01", translator.providerVersion)
val properties = context.getBean(LanguageProviderProperties::class.java) val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll( assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) }, { assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) } { assertEquals(listOf(AWS, PAPAGO), 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(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<String>(), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries)
Mockito.verify(detector).detectDominantLanguage(detectionRequest)
Mockito.verify(client).translateText(translationRequest)
} }
} }
@@ -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 })
}
}
@@ -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<BaseEntity>()
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 <T : BaseEntity> persist(entity: T): T {
TransactionTemplate(transactionManager).executeWithoutResult { entityManager.persist(entity) }
fixtures.add(entity)
return entity
}
protected fun <T : BaseEntity> 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))
}
}
}
}
@@ -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()
}
}
@@ -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<TranslationJob>(), 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":[]}"""
)
}
@@ -30,6 +30,22 @@ class TranslationCoordinatorTest {
assertEquals(emptyList<TranslateRequest>(), first.requests) assertEquals(emptyList<TranslateRequest>(), 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 @Test
@DisplayName("예외와 부분 결과와 공백 결과 뒤에는 전체 요청을 다음 공급자로 넘긴다") @DisplayName("예외와 부분 결과와 공백 결과 뒤에는 전체 요청을 다음 공급자로 넘긴다")
fun shouldFallbackWholeRequestAfterExceptionsOrInvalidResults() { fun shouldFallbackWholeRequestAfterExceptionsOrInvalidResults() {
@@ -102,6 +118,24 @@ class TranslationCoordinatorTest {
assertEquals(emptyList<TranslateRequest>(), first.requests + second.requests) assertEquals(emptyList<TranslateRequest>(), 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<TranslateRequest>(), papago.requests + aws.requests)
}
@Test @Test
@DisplayName("캐시 저장소 오류는 공급자 실패로 숨기지 않는다") @DisplayName("캐시 저장소 오류는 공급자 실패로 숨기지 않는다")
fun shouldPropagateCacheRepositoryFailure() { fun shouldPropagateCacheRepositoryFailure() {
@@ -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<TranslationJobRepository>(repository)
)
Mockito.doAnswer { call ->
entityManager.createNativeQuery(claimSql)
.setParameter("now", call.getArgument<LocalDateTime>(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<TranslationJobRepository>(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
)
)
}
@@ -2,8 +2,12 @@ package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId.PAPAGO import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId.PAPAGO
import org.junit.jupiter.api.Assertions.assertEquals 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.Assertions.assertTrue
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test 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.ArgumentCaptor
import org.mockito.Mockito import org.mockito.Mockito
import org.springframework.scheduling.annotation.Scheduled import org.springframework.scheduling.annotation.Scheduled
@@ -14,12 +18,13 @@ import java.util.Optional
class TranslationJobWorkerTest { class TranslationJobWorkerTest {
@Test @Test
fun shouldRunEveryTenMinutesByDefault() { @DisplayName("번역 워커의 기본 실행 간격은 1초다")
fun shouldRunEverySecondByDefault() {
val scheduled = TranslationJobWorker::class.java val scheduled = TranslationJobWorker::class.java
.getDeclaredMethod("runPendingJobs") .getDeclaredMethod("runPendingJobs")
.getAnnotation(Scheduled::class.java) .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 @Test
@@ -210,8 +215,14 @@ class TranslationJobWorkerTest {
assertEquals(setOf(1L, 2L, 3L, 4L, 5L), completedResourceIds) assertEquals(setOf(1L, 2L, 3L, 4L, 5L), completedResourceIds)
} }
@Test @ParameterizedTest(name = "기존 실패 {0}회 뒤 실패하면 {1}, 대기 {2}분")
fun shouldRetryFailedJobWithBackoff() { @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 jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java) val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java)
val provider = failingProvider() val provider = failingProvider()
@@ -229,17 +240,54 @@ class TranslationJobWorkerTest {
) )
val job = translationJob() val job = translationJob()
job.id = 200L job.id = 200L
val beforeRetryAt = job.nextRetryAt job.retryCount = failuresBeforeAttempt
Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L)) Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L))
Mockito.`when`(jobRepository.findById(200L)).thenReturn(Optional.of(job)) 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(expectedStatus, job.status, "failure #${failuresBeforeAttempt + 1}")
assertEquals(1, job.retryCount) assertEquals(failuresBeforeAttempt + 1, job.retryCount)
assertEquals("all translation providers failed", job.lastErrorMessage) 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( private fun translationJob(
@@ -2,6 +2,7 @@ package kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content
import com.amazonaws.services.s3.AmazonS3Client import com.amazonaws.services.s3.AmazonS3Client
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper 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.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.common.SodaException 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.BeforeEach
import org.junit.jupiter.api.DisplayName import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test 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.ArgumentCaptor
import org.mockito.Mockito import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired 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.data.domain.PageRequest
import org.springframework.mock.web.MockMultipartFile import org.springframework.mock.web.MockMultipartFile
import org.springframework.test.context.ContextConfiguration 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.Propagation
import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate import org.springframework.transaction.support.TransactionTemplate
@@ -45,6 +50,7 @@ import javax.persistence.EntityManager
@SpringBootTest @SpringBootTest
@Transactional @Transactional
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class]) @ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@RecordApplicationEvents
class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor( class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
private val audioContentService: AudioContentService, private val audioContentService: AudioContentService,
private val repository: CreatorAdminContentRepository, private val repository: CreatorAdminContentRepository,
@@ -53,6 +59,15 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
private val entityManager: EntityManager, private val entityManager: EntityManager,
private val transactionTemplate: TransactionTemplate 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 private lateinit var audioContentCloudFront: AudioContentCloudFront
@MockBean @MockBean
@@ -224,6 +239,42 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
return member 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 { private fun saveAudioContent(owner: Member, title: String, duration: String): AudioContent {
val theme = AudioContentTheme(theme = "theme-$title", image = "theme.png") val theme = AudioContentTheme(theme = "theme-$title", image = "theme.png")
entityManager.persist(theme) entityManager.persist(theme)
@@ -146,7 +146,13 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
assertEquals("original", contents[3L]?.content) assertEquals("original", contents[3L]?.content)
assertTrue(contents[3L]?.hasValidTranslation == false) assertTrue(contents[3L]?.hasValidTranslation == false)
assertTrue(4L !in contents) 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 @Test
@@ -231,7 +237,12 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
service.requestTranslations(1L, "EN") service.requestTranslations(1L, "EN")
Mockito.verify(materializer).materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, 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 @Test
@@ -718,7 +729,8 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
materializer = persistentMaterializer(sourceExtractor), materializer = persistentMaterializer(sourceExtractor),
resourceTranslationJobScheduler = ResourceTranslationJobScheduler( resourceTranslationJobScheduler = ResourceTranslationJobScheduler(
sourceExtractor, sourceExtractor,
TranslationJobScheduler(translationJobRepository) TranslationJobScheduler(translationJobRepository),
translationJobRepository
), ),
applicationEventPublisher = applicationEventPublisher, applicationEventPublisher = applicationEventPublisher,
entityManager = entityManager entityManager = entityManager