Compare commits

...
11 Commits
42 changed files with 3248 additions and 218 deletions
@@ -99,6 +99,10 @@ coordinator/cache/worker의 DB 조회·저장 접점에서만 `providerId.code`
## 캐시와 오류 계약 ## 캐시와 오류 계약
콘텐츠의 `tags` 작업은 원문과 쉼표 요소별 정규화 결과가 같은 AWS 응답을 성공으로 인정하지 않고 Papago로 넘긴다.
같은 AWS 캐시도 이 필드의 worker/materializer에서는 사용하지 않는다. Papago가 원문과 같은 값을 반환하면 성공으로 인정한다.
일반 제목/본문과 다른 리소스의 필드에는 이 추가 판정을 적용하지 않으며, 원문 hash와 저장 캐시는 일괄 변경하지 않는다.
감지는 정규화/hash/normalization version을 기존과 같이 사용하고 adapter에는 원래 query를 전달한다. 감지는 정규화/hash/normalization version을 기존과 같이 사용하고 adapter에는 원래 query를 전달한다.
설정된 모든 공급자의 캐시를 순서대로 조회한 뒤, 유효 캐시가 하나도 없을 때만 외부 호출을 시작한다. 설정된 모든 공급자의 캐시를 순서대로 조회한 뒤, 유효 캐시가 하나도 없을 때만 외부 호출을 시작한다.
저장은 실제 성공 공급자로 `insertIfAbsent`하고 이어지는 locking read의 승자를 반환한다. 저장은 실제 성공 공급자로 `insertIfAbsent`하고 이어지는 locking read의 승자를 반환한다.
@@ -2,7 +2,7 @@
| 항목 | 내용 | | 항목 | 내용 |
|---|---| |---|---|
| 상태 | 구현·기능 검증·독립 리뷰 완료 | | 상태 | 시리즈 상세 동기 번역 포함 구현·기능 검증·독립 리뷰 완료 |
| 작성일 | 2026-11-16 | | 작성일 | 2026-11-16 |
| 요구사항 | [prd.md](prd.md) | | 요구사항 | [prd.md](prd.md) |
| 현재 활성 Goal | 없음 | | 현재 활성 Goal | 없음 |
@@ -134,6 +134,63 @@ REQUIRES_NEW 진입점을 사용한다. FAILED 후보가 없으면 원문을 불
## 검증 기록 ## 검증 기록
### 후속 Goal P1-T4: 콘텐츠 상세 조회의 언어 감지 선행
- 시작 조건: MT-010 확정, getDetail의 null/blank 언어 분기 누락과 기존 감지 후 번역 경로 확인.
- 목표: 미감지 콘텐츠 상세 조회가 커밋 후 언어 감지를 거쳐 기존 번역 job 등록으로 이어진다.
- 완료 증거: null/빈 문자열/공백 회귀 RED/GREEN, 실제 트랜잭션의 언어/job 저장, 기존 상세 번역 회귀 통과.
- 범위 밖: API/DB 스키마 변경, 새 감지 job 시스템, 다른 리소스 조회 수정, 운영 일괄 복구, 관련 없는 리팩터링.
- 구현 파일: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt`.
- 테스트 파일: `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt`.
- 기존 회귀: `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt`, `src/test/kotlin/kr/co/vividnext/sodalive/content/MetadataLanguageDetectTransactionTest.kt`, `src/test/kotlin/kr/co/vividnext/sodalive/content/AudioContentServiceTest.kt`.
- [x] **RED:** 기존 HTTP/DB 테스트에 미감지 상세 조회 시나리오를 추가한다.
- [x] **RED 확인:** focused test에서 언어/job 미저장 assertion 실패를 확인한다.
- [x] **GREEN:** 기존 이벤트와 활성 tag 값을 사용하는 미감지 분기를 추가한다.
- [x] **GREEN 확인:** 동일 focused test에서 상세 원문 응답과 감지 후 번역 job 저장을 확인한다.
- [x] **REFACTOR:** 불필요한 정리 없이 관련 회귀 및 ktlintCheck/bootJar 결과를 기록한다.
진행 기록:
- 2026-11-17 변경 전: 아래 4개 클래스 focused 명령 exit 0(42초), 28건 실패/skip 0. 기존 동작의 baseline을 확인했다.
- 2026-11-17 RED: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest.shouldDetectMissingLanguageAfterDetailHttpGetCommits*' --console=plain` — exit 1(32초). 3개 입력 모두 HTTP 200과 원문 응답을 유지하지만 커밋 후 감지 언어가 저장되지 않아 실패했다. 증거: `build/detail-language-evidence/red.xml`, `red.log`.
- 2026-11-17 GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' --console=plain` — exit 0(42초), 4건 통과. 증거: `build/detail-language-evidence/green.xml`, `green.log`.
- 2026-11-17 관련 회귀: 아래 4개 클래스 focused 명령에 `ktlintCheck bootJar --console=plain`을 함께 실행했다. 테스트 31건 실패/skip 0과 bootJar 성공 후, 새 테스트의 인자 줄바꿈 2곳에서 lint가 실패했다(exit 1, 62초). 해당 줄바꿈만 수정했다.
- 2026-11-17 최종 변경 검증: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' ktlintCheck --console=plain` — exit 0(40초), HTTP 4건 통과, Kotlin 테스트 컴파일과 전체 ktlintCheck 성공. production 변경은 없어 bootJar를 반복 실행하지 않았다.
- HTTP/DB 관찰: 실제 `GET /audio-content/{id}?timezone=Asia/Seoul`을 MockMvc로 실행했다. null/빈 문자열/공백 각각 HTTP 200, 원문 제목·미리보기 설명·활성 태그 응답을 확인했다. 커밋 전 감지 호출/번역 job 0건, 커밋 후 별도 트랜잭션 재조회에서 `ko`와 title/detail/tags × en/ja의 PENDING job 6건을 확인했다. 감지 stub은 전체 설명과 활성 태그가 정확히 전달될 때만 성공한다.
- 검증 한계: 테스트 executor는 동기 실행으로 커밋 경계를 결정적으로 검증하며 실제 외부 AWS/Papago와 운영 MySQL은 호출하지 않았다. LSP 진단 도구가 제공되지 않아 Kotlin 컴파일과 ktlint를 사용했다. 전체 테스트는 미실행, 사용자 실행 명령은 `./gradlew test`다. 독립 리뷰 결과 대기.
검증 명령:
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest'
./gradlew --no-daemon ktlintCheck bootJar
```
### 후속 Gate P1-T4-GATE
- 시작 조건: P1-T4의 RED/GREEN과 관련 회귀 완료.
- 완료 증거: HTTP 응답/DB 저장 결과, 변경 diff 확인, 단일 독립 리뷰, 임시 자원 정리.
- 범위 밖: 전체 테스트(사용자 실행 `./gradlew test`), 실제 AWS/Papago 호출, 운영 MySQL/배포.
- TDD 예외 사유: 구현 후 증거 검토이며 신규 동작은 추가하지 않는다.
- [x] 기능 검증·lint/build·리뷰 결과와 미검증 범위를 기록한다.
- 2026-11-17 Gate: 단일 독립 리뷰 APPROVE, 차단 사유 없음. 실제 트랜잭션/이벤트 연결, null/empty/blank HTTP 회귀, 전체 설명·활성 태그 사용, 기존 번역 재개와 롤백 보존을 확인했다. `git diff --check` 통과. 프로덕션 변경은 상세 조회 조건문 한 곳이며, 커밋·배포는 하지 않았다.
- 2026-11-17 커밋 전 재검증: 위 4개 클래스 focused 명령에 `ktlintCheck --console=plain`을 함께 실행해 exit 0(82초), 테스트 31건 실패/오류/skip 0을 확인했다. ktlintCheck는 UP-TO-DATE, `git diff --check` 통과. 전체 테스트와 외부 AWS/Papago·운영 MySQL은 미검증이며, 전체 테스트 사용자 실행 명령은 `./gradlew test`다.
### 후속 Goal P1-T3: 콘텐츠 태그 미번역 fallback과 기존 완료 작업 복구
- 시작 조건: MT-008/009 및 Papago 동일 결과 성공 정책 확정.
- 완료 증거: AWS 동일/쉼표 공백 결과와 캐시 배제, Papago 결과 저장, 기존 완료 작업 재개 후 재요청 안정성, 비대상 필드 보호.
- 범위 밖: 일반 문장 번역 품질 판단, # 제거/태그 형식 변경, AWS 실계정 비교, 운영 일괄 재번역, 원문 hash 변경.
- 공통 결과 검증 파일: `i18n/translation/{TranslateRequest,TranslationCoordinator,SourceTextNormalizer,TranslationJobWorker,TranslationReadModelMaterializer}.kt` (루트 `src/main/kotlin/kr/co/vividnext/sodalive/`).
- 캐시 갱신 파일: 같은 패키지의 `TranslationMemory.kt`. 기존 AWS 미번역 캐시가 있는데 새 AWS 결과가 정상인 경우 같은 행의 번역 텍스트만 갱신한다. 정상 캐시와 Papago 확인 결과는 덮어쓰지 않는다.
- 복구 파일: 같은 패키지의 `TranslationJobScheduler.kt`, `TranslationJobRepository.kt`, `ResourceTranslationJobScheduler.kt` 및 직접 생성자 fixture.
- scoped flag: `TranslateRequest.rejectUnchangedAwsResult: Boolean = false`, `TranslationCoordinator.findCached(..., rejectUnchangedAwsResult: Boolean = false)`. worker/materializer에서 CONTENT/tags만 true로 전달한다.
- 비교 함수: `SourceTextNormalizer.hasSameCommaSeparatedText(first: String, second: String): Boolean`; 기존 normalize를 각 쉼표 요소에 적용하고 순서대로 비교한다. 기존 normalize/hash 동작은 그대로다.
- 복구 판단: 현재 job 언어/hash 일치, CONTENT/tags/COMPLETED, 저장된 content_translation tags가 원문과 동일한 경우만 검사한다. scoped cache가 저장된 rendered tags와 정확히 같으면 이미 확인된 정상 결과로 보존하고, 그 외에는 조건부 COMPLETED→PENDING으로 복구한다. 작업 ID를 보존하고 retryCount/error/nextRetryAt를 초기화한다.
- 현재 원문 태그가 비어 있지 않은데 저장된 응답 행 또는 tags가 누락된 완료 작업도 워커 재조립 대상으로 처리한다. 캐시가 있으면 외부 호출 없이 복구하며 정상 번역된 응답은 유지한다.
- read 복구는 기존 ResourceTranslationJobScheduler 재개 경계에서 COMPLETED CONTENT/tags 후보만 추가 조회해 현재 source와 대조한다. 다른 리소스/필드와 PENDING/RUNNING을 초기화하지 않는다.
- [x] **RED:** coordinator의 scoped 동일 결과/캐시, 실제 worker+materializer 경계, 이전 완료 작업과 Papago 동일 결과 보존 회귀를 작성하고 실패 확인.
- [x] **GREEN:** 최소 결과 판정과 조건부 완료 작업 복구 구현, 같은 focused 테스트 통과.
- [x] **REFACTOR:** 직접 영향 번역/감지/read/관리자/커뮤니티 테스트, ktlintCheck/bootJar, DB 시나리오와 단일 gate 리뷰 완료.
### 후속 Goal P1-T2: 감지도 AWS 우선으로 전환 ### 후속 Goal P1-T2: 감지도 AWS 우선으로 전환
- 시작 조건: 사용자가 기존 감지 캐시 유지와 AWS/Papago 순서를 승인했다. - 시작 조건: 사용자가 기존 감지 캐시 유지와 AWS/Papago 순서를 승인했다.
@@ -174,4 +231,241 @@ REQUIRES_NEW 진입점을 사용한다. FAILED 후보가 없으면 원문을 불
- 2026-11-16 최종 Gate: 동일 독립 reviewer가 P1-R1 수정과 RED/GREEN/XML 74건 및 lint/build 증거를 대조해 APPROVE했다. 차단 사항 없음. 전체 테스트와 운영 MySQL/외부 공급자 검증은 별도이며 커밋·배포는 하지 않았다. - 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: 감지 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 P1-T2 최종: 독립 reviewer APPROVE. 현재 가이드의 잔여 PAPAGO 우선 테스트 설명도 AWS로 정정했다. 이전 기능 검증 기록과 완료 상태를 보존하며, 후속 감지 변경까지 완료했다.
- 2026-11-16 P1-T3 forward RED: H2 JSON을 로딩하는 fixture cleanup 실패를 bulk cleanup으로 고친 뒤, ContentTagTranslationIntegrationTest 8건 중 6건이 AWS 원문 동일 결과/캐시를 성공으로 인정하는 원인으로 실패했다. 설정 오류를 RED 증거로 간주하지 않았다.
- 2026-11-16 P1-T3 forward GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.ContentTagTranslationIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinatorTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest'`: exit 0, 29건. 콘텐츠 태그에만 적용한 판정과 Papago 결과 저장/캐시 조립을 확인했다.
- 2026-11-16 P1-T3 repair RED: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.CompletedContentTagRepairTest'`: 27건 중 11건이 COMPLETED 재개 누락으로 실패했다. 정상 번역/다른 필드/다른 언어/진행 상태/Papago 동일 결과 보호 16건은 통과했다.
- 2026-11-16 P1-T3 repair GREEN: 완료 작업 복구 27건과 forward 9건 통과. 이후 기존 미번역 AWS 캐시 뒤 정상 AWS 결과 갱신 실패를 추가 RED로 확인하고 같은 캐시 행의 translatedText만 갱신했다.
- 2026-11-16 P1-T3 최종 검증: 공통 회귀 232건 통과 후 새 조건문 braces lint 3건을 수정했다. 조회→worker→재조회 연속 DB 사례까지 추가한 최종 직접 영향 회귀 104건과 ktlintCheck/bootJar가 exit 0이다. 고유 사례 277건이며 명령/증거/한계는 [태그 fallback 검증 기록](reviews/tag-fallback-review.md)에 있다. 독립 리뷰 대기.
- 2026-11-16 P1-T3 최종 Gate: 단일 독립 reviewer가 MT-008/009와 전체 태그 처리/캐시/완료 복구/경합 보호 및 실행 증거를 확인해 APPROVE했다. 차단 사항 없음. 이번 태그 후속 변경은 커밋·배포하지 않았다.
- 2026-11-16 커밋 전 검증: 사용자 커밋 요청에 따라 번역·감지 및 직접 영향 기능을 함께 재실행했다. 33개 클래스 261건의 실패/오류/skip 0, ktlintCheck/bootJar는 UP-TO-DATE, 전체 명령은 exit 0(2분 3초)이다. 정확한 명령은 [검증 기록](reviews/verification.md)의 커밋 전 재검증 절에 남긴다. 전체 테스트는 미실행이며 사용자 실행 명령은 `./gradlew test`다. - 2026-11-16 커밋 전 검증: 사용자 커밋 요청에 따라 번역·감지 및 직접 영향 기능을 함께 재실행했다. 33개 클래스 261건의 실패/오류/skip 0, ktlintCheck/bootJar는 UP-TO-DATE, 전체 명령은 exit 0(2분 3초)이다. 정확한 명령은 [검증 기록](reviews/verification.md)의 커밋 전 재검증 절에 남긴다. 전체 테스트는 미실행이며 사용자 실행 명령은 `./gradlew test`다.
- 2026-11-17 P1-T3 커밋 전 재검증: 번역 패키지와 직접 영향 감지·커뮤니티·OSIV 기능 32개 클래스 277건을 실행해 실패/오류/skip 0을 확인했다. ktlintCheck/bootJar는 UP-TO-DATE, 명령은 exit 0(1분 17초), `git diff --check`도 통과했다. 정확한 명령은 [태그 검증 기록](reviews/tag-fallback-review.md)의 커밋 전 재검증 절에 남긴다. 전체 테스트와 실제 외부 공급자·운영 MySQL은 미검증이며 전체 테스트는 사용자 실행 `./gradlew test`로 구분한다.
### Phase 2: 콘텐츠 상세의 동기 번역
- [x] **Task 2.1: 최초 상세 응답에 번역 결과 제공**
**Goal P2-T1:** 미번역 콘텐츠 상세 조회가 요청 언어의 제목·설명·태그를 동기 번역해 저장하고 같은 HTTP 응답으로 제공하며, 실패해도 원문과 기존 재시도를 유지한다.
- 시작 조건: MT-011~014 사용자 승인, 변경 전 상세/worker/tag 테스트 통과.
- 완료 증거: 아래 RED/GREEN 및 직접 영향 회귀, 실제 HTTP 응답과 별도 DB 재조회.
- 범위 밖: 목록·다른 리소스의 처리 변경, 새로운 큐/의존성/스키마, 운영 데이터 및 유료 공급자 호출, 커밋/배포, 공급자 timeout 설정 변경.
- 실행: `subagent-driven-development`의 단일 구현 단위로 순차 TDD. 파일/DB를 공유하므로 구현자를 병렬 실행하지 않는다. 부모가 후속 실제 HTTP QA와 단일 gate 리뷰를 담당한다.
**Files:**
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt`의 상세 번역 분기와 응답 languageCode 매핑.
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentDetailTranslationService.kt`의 상세 전용 동기 조립 경계.
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationMemoryService.kt`에 worker의 기존 캐시·번역·저장 로직 이동.
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt`의 공용 메모리 서비스 사용.
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationReadModelMaterializer.kt`의 CONTENT 저장에 짧은 row lock을 사용하고, `TranslationSourceExtractor.kt`의 콘텐츠 원문 태그를 상세의 활성 태그 기준과 일치시킨다.
- 필요 시 저장 경합의 최소 보정: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationMemoryRepository.kt`, `src/main/kotlin/kr/co/vividnext/sodalive/content/translation/ContentTranslationRepository.kt`.
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/content/AudioContentDetailTranslationHttpIntegrationTest.kt` 신규 Spring HTTP/DB 통합 테스트.
- Test fixture: 같은 테스트 디렉터리의 `ContentDetailTranslationTestConfiguration.kt`에 전용 profile의 HTTP/DB 구성과 외부 공급자 대체를 둔다.
- Update: `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt`의 비동기 감지 기대를 승인된 동기 계약으로 변경한다. 관리자 수정 사례를 보존한다.
- Update: 위 번역 테스트 패키지의 `AudioContentReadRetryTest.kt`, `TranslationJobWorkerTest.kt`, `TranslationJobRetryIntegrationTest.kt`, `ContentTagTranslationIntegrationTest.kt`, `LanguageProviderCacheEndToEndTest.kt` 및 `src/test/kotlin/kr/co/vividnext/sodalive/content/AudioContentServiceTest.kt` 등 영향받는 직접 생성자/Spring import fixture만 갱신한다.
**Interfaces 및 구현 기준:**
- `AudioContentDetailTranslationService.resolve(contentId: Long, targetLanguage: String): AudioContentDetailTranslationResult`는 원문 언어와 nullable `TranslatedContent`를 반환한다. HTTP DTO는 변경하지 않는다.
- `TranslationMemoryService.ensureMemory(resourceType, fieldKey, sourceText, sourceLanguage, targetLanguage)`는 기존 `TranslationJobWorker.ensureMemory`의 의미를 보존한다. 캐시/태그 판정을 복제하지 않는다.
- 상세 번역은 Spring proxy의 `NOT_SUPPORTED` 경계로 상세 트랜잭션과 분리하고 짧은 별도 트랜잭션에서 감지 결과/메모리/최종 payload를 저장한다. commit 오류는 트랜잭션 밖에서 처리한다. 외부 번역 중 DB write lock을 유지하지 않는다.
- 감지는 전체 제목·설명·활성 태그로 기존 `LanguageDetectionCacheService`를 호출한다. 언어 저장 시 현재 값과 원문을 재확인하며 다른 요청이 저장한 언어를 덮어쓰지 않는다. 외부 트랜잭션의 managed entity에는 따로 저장한 언어를 다시 할당하지 않고 반환값을 응답에 사용한다.
- 기존 번역이 있으면 반환하고 기존 FAILED/태그 복구 의미를 유지한다. 없으면 요청 언어의 누락 필드만 동기 번역하고 `TranslationReadModelMaterializer`로 완성한다. 동일 언어/미지원 언어·빈 필드는 기존 규칙대로 처리한다.
- 동기 성공에 새 요청 언어 job은 필수로 만들지 않는다. 동기 실패 시 기존 scheduler로 등록/재개하고 원문 반환한다. 언어 감지 실패는 기존 after-commit 이벤트를 이용한다. 새로운 감지 재시도 체계는 만들지 않는다.
- 동시 요청/worker의 유일키 경쟁은 별도 트랜잭션의 canonical winner 재조회 또는 기존 DB 원자 연산으로 처리한다. 일반 무결성 오류를 성공으로 처리하지 않는다. 중복 provider 호출 자체를 막는 새 분산 lock은 추가하지 않는다.
- worker의 claim/상태 변경/6회 시도/backoff는 변경하지 않는다. materialize의 false를 완성된 번역으로 반환하지 않는다.
**시나리오 계약:**
| 사례 | 통과 조건 | 검증 표면 |
|---|---|---|
| 최초 조회와 재조회 | 첫 HTTP 200의 translated.title/detail/tags와 저장 payload 일치, 재조회는 공급자 재호출 없이 같은 결과 | RANDOM_PORT 상세 GET, 별도 DB 트랜잭션 |
| 언어 미감지와 경계 | null/empty/blank 언어를 감지 후 같은 요청에서 번역, 동일 언어/미지원 언어는 원문, 빈 필드는 빈 문자열 | 상세 GET 및 감지 캐시/콘텐츠 DB |
| 실패와 복구 | 공급자/저장 실패 시 원문 HTTP 200, outer commit 성공, 기존 job 등록 후 worker로 복구 | 상세 GET, 실제 persistence 실패, job/worker/재조회 |
| 인접 동작과 경합 | 기존 AWS 태그 fallback·캐시·worker 정책 보존, 동시 요청 저장 후 고유 키당 한 행과 재사용 가능한 번역 | 기존 focused tests, latch 기반 별도 트랜잭션 |
- [x] **RED:** 최초 동기 응답, 언어 감지, 실패 fallback을 실제 서비스/DB에 연결한 HTTP 테스트로 작성한다. 공급자만 대체하며 로직은 실제로 실행한다.
- [x] **RED 확인:** `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --console=plain`에서 번역 없는 응답의 의도한 assertion 실패를 확인한다.
- [x] **GREEN:** 공유 메모리 로직과 상세 전용 경계로 최소 구현한다. 필요 경합/실패 회귀를 먼저 RED로 확인한다.
- [x] **GREEN 확인:** 같은 focused 명령에서 첫 응답/저장/재사용/실패/경합을 통과한다.
- [x] **REFACTOR:** 생성자 fixture와 기존 비동기 감지 계약만 갱신하고 직접 영향 회귀를 실행한다. 승인 범위 밖 파일 정리는 하지 않는다.
### Phase 2 Gate
**Goal P2-GATE:** 상세 API의 승인된 동작과 기존 번역 회귀, 빌드/포맷, 단일 독립 리뷰 및 임시 자원 정리를 완료한다.
- 시작 조건: P2-T1 체크박스와 RED/GREEN 증거 완료.
- 완료 증거: 아래 명령과 HTTP 관찰 결과, 단일 리뷰에 차단 사유 없음, 소유 임시 디렉터리/프로세스 제거.
- TDD 예외 사유: 검증/리뷰 Goal이며 새 기능을 구현하지 않는다.
- 범위 밖: 전체 테스트, 실제 외부 공급자·운영 MySQL·배포 검증.
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --console=plain
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.*' --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' --console=plain
./gradlew --no-daemon ktlintCheck bootJar --console=plain
```
- [x] 실제 상세 GET 응답과 committed DB/재시도 결과를 기록한다.
- [x] 직접 영향 회귀 및 ktlintCheck/bootJar 성공 또는 외부 제한의 근거를 기록한다. LSP 도구는 제공되지 않아 Kotlin 컴파일과 ktlint로 대체한다.
- [x] 단일 reviewer의 요구사항/트랜잭션/동시성/테스트 검토를 완료한다.
- [x] 임시 RUN_TMP, 테스트/QA 자원을 정리하고 PRD/계획 상태를 완료로 기록한다.
- 전체 테스트는 에이전트 미실행이며 사용자 실행 명령은 `./gradlew test`다.
### P2 진행 기록
- 2026-11-17 baseline: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.ContentTagTranslationIntegrationTest' --console=plain` — exit 0, 37초. 기존 상세/worker/tag 동작이 통과했다. Gradle 9 호환 deprecation 안내는 기존 상태다.
- 2026-11-17 계획 결정: 같은 상세 감지 기능의 연속 작업이므로 신규 문서 디렉터리 대신 이 PRD/계획에 P2를 추가했다. 기존 완료 기록은 보존한다. 계획 agent 제안 중 성공 시 무조건 job 예약·여러 리뷰·추가 추상화는 채택하지 않고 승인된 최소 범위로 제한한다.
- 2026-11-17 P2-T1 RED: 신규 RANDOM_PORT HTTP 테스트 7건 중 5건이 `expected: <English title> but was: <null>`로 실패했다(exit 1, 34초). production 변경 전 최초 응답·감지 null/empty/blank·cache-only 요구 부재를 확인했다. 테스트 구성 오류 3회는 RED 근거에 포함하지 않는다.
- 2026-11-17 P2-T1 추가 RED: `AudioContentDetailTranslationHttpIntegrationTest.shouldRestartOnlyExistingFailedJobAfterSynchronousSuccess`에서 번역 성공 후 기존 FAILED가 유지되어 `expected: <PENDING> but was: <FAILED>`로 실패했다(exit 1, 38초). 성공 시에도 새 job 없이 기존 FAILED/태그 유지보수만 수행하도록 보완했다.
- 2026-11-17 P2-T1 GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.*' --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' --tests 'kr.co.vividnext.sodalive.osiv.OsivLazyLoadingRegressionTest' --console=plain` — exit 0, 3분 5초. 30개 클래스 277건, 실패/오류/skip 0. 부모가 `build/reports/tests/test/index.html` 및 신규 HTTP 15건/worker 13건 XML을 직접 확인했다.
- 2026-11-17 P2-GATE 1차 lint/build: `./gradlew --no-daemon ktlintCheck bootJar --console=plain` — exit 1, 21초. 새 Kotlin 코드의 인자 줄바꿈/130자 초과로 ktlintMainSourceSetCheck 실패. bootJar 완료로 간주하지 않으며 변경된 파일의 포맷만 수정한다.
- 구현 상세: NOT_SUPPORTED 상세 경계와 짧은 REQUIRES_NEW 저장으로 commit 실패를 격리한다. 실제 CHECK 제약 위반에서 원문 HTTP 200과 job 복구를 확인했다. 동시 상세 2건/worker 1건은 실제 H2 유일키 충돌 후 메모리 3행·payload 1행으로 수렴했다. H2 JSON fixture는 converter 문자열 재조회용 varchar이며 운영 MySQL JSON/잠금 검증은 아니다.
- 2026-11-17 포맷/정리: 변경 파일의 줄바꿈·130자 제한만 수정했다. 상세 변경으로 고아가 된 AudioContentService의 ResourceTranslationJobScheduler 생성자 의존성을 제거하고 직접 생성자 테스트 2곳을 맞췄다. ContentTranslationRepository는 목록 사용처가 있어 유지했다. `./gradlew --no-daemon ktlintCheck --console=plain` — exit 0, 21초.
- 2026-11-17 부모 QA/빌드: 임시 Gradle init task로 기존 테스트 context와 fixture를 띄우고 Java HttpClient에서 상세 GET을 직접 호출했다. 최초 번역·DB 저장·재조회, 미감지 언어, 공급자 실패→worker 복구, 실제 DB CHECK 실패→worker 복구가 모두 HTTP 200과 기대 번역으로 확인됐다. 첫 실행은 bootJar/컴파일과 모든 기능 assertion은 성공했으나 임시 QA runner의 afterTestClass 호출을 context 종료 뒤에 둬 종료 코드 1이었다. runner 종료 순서만 수정했다.
- 2026-11-17 최종 QA/생성자 회귀: `./gradlew --no-daemon -I "$RUN_TMP/qa.init.gradle" runContentDetailQa test --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' --console=plain` — exit 0. 실제 HTTP QA 전체 통과, 생성자 정리 영향 테스트 17건 실패/skip 0. 277건 전체 기능 범위는 앞선 실행 결과이며 포맷/미사용 생성자 제거 후 변경 영향만 재검증했다.
- 최종 실제 HTTP 응답·QA 관찰·리뷰 판정은 [동기 상세 검증 기록](reviews/synchronous-detail-review.md)에 보존한다. LSP 도구·실제 공급자·운영 MySQL은 미검증, 전체 테스트는 사용자 실행 `./gradlew test`다.
- 2026-11-17 P2-GATE 리뷰: 단일 Oracle reviewer APPROVE. MT-011~014 충족, API/DB/worker 정책 보존과 실제 HTTP/DB 실패·경합 증거를 확인했고 차단 사항이 없다. 구매 전 translated.detail이 전체 payload인 기존 계약을 변경하지 않았음을 확인했다. 운영 MySQL JSON/1062/잠금 및 실제 공급자 지연은 미검증 범위다. 신규 테스트 명령 예시는 `docs/agent-guides/실행명령어.md`에 추가했다.
- 2026-11-17 P2-GATE 정리 완료: 부모 QA runner/test worker/Gradle wrapper가 없고 HTTP 포트 58600에 listener가 없음을 확인했다. 검증 결과와 응답 발췌를 문서에 보존한 뒤 부모 RUN_TMP의 Java/init script·class·로그·notepad를 삭제하고 디렉터리 부재를 확인했다(exit 0). 구현자 임시 root 2개도 제거했으며 공유 캐시/기존 IDE daemon은 건드리지 않았다. 커밋·배포는 하지 않았다.
- 2026-11-17 P2 커밋 전 재검증: 사용자 커밋 요청에 따라 상세 동기 번역·번역 패키지·감지·OSIV 직접 영향 범위 30개 클래스 277건을 재실행해 실패/오류/skip 0을 확인했다. `ktlintCheck`와 `bootJar`는 UP-TO-DATE, 전체 명령은 exit 0(2분 22초), `git diff --check`도 통과했다. 정확한 명령은 [동기 상세 검증 기록](reviews/synchronous-detail-review.md)의 커밋 전 재검증 절에 남긴다. 전체 테스트·실제 공급자·운영 MySQL은 미검증이며 전체 테스트는 사용자 실행 `./gradlew test`다.
## Phase 3: 상세 연관 콘텐츠의 저장된 번역 제목
**목표:** 상세의 이전화/다음화와 두 추천 목록에서 요청 언어에 맞는 저장된 제목이 표시된다.
**설계:** 기존 조회 결과의 ID를 모아 ContentTranslationRepository로 한 번 조회하고 OtherContentResponse를 copy한다.
원문 기반 탐색·정렬과 DTO 스키마를 보존하며, 공통 서비스나 새 의존성을 추가하지 않는다.
**기준:** PRD MT-015~016. 기존 상세 번역 작업의 연속 수정이므로 문서를 재사용한다.
- [x] **Task 3.1: 연관 콘텐츠 제목 번역 누락 수정**
**Goal P3-T1:** 네 응답 필드의 title은 현재 언어의 비어 있지 않은 저장 번역이며 없으면 기존 원문이다.
- 시작 조건: 사용자 최소 범위 승인, 기존 코드 및 HTTP 테스트 확인.
- 완료 증거: 실제 결함의 RED, 동일 HTTP 테스트 GREEN, 직접 영향 회귀.
- 범위 밖: 새 번역 생성, 공급자/작업 큐 변경, navigation 정렬 변경, DTO 확장, 전체 테스트.
Files:
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/content/AudioContentDetailTranslationHttpIntegrationTest.kt`
- Test configuration: `src/test/kotlin/kr/co/vividnext/sodalive/content/ContentDetailTranslationTestConfiguration.kt`
Interfaces: `findByContentIdInAndLocale(contentIds, locale)`와 기존 `OtherContentResponse(contentId, title, coverUrl)`를 사용한다.
- [x] **RED:** 기존 HTTP 테스트를 먼저 실행한 뒤 네 필드의 번역 선택과 fallback 회귀를 같은 테스트 클래스에 추가한다.
- [x] **RED 확인:** 새 번역 시나리오가 원문 제목 반환 assertion으로 실패함을 확인한다.
- [x] **GREEN:** getDetail에서 중복 제거한 관련 ID의 번역을 일괄 조회하고 비어 있지 않은 제목만 응답에 적용한다.
- [x] **GREEN 확인:** 같은 HTTP 테스트를 실행해 모든 필드가 기대 번역 또는 원문인 것을 확인한다.
- [x] **REFACTOR:** 직접 영향 기능 테스트 및 Kotlin 컴파일/ktlint 검증을 수행한다. 새 추상화나 무관한 정리는 하지 않는다.
### 시나리오 계약
1. 저장된 en/ja 제목: 실제 `GET /audio-content/{id}?timezone=UTC`를 en→ja→en으로 호출할 때 네 필드의 제목이 각 locale 값과 정확히 일치한다. ID·순서·coverUrl은 변하지 않는다.
2. fallback: 번역 없음·다른 locale만 존재·빈 제목·공백 제목에서 해당 항목은 원문이다. 연관 콘텐츠 때문에 공급자 호출 또는 번역 job이 추가되지 않는다.
3. 인접 회귀: 시리즈 없는 콘텐츠는 previousContent/nextContent가 null이고 관련 콘텐츠가 없으면 목록은 비어 있다. 본문 상세 번역과 기존 언어 감지·실패 복구 테스트는 통과한다.
### Phase 3 Gate
**Goal P3-GATE:** 승인된 네 필드의 HTTP 동작과 최소 변경 범위를 독립 검토하고 종료한다.
- 시작 조건: P3-T1 완료.
- 완료 증거: 아래 focused tests, 실제 HTTP JSON 관찰, lint/build, 단일 리뷰 판정과 임시 자원 정리 기록.
- 범위 밖: 운영 데이터 변경, 전체 테스트, 유료 공급자 호출.
- TDD 예외 사유: Gate는 구현이 아니라 결과 검증이다.
- 대체 검증 방법: HTTP 응답/테스트 결과/변경 diff 대조.
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' --console=plain
./gradlew --no-daemon ktlintCheck bootJar --console=plain
```
- [x] 실제 HTTP 응답에서 세 시나리오의 결과를 확인하고 기록한다.
- [x] 직접 영향 테스트와 ktlintCheck/bootJar 결과를 기록한다. LSP 도구가 제공되지 않으면 Kotlin 컴파일/ktlint 대체 사실을 명시한다.
- [x] 단일 독립 리뷰에서 차단 사항이 없음을 확인한다.
- [x] 작업 소유 임시 파일과 QA 자원을 정리하고 문서 상태를 갱신한다.
- 종료 조건: 위 시나리오가 실제 HTTP로 확인되고 관련 테스트 통과, 가능한 진단/빌드의 결과 및 한계 기록, 리뷰 승인과 임시 자원 정리가 끝나면 즉시 종료한다.
- 전체 테스트는 사용자 실행 `./gradlew test`이며 기능 범위 완료와 구분한다.
### P3 진행 기록
- 2026-11-17 조사/승인: 네 projection이 원문 title을 반환하고 상세 조립에 번역 적용이 없음을 확인했다. 기존 목록의 batch lookup 및 blank fallback을 재사용한다. 사용자가 저장된 번역만 적용하는 범위를 승인했다. 시작 작업 트리는 깨끗하다.
- 2026-11-17 baseline: 기존 `AudioContentDetailTranslationHttpIntegrationTest` 15건 통과(exit 0, 29초).
- 2026-11-17 P3-T1 RED: 테스트만 추가한 뒤 같은 HTTP 클래스 21건 중 1건 실패(exit 1, 38초). `shouldLocalizeRelatedTitlesForEachRequestedLanguageWithoutChangingNavigation`에서 previousContent의 기대 제목 `en 가 이전` 대신 `가 이전` 반환을 확인했다. ID와 coverUrl은 일치했다.
- 2026-11-17 P3-T1 GREEN: 위 Gate의 세 클래스 focused 명령 exit 0(51초). 상세 HTTP 21건, AudioContentServiceTest 16건, AudioContentReadRetryTest 1건으로 38건 전부 통과(실패/오류/skip 0). 부모가 XML 세 파일을 직접 확인했다. en→ja→en, 네 필드의 fallback·ID·cover·null/빈 목록, distinct 배치 1회/빈 경우 0회, 관련 공급자 호출·job 추가 없음이 검증됐다. 랜덤 추천 목록은 ID별로 대조하고, 각 요청의 순서는 서비스 map이 보존한다.
- 2026-11-17 lint/build 1차: `./gradlew --no-daemon ktlintCheck bootJar --console=plain` exit 1(25초). 신규 HTTP 테스트 두 표현식의 130자 초과 및 인자 줄바꿈 오류로 ktlintTestSourceSetCheck 실패. 제품 로직의 실패는 아니며 bootJar 성공으로 기록하지 않는다. 해당 표현식의 포맷만 수정하고 재검증한다.
- 2026-11-17 P3-GATE 부모 QA/lint/build: 인자 줄바꿈만 수정 후 `./gradlew --no-daemon -I "$TMPDIR/qa.init.gradle" runRelatedContentQa ktlintCheck bootJar --console=plain` exit 0(50초). Kotlin 테스트 재컴파일, ktlintCheck 및 bootJar 성공. 임시 Java HttpClient에서 실제 Tomcat 포트 59748로 GET 5회를 호출해 en→ja→en, 혼합 fallback, 빈 관계와 본문 번역 보존을 확인했다. 기존 38건의 동작 검증은 그대로 유효하며 포맷 수정 후 실제 HTTP QA로 추가 확인했다. 상세 증거는 [연관 콘텐츠 검증 기록](reviews/related-content-title-review.md)에 보존한다.
- 2026-11-17 P3-GATE 리뷰: 단일 Oracle reviewer APPROVE(신뢰도 높음), 차단 사항 없음. 네 필드의 요청 언어/fallback·조회 계약·번역 부작용 없음과 XML/실제 HTTP 증거를 확인했다. 부모가 QA PID 85049 부재, TCP 59748 listener 없음, 구현자 임시 root 부재를 확인했다.
- 2026-11-17 P3-GATE 완료: 실제 응답 및 리뷰 결과를 문서에 보존한 뒤 부모 `content-translation.TfjAph` root의 QA Java/init script·class·보고서와 별도 ulw 노트를 삭제했다(exit 0). 경로 부재를 확인했으며 공유 캐시와 작업 외 파일은 유지했다. 전체 테스트·운영 MySQL·실제 공급자/인증·배포는 미검증이다. 전체 테스트는 사용자 실행 `./gradlew test`다. 커밋은 하지 않았다.
- 2026-11-17 P3 커밋 전 재검증: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' ktlintCheck bootJar --console=plain` exit 0(1분 1초). XML 세 파일에서 38건(21/16/1) 성공, 실패/오류/skip 0을 확인했다. `ktlintCheck`와 `bootJar`는 UP-TO-DATE이며 `git diff --check`도 통과했다. 전체 테스트·운영 MySQL·실제 공급자/인증·배포는 미검증이며 전체 테스트는 사용자 실행 `./gradlew test`다.
## Phase 4: 시리즈 상세의 동기 감지·번역
**목표:** 첫 시리즈 상세 응답에 요청 언어의 제목·소개·키워드가 저장 후 반환된다.
**기준:** PRD MT-017~018, 사용자 "시리즈 자체만" 승인. 열린 요구사항 없음.
**설계:** 콘텐츠 상세의 NOT_SUPPORTED + REQUIRES_NEW 패턴을 시리즈 resolver에 적용한다.
기존 감지 캐시, TranslationMemoryService, TranslationReadModelMaterializer와 SERIES 이벤트/재시도 경로를 재사용한다.
새 worktree 없이 깨끗한 `test` 브랜치의 기존 작업 위치에서 수행하며 커밋은 하지 않는다.
- [x] **Task 4.1: 시리즈 상세 동기 번역 연결**
**Goal P4-T1:** 시리즈 메타데이터의 미감지·미번역을 같은 HTTP 응답 전에 처리하고 실패 시 원문과 기존 복구를 유지한다.
- 시작 조건: 승인된 MT-017~018 및 콘텐츠 상세의 구현·HTTP 테스트 조사 완료.
- 완료 증거: 요구 동작의 RED/GREEN, 실제 HTTP 및 DB 재조회, 직접 영향 회귀 통과.
- 범위 밖: 하위 콘텐츠 신규 번역, 공개 스키마/공급자 설정/DB 변경, 콘텐츠 resolver 리팩터링, 전체 테스트.
Files:
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesDetailTranslationService.kt`
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt`
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationReadModelMaterializer.kt`
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/content/ContentSeriesDetailTranslationHttpIntegrationTest.kt`
- Test configuration: `src/test/kotlin/kr/co/vividnext/sodalive/content/ContentDetailTranslationTestConfiguration.kt`
- Test fixture: `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt`
- Test command guide: `docs/agent-guides/실행명령어.md`
Interfaces:
- `ContentSeriesDetailTranslationService.resolve(seriesId: Long, targetLanguage: String): ContentSeriesDetailTranslationResult`
- 결과는 `languageCode: String?`, `translated: TranslatedSeries?`, `detectionQuery: String?`를 가진다.
- snapshot은 기존 extractor와 동일하게 title/introduction/keywords(`joinToString(", ")`)를 사용한다.
- 감지 query는 제목·전체 소개·공백으로 이은 키워드의 비어 있지 않은 텍스트를 합친다.
- 외부 호출은 쓰기 잠금 밖에서 수행한다. 감지 저장과 materialize 직전에 Series 잠금 및 snapshot 비교로 원문 경합을 막는다.
- materializer의 `upsertSeries`도 기존 content와 같은 부모 row 잠금으로 worker/상세의 upsert를 직렬화한다.
- 기존 서비스의 번역 블록을 resolver 호출로 교체하고 감지 실패는 기존 SERIES LanguageDetectEvent로 넘긴다.
- 기존 empty keywords의 원문 fallback, 하위 콘텐츠의 batch 조회, 장르·권한·원문 응답을 보존한다.
- [x] **RED:** 기존 상세 HTTP baseline을 확인하고 시리즈 첫 응답/언어 미감지의 HTTP·DB 회귀 테스트를 작성한다.
- [x] **RED 확인:** 아래 새 클래스 실행에서 translated 누락 및 languageCode 미저장 assertion 실패를 확인한다.
- [x] **GREEN:** resolver와 상세 조립 연결, materializer 잠금 및 직접 생성자 fixture만 최소 수정한다.
- [x] **GREEN 확인:** 같은 클래스에서 캐시/빈 필드/동일·미지원 언어/실패 복구/경합/하위 목록 보존을 검증한다.
- [x] **REFACTOR:** 새 코드의 불필요한 부분만 정리하고 아래 직접 영향 회귀 및 lint/build를 검증한다.
### 시나리오 계약
1. 첫 응답·재사용: 실제 GET에서 200과 요청 locale의 translated가 반환되고 별도 DB 재조회와 일치한다. 두 번째 조회는 공급자 추가 호출이 없다.
2. 감지·경계: null/빈 문자열/공백 언어는 감지 결과를 커밋하고 같은 응답에서 번역한다. 동일/미지원 언어는 번역하지 않고 캐시/빈 필드는 기존 정책을 따른다.
3. 실패·경합: 공급자/실제 저장 실패에도 원문 200과 복구 job이 남고 worker 후 재조회가 성공한다. 동시 원문 수정은 덮어쓰거나 오래된 번역으로 저장하지 않는다. worker/상세가 하나의 번역 행으로 수렴한다.
4. 인접 회귀: 시리즈 원문/장르/응답 스키마와 하위 콘텐츠의 저장 번역/원문 선택은 그대로이며 하위 콘텐츠 신규 번역 호출·job은 없다. 콘텐츠 상세와 기존 FAILED 재개 테스트가 통과한다.
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.ContentSeriesDetailTranslationHttpIntegrationTest' --console=plain
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.ContentSeriesDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.ContentSeriesReadRetryTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.ContentTagTranslationIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --console=plain
./gradlew --no-daemon ktlintCheck bootJar --console=plain
```
### Phase 4 Gate
**Goal P4-GATE:** 실제 시리즈 상세 HTTP/DB 결과, 직접 영향 회귀와 최소 변경 범위를 검증하고 종료한다.
- 시작 조건: P4-T1 완료.
- 완료 증거: 부모가 직접 Java HttpClient로 실제 테스트 서버 호출, 응답/DB 대조, 테스트 XML, lint/build, 단일 독립 리뷰.
- 범위 밖: 운영 MySQL/실제 유료 공급자/실제 인증/배포 검증 및 전체 테스트.
- TDD 예외 사유: 구현이 아닌 검증 작업. 실제 HTTP/DB 결과와 diff/명령 출력을 대조한다.
- [x] 실제 HTTP에서 첫 응답·재사용, 감지, 실패·worker 복구 및 하위 목록 보존을 확인한다.
- [x] 관련 테스트 XML 및 ktlintCheck/bootJar 확인. LSP 도구 미제공 시 Kotlin 컴파일 대체를 기록한다.
- [x] 단일 독립 리뷰의 차단 사항을 해소하고 승인받는다.
- [x] 소유 임시 파일·QA 서버·캐시를 정리하고 부재를 확인한다.
- 종료 조건: 위 시나리오의 HTTP/DB 결과와 관련 테스트가 통과하고 빌드/진단 한계, 리뷰 승인, 임시 자원 정리가 기록되면 즉시 종료한다.
- 전체 테스트는 사용자 실행 `./gradlew test`로 분리한다.
### P4 진행 기록
- 2026-11-17 조사/승인: 시리즈 상세에는 감지 없이 저장 번역 조회 또는 job 예약만 있음을 확인했다. 사용자는 시리즈 자체만 동기 처리하도록 승인했다. 명확성 Goal/Scope/Constraints/Success/Context 모두 1.0, 최종 모호성 0.00, 열린 질문 없음. 기존 P1~P3 완료 기록을 보존하고 후속 goal로 추가했다.
- 2026-11-17 P4-T1 TDD: 기존 콘텐츠 HTTP baseline 21건 성공. 최초 시리즈 fixture의 필수 theme 누락을 수정한 뒤 production 수정 전 15건 중 12건의 의도한 RED를 확인했다. 첫 번역 null 및 미감지 언어 미저장이 원인이었다. 최소 구현 후 15건 GREEN, 지정 회귀 7개 클래스 총 82건 성공(exit 0, 1분 1초). 부모가 XML의 실패/오류/skip 0을 확인했다. 첫 GREEN의 컴파일 시간 제한은 성공으로 처리하지 않았으며 종료 확인 후 300초로 재실행했다.
- 2026-11-17 P4-GATE HTTP/lint 1차: 임시 Java HttpClient로 실제 서버 GET 8회/5개 시나리오를 확인했다. 최초 번역·재사용, 하위 저장 제목, 미감지 언어 저장, 공급자 실패 및 실제 CHECK 실패의 원문 200/worker 복구가 모두 PASS. 이어진 ktlintTestSourceSetCheck는 테스트 3파일의 포맷 14건으로 실패했고 bootJar는 미실행이다. 구현자가 포맷만 보정 중이다. [실제 응답과 테스트 증거](reviews/series-detail-review.md).
- 2026-11-17 P4-T1 완료/P4-GATE lint/build: 테스트 3파일의 줄바꿈/import 순서만 보정한 뒤 `./gradlew --no-daemon ktlintCheck bootJar --console=plain` 성공(exit 0, 26초). `git diff --check` 통과. 제품 코드와 테스트 동작 변경이 없어 82건과 실제 HTTP 증거는 유지한다. LSP 도구는 없으며 기존 Kotlin 컴파일/ktlint로 대체했다. 최종 독립 리뷰와 부모 임시 경로 정리가 남았다.
- 2026-11-17 P4-GATE 완료: 단일 Oracle 리뷰 APPROVE(신뢰도 높음), 차단 사항 없음. MT-017/018·원문 경합·실패 격리·하위 목록 보존과 XML 82건/부모 HTTP 증거의 일치를 확인했다. QA PID 1275/TCP 61019 종료와 구현자 root 부재 확인 후 부모 `series-translation.AH2ekJ`의 runner/classes/report/cache 및 별도 ulw 노트를 삭제하고 경로 부재를 확인했다(exit 0). 전체 테스트·운영 MySQL·실제 공급자/인증·배포는 미검증이며 사용자 전체 테스트 명령은 `./gradlew test`다. 커밋하지 않았다.
- 2026-11-17 P4 커밋 전 재검증: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.ContentSeriesDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.ContentSeriesReadRetryTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' ktlintCheck bootJar --console=plain` exit 0(45초). XML 세 파일에서 38건(15/2/21) 성공, 실패/오류/skip 0을 확인했다. `ktlintCheck`와 `bootJar`는 UP-TO-DATE이며 `git diff --check`도 통과했다. 전체 테스트·운영 MySQL·실제 공급자/인증·배포는 미검증이며 전체 테스트는 사용자 실행 `./gradlew test`다.
@@ -3,7 +3,7 @@
| 항목 | 내용 | | 항목 | 내용 |
|---|---| |---|---|
| 작성일 | 2026-11-16 | | 작성일 | 2026-11-16 |
| 상태 | 구현·기능 검증·독립 리뷰 완료 | | 상태 | 콘텐츠·시리즈 상세 동기 번역 및 연관 제목 번역 구현·기능 검증·독립 리뷰 완료 |
| 구현 계획 | [plan-task.md](plan-task.md) | | 구현 계획 | [plan-task.md](plan-task.md) |
| 결정권자 | 사용자 | | 결정권자 | 사용자 |
@@ -24,6 +24,17 @@
| MT-005 | 번역을 빠르게 반영한다. | 워커 기본 fixedDelay는 1000ms, 실행당 최대 5개 그룹을 유지한다. 실제 완료 시간은 대기량과 외부 API 처리 시간에 좌우된다. | | MT-005 | 번역을 빠르게 반영한다. | 워커 기본 fixedDelay는 1000ms, 실행당 최대 5개 그룹을 유지한다. 실제 완료 시간은 대기량과 외부 API 처리 시간에 좌우된다. |
| MT-006 | 콘텐츠 수정과 기존 조회 흐름을 연결한다. | 일반 관리자 제목/상세 수정과 크리에이터 관리자 태그 없는 제목/상세 수정도 작업을 요청한다. 기존 번역 응답이 남아 있어도 관련 조회 요청은 현재 원문의 FAILED 작업을 재개할 수 있다. | | MT-006 | 콘텐츠 수정과 기존 조회 흐름을 연결한다. | 일반 관리자 제목/상세 수정과 크리에이터 관리자 태그 없는 제목/상세 수정도 작업을 요청한다. 기존 번역 응답이 남아 있어도 관련 조회 요청은 현재 원문의 FAILED 작업을 재개할 수 있다. |
| MT-007 | 기존 계약과 경쟁 처리를 유지한다. | ko/en/ja, 공개 API/원문 fallback, provider별 캐시, SKIP LOCKED 작업 claim, 커뮤니티 revision 보호를 유지한다. job 등록/재개와 워커의 상태 경쟁을 DB 조건 또는 잠금으로 보호한다. | | MT-007 | 기존 계약과 경쟁 처리를 유지한다. | ko/en/ja, 공개 API/원문 fallback, provider별 캐시, SKIP LOCKED 작업 claim, 커뮤니티 revision 보호를 유지한다. job 등록/재개와 워커의 상태 경쟁을 DB 조건 또는 잠금으로 보호한다. |
| MT-008 | 콘텐츠 태그의 AWS 미번역 결과는 Papago로 넘긴다. | CONTENT/tags에 한정하여 원문과 NFC/공백 정규화 및 쉼표 요소별 trim 후 같은 AWS 결과를 거부한다. 새 응답과 캐시에 같은 기준을 적용한다. Papago 동일 결과는 사용자 승인에 따라 성공이다. |
| MT-009 | 기존 잘못 완료된 콘텐츠 태그를 요청 시 복구한다. | 현재 원문/언어에 해당하는 COMPLETED 태그 중 저장된 응답이 원문과 동일하고 유효 캐시 결과와 일치하지 않는 작업을 기존 조회/수정 요청에서 재개한다. 정상 번역 및 Papago로 확인된 동일 결과는 반복 재개하지 않는다. 운영 일괄 변경은 하지 않는다. |
| MT-010 | 콘텐츠 상세 조회에서 언어 미감지를 복구한다. | languageCode가 null/빈 문자열/공백이면 제목·전체 설명·활성 태그로 기존 LanguageDetectEvent를 발행한다. 커밋 후 감지 성공 시 기존 리스너가 언어와 번역 job을 저장한다. 현재 응답의 원문 fallback과 이미 감지된 콘텐츠의 번역 동작을 유지한다. |
| MT-011 | 콘텐츠 상세의 미번역 데이터를 같은 응답에서 제공한다. | 저장된 요청 언어 번역이 없으면 title/detail/tags를 동기 번역하고 기존 캐시와 ContentTranslation에 저장한 뒤 기존 translated 필드로 반환한다. 이미 번역된 데이터는 재사용하고 같은 언어·미지원 언어는 번역하지 않는다. |
| MT-012 | 상세 조회의 원문 언어 감지도 동기로 완료한다. | null/빈 문자열/공백 언어는 제목·전체 설명·활성 태그를 기존 감지 캐시 서비스에 전달하고, 감지 성공 시 같은 요청에서 언어 저장과 요청 언어 번역을 수행한다. 상세 조회에 한해 MT-010의 비동기 선행 정책을 대체한다. |
| MT-013 | 동기 번역 실패에도 원문 상세와 기존 재시도를 유지한다. | 공급자 실패 시 원문 응답을 반환하며 요청 언어의 기존 job을 등록/재개한다. 실패한 번역 트랜잭션이 상세 조회 트랜잭션을 rollback-only로 만들지 않는다. 감지 실패는 기존 감지 이벤트 경로를 보존하며 새 감지 큐는 만들지 않는다. |
| MT-014 | 동기 경로와 worker가 같은 번역 정책을 사용한다. | worker의 캐시 조회·공급자 fallback·태그 정책·메모리 저장을 공유한다. 빈 필드, 기존 캐시, 동시 상세 요청과 worker의 저장 경합을 처리하며 다른 리소스의 큐 처리 의미는 유지한다. |
| MT-015 | 상세 연관 콘텐츠 제목에 현재 요청 언어의 저장된 번역을 표시한다. | previousContent, nextContent, creatorOtherContentList, sameThemeOtherContentList의 title에 LangContext 언어의 저장된 번역을 적용한다. 번역 행 없음·빈 제목·공백 제목은 원문이며 다른 언어 번역을 대신 사용하지 않는다. |
| MT-016 | 연관 콘텐츠의 조회 계약을 보존한다. | ID·순서·개수·coverUrl·null/빈 목록·기존 조회 조건을 유지한다. 이전/다음 선택은 원문 제목 기준이다. 연관 콘텐츠 번역을 새로 생성하거나 작업을 등록하지 않고, ID를 중복 제거하여 최대 한 번 일괄 조회한다. 본문 상세의 기존 동기 번역은 유지한다. |
| MT-017 | 시리즈 상세도 같은 응답 전에 언어 감지와 누락 번역을 완료한다. | `GET /audio-content/series/{id}`에서 null/빈 문자열/공백 언어는 제목·소개·키워드로 감지하고 저장한다. 요청 언어의 title/introduction/keywords 번역이 없으면 기존 감지 캐시·번역 메모리·materializer를 사용해 동기로 저장하고 기존 translated 필드에 반환한다. 저장된 번역은 재사용하고 같은 언어·미지원 언어는 번역하지 않는다. |
| MT-018 | 시리즈 동기 처리의 실패 격리와 조회 계약을 보존한다. | 감지·번역 실패에도 원문 상세를 반환하고 기존 감지 이벤트/번역 job 복구 경로를 사용한다. 시리즈 원문 필드, 장르, 권한, 응답 스키마를 유지한다. 하위 콘텐츠 목록은 저장된 제목 번역만 사용하며 신규 동기 번역을 생성하지 않는다. 동시 원문 변경을 덮어쓰지 않는다. |
## 구현 결정 ## 구현 결정
@@ -47,3 +58,14 @@
- 2026-11-16: 기존 DB 큐와 1초 워커, 동일 트랜잭션 작업 등록안을 제시했다. 사용자가 재시도는 5회로 제한하고 소진 후 조회/수정 요청 때 다시 5회로 재개하도록 확정했다. - 2026-11-16: 기존 DB 큐와 1초 워커, 동일 트랜잭션 작업 등록안을 제시했다. 사용자가 재시도는 5회로 제한하고 소진 후 조회/수정 요청 때 다시 5회로 재개하도록 확정했다.
- 2026-11-16: 구현 후 기능별 고유 사례 259건, ktlintCheck/bootJar를 검증했다. 독립 리뷰의 원문 언어 일치 누락을 회귀 테스트로 보완한 뒤 APPROVE 판정을 받았다. 상세 명령과 미검증 범위는 [검증 기록](reviews/verification.md)에 있다. - 2026-11-16: 구현 후 기능별 고유 사례 259건, ktlintCheck/bootJar를 검증했다. 독립 리뷰의 원문 언어 일치 누락을 회귀 테스트로 보완한 뒤 APPROVE 판정을 받았다. 상세 명령과 미검증 범위는 [검증 기록](reviews/verification.md)에 있다.
- 2026-11-16 후속 승인: 사용자가 감지도 AWS 우선으로 변경하는 데 동의했다. 초기의 Papago 우선 감지 정책을 정정하고, 기존 감지 캐시는 그대로 재사용한다. P1-T2로 검증한다. - 2026-11-16 후속 승인: 사용자가 감지도 AWS 우선으로 변경하는 데 동의했다. 초기의 Papago 우선 감지 정책을 정정하고, 기존 감지 캐시는 그대로 재사용한다. P1-T2로 검증한다.
- 2026-11-16 태그 후속: 사용자가 AWS가 쉼표 공백만 바꾸는 태그를 성공 처리하는 문제를 보고하고 Papago fallback을 요청했다. Papago도 같은 값을 반환하면 성공으로 인정하기로 선택했다. 원문 해시/일반 텍스트 정책은 변경하지 않는다.
- 2026-11-16 태그 후속 완료: 신규/기존 AWS 미번역 캐시와 완료 작업 복구를 구현했다. 고유 기능 사례 277건, lint/build 및 단일 독립 리뷰 APPROVE를 확인했다. [태그 검증 기록](reviews/tag-fallback-review.md).
- 2026-11-17 상세 조회 후속: 사용자가 언어 미감지 콘텐츠의 감지 선행을 최소 수정으로 요청했다. 상세 조회에 기존 감지 이벤트 분기만 추가하며, 새 감지 큐·재시도 정책은 추가하지 않는다. P1-T4로 추적한다.
- 2026-11-17 상세 조회 후속 완료: null/빈 문자열/공백 HTTP 회귀 3건의 RED/GREEN, 관련 테스트 31건, ktlintCheck/bootJar 및 독립 리뷰 APPROVE를 확인했다. 기존 원문 응답을 유지하며 감지 후 번역 job을 등록한다.
- 2026-11-17 동기 번역 후속 승인: 사용자가 상세 조회에서 번역 완료를 기다려 같은 응답에 표시하는 최소 수정안을 승인했다. 기존 번역 재사용, 요청 언어의 제목·설명·태그 번역 및 저장, 미감지 언어 동기 감지, 실패 시 원문+기존 job 재시도를 포함한다. P2-T1로 추적한다. 목록과 다른 리소스의 비동기 처리, API 스키마, 공급자 설정과 DB 스키마는 변경하지 않는다.
- 2026-11-17 정책 정정: MT-012는 상세 조회에서만 MT-010의 비동기 감지 선행을 대체한다. 기존 완료 기록은 당시 검증 이력으로 보존한다. 첫 조회에 외부 감지/번역 시간이 추가되고 공급자 설정에 명시적인 요청 제한 시간이 없다는 위험은 승인 전 설명했다.
- 2026-11-17 동기 번역 완료: 관련 277건 및 최종 생성자 정리 영향 17건, 실제 HTTP QA 4개 시나리오, Kotlin 컴파일·ktlintCheck·bootJar를 확인했다. 단일 독립 리뷰 APPROVE, 차단 사항 없음. [동기 상세 검증 기록](reviews/synchronous-detail-review.md)에 실제 응답·실패 복구·동시성 증거와 운영 MySQL/실제 공급자/전체 테스트의 미검증 범위를 구분했다.
- 2026-11-17 연관 콘텐츠 후속 승인: 사용자가 네 필드의 기존 title에 저장된 번역만 적용하고 번역 없음·공백은 원문으로 반환하는 최소 범위를 선택했다. 새 번역 생성과 응답 스키마 확장은 제외한다. P3-T1로 추적한다.
- 2026-11-17 연관 콘텐츠 후속 완료: 관련 테스트 38건, 실제 HTTP 5회/3개 시나리오, Kotlin 컴파일·ktlintCheck·bootJar 통과 및 단일 독립 리뷰 APPROVE를 확인했다. 작업 임시 자원은 정리했다. [연관 콘텐츠 검증 기록](reviews/related-content-title-review.md)에 응답·fallback·원문 탐색 보존과 미검증 범위를 기록했다.
- 2026-11-17 시리즈 상세 후속 승인: 사용자가 콘텐츠 상세와 같은 감지·동기 번역을 최소 구현으로 요청하고 인터뷰에서 "시리즈 자체만"을 선택했다. 제목·소개·키워드만 동기 처리하고 하위 콘텐츠는 저장 번역 조회를 유지한다. 콘텐츠 상세의 캐시 재사용·실패 시 원문과 기존 재시도 정책을 따른다. 추가 공급자 호출에 따른 첫 응답 대기는 동기 번역 범위에 한정한다. P4-T1/P4-GATE로 추적한다.
- 2026-11-17 시리즈 상세 후속 완료: 새 시리즈 HTTP 15건 포함 직접 영향 회귀 82건, 부모의 실제 HTTP 8회/5개 시나리오, ktlintCheck/bootJar 및 단일 독립 리뷰 APPROVE를 확인했다. 소유 QA 서버·임시 파일/캐시/노트를 정리했다. [시리즈 상세 검증 기록](reviews/series-detail-review.md)에 실패 이력과 미검증 범위를 구분했다.
@@ -0,0 +1,99 @@
# 상세 연관 콘텐츠 제목 번역 검증과 리뷰
| 항목 | 내용 |
|---|---|
| 대상 | MT-015~016 / P3-T1, P3-GATE / 미커밋 working tree |
| 일자 | 2026-11-17 |
| 기준 | [PRD](../prd.md), [계획](../plan-task.md) |
| 상태 | 기능 검증 완료, 독립 리뷰 APPROVE |
## 범위와 구현 근거
`AudioContentService.getDetail`에서 네 관련 필드의 ID를 중복 제거하고 현재 LangContext locale의 저장 번역을 한 번 조회한다.
비어 있지 않은 title만 immutable DTO copy로 반영하고 원문 기반 navigation/쿼리/ID/cover/각 요청의 목록 순서를 유지한다.
새 번역 생성·job·스키마·의존성·공개 API는 추가하지 않는다. 제품 변경은 서비스 18줄 추가와 응답 할당 4줄 교체다.
## 자동 검증
- 기존 HTTP baseline: 15건 성공.
- RED: 신규 HTTP 포함 21건 중 1건 실패. expected `title=en 가 이전`, actual `title=가 이전`, ID와 cover 일치.
- GREEN: 아래 focused 명령에서 38건 성공(HTTP 21, service 16, retry 1), 실패/오류/skip 0. 부모가 XML 세 파일을 직접 확인했다.
- 테스트 두 표현식의 포맷 실패를 수정한 뒤 실제 HTTP QA 및 `ktlintCheck`, `bootJar`를 실행해 exit 0을 확인했다. 테스트 동작은 변경하지 않았다.
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' --console=plain
./gradlew --no-daemon -I "$TMPDIR/qa.init.gradle" runRelatedContentQa ktlintCheck bootJar --console=plain
```
자동 검증 산출물: `build/test-results/test/TEST-kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest.xml`,
`TEST-kr.co.vividnext.sodalive.content.AudioContentServiceTest.xml`, `TEST-kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest.xml`.
HTTP 테스트 timestamp는 `2026-11-17T03:26:24`이며 이후 변경은 인자 줄바꿈뿐이다.
## 부모가 직접 실행한 HTTP QA
위 두 번째 명령은 임시 Java runner가 기존 Spring test context와 fixture를 사용하고 Java HttpClient로 실제 Tomcat 서버를 호출한다.
외부 공급자·principal은 테스트 대체이며 controller/service/JPA/트랜잭션은 실제 코드다. H2 DB에서 fixture를 커밋한 후 요청했다.
검증 시 원본 runner: `/var/folders/yh/8xsbvpsj5wg2qnxzxdp11_gm0000gn/T/opencode/content-translation.TfjAph/RelatedContentQa.java`.
임시 runner는 종료 시 삭제하며 실제 응답 발췌와 판정은 이 문서에 보존한다.
| 시나리오 | 실행 | 기대/관찰 | 판정 |
|---|---|---|---|
| 현재 언어 저장 번역 | 같은 `/audio-content/1?timezone=UTC`에 en→ja→en GET | 모두 200. 네 필드의 제목이 각 locale로 전환되고 ID·cover가 유지됨 | PASS |
| 혼합 fallback | en 제목 삭제/빈 문자열/공백, ja만 남은 항목을 함께 GET | 모두 원문 제목. 공급자는 본문 최초 번역 3회만, job 0개 | PASS |
| 인접/빈 관계 | `/audio-content/6?timezone=UTC` GET | 200, 이전/다음 null, 두 목록 [], 본문 translated.title은 English title | PASS |
실제 호출과 응답 발췌:
```text
QA GET http://localhost:59748/audio-content/1?timezone=UTC locale=en status=200
previousContent={"contentId":2,"title":"en 가 이전","coverUrl":"https://cdn.test/related-0.png"}
nextContent={"contentId":3,"title":"en 하 다음","coverUrl":"https://cdn.test/related-1.png"}
creatorOtherContentList=[{"contentId":3,"title":"en 하 다음"},{"contentId":4,"title":"en creator only"},{"contentId":2,"title":"en 가 이전"}]
sameThemeOtherContentList=[{"contentId":5,"title":"en theme only"},{"contentId":2,"title":"en 가 이전"},{"contentId":3,"title":"en 하 다음"}]
translated={"title":"English title","detail":"English detail","tags":"#Healing"}
QA GET http://localhost:59748/audio-content/1?timezone=UTC locale=ja status=200
previousContent={"contentId":2,"title":"ja 가 이전","coverUrl":"https://cdn.test/related-0.png"}
nextContent={"contentId":3,"title":"ja 하 다음","coverUrl":"https://cdn.test/related-1.png"}
creatorOtherContentList=[{"contentId":4,"title":"ja creator only"},{"contentId":2,"title":"ja 가 이전"},{"contentId":3,"title":"ja 하 다음"}]
sameThemeOtherContentList=[{"contentId":5,"title":"ja theme only"},{"contentId":3,"title":"ja 하 다음"},{"contentId":2,"title":"ja 가 이전"}]
translated={"title":"Japanese title","detail":"Japanese detail","tags":"#Japanese"}
QA GET http://localhost:59748/audio-content/1?timezone=UTC locale=en status=200
QA PASS locale switching: all four fields, IDs/covers, main translation
QA GET http://localhost:59748/audio-content/1?timezone=UTC locale=en status=200
previousContent.title="가 이전", nextContent.title="하 다음"
creatorOtherContentList titles=["가 이전","하 다음","creator only"]
sameThemeOtherContentList titles=["하 다음","theme only","가 이전"]
QA PASS mixed fallback: originals, no related provider calls/jobs
QA GET http://localhost:59748/audio-content/6?timezone=UTC locale=en status=200
{"previousContent":null,"nextContent":null,"creatorOtherContentList":[],"sameThemeOtherContentList":[],"translated":{"title":"English title","detail":"English detail","tags":"#Healing"}}
QA PASS empty relations: null neighbors, empty lists, translated main
QA CLEANUP: Spring HTTP server and database context closed
BUILD SUCCESSFUL in 50s
```
목록은 기존 rand 정렬이므로 서로 다른 요청 사이 순서는 달라질 수 있다. 각 요청에서 조회된 순서를 바꾸지 않는 것은 코드의 map/copy와 대조했다.
배치 1회/중복 ID 제거/빈 관계 조회 0회는 실제 repository spy로 반환을 stub하지 않고 HTTP 테스트에서 검증했다.
## 실행 한계 및 자원
- LSP 도구가 제공되지 않아 Kotlin 컴파일과 ktlint로 대체했다.
- 전체 테스트, 운영 MySQL JSON, 실제 AWS/Papago, 실제 로그인·배포는 실행하지 않았다. 전체 테스트는 사용자 실행 `./gradlew test`다.
- 기존 Gradle 9 deprecation, duplicate JSONObject, macOS Netty DNS 경고를 변경하거나 suppress하지 않았다.
- 임시 QA Java 컴파일에는 runtime classpath에 없는 API guardian annotation 관련 경고 4건이 있었지만 컴파일/실행은 성공했다. 제품 의존성은 변경하지 않았다.
- Tomcat 종료 시 Hikari housekeeper 경고 뒤 JPA close와 Hikari Shutdown completed가 출력됐고 QA JVM이 정상 종료했다. 별도 상주 서버는 만들지 않았다.
- 구현자의 `p3-t1.JgkJkn` 임시 root 부재를 확인했다. QA PID 85049 부재 및 TCP 59748 listener 없음도 확인했다.
- 승인 후 부모 `content-translation.TfjAph` root의 QA 실행기·init script·class·임시 보고서와 별도 ulw 노트를 삭제하고 경로 부재를 확인했다(exit 0). 검증 응답/리뷰 결과는 이 문서에 보존했으며 공유 캐시·작업 외 파일은 변경하지 않았다.
## 독립 리뷰
2026-11-17 단일 Oracle reviewer 판정: **APPROVE**, 신뢰도 높음, 차단 사항 없음.
- MT-015/016: 네 필드의 요청 언어 번역과 fallback, 지역 번역 맵을 통한 요청 간 격리, distinct 배치 조회를 확인했다.
- ID·cover·개수·null 및 각 조회 결과의 순서, 원문 제목 navigation을 보존하며 관련 공급자 호출/job/API/DB/의존성 변경이 없음을 확인했다.
- 테스트는 실제 HTTP/JPA 계약을 검증하며 mock echo·prose pin·테스트 전용 제품 seam이 없다. 배치 횟수 spy는 PRD의 명시적 제약을 검증한다.
- reviewer가 XML의 38건 성공과 구현 보고서 RED, QA 문서·Java runner·Gradle init script를 직접 대조했다. 리뷰에서 테스트를 재실행하지 않았다.
- 잔여 한계: H2는 운영 MySQL 검증을 대체하지 않으며 실제 공급자·인증·전체 테스트는 미검증이다.
@@ -0,0 +1,102 @@
# 시리즈 상세 동기 번역 검증과 리뷰
| 항목 | 내용 |
|---|---|
| 대상 | MT-017~018 / P4-T1, P4-GATE / 미커밋 working tree |
| 일자 | 2026-11-17 |
| 기준 | [PRD](../prd.md), [계획](../plan-task.md) |
| 상태 | HTTP/기능/lint/build 검증 완료, 독립 리뷰 APPROVE |
## 범위
시리즈 제목·소개·키워드의 언어 감지와 요청 언어 번역을 같은 상세 응답 전에 저장한다.
기존 콘텐츠 상세와 같은 트랜잭션 격리, 감지 캐시·번역 메모리·materializer·복구 job을 사용한다.
시리즈 원문·장르·권한·DTO와 하위 콘텐츠의 저장된 제목 번역 조회는 유지한다.
공급자 설정·의존성·DB 스키마·콘텐츠 상세 resolver는 변경하지 않았다.
## TDD와 기능별 검증
- 변경 전 콘텐츠 상세 HTTP baseline 21건 성공(exit 0, 27초).
- 최초 새 테스트 실행은 fixture의 필수 theme 누락으로 실패했다. fixture를 수정했으며 제품 RED로 인정하지 않았다.
- production 수정 전 시리즈 HTTP 15건 중 12건 실패(exit 1, 37초). 첫 translated.title은 기대 `English title` 대신 null, 미감지 3종은 DB의 기대 `ko` 대신 null/빈 문자열/공백이었다.
- 첫 GREEN 실행은 compileTestKotlin 중 도구 120초 제한으로 종료됐다. 종료 확인 후 300초 제한으로 실행하여 15건 모두 성공(exit 0, 2분 22초).
- 직접 영향 7개 클래스 82건 성공(exit 0, 1분 1초). 부모가 최종 XML 7개의 tests/failures/errors/skipped를 직접 확인했다.
| 테스트 클래스 | 성공 건수 | 실패/오류/skip |
|---|---:|---|
| AudioContentDetailTranslationHttpIntegrationTest | 21 | 0/0/0 |
| ContentSeriesDetailTranslationHttpIntegrationTest | 15 | 0/0/0 |
| MetadataLanguageDetectTransactionTest | 10 | 0/0/0 |
| ContentSeriesReadRetryTest | 2 | 0/0/0 |
| ContentTagTranslationIntegrationTest | 11 | 0/0/0 |
| TranslationJobRetryIntegrationTest | 10 | 0/0/0 |
| TranslationJobWorkerTest | 13 | 0/0/0 |
명령은 계획의 P4 검증 블록에 있다. XML은 `build/test-results/test/TEST-kr.co.vividnext.sodalive.` 접두사의 각 클래스 경로에 있다.
새 HTTP 테스트는 실제 응답과 별도 트랜잭션의 저장 결과를 비교한다. 감지 캐시, 빈 필드, 동일/미지원 언어,
감지 실패의 SERIES 이벤트, 원문 변경, 상세 2건/worker 1건의 저장 경합, 하위 제목 en→ja→en도 포함한다.
## 부모의 실제 HTTP QA
명령: `./gradlew --no-daemon -I "$TMPDIR/qa.init.gradle" runSeriesQa ktlintCheck bootJar --console=plain`.
임시 `SeriesQa.java`가 기존 테스트 context와 DB fixture를 사용해 Java HttpClient로 실제 Tomcat에 GET 8회를 보냈다.
인증 principal·외부 공급자만 테스트 대역이며 controller/service/JPA/트랜잭션은 실제 구현이다.
아래 응답 및 assertion 결과는 2026-11-17 13:58 KST 실행 출력에서 보존했다.
| 시나리오 | 관찰한 응답/DB 결과 | 판정 |
|---|---|---|
| 첫 번역·재사용 | series/1 GET 2회 200, 세 translated 필드 일치, 별도 repository 조회 title 일치, 공급자 총 3회/job 0개 | PASS |
| 하위 콘텐츠 저장 번역 | 첫 응답의 `기본 child`가 저장 번역 추가 후 `Stored child`, 부모 원문은 유지, 공급자 총 3회/job 0개 유지 | PASS |
| 미감지 원문 | series/2 GET 200, 같은 응답에 세 번역 필드, JDBC 재조회 language_code=ko, 전체 감지 query 일치 | PASS |
| 공급자 실패·복구 | series/3 GET 200/translated=null/원문 title, job 3개, worker 실행 후 GET 200/세 번역 필드 | PASS |
| 실제 저장 실패·복구 | series/4 CHECK 23513 후 GET 200/translated=null, 번역 0행/메모리 3행/job 3개, 제약 해제와 worker 후 GET 번역, 공급자 총 3회 | PASS |
실제 응답 발췌:
```text
QA PID=1275 PORT=61019
GET http://localhost:61019/audio-content/series/1 locale=en
status=200 content-type=application/json
title="원문 제목", introduction="원문 설명"
translated={"title":"English title","introduction":"English detail","keywords":["#Healing","#Calm"]}
translatedGenre="Stored genre"
QA PASS first-response/DB/reuse calls=3 jobs=0
QA PASS child stored-only/original preserved calls=3 jobs=0
QA PASS missing-language committed before response
GET http://localhost:61019/audio-content/series/3 locale=en
status=200 translated=null
worker 후 status=200 translated={"title":"English title","introduction":"English detail","keywords":["#Healing","#Calm"]}
QA PASS provider-failure original 200/jobs=3/worker recovery
SQL Error: 23513 / constraint qa_reject_series
QA PASS database-rollback isolation/worker cached recovery calls=3
QA CLEANUP context closed active=false
```
이 실행은 HTTP QA 이후 ktlintTestSourceSetCheck의 새 테스트 포맷 14건에서 exit 1로 종료됐다.
HTTP 결과는 PASS지만 전체 명령 또는 bootJar 성공으로 기록하지 않는다. 줄바꿈/import 정렬만 보정한다.
포맷 보정 뒤 `./gradlew --no-daemon ktlintCheck bootJar --console=plain`는 exit 0, 26초로 성공했다.
`git diff --check`도 통과했다. 테스트 3파일의 줄바꿈과 import 순서만 바뀌었으며 제품 동작/assertion은 동일하다.
기존 82건과 HTTP 증거를 재실행한 것으로 기록하지 않는다.
## 한계 및 정리
- 운영 MySQL JSON/잠금, 실제 AWS/Papago, 실제 로그인·배포·전체 테스트는 미검증이다. 전체 테스트는 사용자 실행 `./gradlew test`다.
- H2 JSON 래핑은 기존 테스트와 같은 varchar 변환기 왕복으로 검증한다. worker claim은 기존 H2 대역이며 운영 SKIP LOCKED를 재현하지 않는다.
- LSP 도구가 없어 Kotlin compileKotlin/compileTestKotlin과 ktlint로 대체한다. 첫 조회 대기 시간은 공급자 응답 시간에 좌우되며 동시 요청의 중복 공급자 호출은 가능하다.
- 기존 중복 JSONObject/Netty macOS DNS/Gradle deprecation 경고와 임시 Java runner의 apiguardian annotation 경고는 변경하지 않았다.
- 종료 시 Tomcat의 Hikari housekeeper 경고 이후 JPA 종료와 Hikari Shutdown completed를 확인했다. 부모가 PID 1275 부재와 TCP 61019 listener 부재를 확인했다(exit 0).
- 구현자 임시 root `p4-t1.5u5PX9` 부재를 부모가 확인했다. 리뷰 승인 후 부모 `series-translation.AH2ekJ`의 QA runner/init/classes/report/cache와 별도 ulw 노트를 삭제하고 두 경로 부재를 확인했다(exit 0). 응답·검증 기록은 이 문서와 계획에 보존했다. 공유 캐시는 삭제하지 않았다.
## 독립 리뷰
2026-11-17 단일 Oracle 리뷰: **APPROVE**, 신뢰도 높음, 차단 사항 없음.
- MT-017: 세 메타데이터 필드, 동기 감지/저장, 캐시 및 기존 번역 재사용, 동일·미지원 언어 제외를 확인했다.
- MT-018: 서비스 간 NOT_SUPPORTED와 REQUIRES_NEW, 실제 저장 rollback 후 원문 200과 복구, FAILED 재개 assertion 보존을 확인했다.
- 감지 저장·materialize의 snapshot/부모 잠금, 외부 managed entity 미갱신, worker/상세 수렴과 하위 저장 제목 계약을 확인했다.
- XML 7개의 82건과 부모 Java HttpClient의 8회/5개 시나리오 및 DB assertion을 대조했다. 포맷 보정 전후 증거 구분과 실행 한계에 불일치가 없었다.
- 리뷰어는 settled 테스트를 재실행하지 않았다. 확정 발견 사항 및 회귀 수정 Goal 전환 항목 없음.
관련 이력: `ff30ebac` 콘텐츠 상세 동기 번역, `081f22b2` 현재 원문 FAILED 재개, `f7fadf7a` 공급자/캐시 공통화.
새 시리즈 resolver는 이 정책들을 재사용하며 `d82185e9`의 시리즈 정책 호출/권한 흐름은 보존한다.
@@ -0,0 +1,90 @@
# 콘텐츠 상세 동기 번역 검증과 리뷰
| 항목 | 내용 |
|---|---|
| 대상 | MT-011~014 / P2-T1, P2-GATE / 미커밋 working tree |
| 일자 | 2026-11-17 |
| 기준 | [PRD](../prd.md), [계획](../plan-task.md) |
| 상태 | 기능 검증 완료, 독립 리뷰 APPROVE |
## 범위와 구현
상세 조회가 요청 언어의 title/detail/tags를 동기로 번역·저장해 기존 translated 필드에 반환한다. 기존 번역과 메모리를 재사용하고 미감지 언어는 같은 요청에서 감지한다. 실패는 원문 응답과 기존 job/감지 이벤트 복구를 유지한다.
공유 TranslationMemoryService에 기존 worker 정책을 이동했고 상세 전용 서비스가 트랜잭션 실패를 격리한다. 공개 API, DB 스키마, 의존성, 공급자 설정과 다른 리소스 호출 경로는 변경하지 않는다.
## 자동 검증 증거
- 신규 RANDOM_PORT 상세 HTTP/DB 15건 포함, 관련 30개 클래스 277건 통과(실패/오류/skip 0). 정확한 필터와 RED/GREEN 결과는 계획의 P2 진행 기록에 있다.
- 실제 유일키 경합: 상세 GET 2건과 worker 1건을 latch로 동기화해 H2 23505 충돌을 만들고 메모리 3행·번역 1행·COMPLETED job으로 수렴시켰다.
- 실제 CHECK 위반: payload insert와 메모리 UPDATE commit 실패에서도 원문 HTTP 200과 기존 job 복구가 유지됐다. 기존 번역의 retry-maintenance 실패도 응답을 막지 않았다.
- 마지막 포맷/미사용 생성자 제거 후 관련 17건 통과. `ktlintCheck` exit 0, production/test Kotlin 컴파일과 bootJar task 성공, `git diff --check` 통과.
- 기존 Gradle 9 deprecation, macOS Netty DNS, 작업 밖 Kotlin 불필요 `!!`/unchecked cast 경고는 suppress하거나 수정하지 않았다.
## 부모가 직접 실행한 HTTP QA
명령: `./gradlew --no-daemon -I "$RUN_TMP/qa.init.gradle" runContentDetailQa test --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AudioContentReadRetryTest' --console=plain`.
임시 Java runner가 Spring 테스트 context와 기존 fixture를 재사용하되 Java HttpClient로 localhost 실제 Tomcat 서버를 호출했다. 테스트 principal과 외부 번역 provider만 대체했으며 controller/service/트랜잭션/JPA는 실제 코드다. 종료 코드 0.
| 시나리오 | 기대 | 실제 관찰 | 판정 |
|---|---|---|---|
| 최초 조회·재조회 | 첫 응답 번역 저장, 재조회 외부 재호출 없음 | GET 2회 모두 200, 번역 3필드 일치, provider 총 3회, 새 job 0개, DB title 일치 | PASS |
| 원문 언어 없음 | 같은 응답에서 언어 감지 및 번역 | GET 200, languageCode=ko, translated.title=English title, content DB language_code=ko | PASS |
| 공급자 실패와 복구 | 원문 200, job 등록 후 worker가 번역 | 첫 GET translated=null, 요청 언어 job 3개, worker 후 GET 번역 3필드 반환 | PASS |
| 저장 실패 격리와 복구 | 상세 commit 성공, 저장된 메모리 재사용 | 실제 CHECK 23513 후 GET 200/translated=null, job 3개, 제약 해제 및 worker 후 번역, provider 총 3회 | PASS |
실제 응답 발췌(테스트 데이터):
```text
GET http://localhost:58600/audio-content/1?timezone=UTC
200 content-type=application/json
languageCode="ko"
translated={"title":"English title","detail":"English detail","tags":"#Healing"}
GET http://localhost:58600/audio-content/3?timezone=UTC
200 content-type=application/json languageCode="ko" translated=null
worker 복구 후 같은 GET:
200 content-type=application/json
translated={"title":"English title","detail":"English detail","tags":"#Healing"}
QA PASS first-response/persist/reuse: provider=3 jobs=0
QA PASS unknown-language: detected and committed before response
QA PASS provider-failure/recovery: original 200, jobs=3, worker restored translation
QA PASS persistence-failure/isolation: original 200, worker reused committed memories
QA CLEANUP: HTTP server, JPA and Hikari context closed
```
## 실행 한계와 정리
- H2에서 실제 저장·커밋·경합을 검증했다. JSON fixture는 converter 텍스트 왕복용 varchar이며 운영 MySQL JSON 및 1062 경합/잠금 검증을 대체하지 않는다.
- 실제 AWS/Papago, 운영 DB, 실제 로그인, 전체 테스트, 배포는 실행하지 않았다. 전체 테스트 명령: `./gradlew test`.
- LSP 도구가 없어 Kotlin 컴파일/ktlint로 확인했다. 공급자 timeout 설정은 유지했으므로 첫 조회 지연은 외부 API 처리 시간에 좌우되며 경합 시 중복 공급자 호출은 가능하다.
- 첫 임시 QA 실행의 종료 순서 오류는 runner에서만 수정했다. 기능은 모두 성공했지만 그 실행의 전체 exit 1을 성공으로 기록하지 않는다.
- 최종 runner의 Tomcat 종료 직후 Hikari housekeeper 경고가 있었으나 뒤이어 JPA와 Hikari의 Shutdown completed가 출력됐고 프로세스가 exit 0으로 종료됐다.
- 구현자 소유 임시 root 2개 및 부모 RUN_TMP의 runner/init script/class/log/notepad는 제거 완료다. 부모가 디렉터리 부재(exit 0), QA runner/test worker/Gradle wrapper 없음, 포트 58600 listener 없음을 확인했다. 위 응답 발췌와 결과는 원본 임시 로그 삭제 전에 대조·보존했다. 공유 캐시/기존 IDE daemon은 유지했다.
## 독립 리뷰
2026-11-17 단일 Oracle reviewer 판정: **APPROVE**, 차단 사항 없음.
- MT-011~014: 기존 번역/메모리 재사용, 요청 언어의 즉시 응답, 동기 언어 감지, commit 실패 격리, 원문+기존 복구 경로와 동시 저장 수렴을 코드/증거로 확인했다.
- worker의 claim/6회 시도/backoff/1초 주기, AWS 태그 fallback 및 FAILED/완료 태그 복구를 보존했다. 공개 API/DB 스키마/의존성/공급자 설정/목록 진입점 변경은 없다.
- 현재 XML의 16+1건과 앞선 277건 기록을 구분했으며, 이전 XML을 다시 확인한 것으로 주장하지 않았다. 임시 runner 첫 실행의 종료 오류와 최종 성공도 구분했다.
- 새 테스트는 실제 응답·committed DB·제약 위반을 검증하고 경합 spy는 실제 저장을 위임한다. production 테스트 전용 hook이나 mock 결과만 반복하는 검증은 발견하지 못했다.
- 참고: 구매 전 원문 설명은 잘리지만 translated.detail은 전체 payload를 반환하는 기존 계약이 유지된다. 변경 전에도 같은 동작이므로 이번 변경의 신규 회귀는 아니다.
- 미검증: 운영 MySQL JSON/1062/잠금, 실제 공급자와 지연, 전체 테스트. 동시 외부 번역의 중복 호출 가능성은 남는다.
확정 발견 사항 없음. 회귀 수정 Goal 전환 항목 없음.
## 커밋 전 재검증
2026-11-17 사용자 커밋 요청에 따라 다음 명령을 실행했다.
```bash
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest' --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.*' --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' --tests 'kr.co.vividnext.sodalive.osiv.OsivLazyLoadingRegressionTest' ktlintCheck bootJar --console=plain
git diff --check
```
- Gradle exit 0, `BUILD SUCCESSFUL in 2m 22s`.
- 현재 HTML 보고서와 XML 30개에서 277건, 실패/오류/skip 0을 확인했다. 신규 상세 HTTP 15건이 포함된다.
- `test`는 실제 재실행했으며 `ktlintCheck`와 `bootJar`는 UP-TO-DATE다. `git diff --check`는 exit 0이다.
- 전체 테스트·실제 외부 공급자·운영 MySQL 검증은 실행하지 않았다. 전체 테스트 사용자 실행 명령은 `./gradlew test`다.
@@ -0,0 +1,100 @@
# 콘텐츠 태그 미번역 fallback 검증 및 리뷰
## 범위와 판정 기준
2026-11-16 P1-T3, MT-008/009. 콘텐츠 `tags`에 한정해 AWS가 원문을 그대로 반환하거나 쉼표 요소의 공백만 바꾼 경우 Papago를 사용한다.
사용자는 Papago도 같은 값을 반환하면 성공으로 인정한다고 명시했다. 일반 제목/본문과 다른 리소스 태그에는 적용하지 않는다.
기존 AWS 캐시를 일괄 삭제하지 않으며 현재 콘텐츠 조회/수정 시 해당 완료 작업만 복구한다.
실제 AWS에서 # 문자가 원인인지는 검증하지 않았다. 보고된 응답 형태를 외부 공급자 대역으로 재현하고 실제 coordinator/worker/JPA 동작을 검증했다.
## QA 증거
| 시나리오 | 실행/저장 경계 | 결과 |
|---|---|---|
| AWS 원문 동일·쉼표 공백 결과 | ContentTagTranslationIntegrationTest, 실제 worker/coordinator/materializer/H2 | Papago 호출 및 Papago 결과 저장, job COMPLETED |
| 기존 AWS 미번역 캐시 | 같은 테스트 | AWS 캐시를 무시하고 Papago 결과로 content_translation 조립 |
| AWS 캐시만 있는 조립 | 같은 테스트 | materialize=false, 잘못된 응답 행 생성 없음 |
| Papago 동일 결과 | 같은 테스트 | provider=papago, 동일 태그 저장 및 COMPLETED |
| AWS 정상 결과/일반 제목 | 같은 테스트 | 기존 AWS 성공 정책 유지, Papago 미호출 |
| Papago 장애 | 같은 테스트 | 잘못된 AWS 결과로 완료하지 않고 PENDING/retryCount=1, 캐시·응답 저장 없음 |
| 기존 잘못된 AWS 캐시 뒤 정상 AWS 결과 | 같은 테스트 | 같은 cache ID의 translatedText 갱신 및 정상 응답 조립 |
| 과거 완료 작업 복구 | CompletedContentTagRepairTest, H2 | 같은 작업 ID를 조건부 COMPLETED→PENDING, count0/error null/due now |
| 정상/비대상/경합 보호 | 같은 테스트 | Papago 확인 동일 태그, 정상 AWS 번역, 다른 원문/언어/리소스/필드, PENDING/RUNNING 보호 |
| 조회→worker→재조회 연속 흐름 | ContentTagTranslationIntegrationTest.shouldRepairCompletedTagsOnceAcrossReadWorkerAndRead | 동일 ID 복구 후 Papago 동일 결과를 저장하고 다음 조회에서는 COMPLETED 유지 |
연속 흐름의 실제 테스트 출력:
```text
Tag repair QA: same job=3, AWS unchanged rejected, Papago identical accepted, next read remains COMPLETED
```
최종 XML: `build/test-results/test/TEST-kr.co.vividnext.sodalive.i18n.translation.ContentTagTranslationIntegrationTest.xml`.
태그 원문 추출은 이 통합 테스트의 고정 fixture이며 worker/coordinator/repository/materializer는 실제 구현이다.
공급자 응답만 통제하고 H2 JSON의 문자열 감싸기 차이는 테스트에서 JSON 객체로 맞춘다. 운영 저장 변환은 변경하지 않았다.
## RED/GREEN
- 최초 테스트 cleanup이 H2 JSON 변환으로 실패한 것은 setup 문제로 분류하고 bulk cleanup으로 수정했다.
- forward 8건 중 6건 RED: AWS 동일 결과/캐시가 성공으로 처리되는 assertion 실패. 구현 후 forward/coordinator/worker 29건 GREEN.
- completed repair 27건 중 11건 RED: 현재 COMPLETED 중복 가드로 재개되지 않음. 구현 후 27건 GREEN.
- cache refresh 추가 RED 1건: 정상 AWS 결과가 와도 기존 미번역 캐시가 갱신되지 않음. 같은 행의 translatedText 갱신으로 GREEN.
- 일반 회귀 실행은 번역 패키지+감지 원자성+감지 캐시 232건 모두 통과했으나 lint에서 새 multiline 조건 braces 누락이 발견됐다. 변경 줄만 수정했다.
## 실행 명령
공통 회귀:
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.*' \
--tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' \
--tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' --continue
```
테스트 232건은 실패/오류/skip 0, 이 실행의 비정상 종료 원인은 위 lint 3건이었다.
보완 후 직접 영향 회귀 및 최종 lint/build:
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.ContentTagTranslationIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.CompletedContentTagRepairTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinatorTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \
--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.osiv.OsivLazyLoadingRegressionTest'
```
exit 0, 10개 클래스 104건 실패/오류/skip 0. 두 실행의 중복을 제외한 고유 기능 검증은 277건이다.
최종 `git diff --check`도 통과했다. Kotlin 컴파일·ktlint를 사용했으며 LSP 도구는 제공되지 않았다.
## 미검증과 최종 상태
- 실제 AWS/Papago 호출·번역 품질/과금/IAM 및 운영 MySQL 잠금은 미검증이다. 원문 동일 판정은 번역 품질 전반이나 일부 태그만 미번역인 상황을 판정하지 않는다.
- 전체 테스트는 사용자 실행 `./gradlew test`로 구분한다. 운영 DB 일괄 변경과 커밋/배포는 하지 않았다.
- 단일 독립 gate review APPROVE. MT-008/009, 태그 전용 결과/캐시 판정, 같은 캐시 행 갱신, 완료 작업 조건부 복구, Papago 동일 결과의 반복 재개 방지, 상태 경쟁 보호와 104건 최종 XML/lint/build 증거를 확인했다. 차단 사항 없음.
- 정리 완료: reviewer가 원본 실행 로그를 확인한 뒤 소유 임시 루트 `tag-fallback.UmKdRY`와 하위 로그/메모를 삭제하고 경로 부재를 확인했다. 소유 Gradle test worker/Redis 프로세스 없음, 공유 캐시 보존. 검증 이력은 이 문서와 계획에 유지한다.
## 2026-11-17 커밋 전 재검증
사용자 커밋 요청에 따라 태그 처리와 직접 영향 기능을 재검증했다.
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.*' \
--tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' \
--tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' \
--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.osiv.OsivLazyLoadingRegressionTest'
```
- exit 0, 1분 17초. XML 32개 클래스 277건, 실패/오류/skip 0.
- 테스트는 실행됐고 ktlintCheck/bootJar는 UP-TO-DATE다. `git diff --check`도 통과했다.
- 전체 테스트는 미실행이며 사용자 실행 명령은 `./gradlew test`다. 실제 AWS/Papago 및 운영 MySQL 검증은 포함하지 않는다.
+3
View File
@@ -23,8 +23,11 @@
./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.i18n.translation.TranslationJobRetryIntegrationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.ContentTagTranslationIntegrationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.CompletedContentTagRepairTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' ./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 --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.AudioContentDetailTranslationHttpIntegrationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.ContentSeriesDetailTranslationHttpIntegrationTest'
./gradlew bootJar ./gradlew bootJar
./gradlew ktlintCheck ./gradlew ktlintCheck
./gradlew ktlintFormat ./gradlew ktlintFormat
@@ -0,0 +1,144 @@
package kr.co.vividnext.sodalive.content
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.content.translation.TranslatedContent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryService
import kr.co.vividnext.sodalive.i18n.translation.TranslationReadModelMaterializer
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import javax.persistence.EntityManager
import javax.persistence.LockModeType
data class AudioContentDetailTranslationResult(
val languageCode: String?,
val translated: TranslatedContent? = null,
val detectionQuery: String? = null
)
@Service
class AudioContentDetailTranslationService(
private val repository: AudioContentRepository,
private val translations: ContentTranslationRepository,
private val detector: LanguageDetectionCacheService,
private val memories: TranslationMemoryService,
private val materializer: TranslationReadModelMaterializer,
private val scheduler: ResourceTranslationJobScheduler,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
private val log = LoggerFactory.getLogger(javaClass)
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun resolve(contentId: Long, targetLanguage: String): AudioContentDetailTranslationResult {
var source = transaction.execute { snapshot(contentId) } ?: return AudioContentDetailTranslationResult(null)
if (source.languageCode.isNullOrBlank()) {
val beforeDetection = source
try {
val detected = detector.detectWithCache(source.query)?.detectedLanguage
?: return AudioContentDetailTranslationResult(source.languageCode, detectionQuery = source.query)
source = transaction.execute {
val content = entityManager.find(AudioContent::class.java, contentId, LockModeType.PESSIMISTIC_WRITE)
?: return@execute null
val current = snapshot(contentId) ?: return@execute null
if (current == beforeDetection) content.languageCode = detected
snapshot(contentId)
} ?: return AudioContentDetailTranslationResult(null)
} catch (ex: Exception) {
log.warn("Content detail language detection failed. contentId={}, error={}", contentId, ex.message)
return AudioContentDetailTranslationResult(source.languageCode, detectionQuery = source.query)
}
}
val language = source.languageCode
if (language.isNullOrBlank()) return AudioContentDetailTranslationResult(language, detectionQuery = source.query)
val target = targetLanguage.lowercase()
if (
!TranslationLanguages.isSupported(language) || !TranslationLanguages.isSupported(target) ||
language.lowercase() == target
) {
return AudioContentDetailTranslationResult(language)
}
val existing = transaction.execute { translations.findByContentIdAndLocale(contentId, target)?.renderedPayload }
if (existing != null) {
maintainRetries(contentId, target, scheduleMissing = false)
return result(language, existing)
}
return try {
source.fields.forEach { field ->
memories.ensureMemory(LanguageTranslationTargetType.CONTENT, field.fieldKey, field.sourceText, language, target)
}
val payload = transaction.execute {
entityManager.find(AudioContent::class.java, contentId, LockModeType.PESSIMISTIC_WRITE)
check(snapshot(contentId) == source) { "content translation source changed" }
check(materializer.materialize(LanguageTranslationTargetType.CONTENT, contentId, target)) {
"content translation is incomplete"
}
requireNotNull(translations.findByContentIdAndLocale(contentId, target)).renderedPayload
}
maintainRetries(contentId, target, scheduleMissing = false)
result(language, requireNotNull(payload))
} catch (ex: Exception) {
log.warn("Content detail translation failed. contentId={}, locale={}, error={}", contentId, target, ex.message)
maintainRetries(contentId, target, scheduleMissing = true)
AudioContentDetailTranslationResult(language)
}
}
private fun maintainRetries(contentId: Long, target: String, scheduleMissing: Boolean) {
try {
transaction.executeWithoutResult {
scheduler.restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.CONTENT,
listOf(contentId),
target
)
if (scheduleMissing) {
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.CONTENT, contentId, target)
}
}
} catch (ex: Exception) {
log.warn(
"Content detail translation retry request failed. contentId={}, locale={}, error={}",
contentId,
target,
ex.message
)
}
}
private fun result(language: String, payload: ContentTranslationPayload) = AudioContentDetailTranslationResult(
language,
TranslatedContent(payload.title, payload.detail, payload.tags)
)
private fun snapshot(contentId: Long): DetailSource? {
val content = repository.findById(contentId).orElse(null) ?: return null
val tags = content.audioContentHashTags.filter { it.isActive }.mapNotNull { it.hashTag?.tag }
return DetailSource(
content.languageCode,
listOf(
TranslationSourceField("title", content.title),
TranslationSourceField("detail", content.detail),
TranslationSourceField("tags", tags.joinToString(","))
),
listOf(content.title.trim(), content.detail.trim(), tags.joinToString(" ").trim())
.filter { it.isNotBlank() }.joinToString(" ")
)
}
private data class DetailSource(val languageCode: String?, val fields: List<TranslationSourceField>, val query: String)
}
@@ -23,7 +23,6 @@ import kr.co.vividnext.sodalive.content.pin.PinContentRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.content.translation.TranslatedContent
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.extensions.convertLocalDateTime import kr.co.vividnext.sodalive.extensions.convertLocalDateTime
import kr.co.vividnext.sodalive.fcm.FcmDeepLinkValue import kr.co.vividnext.sodalive.fcm.FcmDeepLinkValue
@@ -34,7 +33,6 @@ import kr.co.vividnext.sodalive.i18n.LangContext
import kr.co.vividnext.sodalive.i18n.SodaMessageSource import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent 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.member.Member import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRepository import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
@@ -83,8 +81,8 @@ class AudioContentService(
private val pinContentRepository: PinContentRepository, private val pinContentRepository: PinContentRepository,
private val memberRepository: MemberRepository, private val memberRepository: MemberRepository,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler,
private val contentTranslationRepository: ContentTranslationRepository, private val contentTranslationRepository: ContentTranslationRepository,
private val detailTranslationService: AudioContentDetailTranslationService,
private val s3Uploader: S3Uploader, private val s3Uploader: S3Uploader,
private val objectMapper: ObjectMapper, private val objectMapper: ObjectMapper,
@@ -802,6 +800,24 @@ class AudioContentService(
isAdult = isAdult isAdult = isAdult
) )
val relatedContentIds = listOfNotNull(previousContent, nextContent)
.plus(creatorOtherContentList)
.plus(sameThemeOtherContentList)
.map { it.contentId }
.distinct()
val relatedTranslations = if (relatedContentIds.isNotEmpty()) {
contentTranslationRepository
.findByContentIdInAndLocale(contentIds = relatedContentIds, locale = langContext.lang.code)
.associateBy { it.contentId }
} else {
emptyMap()
}
fun translateRelatedContent(item: OtherContentResponse): OtherContentResponse {
val translatedTitle = relatedTranslations[item.contentId]?.renderedPayload?.title
return if (translatedTitle.isNullOrBlank()) item else item.copy(title = translatedTitle)
}
val likeCount = audioContentLikeRepository.totalCountAudioContentLike(contentId = id) val likeCount = audioContentLikeRepository.totalCountAudioContentLike(contentId = id)
val isLike = audioContentLikeRepository.findByMemberIdAndContentId( val isLike = audioContentLikeRepository.findByMemberIdAndContentId(
memberId = member.id!!, memberId = member.id!!,
@@ -875,49 +891,14 @@ class AudioContentService(
listOf() listOf()
} }
var translated: TranslatedContent? = null val translation = detailTranslationService.resolve(id, langContext.lang.code)
if (translation.detectionQuery != null) {
/** applicationEventPublisher.publishEvent(
* audioContent.languageCode != languageCode LanguageDetectEvent(
* id = id,
* 번역 콘텐츠를 조회한다. - contentId, locale query = translation.detectionQuery
* 번역 콘텐츠가 있으면
* TranslatedContent로 가공한다
*
* 번역 콘텐츠가 없으면
* 누락 번역 job을 예약하고 원문 응답을 유지한다.
*
* 번역 대상: title, detail, tags
*
* 파파고로 번역한 데이터를 TranslatedContent로 가공한다
*/
if (
audioContent.languageCode != null &&
audioContent.languageCode!!.isNotBlank() &&
audioContent.languageCode != langContext.lang.code
) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CONTENT,
listOf(id),
langContext.lang.code
) )
val existing = contentTranslationRepository
.findByContentIdAndLocale(audioContent.id!!, langContext.lang.code)
if (existing != null) {
val payload = existing.renderedPayload
translated = TranslatedContent(
title = payload.title,
detail = payload.detail,
tags = payload.tags
) )
} else {
resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = audioContent.id!!,
targetLanguage = langContext.lang.code
)
}
} }
/** /**
@@ -959,7 +940,7 @@ class AudioContentService(
contentId = audioContent.id!!, contentId = audioContent.id!!,
title = audioContent.title, title = audioContent.title,
detail = contentDetail, detail = contentDetail,
languageCode = audioContent.languageCode, languageCode = translation.languageCode,
coverImageUrl = "$coverImageHost/${audioContent.coverImage!!}", coverImageUrl = "$coverImageHost/${audioContent.coverImage!!}",
contentUrl = audioContentUrl, contentUrl = audioContentUrl,
themeStr = themeStrTranslated, themeStr = themeStrTranslated,
@@ -979,8 +960,8 @@ class AudioContentService(
purchaseOption = purchaseOption, purchaseOption = purchaseOption,
orderType = orderType, orderType = orderType,
remainingTime = remainingTime, remainingTime = remainingTime,
creatorOtherContentList = creatorOtherContentList, creatorOtherContentList = creatorOtherContentList.map(::translateRelatedContent),
sameThemeOtherContentList = sameThemeOtherContentList, sameThemeOtherContentList = sameThemeOtherContentList.map(::translateRelatedContent),
isCommentAvailable = audioContent.isCommentAvailable, isCommentAvailable = audioContent.isCommentAvailable,
isLike = isLike, isLike = isLike,
likeCount = likeCount, likeCount = likeCount,
@@ -1000,11 +981,11 @@ class AudioContentService(
isFollow = creatorFollowing?.isFollow ?: false, isFollow = creatorFollowing?.isFollow ?: false,
isNotify = creatorFollowing?.isNotify ?: false isNotify = creatorFollowing?.isNotify ?: false
), ),
previousContent = previousContent, previousContent = previousContent?.let(::translateRelatedContent),
nextContent = nextContent, nextContent = nextContent?.let(::translateRelatedContent),
buyerList = buyerList, buyerList = buyerList,
isAvailableUsePoint = audioContent.isPointAvailable && audioContent.price > 0, isAvailableUsePoint = audioContent.isPointAvailable && audioContent.price > 0,
translated = translated, translated = translation.translated,
subtitle = if ( subtitle = if (
(isExistsAudioContent || creatorId == member.id || audioContent.price <= 0) && (isExistsAudioContent || creatorId == member.id || audioContent.price <= 0) &&
(audioContent.releaseDate == null || audioContent.releaseDate!! <= LocalDateTime.now() || creatorId == member.id) (audioContent.releaseDate == null || audioContent.releaseDate!! <= LocalDateTime.now() || creatorId == member.id)
@@ -0,0 +1,146 @@
package kr.co.vividnext.sodalive.content.series
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationPayload
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.TranslatedSeries
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryService
import kr.co.vividnext.sodalive.i18n.translation.TranslationReadModelMaterializer
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import org.slf4j.LoggerFactory
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import javax.persistence.EntityManager
import javax.persistence.LockModeType
data class ContentSeriesDetailTranslationResult(
val languageCode: String?,
val translated: TranslatedSeries? = null,
val detectionQuery: String? = null
)
@Service
class ContentSeriesDetailTranslationService(
private val repository: ContentSeriesRepository,
private val translations: SeriesTranslationRepository,
private val detector: LanguageDetectionCacheService,
private val memories: TranslationMemoryService,
private val materializer: TranslationReadModelMaterializer,
private val scheduler: ResourceTranslationJobScheduler,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
private val log = LoggerFactory.getLogger(javaClass)
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun resolve(seriesId: Long, targetLanguage: String): ContentSeriesDetailTranslationResult {
var source = transaction.execute { snapshot(seriesId) } ?: return ContentSeriesDetailTranslationResult(null)
if (source.languageCode.isNullOrBlank()) {
val beforeDetection = source
try {
val detected = detector.detectWithCache(source.query)?.detectedLanguage
?: return ContentSeriesDetailTranslationResult(source.languageCode, detectionQuery = source.query)
source = transaction.execute {
val series = entityManager.find(Series::class.java, seriesId, LockModeType.PESSIMISTIC_WRITE)
?: return@execute null
val current = snapshot(seriesId) ?: return@execute null
if (current == beforeDetection) series.languageCode = detected
snapshot(seriesId)
} ?: return ContentSeriesDetailTranslationResult(null)
} catch (ex: Exception) {
log.warn("Series detail language detection failed. seriesId={}, error={}", seriesId, ex.message)
return ContentSeriesDetailTranslationResult(source.languageCode, detectionQuery = source.query)
}
}
val language = source.languageCode
if (language.isNullOrBlank()) return ContentSeriesDetailTranslationResult(language, detectionQuery = source.query)
val target = targetLanguage.lowercase()
if (
!TranslationLanguages.isSupported(language) || !TranslationLanguages.isSupported(target) ||
language.lowercase() == target
) {
return ContentSeriesDetailTranslationResult(language)
}
val existing = transaction.execute { translations.findBySeriesIdAndLocale(seriesId, target)?.renderedPayload }
if (existing != null) {
maintainRetries(seriesId, target, scheduleMissing = false)
return result(language, existing)
}
return try {
source.fields.forEach { field ->
memories.ensureMemory(LanguageTranslationTargetType.SERIES, field.fieldKey, field.sourceText, language, target)
}
val payload = transaction.execute {
entityManager.find(Series::class.java, seriesId, LockModeType.PESSIMISTIC_WRITE)
check(snapshot(seriesId) == source) { "series translation source changed" }
check(materializer.materialize(LanguageTranslationTargetType.SERIES, seriesId, target)) {
"series translation is incomplete"
}
requireNotNull(translations.findBySeriesIdAndLocale(seriesId, target)).renderedPayload
}
maintainRetries(seriesId, target, scheduleMissing = false)
result(language, requireNotNull(payload))
} catch (ex: Exception) {
log.warn("Series detail translation failed. seriesId={}, locale={}, error={}", seriesId, target, ex.message)
maintainRetries(seriesId, target, scheduleMissing = true)
ContentSeriesDetailTranslationResult(language)
}
}
private fun maintainRetries(seriesId: Long, target: String, scheduleMissing: Boolean) {
try {
transaction.executeWithoutResult {
scheduler.restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.SERIES,
listOf(seriesId),
target
)
if (scheduleMissing) {
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.SERIES, seriesId, target)
}
}
} catch (ex: Exception) {
log.warn(
"Series detail translation retry request failed. seriesId={}, locale={}, error={}",
seriesId,
target,
ex.message
)
}
}
private fun result(language: String, payload: SeriesTranslationPayload) = ContentSeriesDetailTranslationResult(
language,
TranslatedSeries(payload.title, payload.introduction, payload.keywords)
)
private fun snapshot(seriesId: Long): DetailSource? {
val series = repository.findById(seriesId).orElse(null) ?: return null
val keywords = series.keywordList.mapNotNull { it.keyword?.tag }
return DetailSource(
series.languageCode,
listOf(
TranslationSourceField("title", series.title),
TranslationSourceField("introduction", series.introduction),
TranslationSourceField("keywords", keywords.joinToString(", "))
),
listOf(series.title.trim(), series.introduction.trim(), keywords.joinToString(" ").trim())
.filter { it.isNotBlank() }.joinToString(" ")
)
}
private data class DetailSource(val languageCode: String?, val fields: List<TranslationSourceField>, val query: String)
}
@@ -2,13 +2,13 @@ package kr.co.vividnext.sodalive.content.series
import kr.co.vividnext.sodalive.common.SodaException import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.ContentType import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.LanguageDetectEvent
import kr.co.vividnext.sodalive.content.LanguageDetectTargetType
import kr.co.vividnext.sodalive.content.order.OrderRepository import kr.co.vividnext.sodalive.content.order.OrderRepository
import kr.co.vividnext.sodalive.content.order.OrderType import kr.co.vividnext.sodalive.content.order.OrderType
import kr.co.vividnext.sodalive.content.series.content.ContentSeriesContentRepository import kr.co.vividnext.sodalive.content.series.content.ContentSeriesContentRepository
import kr.co.vividnext.sodalive.content.series.content.GetSeriesContentListResponse import kr.co.vividnext.sodalive.content.series.content.GetSeriesContentListResponse
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslationRepository import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.TranslatedSeries
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesPublishedDaysOfWeek import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesPublishedDaysOfWeek
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesSortType import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesSortType
@@ -21,6 +21,7 @@ import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import org.springframework.beans.factory.annotation.Value import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.annotation.Transactional
import java.time.ZoneId import java.time.ZoneId
@@ -36,7 +37,8 @@ class ContentSeriesService(
private val langContext: LangContext, private val langContext: LangContext,
private val seriesTranslationRepository: SeriesTranslationRepository, private val detailTranslationService: ContentSeriesDetailTranslationService,
private val applicationEventPublisher: ApplicationEventPublisher,
private val seriesGenreTranslationRepository: SeriesGenreTranslationRepository, private val seriesGenreTranslationRepository: SeriesGenreTranslationRepository,
private val contentTranslationRepository: ContentTranslationRepository, private val contentTranslationRepository: ContentTranslationRepository,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler, private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler,
@@ -259,52 +261,16 @@ class ContentSeriesService(
limit = 5 limit = 5
) )
/**
* series.languageCode != null && series.languageCode != languageCode
*
* 번역 시리즈를 조회한다. - series, locale
* 번역 콘텐츠가 있으면
* TranslatedSeries로 가공한다
*
* 번역 콘텐츠가 없으면
* 누락 번역 job을 예약하고 원문 응답을 유지한다.
*
* 번역 대상: title, introduction, keywordList
*
* 파파고로 번역한 데이터를 TranslatedSeries 가공한다
*/
val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy.MM.dd") val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy.MM.dd")
// 요청된 언어(locale)에 대한 시리즈 번역을 조회하거나, 없으면 동기 번역 후 저장한다. val translation = detailTranslationService.resolve(seriesId, langContext.lang.code)
var translated: TranslatedSeries? = null if (translation.detectionQuery != null) {
run { applicationEventPublisher.publishEvent(
val locale = langContext.lang.code LanguageDetectEvent(seriesId, translation.detectionQuery, LanguageDetectTargetType.SERIES)
val languageCode = series.languageCode
// 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리
if (!languageCode.isNullOrBlank() && languageCode != locale) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.SERIES,
listOf(seriesId),
locale
)
val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale)
if (existing != null) {
val payload = existing.renderedPayload
val kws = payload.keywords.ifEmpty { keywordList }
translated = TranslatedSeries(
title = payload.title,
introduction = payload.introduction,
keywords = kws
)
} else {
resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.SERIES,
resourceId = seriesId,
targetLanguage = locale
) )
} }
} val translated = translation.translated?.let {
it.copy(keywords = it.keywords.ifEmpty { keywordList })
} }
// 장르 번역 조회 (있으면 반환) // 장르 번역 조회 (있으면 반환)
@@ -1,9 +1,20 @@
package kr.co.vividnext.sodalive.content.translation package kr.co.vividnext.sodalive.content.translation
import org.springframework.data.jpa.repository.JpaRepository import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Lock
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import javax.persistence.LockModeType
interface ContentTranslationRepository : JpaRepository<ContentTranslation, Long> { interface ContentTranslationRepository : JpaRepository<ContentTranslation, Long> {
fun findByContentIdAndLocale(contentId: Long, locale: String): ContentTranslation? fun findByContentIdAndLocale(contentId: Long, locale: String): ContentTranslation?
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("select t from ContentTranslation t where t.contentId = :contentId and t.locale = :locale")
fun findByContentIdAndLocaleForUpdate(
@Param("contentId") contentId: Long,
@Param("locale") locale: String
): ContentTranslation?
fun findByContentIdInAndLocale(contentIds: List<Long>, locale: String): List<ContentTranslation> fun findByContentIdInAndLocale(contentIds: List<Long>, locale: String): List<ContentTranslation>
} }
@@ -53,18 +53,34 @@ class ResourceTranslationJobScheduler(
resourceIds, resourceIds,
target, target,
TranslationJobStatus.FAILED TranslationJobStatus.FAILED
) ) + if (resourceType == LanguageTranslationTargetType.CONTENT) {
translationJobRepository.findCompletedContentTagJobs(resourceIds, target)
} else {
emptyList()
}
val now = LocalDateTime.now() val now = LocalDateTime.now()
candidates.groupBy { it.resourceId }.forEach { (resourceId, failedJobs) -> candidates.groupBy { it.resourceId }.forEach { (resourceId, resourceJobs) ->
val source = sourceExtractor.extract(resourceType, resourceId) ?: return@forEach val source = sourceExtractor.extract(resourceType, resourceId) ?: return@forEach
val sourceLanguage = source.sourceLanguage.lowercase() val sourceLanguage = source.sourceLanguage.lowercase()
if (!TranslationLanguages.isSupported(sourceLanguage) || sourceLanguage == target) return@forEach if (!TranslationLanguages.isSupported(sourceLanguage) || sourceLanguage == target) return@forEach
val sourceHashes = source.fields.associate { it.fieldKey to SourceTextNormalizer.hash(it.sourceText) } val sourceFields = source.fields.associateBy { it.fieldKey }
failedJobs.filter { job -> resourceJobs.filter { job ->
job.sourceLanguage == sourceLanguage && job.sourceHash == sourceHashes[job.fieldKey] job.sourceLanguage == sourceLanguage &&
job.sourceHash == sourceFields[job.fieldKey]?.let { SourceTextNormalizer.hash(it.sourceText) }
}.forEach { job -> }.forEach { job ->
translationJobRepository.restartFailedJob(requireNotNull(job.id), now) when (job.status) {
TranslationJobStatus.FAILED -> translationJobRepository.restartFailedJob(requireNotNull(job.id), now)
TranslationJobStatus.COMPLETED -> translationJobScheduler.scheduleMissingTranslation(
resourceType = resourceType,
resourceId = resourceId,
fieldKey = job.fieldKey,
sourceText = sourceFields.getValue(job.fieldKey).sourceText,
sourceLanguage = sourceLanguage,
targetLanguage = target
)
TranslationJobStatus.PENDING, TranslationJobStatus.RUNNING -> Unit
}
} }
} }
} }
@@ -20,4 +20,8 @@ object SourceTextNormalizer {
.digest(normalized.toByteArray(Charsets.UTF_8)) .digest(normalized.toByteArray(Charsets.UTF_8))
return digest.joinToString("") { "%02x".format(it) } return digest.joinToString("") { "%02x".format(it) }
} }
fun hasSameCommaSeparatedText(first: String, second: String): Boolean {
return first.split(',').map(::normalize) == second.split(',').map(::normalize)
}
} }
@@ -3,7 +3,8 @@ package kr.co.vividnext.sodalive.i18n.translation
data class TranslateRequest( data class TranslateRequest(
val texts: List<String>, val texts: List<String>,
val sourceLanguage: String, val sourceLanguage: String,
val targetLanguage: String val targetLanguage: String,
val rejectUnchangedAwsResult: Boolean = false
) )
data class TranslateResult( data class TranslateResult(
@@ -10,7 +10,12 @@ class TranslationCoordinator(
) { ) {
private val providers = properties.orderedProviders(properties.translationOrder, providers) { it.providerId } private val providers = properties.orderedProviders(properties.translationOrder, providers) { it.providerId }
fun findCached(sourceHash: String, sourceLanguage: String, targetLanguage: String): TranslationMemory? { fun findCached(
sourceHash: String,
sourceLanguage: String,
targetLanguage: String,
rejectUnchangedAwsResult: Boolean = false
): TranslationMemory? {
providers.forEach { provider -> providers.forEach { provider ->
val memory = translationMemoryRepository val memory = translationMemoryRepository
.findBySourceHashAndSourceLanguageAndTargetLanguageAndProviderAndNormalizationVersion( .findBySourceHashAndSourceLanguageAndTargetLanguageAndProviderAndNormalizationVersion(
@@ -20,7 +25,14 @@ class TranslationCoordinator(
provider.providerId.code, provider.providerId.code,
SourceTextNormalizer.NORMALIZATION_VERSION SourceTextNormalizer.NORMALIZATION_VERSION
) )
if (memory != null && memory.translatedText.isNotBlank()) return memory if (memory == null || memory.translatedText.isBlank()) return@forEach
if (
rejectUnchangedAwsResult && provider.providerId == LanguageProviderId.AWS &&
SourceTextNormalizer.hasSameCommaSeparatedText(memory.sourceText, memory.translatedText)
) {
return@forEach
}
return memory
} }
return null return null
} }
@@ -42,6 +54,14 @@ class TranslationCoordinator(
result != null && result.translatedText.size == request.texts.size && result != null && result.translatedText.size == request.texts.size &&
result.translatedText.none { it.isBlank() } result.translatedText.none { it.isBlank() }
) { ) {
if (
request.rejectUnchangedAwsResult && provider.providerId == LanguageProviderId.AWS &&
request.texts.zip(result.translatedText).any { (source, translated) ->
SourceTextNormalizer.hasSameCommaSeparatedText(source, translated)
}
) {
return@forEach
}
return ProviderTranslationResult(result, provider.providerId, provider.providerVersion) return ProviderTranslationResult(result, provider.providerId, provider.providerVersion)
} }
} }
@@ -22,6 +22,21 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
status: TranslationJobStatus status: TranslationJobStatus
): List<TranslationJob> ): List<TranslationJob>
@Query(
"""
select j from TranslationJob j
where j.resourceType = kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType.CONTENT
and j.resourceId in :resourceIds
and j.targetLanguage = :targetLanguage
and j.fieldKey = 'tags'
and j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.COMPLETED
"""
)
fun findCompletedContentTagJobs(
@Param("resourceIds") resourceIds: Collection<Long>,
@Param("targetLanguage") targetLanguage: String
): List<TranslationJob>
@Modifying @Modifying
@Query( @Query(
""" """
@@ -36,6 +51,22 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
) )
fun restartFailedJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int fun restartFailedJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int
@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.resourceType = kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType.CONTENT
and j.fieldKey = 'tags'
and j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.COMPLETED
"""
)
fun restartCompletedContentTagsJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int
@Query( @Query(
""" """
select j from TranslationJob j select j from TranslationJob j
@@ -1,12 +1,15 @@
package kr.co.vividnext.sodalive.i18n.translation package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime import java.time.LocalDateTime
@Service @Service
class TranslationJobScheduler( class TranslationJobScheduler(
private val translationJobRepository: TranslationJobRepository private val translationJobRepository: TranslationJobRepository,
private val translationCoordinator: TranslationCoordinator,
private val contentTranslationRepository: ContentTranslationRepository
) { ) {
@Transactional @Transactional
fun scheduleMissingTranslation( fun scheduleMissingTranslation(
@@ -35,8 +38,34 @@ class TranslationJobScheduler(
sourceHash = sourceHash sourceHash = sourceHash
) )
if (existingJob != null) { if (existingJob != null) {
if (existingJob.status == TranslationJobStatus.FAILED && existingJob.sourceLanguage == normalizedSourceLanguage) { if (existingJob.sourceLanguage != normalizedSourceLanguage) return
translationJobRepository.restartFailedJob(existingJob.id!!, LocalDateTime.now())
when (existingJob.status) {
TranslationJobStatus.FAILED ->
translationJobRepository.restartFailedJob(requireNotNull(existingJob.id), LocalDateTime.now())
TranslationJobStatus.COMPLETED -> {
if (resourceType != LanguageTranslationTargetType.CONTENT || fieldKey != "tags") return
val renderedTags = contentTranslationRepository.findByContentIdAndLocale(resourceId, normalizedTargetLanguage)
?.renderedPayload?.tags
if (
!renderedTags.isNullOrBlank() &&
!SourceTextNormalizer.hasSameCommaSeparatedText(normalizedText, renderedTags)
) {
return
}
val cached = translationCoordinator.findCached(
sourceHash,
normalizedSourceLanguage,
normalizedTargetLanguage,
rejectUnchangedAwsResult = true
)
if (cached != null && cached.translatedText == renderedTags) return
translationJobRepository.restartCompletedContentTagsJob(requireNotNull(existingJob.id), LocalDateTime.now())
}
TranslationJobStatus.PENDING, TranslationJobStatus.RUNNING -> Unit
} }
return return
} }
@@ -10,8 +10,7 @@ import java.time.LocalDateTime
@Component @Component
class TranslationJobWorker( class TranslationJobWorker(
private val translationJobRepository: TranslationJobRepository, private val translationJobRepository: TranslationJobRepository,
private val translationMemoryRepository: TranslationMemoryRepository, private val translationMemoryService: TranslationMemoryService,
private val translationCoordinator: TranslationCoordinator,
private val materializer: TranslationReadModelMaterializer, private val materializer: TranslationReadModelMaterializer,
transactionManager: PlatformTransactionManager transactionManager: PlatformTransactionManager
) { ) {
@@ -34,7 +33,13 @@ class TranslationJobWorker(
val failedJobs = mutableListOf<Pair<TranslationJob, Exception>>() val failedJobs = mutableListOf<Pair<TranslationJob, Exception>>()
jobs.forEach { job -> jobs.forEach { job ->
try { try {
ensureMemory(job) translationMemoryService.ensureMemory(
job.resourceType,
job.fieldKey,
job.sourceText,
job.sourceLanguage,
job.targetLanguage
)
succeededJobs.add(job) succeededJobs.add(job)
} catch (ex: Exception) { } catch (ex: Exception) {
failedJobs.add(job to ex) failedJobs.add(job to ex)
@@ -68,44 +73,6 @@ class TranslationJobWorker(
}.orEmpty() }.orEmpty()
} }
private fun ensureMemory(job: TranslationJob) {
val existing = translationCoordinator.findCached(job.sourceHash, job.sourceLanguage, job.targetLanguage)
if (existing != null) return
val response = translationCoordinator.translate(
TranslateRequest(
texts = listOf(job.sourceText),
sourceLanguage = job.sourceLanguage,
targetLanguage = job.targetLanguage
)
)
val translated = response.result.translatedText.single()
transactionTemplate.executeWithoutResult {
val memory = translationMemoryRepository
.findBySourceHashAndSourceLanguageAndTargetLanguageAndProviderAndNormalizationVersion(
sourceHash = job.sourceHash,
sourceLanguage = job.sourceLanguage,
targetLanguage = job.targetLanguage,
provider = response.providerId.code,
normalizationVersion = SourceTextNormalizer.NORMALIZATION_VERSION
)
if (memory == null) {
translationMemoryRepository.save(
TranslationMemory(
sourceHash = job.sourceHash,
sourceText = job.sourceText,
sourceLanguage = job.sourceLanguage,
targetLanguage = job.targetLanguage,
translatedText = translated,
provider = response.providerId.code,
providerVersion = response.providerVersion
)
)
}
}
}
private fun completeJob(jobId: Long) { private fun completeJob(jobId: Long) {
transactionTemplate.executeWithoutResult { transactionTemplate.executeWithoutResult {
val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult
@@ -30,7 +30,7 @@ class TranslationMemory(
val targetLanguage: String, val targetLanguage: String,
@Column(name = "translated_text", nullable = false, columnDefinition = "text") @Column(name = "translated_text", nullable = false, columnDefinition = "text")
val translatedText: String, var translatedText: String,
@Column(name = "provider", nullable = false, length = 50) @Column(name = "provider", nullable = false, length = 50)
val provider: String, val provider: String,
@@ -0,0 +1,88 @@
package kr.co.vividnext.sodalive.i18n.translation
import org.hibernate.exception.ConstraintViolationException
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.stereotype.Service
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.sql.SQLException
@Service
class TranslationMemoryService(
private val translationMemoryRepository: TranslationMemoryRepository,
private val translationCoordinator: TranslationCoordinator,
transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun ensureMemory(
resourceType: LanguageTranslationTargetType,
fieldKey: String,
sourceText: String,
sourceLanguage: String,
targetLanguage: String
) {
val text = SourceTextNormalizer.normalize(sourceText)
if (text.isBlank()) return
val sourceHash = SourceTextNormalizer.hash(text)
val source = sourceLanguage.lowercase()
val target = targetLanguage.lowercase()
val rejectUnchangedAwsResult = resourceType == LanguageTranslationTargetType.CONTENT && fieldKey == "tags"
val existing = transaction.execute {
translationCoordinator.findCached(sourceHash, source, target, rejectUnchangedAwsResult)
}
if (existing != null) return
val response = translationCoordinator.translate(
TranslateRequest(listOf(text), source, target, rejectUnchangedAwsResult)
)
val translated = response.result.translatedText.single()
try {
transaction.executeWithoutResult {
val memory = translationMemoryRepository
.findBySourceHashAndSourceLanguageAndTargetLanguageAndProviderAndNormalizationVersion(
sourceHash,
source,
target,
response.providerId.code,
SourceTextNormalizer.NORMALIZATION_VERSION
)
if (memory == null) {
translationMemoryRepository.save(
TranslationMemory(
sourceHash,
text,
source,
target,
translated,
response.providerId.code,
response.providerVersion
)
)
} else if (
rejectUnchangedAwsResult && response.providerId == LanguageProviderId.AWS &&
SourceTextNormalizer.hasSameCommaSeparatedText(memory.sourceText, memory.translatedText)
) {
memory.translatedText = translated
translationMemoryRepository.save(memory)
}
}
} catch (ex: DataIntegrityViolationException) {
val constraint = generateSequence<Throwable>(ex) { it.cause }
.filterIsInstance<ConstraintViolationException>().firstOrNull()?.constraintName
if (constraint?.contains("uk_translation_memory_source_target_provider", ignoreCase = true) != true) throw ex
val sql = generateSequence<Throwable>(ex) { it.cause }.filterIsInstance<SQLException>().firstOrNull()
if (sql?.sqlState != "23505" && sql?.errorCode != 1062) throw ex
val winner = transaction.execute {
translationCoordinator.findCached(sourceHash, source, target, rejectUnchangedAwsResult)
}
if (winner == null) throw ex
}
}
}
@@ -6,6 +6,7 @@ import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationR
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslation 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.OriginalWorkTranslationPayload
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationRepository import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationRepository
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.category.CategoryTranslation import kr.co.vividnext.sodalive.content.category.CategoryTranslation
import kr.co.vividnext.sodalive.content.category.CategoryTranslationRepository import kr.co.vividnext.sodalive.content.category.CategoryTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslation import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslation
@@ -18,6 +19,7 @@ import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslatio
import kr.co.vividnext.sodalive.content.translation.ContentTranslation import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository
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.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.adapter.out.persistence.CreatorCommunityTranslationRepository
@@ -74,7 +76,9 @@ class TranslationReadModelMaterializer(
val memory = translationCoordinator.findCached( val memory = translationCoordinator.findCached(
sourceHash = SourceTextNormalizer.hash(normalizedText), sourceHash = SourceTextNormalizer.hash(normalizedText),
sourceLanguage = source.sourceLanguage.lowercase(), sourceLanguage = source.sourceLanguage.lowercase(),
targetLanguage = targetLanguage targetLanguage = targetLanguage,
rejectUnchangedAwsResult = source.resourceType == LanguageTranslationTargetType.CONTENT &&
field.fieldKey == "tags"
) ?: return null ) ?: return null
result[field.fieldKey] = memory.translatedText result[field.fieldKey] = memory.translatedText
@@ -88,7 +92,8 @@ class TranslationReadModelMaterializer(
detail = translations["detail"].orEmpty(), detail = translations["detail"].orEmpty(),
tags = translations["tags"].orEmpty() tags = translations["tags"].orEmpty()
) )
val existing = contentTranslationRepository.findByContentIdAndLocale(resourceId, targetLanguage) entityManager.find(AudioContent::class.java, resourceId, LockModeType.PESSIMISTIC_WRITE)
val existing = contentTranslationRepository.findByContentIdAndLocaleForUpdate(resourceId, targetLanguage)
if (existing == null) { if (existing == null) {
contentTranslationRepository.save(ContentTranslation(resourceId, targetLanguage, payload)) contentTranslationRepository.save(ContentTranslation(resourceId, targetLanguage, payload))
} else { } else {
@@ -137,6 +142,7 @@ class TranslationReadModelMaterializer(
.map { it.trim() } .map { it.trim() }
.filter { it.isNotBlank() } .filter { it.isNotBlank() }
) )
entityManager.find(Series::class.java, resourceId, LockModeType.PESSIMISTIC_WRITE)
val existing = seriesTranslationRepository.findBySeriesIdAndLocale(resourceId, targetLanguage) val existing = seriesTranslationRepository.findBySeriesIdAndLocale(resourceId, targetLanguage)
if (existing == null) { if (existing == null) {
seriesTranslationRepository.save(SeriesTranslation(resourceId, targetLanguage, payload)) seriesTranslationRepository.save(SeriesTranslation(resourceId, targetLanguage, payload))
@@ -52,6 +52,7 @@ class TranslationSourceExtractor(
val content = audioContentRepository.findByIdOrNull(resourceId) ?: return null val content = audioContentRepository.findByIdOrNull(resourceId) ?: return null
val sourceLanguage = content.languageCode?.takeIf { it.isNotBlank() } ?: return null val sourceLanguage = content.languageCode?.takeIf { it.isNotBlank() } ?: return null
val tags = content.audioContentHashTags val tags = content.audioContentHashTags
.filter { it.isActive }
.mapNotNull { it.hashTag?.tag } .mapNotNull { it.hashTag?.tag }
.joinToString(",") .joinToString(",")
return TranslationSource( return TranslationSource(
@@ -0,0 +1,543 @@
package kr.co.vividnext.sodalive.content
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.hashtag.AudioContentHashTag
import kr.co.vividnext.sodalive.content.hashtag.HashTag
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
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.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesContent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationJob
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorker
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemory
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryRepository
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.assertTrue
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.NullAndEmptySource
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.SpyBean
import org.springframework.boot.test.web.client.TestRestTemplate
import org.springframework.http.HttpEntity
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.test.context.ActiveProfiles
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import java.util.concurrent.Callable
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.persistence.EntityManager
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
classes = [ContentDetailTranslationTestConfiguration::class],
properties = [
"spring.cache.type=none", "spring.jpa.properties.hibernate.show_sql=false",
"cloud.aws.cloud-front.host=https://cdn.test"
]
)
@ActiveProfiles("content-detail-translation-test")
class AudioContentDetailTranslationHttpIntegrationTest @Autowired constructor(
private val http: TestRestTemplate,
private val mapper: ObjectMapper,
private val provider: DetailTranslationProvider,
private val translations: ContentTranslationRepository,
private val memories: TranslationMemoryRepository,
private val jobs: TranslationJobRepository,
private val jdbc: JdbcTemplate,
private val worker: TranslationJobWorker,
private val scheduler: ResourceTranslationJobScheduler,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@SpyBean
private lateinit var memoryWriter: TranslationMemoryRepository
@SpyBean
private lateinit var jobClaims: TranslationJobRepository
@SpyBean
private lateinit var translationReads: ContentTranslationRepository
@BeforeEach
fun prepare() {
provider.reset()
jobs.deleteAllInBatch()
translations.deleteAllInBatch()
memories.deleteAllInBatch()
jdbc.update("delete from language_detection_result")
Mockito.doAnswer {
jobs.findAll().filter { it.status == TranslationJobStatus.PENDING }.mapNotNull { it.id }
}.`when`(jobClaims).findNextPendingGroupJobIdsForUpdate(Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now())
// H2 JSON wraps converter output in a JSON string; keep the real converter's MySQL text contract.
jdbc.execute("alter table content_translation alter column rendered_payload varchar(1000000)")
}
@Test
@DisplayName("첫 상세 HTTP 응답은 번역을 커밋하고 재조회는 저장 결과를 재사용한다")
fun shouldReturnCommittedTranslationOnFirstRequestAndReuseIt() {
val fixture = fixture()
val response = detail(fixture)
assertTranslation(response, "English title", "English detail", "#Healing")
transaction.executeWithoutResult {
val payload = translations.findByContentIdAndLocale(fixture.first, "en")!!.renderedPayload
assertEquals("English title", payload.title)
assertEquals("English detail", payload.detail)
assertEquals("#Healing", payload.tags)
}
assertEquals(3, provider.calls.get())
assertEquals(setOf("en"), memories.findAll().map { it.targetLanguage }.toSet())
assertEquals(0L, jobs.count())
assertEquals(response.path("translated"), detail(fixture).path("translated"))
assertEquals(3, provider.calls.get())
}
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = [" \t "])
@DisplayName("미감지 언어는 같은 상세 응답 전에 감지하고 언어와 번역을 커밋한다")
fun shouldDetectMissingLanguageBeforeReturningTranslation(language: String?) {
val fixture = fixture(language)
val response = detail(fixture)
assertTranslation(response, "English title", "English detail", "#Healing")
assertEquals("ko", response.path("languageCode").textValue())
assertEquals("ko", transaction.execute { entityManager.find(AudioContent::class.java, fixture.first).languageCode })
assertEquals(listOf("원문 제목 원문 설명 #힐링"), provider.detectionQueries)
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("기존 메모리만으로 빈 필드를 포함한 상세 번역을 저장하고 공급자를 호출하지 않는다")
fun shouldMaterializeCachedFieldsAndKeepBlankFieldsEmpty() {
val fixture = fixture(detail = " ", tags = false)
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash("원문 제목"), "원문 제목", "ko", "en", "Cached title", "aws", "test")
)
val response = detail(fixture)
assertTranslation(response, "Cached title", "", "")
assertEquals(0, provider.calls.get())
assertEquals(0L, jobs.count())
}
@ParameterizedTest
@ValueSource(strings = ["en", "fr"])
@DisplayName("동일 언어와 미지원 원문 언어에는 동기 번역이나 작업을 만들지 않는다")
fun shouldKeepOriginalForSameOrUnsupportedLanguage(language: String) {
val fixture = fixture(language)
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals(0, provider.calls.get())
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("공급자 실패는 원문과 작업을 반환하고 worker가 누락 필드만 복구한다")
fun shouldReturnOriginalAndRecoverPartialTranslationThroughWorker() {
val fixture = fixture()
provider.beforeTranslate = { if (provider.calls.get() == 2) provider.fail = true }
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals(1L, memories.count())
assertEquals(3L, jobs.count())
provider.fail = false
provider.beforeTranslate = {}
assertTrue(worker.processNextGroup())
assertEquals(4, provider.calls.get())
assertEquals(setOf(TranslationJobStatus.COMPLETED), jobs.findAll().map { it.status }.toSet())
assertTranslation(detail(fixture), "English title", "English detail", "#Healing")
assertEquals(4, provider.calls.get())
}
@Test
@DisplayName("실제 payload 제약 위반은 상세 트랜잭션을 오염시키지 않고 작업으로 복구된다")
fun shouldIsolateRealPersistenceFailureAndRecoverFromCommittedMemories() {
val fixture = fixture()
jdbc.execute(
"alter table content_translation add constraint reject_detail_payload check (content_id <> ${fixture.first})"
)
try {
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals(0L, translations.count())
assertEquals(3L, memories.count())
assertEquals(3L, jobs.count())
} finally {
jdbc.execute("alter table content_translation drop constraint reject_detail_payload")
}
assertTrue(worker.processNextGroup())
assertTranslation(detail(fixture), "English title", "English detail", "#Healing")
assertEquals(3, provider.calls.get())
}
@Test
@DisplayName("메모리 update의 commit 시점 제약 위반도 원문을 반환하고 기존 재시도로 복구한다")
fun shouldIsolateMemoryCommitFailure() {
val fixture = fixture()
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash("#힐링"), "#힐링", "ko", "en", "#힐링", "aws", "test")
)
jdbc.execute("alter table translation_memory add constraint reject_tag_update check (translated_text <> '#Healing')")
try {
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals("#힐링", memories.findAll().single { it.sourceText == "#힐링" }.translatedText)
assertEquals(3L, jobs.count())
} finally {
jdbc.execute("alter table translation_memory drop constraint reject_tag_update")
}
assertTrue(worker.processNextGroup())
assertTranslation(detail(fixture), "English title", "English detail", "#Healing")
assertEquals(4, provider.calls.get())
}
@Test
@DisplayName("감지 실패 응답 뒤 기존 after-commit 이벤트가 언어와 비동기 작업을 복구한다")
fun shouldRetainAfterCommitDetectionRecovery() {
val fixture = fixture(null)
provider.detection = null
provider.beforeDetect = { if (provider.detectionQueries.size == 2) provider.detection = "ko" }
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertTrue(response.path("languageCode").isNull)
assertEquals("ko", transaction.execute { entityManager.find(AudioContent::class.java, fixture.first).languageCode })
assertEquals(6L, jobs.count())
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("감지 중 커밋된 원문과 언어 수정은 동기 감지나 외부 managed entity가 덮어쓰지 않는다")
fun shouldPreserveConcurrentLanguageAndSourceEdit() {
val fixture = fixture(null)
provider.beforeDetect = {
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, fixture.first).apply {
title = "Edited title"
languageCode = "en"
}
}
}
val response = detail(fixture)
assertEquals("en", response.path("languageCode").textValue())
assertTrue(response.path("translated").isNull)
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, fixture.first)
assertEquals("en", content.languageCode)
assertEquals("Edited title", content.title)
}
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("기존 번역은 FAILED 재개 유지보수의 실제 DB 실패에도 반환된다")
fun shouldReturnExistingTranslationWhenRetryMaintenanceFails() {
val fixture = fixture()
val first = detail(fixture)
jobs.saveAndFlush(
TranslationJob(
LanguageTranslationTargetType.CONTENT, fixture.first, "title", SourceTextNormalizer.hash("원문 제목"),
"원문 제목", "ko", "en", TranslationJobStatus.FAILED, 6
)
)
jdbc.execute("alter table translation_job add constraint reject_restart check (status <> 'PENDING')")
try {
assertEquals(first.path("translated"), detail(fixture).path("translated"))
assertEquals(TranslationJobStatus.FAILED, jobs.findAll().single().status)
assertEquals(3, provider.calls.get())
} finally {
jdbc.execute("alter table translation_job drop constraint reject_restart")
}
}
@Test
@DisplayName("누락 번역의 동기 성공도 기존 FAILED 행만 재개하고 새 작업은 만들지 않는다")
fun shouldRestartOnlyExistingFailedJobAfterSynchronousSuccess() {
val fixture = fixture()
val failed = jobs.saveAndFlush(
TranslationJob(
LanguageTranslationTargetType.CONTENT, fixture.first, "title", SourceTextNormalizer.hash("원문 제목"),
"원문 제목", "ko", "en", TranslationJobStatus.FAILED, 6
)
)
assertTranslation(detail(fixture), "English title", "English detail", "#Healing")
val restarted = jobs.findAll().single()
assertEquals(failed.id, restarted.id)
assertEquals(TranslationJobStatus.PENDING, restarted.status)
assertEquals(0, restarted.retryCount)
}
@Test
@DisplayName("동시 상세와 worker의 메모리 유일키 경합은 커밋된 한 결과로 수렴한다")
fun shouldConvergeConcurrentDetailAndWorkerStorage() {
val fixture = fixture()
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.CONTENT, fixture.first, "en")
val inserts = CountDownLatch(3)
val originalSave = Mockito.mockingDetails(memoryWriter).mockCreationSettings.defaultAnswer
Mockito.doAnswer { invocation ->
val memory = invocation.getArgument<TranslationMemory>(0)
if (memory.sourceText == "원문 제목") {
inserts.countDown()
check(inserts.await(10, TimeUnit.SECONDS)) { "competing memory inserts did not arrive" }
}
originalSave.answer(invocation)
}.`when`(memoryWriter).save(Mockito.any(TranslationMemory::class.java) ?: TranslationMemory("", "", "", "", "", "", ""))
val pool = Executors.newFixedThreadPool(3)
try {
val left = pool.submit(Callable { detail(fixture) })
val right = pool.submit(Callable { detail(fixture) })
val background = pool.submit(Callable { worker.processNextGroup() })
assertTranslation(left.get(20, TimeUnit.SECONDS), "English title", "English detail", "#Healing")
assertTranslation(right.get(20, TimeUnit.SECONDS), "English title", "English detail", "#Healing")
assertTrue(background.get(20, TimeUnit.SECONDS))
assertEquals(3L, memories.count())
assertEquals(1L, translations.count())
assertEquals(setOf(TranslationJobStatus.COMPLETED), jobs.findAll().map { it.status }.toSet())
val calls = provider.calls.get()
assertTranslation(detail(fixture), "English title", "English detail", "#Healing")
assertEquals(calls, provider.calls.get())
} finally {
pool.shutdownNow()
check(pool.awaitTermination(5, TimeUnit.SECONDS))
}
}
@Test
@DisplayName("연관 콘텐츠 네 필드는 en-ja-en 요청 언어의 저장 제목만 적용하고 원문 탐색을 유지한다")
fun shouldLocalizeRelatedTitlesForEachRequestedLanguageWithoutChangingNavigation() {
val fixture = fixture()
val related = relatedFixture(fixture)
translations.saveAllAndFlush(
related.flatMap { item ->
listOf("en", "ja").map { locale ->
ContentTranslation(item.contentId, locale, ContentTranslationPayload("$locale ${item.title}", "", ""))
}
} + ContentTranslation(
fixture.first,
"ja",
ContentTranslationPayload("Japanese title", "Japanese detail", "#Japanese")
)
)
listOf("en", "ja", "en").forEach { locale ->
Mockito.clearInvocations(translationReads)
val response = detail(fixture, locale)
assertRelatedContent(response, related.map { it.copy(title = "$locale ${it.title}") })
assertTranslation(
response,
if (locale == "en") "English title" else "Japanese title",
if (locale == "en") "English detail" else "Japanese detail",
if (locale == "en") "#Healing" else "#Japanese"
)
val batches = Mockito.mockingDetails(translationReads).invocations
.filter { it.method.name == "findByContentIdInAndLocale" }
assertEquals(1, batches.size)
val ids = batches.single().getArgument<List<Long>>(0)
assertEquals(related.size, ids.size)
assertEquals(related.map { it.contentId }.toSet(), ids.toSet())
assertEquals(locale, batches.single().getArgument<String>(1))
assertEquals(3, provider.calls.get())
assertEquals(0L, jobs.count())
assertEquals(related.size * 2 + 2L, translations.count())
}
}
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = [" \t ", "Japanese only"])
@DisplayName("연관 제목은 요청 언어 번역 없음 또는 빈 값이면 다른 언어 대신 원문을 유지한다")
fun shouldKeepOriginalRelatedTitlesWhenRequestedTranslationIsMissingOrBlank(title: String?) {
val fixture = fixture()
val related = relatedFixture(fixture)
if (title != null) {
translations.saveAllAndFlush(
related.map {
ContentTranslation(
it.contentId,
if (title == "Japanese only") "ja" else "en",
ContentTranslationPayload(title, "", "")
)
}
)
}
val response = detail(fixture, "en")
assertRelatedContent(response, related)
assertTranslation(response, "English title", "English detail", "#Healing")
assertEquals(3, provider.calls.get())
assertEquals(0L, jobs.count())
assertEquals(if (title == null) 1L else related.size + 1L, translations.count())
}
@Test
@DisplayName("연관 콘텐츠가 없으면 이전 다음은 null이고 추천은 빈 목록이며 배치 조회를 생략한다")
fun shouldKeepNullNeighborsAndEmptyRecommendationsWithoutTranslationLookup() {
val fixture = fixture()
Mockito.clearInvocations(translationReads)
val response = detail(fixture)
assertTrue(response.path("previousContent").isNull)
assertTrue(response.path("nextContent").isNull)
assertEquals(emptyList<JsonNode>(), response.path("creatorOtherContentList").toList())
assertEquals(emptyList<JsonNode>(), response.path("sameThemeOtherContentList").toList())
assertEquals(
0,
Mockito.mockingDetails(translationReads).invocations.count { it.method.name == "findByContentIdInAndLocale" }
)
assertTranslation(response, "English title", "English detail", "#Healing")
assertEquals(3, provider.calls.get())
assertEquals(0L, jobs.count())
}
private fun assertRelatedContent(response: JsonNode, expected: List<OtherContentResponse>) {
assertEquals(expected[0], mapper.treeToValue(response.path("previousContent"), OtherContentResponse::class.java))
assertEquals(expected[1], mapper.treeToValue(response.path("nextContent"), OtherContentResponse::class.java))
listOf("creatorOtherContentList" to listOf(0, 1, 2), "sameThemeOtherContentList" to listOf(0, 1, 3))
.forEach { (field, indices) ->
val actual = response.path(field).map { mapper.treeToValue(it, OtherContentResponse::class.java) }
assertEquals(indices.size, actual.size)
assertEquals(indices.map { expected[it] }.associateBy { it.contentId }, actual.associateBy { it.contentId })
}
}
private fun relatedFixture(fixture: Pair<Long, Long>): List<OtherContentResponse> = transaction.execute {
val current = entityManager.find(AudioContent::class.java, fixture.first)
current.releaseDate = LocalDateTime.of(2020, 1, 1, 0, 0)
val genre = SeriesGenre("related-genre")
val series = Series("related-series", "related-introduction", "ko").apply {
member = current.member
this.genre = genre
}
val otherCreator = Member(password = "test", nickname = "other-creator", role = MemberRole.CREATOR)
val otherTheme = AudioContentTheme("other-theme", "other-theme.png")
listOf(genre, series, otherCreator, otherTheme).forEach(entityManager::persist)
entityManager.persist(
SeriesContent().apply {
this.series = series
content = current
}
)
listOf("가 이전", "하 다음", "creator only", "theme only").mapIndexed { index, title ->
val content = AudioContent(title, "related detail", "ko", releaseDate = current.releaseDate).apply {
member = if (index == 3) otherCreator else current.member
theme = if (index == 2) otherTheme else current.theme
coverImage = "related-$index.png"
isActive = true
}
entityManager.persist(content)
if (index < 2) {
entityManager.persist(
SeriesContent().apply {
this.series = series
this.content = content
}
)
}
OtherContentResponse(requireNotNull(content.id), title, "https://cdn.test/related-$index.png")
}
}!!
private fun detail(fixture: Pair<Long, Long>, locale: String? = null): JsonNode {
val response = http.exchange(
"/audio-content/${fixture.first}?timezone=UTC",
HttpMethod.GET,
HttpEntity<Void>(
HttpHeaders().apply {
set("X-Test-Member", fixture.second.toString())
if (locale != null) set("Accept-Language", locale)
}
),
String::class.java
)
assertEquals(200, response.statusCodeValue, response.body)
val body = mapper.readTree(response.body)
assertTrue(body.path("success").booleanValue(), response.body)
return body.path("data")
}
private fun assertTranslation(response: JsonNode, title: String, detail: String, tags: String) {
assertEquals(title, response.path("translated").path("title").textValue())
assertEquals(detail, response.path("translated").path("detail").textValue())
assertEquals(tags, response.path("translated").path("tags").textValue())
}
private fun fixture(language: String? = "ko", detail: String = "원문 설명", tags: Boolean = true): Pair<Long, Long> =
transaction.execute {
val creator = Member(password = "test", nickname = "detail-creator", role = MemberRole.CREATOR)
val viewer = Member(password = "test", nickname = "detail-viewer")
val theme = AudioContentTheme("테마", "theme.png")
listOf(creator, viewer, theme).forEach(entityManager::persist)
val content = AudioContent("원문 제목", detail, language, isCommentAvailable = false).apply {
member = creator
this.theme = theme
this.content = "output/audio.mp3"
coverImage = "cover.png"
duration = "00:01:00"
isActive = true
}
entityManager.persist(content)
if (tags) {
listOf("#힐링" to true, "#비활성" to false).forEach { (tag, active) ->
val hashTag = HashTag(tag)
entityManager.persist(hashTag)
entityManager.persist(
AudioContentHashTag().apply {
audioContent = content
this.hashTag = hashTag
isActive = active
}
)
}
}
requireNotNull(content.id) to requireNotNull(viewer.id)
}!!
}
@@ -19,7 +19,6 @@ import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.i18n.LangContext import kr.co.vividnext.sodalive.i18n.LangContext
import kr.co.vividnext.sodalive.i18n.SodaMessageSource import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.member.Member import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRepository import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
@@ -60,7 +59,6 @@ class AudioContentServiceTest {
private lateinit var audioContentLikeRepository: AudioContentLikeRepository private lateinit var audioContentLikeRepository: AudioContentLikeRepository
private lateinit var pinContentRepository: PinContentRepository private lateinit var pinContentRepository: PinContentRepository
private lateinit var memberRepository: MemberRepository private lateinit var memberRepository: MemberRepository
private lateinit var resourceTranslationJobScheduler: ResourceTranslationJobScheduler
private lateinit var contentTranslationRepository: ContentTranslationRepository private lateinit var contentTranslationRepository: ContentTranslationRepository
private lateinit var s3Uploader: S3Uploader private lateinit var s3Uploader: S3Uploader
private lateinit var audioContentCloudFront: AudioContentCloudFront private lateinit var audioContentCloudFront: AudioContentCloudFront
@@ -87,7 +85,6 @@ class AudioContentServiceTest {
audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java) audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java)
pinContentRepository = Mockito.mock(PinContentRepository::class.java) pinContentRepository = Mockito.mock(PinContentRepository::class.java)
memberRepository = Mockito.mock(MemberRepository::class.java) memberRepository = Mockito.mock(MemberRepository::class.java)
resourceTranslationJobScheduler = Mockito.mock(ResourceTranslationJobScheduler::class.java)
contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java) contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java)
s3Uploader = Mockito.mock(S3Uploader::class.java) s3Uploader = Mockito.mock(S3Uploader::class.java)
audioContentCloudFront = Mockito.mock(AudioContentCloudFront::class.java) audioContentCloudFront = Mockito.mock(AudioContentCloudFront::class.java)
@@ -112,8 +109,11 @@ class AudioContentServiceTest {
audioContentLikeRepository = audioContentLikeRepository, audioContentLikeRepository = audioContentLikeRepository,
pinContentRepository = pinContentRepository, pinContentRepository = pinContentRepository,
memberRepository = memberRepository, memberRepository = memberRepository,
resourceTranslationJobScheduler = resourceTranslationJobScheduler,
contentTranslationRepository = contentTranslationRepository, contentTranslationRepository = contentTranslationRepository,
detailTranslationService = Mockito.mock(AudioContentDetailTranslationService::class.java).also {
Mockito.`when`(it.resolve(Mockito.anyLong(), Mockito.anyString()))
.thenReturn(AudioContentDetailTranslationResult("ko"))
},
s3Uploader = s3Uploader, s3Uploader = s3Uploader,
objectMapper = ObjectMapper(), objectMapper = ObjectMapper(),
audioContentCloudFront = audioContentCloudFront, audioContentCloudFront = audioContentCloudFront,
@@ -0,0 +1,157 @@
package kr.co.vividnext.sodalive.content
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.series.ContentSeriesController
import kr.co.vividnext.sodalive.content.series.ContentSeriesDetailTranslationService
import kr.co.vividnext.sodalive.content.series.ContentSeriesService
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.i18n.LangContext
import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.i18n.translation.LanguageDetectionProvider
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderProperties
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslateRequest
import kr.co.vividnext.sodalive.i18n.translation.TranslateResult
import kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinator
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorker
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryService
import kr.co.vividnext.sodalive.i18n.translation.TranslationProvider
import kr.co.vividnext.sodalive.i18n.translation.TranslationReadModelMaterializer
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberAdapter
import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.member.contentpreference.ViewerContentPreference
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import kr.co.vividnext.sodalive.v2.creatorname.application.CreatorLocalizedNameService
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.mockito.Mockito
import org.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration
import org.springframework.boot.autoconfigure.EnableAutoConfiguration
import org.springframework.boot.autoconfigure.domain.EntityScan
import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Import
import org.springframework.context.annotation.Profile
import org.springframework.data.jpa.repository.config.EnableJpaRepositories
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver
import org.springframework.web.filter.OncePerRequestFilter
import org.springframework.web.method.support.HandlerMethodArgumentResolver
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
import java.util.Collections
import java.util.concurrent.atomic.AtomicInteger
import javax.servlet.FilterChain
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
@Configuration
@Profile("content-detail-translation-test")
@EnableAutoConfiguration(exclude = [SecurityAutoConfiguration::class, ManagementWebSecurityAutoConfiguration::class])
@EntityScan("kr.co.vividnext.sodalive")
@EnableJpaRepositories("kr.co.vividnext.sodalive")
@Import(
QueryDslConfig::class, AudioContentService::class, AudioContentController::class,
ExplorerQueryRepository::class, AudioContentThemeQueryRepository::class, SodaMessageSource::class,
LangContext::class, TranslationSourceExtractor::class, TranslationCoordinator::class,
TranslationJobScheduler::class, ResourceTranslationJobScheduler::class,
TranslationReadModelMaterializer::class, LanguageDetectionCacheService::class,
AudioContentDetailTranslationService::class, TranslationMemoryService::class, TranslationJobWorker::class,
LanguageDetectListener::class, ContentSeriesController::class, ContentSeriesService::class,
ContentSeriesDetailTranslationService::class
)
@MockBean(
classes = [
S3Uploader::class, CreatorContentViewHistoryService::class, CreatorLocalizedNameService::class,
HomeFollowingNewsPublishService::class, SubtitleJobService::class, CreatorCommunityTranslationService::class
]
)
class ContentDetailTranslationTestConfiguration : WebMvcConfigurer {
override fun addArgumentResolvers(resolvers: MutableList<HandlerMethodArgumentResolver>) {
resolvers.add(AuthenticationPrincipalArgumentResolver())
}
@Bean
fun properties() = LanguageProviderProperties(listOf(LanguageProviderId.AWS), listOf(LanguageProviderId.AWS))
@Bean
fun provider() = DetailTranslationProvider()
@Bean
fun cloudFront(): AudioContentCloudFront = Mockito.mock(AudioContentCloudFront::class.java).also {
Mockito.`when`(it.generateSignedURL(Mockito.anyString(), Mockito.anyLong())).thenReturn("https://signed.test/audio")
}
@Bean
fun preferences(): MemberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java).also {
Mockito.`when`(it.resolveForQuery(Mockito.any(Member::class.java) ?: Member(password = "test", nickname = "unused")))
.thenReturn(ViewerContentPreference("KR", false, ContentType.ALL, false))
}
@Bean
fun principalFilter(members: MemberRepository, lang: LangContext) = object : OncePerRequestFilter() {
override fun doFilterInternal(request: HttpServletRequest, response: HttpServletResponse, chain: FilterChain) {
val principal = MemberAdapter(members.findById(request.getHeader("X-Test-Member").toLong()).orElseThrow())
SecurityContextHolder.getContext().authentication =
UsernamePasswordAuthenticationToken(principal, null, principal.authorities)
lang.setLang(Lang.fromAcceptLanguage(request.getHeader("Accept-Language") ?: "en"))
try {
chain.doFilter(request, response)
} finally {
SecurityContextHolder.clearContext()
}
}
}
}
class DetailTranslationProvider : TranslationProvider, LanguageDetectionProvider {
override val providerId = LanguageProviderId.AWS
override val providerVersion = "test"
val calls = AtomicInteger()
val detectionQueries: MutableList<String> = Collections.synchronizedList(mutableListOf())
var fail = false
var detection: String? = "ko"
var beforeTranslate: () -> Unit = {}
var beforeDetect: () -> Unit = {}
fun reset() {
calls.set(0)
detectionQueries.clear()
fail = false
detection = "ko"
beforeTranslate = {}
beforeDetect = {}
}
override fun detect(query: String): String? {
detectionQueries.add(query)
beforeDetect()
return detection
}
override fun translate(request: TranslateRequest): TranslateResult {
calls.incrementAndGet()
beforeTranslate()
check(!fail) { "provider unavailable" }
val translations = mapOf(
"원문 제목" to "English title",
"원문 설명" to "English detail",
"#힐링" to "#Healing",
"#힐링, #차분" to "#Healing, #Calm",
"수정 제목" to "Edited title"
)
return TranslateResult(request.texts.map(translations::getValue))
}
}
@@ -0,0 +1,432 @@
package kr.co.vividnext.sodalive.content
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.hashtag.HashTag
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.theme.AudioContentTheme
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.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesContent
import kr.co.vividnext.sodalive.creator.admin.content.series.keyword.SeriesKeyword
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorker
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemory
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryRepository
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.assertTrue
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.NullAndEmptySource
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.SpyBean
import org.springframework.boot.test.web.client.TestRestTemplate
import org.springframework.http.HttpEntity
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.test.context.ActiveProfiles
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import java.util.concurrent.Callable
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.persistence.EntityManager
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
classes = [ContentDetailTranslationTestConfiguration::class],
properties = [
"spring.cache.type=none", "spring.jpa.properties.hibernate.show_sql=false",
"spring.jpa.database-platform=kr.co.vividnext.sodalive.support.H2MySqlFunctionDialect",
"cloud.aws.cloud-front.host=https://cdn.test"
]
)
@ActiveProfiles("content-detail-translation-test")
class ContentSeriesDetailTranslationHttpIntegrationTest @Autowired constructor(
private val http: TestRestTemplate,
private val mapper: ObjectMapper,
private val provider: DetailTranslationProvider,
private val translations: SeriesTranslationRepository,
private val genres: SeriesGenreTranslationRepository,
private val contentTranslations: ContentTranslationRepository,
private val memories: TranslationMemoryRepository,
private val jobs: TranslationJobRepository,
private val jdbc: JdbcTemplate,
private val worker: TranslationJobWorker,
private val scheduler: ResourceTranslationJobScheduler,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@SpyBean
private lateinit var memoryWriter: TranslationMemoryRepository
@SpyBean
private lateinit var jobClaims: TranslationJobRepository
@BeforeEach
fun prepare() {
provider.reset()
jobs.deleteAllInBatch()
translations.deleteAllInBatch()
contentTranslations.deleteAllInBatch()
genres.deleteAllInBatch()
memories.deleteAllInBatch()
jdbc.update("delete from language_detection_result")
Mockito.doAnswer {
jobs.findAll().filter { it.status == TranslationJobStatus.PENDING }.mapNotNull { it.id }
}.`when`(jobClaims).findNextPendingGroupJobIdsForUpdate(Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now())
// H2 JSON wraps converter output; preserve the real converter's MySQL text contract.
listOf("series_translation", "content_translation").forEach {
jdbc.execute("alter table $it alter column rendered_payload varchar(1000000)")
}
jdbc.execute(
"CREATE ALIAS IF NOT EXISTS DATE_FORMAT FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.dateFormat'"
)
jdbc.execute(
"CREATE ALIAS IF NOT EXISTS CONVERT_TZ FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.convertTz'"
)
}
@Test
@DisplayName("시리즈 첫 HTTP 응답의 세 번역 필드는 커밋되고 재조회에 재사용된다")
fun shouldCommitTranslationBeforeFirstResponseAndReuseIt() {
val fixture = fixture()
val response = detail(fixture)
assertTranslation(response)
transaction.executeWithoutResult {
val payload = translations.findBySeriesIdAndLocale(fixture.first, "en")!!.renderedPayload
assertEquals(SeriesTranslationPayload("English title", "English detail", listOf("#Healing", "#Calm")), payload)
}
assertEquals(3, provider.calls.get())
assertEquals(setOf("en"), memories.findAll().map { it.targetLanguage }.toSet())
assertEquals(response.path("translated"), detail(fixture).path("translated"))
assertEquals(3, provider.calls.get())
assertEquals(0L, jobs.count())
}
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = [" \t "])
@DisplayName("null 빈 문자열 공백 언어는 같은 HTTP 응답 전에 감지 결과와 번역을 저장한다")
fun shouldDetectAndCommitMissingLanguage(language: String?) {
val fixture = fixture(language)
val response = detail(fixture)
assertEquals("ko", transaction.execute { entityManager.find(Series::class.java, fixture.first).languageCode })
assertTranslation(response)
assertEquals(listOf("원문 제목 원문 설명 #힐링 #차분"), provider.detectionQueries)
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("감지 캐시와 번역 메모리만으로 빈 소개와 키워드도 공급자 호출 없이 저장한다")
fun shouldUseDetectionAndMemoryCachesWithEmptyFields() {
val fixture = fixture(null, " ", false)
jdbc.update(
"insert into language_detection_result " +
"(source_hash, source_text_sample, detected_language, provider, normalization_version) values (?, ?, ?, ?, ?)",
SourceTextNormalizer.hash("원문 제목"),
"원문 제목",
"ko",
"aws",
SourceTextNormalizer.NORMALIZATION_VERSION
)
memories.saveAndFlush(TranslationMemory(SourceTextNormalizer.hash("원문 제목"), "원문 제목", "ko", "en", "Cached", "aws", "test"))
val response = detail(fixture)
assertEquals("Cached", response.path("translated").path("title").textValue())
assertEquals("", response.path("translated").path("introduction").textValue())
assertEquals(emptyList<String>(), response.path("translated").path("keywords").map { it.textValue() })
assertEquals("ko", transaction.execute { entityManager.find(Series::class.java, fixture.first).languageCode })
assertEquals(1L, translations.count())
assertEquals(0, provider.calls.get())
assertTrue(provider.detectionQueries.isEmpty())
}
@ParameterizedTest
@ValueSource(strings = ["en", "fr"])
@DisplayName("동일 또는 미지원 언어에는 번역과 job을 만들지 않는다")
fun shouldKeepOriginalForSameOrUnsupportedLanguage(language: String) {
val response = detail(fixture(language))
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals(0, provider.calls.get())
assertEquals(0L, translations.count())
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("저장 번역의 빈 키워드는 기존 원문 fallback과 장르 응답을 유지한다")
fun shouldKeepOriginalKeywordsWhenStoredTranslationKeywordsAreEmpty() {
val fixture = fixture()
translations.saveAndFlush(
SeriesTranslation(fixture.first, "en", SeriesTranslationPayload("Stored", "Stored intro", emptyList()))
)
val response = detail(fixture)
assertEquals("Stored", response.path("translated").path("title").textValue())
assertEquals(listOf("#힐링", "#차분"), response.path("translated").path("keywords").map { it.textValue() })
assertEquals("원문 장르", response.path("genre").textValue())
assertEquals("Stored genre", response.path("translatedGenre").textValue())
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("공급자 실패는 원문 200과 복구 job을 남기고 worker가 누락 필드만 채운다")
fun shouldRecoverPartialProviderFailureThroughWorker() {
val fixture = fixture()
provider.beforeTranslate = { if (provider.calls.get() == 2) provider.fail = true }
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals(1L, memories.count())
assertEquals(3L, jobs.count())
provider.fail = false
provider.beforeTranslate = {}
assertTrue(worker.processNextGroup())
assertTranslation(detail(fixture))
assertEquals(4, provider.calls.get())
assertEquals(setOf(TranslationJobStatus.COMPLETED), jobs.findAll().map { it.status }.toSet())
}
@Test
@DisplayName("실제 번역 저장 제약 실패는 별도 트랜잭션에서 rollback되고 worker로 복구된다")
fun shouldIsolatePayloadRollbackAndRecoverCommittedMemories() {
val fixture = fixture()
jdbc.execute("alter table series_translation add constraint reject_series_payload check (series_id <> ${fixture.first})")
try {
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("원문 제목", response.path("title").textValue())
assertEquals(0L, translations.count())
assertEquals(3L, memories.count())
assertEquals(3L, jobs.count())
} finally {
jdbc.execute("alter table series_translation drop constraint reject_series_payload")
}
assertTrue(worker.processNextGroup())
assertTranslation(detail(fixture))
assertEquals(3, provider.calls.get())
}
@Test
@DisplayName("동기 감지 실패 뒤 기존 SERIES after-commit 이벤트가 언어와 복구 작업을 저장한다")
fun shouldRetainSeriesDetectionEventRecovery() {
val fixture = fixture(null)
provider.detection = null
provider.beforeDetect = { if (provider.detectionQueries.size == 2) provider.detection = "ko" }
val response = detail(fixture)
assertTrue(response.path("translated").isNull)
assertEquals("ko", transaction.execute { entityManager.find(Series::class.java, fixture.first).languageCode })
assertEquals(6L, jobs.count())
assertEquals(setOf(LanguageTranslationTargetType.SERIES), jobs.findAll().map { it.resourceType }.toSet())
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("감지 중 커밋된 원문 언어 변경을 상세의 managed entity가 덮어쓰지 않는다")
fun shouldPreserveSourceAndLanguageEditedDuringDetection() {
val fixture = fixture(null)
provider.beforeDetect = {
transaction.executeWithoutResult {
entityManager.find(Series::class.java, fixture.first).apply {
title = "수정 제목"
languageCode = "en"
}
}
}
assertTrue(detail(fixture).path("translated").isNull)
transaction.executeWithoutResult {
val series = entityManager.find(Series::class.java, fixture.first)
assertEquals("수정 제목", series.title)
assertEquals("en", series.languageCode)
}
assertEquals(0, provider.calls.get())
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("번역 공급자 호출 중 원문 수정은 오래된 번역을 저장하지 않고 현재 원문 작업으로 복구한다")
fun shouldRejectStaleTranslationAndRecoverCurrentSource() {
val fixture = fixture()
provider.beforeTranslate = {
transaction.executeWithoutResult { entityManager.find(Series::class.java, fixture.first).title = "수정 제목" }
}
assertTrue(detail(fixture).path("translated").isNull)
assertEquals(0L, translations.count())
assertEquals(3L, jobs.count())
assertEquals("수정 제목", jobs.findAll().single { it.fieldKey == "title" }.sourceText)
provider.beforeTranslate = {}
assertTrue(worker.processNextGroup())
assertEquals("Edited title", detail(fixture).path("translated").path("title").textValue())
assertEquals("수정 제목", transaction.execute { entityManager.find(Series::class.java, fixture.first).title })
}
@Test
@DisplayName("동시 상세와 worker는 메모리 및 시리즈 번역을 각각 한 행으로 수렴시킨다")
fun shouldConvergeConcurrentDetailsAndWorker() {
val fixture = fixture()
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.SERIES, fixture.first, "en")
val inserts = CountDownLatch(3)
val originalSave = Mockito.mockingDetails(memoryWriter).mockCreationSettings.defaultAnswer
Mockito.doAnswer { invocation ->
if (invocation.getArgument<TranslationMemory>(0).sourceText == "원문 제목") {
inserts.countDown()
check(inserts.await(10, TimeUnit.SECONDS)) { "competing series inserts did not arrive" }
}
originalSave.answer(invocation)
}.`when`(memoryWriter).save(Mockito.any(TranslationMemory::class.java) ?: TranslationMemory("", "", "", "", "", "", ""))
val pool = Executors.newFixedThreadPool(3)
try {
val left = pool.submit(Callable { detail(fixture) })
val right = pool.submit(Callable { detail(fixture) })
val background = pool.submit(Callable { worker.processNextGroup() })
assertTranslation(left.get(20, TimeUnit.SECONDS))
assertTranslation(right.get(20, TimeUnit.SECONDS))
assertTrue(background.get(20, TimeUnit.SECONDS))
assertEquals(3L, memories.count())
assertEquals(1L, translations.count())
assertEquals(setOf(TranslationJobStatus.COMPLETED), jobs.findAll().map { it.status }.toSet())
} finally {
pool.shutdownNow()
check(pool.awaitTermination(5, TimeUnit.SECONDS))
}
}
@Test
@DisplayName("하위 콘텐츠는 요청 언어의 저장 제목만 사용하고 누락 빈 제목은 원문을 유지한다")
fun shouldKeepChildTitlesStoredOnlyForEachLocale() {
val fixture = fixture()
val children = transaction.execute {
val series = entityManager.find(Series::class.java, fixture.first)
listOf("원문 child", "빈 child", "누락 child").map { title ->
val content = child(series, title)
requireNotNull(content.id) to title
}
}!!
contentTranslations.saveAllAndFlush(
listOf(
ContentTranslation(children[0].first, "en", ContentTranslationPayload("Stored child", "", "")),
ContentTranslation(children[0].first, "ja", ContentTranslationPayload("Japanese child", "", "")),
ContentTranslation(children[1].first, "en", ContentTranslationPayload(" \t ", "", ""))
)
)
translations.saveAndFlush(SeriesTranslation(fixture.first, "ja", SeriesTranslationPayload("Japanese", "", emptyList())))
listOf("en", "ja", "en").forEach { locale ->
val response = detail(fixture, locale)
val titles = response.path("contentList").associate {
it.path("contentId").longValue() to it.path("title").textValue()
}
assertEquals(if (locale == "en") "Stored child" else "Japanese child", titles[children[0].first])
assertEquals("빈 child", titles[children[1].first])
assertEquals("누락 child", titles[children[2].first])
assertEquals(4, response.path("contentCount").intValue())
assertEquals("원문 제목", response.path("title").textValue())
assertEquals("원문 설명", response.path("introduction").textValue())
assertEquals(3, provider.calls.get())
assertEquals(0L, jobs.count())
assertEquals(3L, contentTranslations.count())
}
}
private fun detail(fixture: Pair<Long, Long>, locale: String = "en"): JsonNode {
val response = http.exchange(
"/audio-content/series/${fixture.first}",
HttpMethod.GET,
HttpEntity<Void>(
HttpHeaders().apply {
set("X-Test-Member", fixture.second.toString())
set("Accept-Language", locale)
}
),
String::class.java
)
assertEquals(200, response.statusCodeValue, response.body)
val body = mapper.readTree(response.body)
assertTrue(body.path("success").booleanValue(), response.body)
return body.path("data")
}
private fun assertTranslation(response: JsonNode) {
val translated = response.path("translated")
assertEquals("English title", translated.path("title").textValue())
assertEquals("English detail", translated.path("introduction").textValue())
assertEquals(listOf("#Healing", "#Calm"), translated.path("keywords").map { it.textValue() })
}
private fun fixture(language: String? = "ko", introduction: String = "원문 설명", keywords: Boolean = true): Pair<Long, Long> =
transaction.execute {
val creator = Member(password = "test", nickname = "series-creator", role = MemberRole.CREATOR)
val viewer = Member(password = "test", nickname = "series-viewer")
val genre = SeriesGenre("원문 장르")
listOf(creator, viewer, genre).forEach(entityManager::persist)
val series = Series("원문 제목", introduction, language).apply {
member = creator
this.genre = genre
coverImage = "series.png"
}
entityManager.persist(series)
genres.save(SeriesGenreTranslation(requireNotNull(genre.id), "en", "Stored genre"))
if (keywords) {
listOf("#힐링", "#차분").forEachIndexed { index, tag ->
val keyword = HashTag(tag)
entityManager.persist(keyword)
entityManager.persist(
SeriesKeyword().apply {
this.series = series
this.keyword = keyword
isActive = index == 0
}
)
}
}
child(series, "기본 child")
requireNotNull(series.id) to requireNotNull(viewer.id)
}!!
private fun child(series: Series, title: String): AudioContent {
val theme = AudioContentTheme("child theme", "theme.png")
entityManager.persist(theme)
val content = AudioContent(title, "child detail", "ko", releaseDate = LocalDateTime.of(2020, 1, 1, 0, 0)).apply {
member = series.member
this.theme = theme
coverImage = "child.png"
duration = "00:01:00"
isActive = true
}
entityManager.persist(content)
entityManager.persist(
SeriesContent().apply {
this.series = series
this.content = content
}
)
return content
}
}
@@ -16,6 +16,7 @@ import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJob import kr.co.vividnext.sodalive.i18n.translation.TranslationJob
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTestConfiguration
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor
import kr.co.vividnext.sodalive.member.Member import kr.co.vividnext.sodalive.member.Member
@@ -56,7 +57,8 @@ import javax.persistence.EntityManager
LanguageDetectListener::class, LanguageDetectListener::class,
TranslationSourceExtractor::class, TranslationSourceExtractor::class,
ResourceTranslationJobScheduler::class, ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class
) )
@Transactional(propagation = Propagation.NOT_SUPPORTED) @Transactional(propagation = Propagation.NOT_SUPPORTED)
class MetadataLanguageDetectTransactionTest @Autowired constructor( class MetadataLanguageDetectTransactionTest @Autowired constructor(
@@ -4,8 +4,10 @@ import com.fasterxml.jackson.databind.ObjectMapper
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.content.AudioContent import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentDetailTranslationService
import kr.co.vividnext.sodalive.content.AudioContentRepository import kr.co.vividnext.sodalive.content.AudioContentRepository
import kr.co.vividnext.sodalive.content.AudioContentService import kr.co.vividnext.sodalive.content.AudioContentService
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.content.PlaybackTrackingRepository import kr.co.vividnext.sodalive.content.PlaybackTrackingRepository
import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository
import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository
@@ -36,6 +38,7 @@ import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher import org.springframework.context.ApplicationEventPublisher
import java.util.Optional import java.util.Optional
import javax.persistence.EntityManager
class AudioContentReadRetryTest : MetadataReadRetryTestSupport() { class AudioContentReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired @Autowired
@@ -83,8 +86,17 @@ class AudioContentReadRetryTest : MetadataReadRetryTestSupport() {
audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java), audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java),
pinContentRepository = Mockito.mock(PinContentRepository::class.java), pinContentRepository = Mockito.mock(PinContentRepository::class.java),
memberRepository = Mockito.mock(MemberRepository::class.java), memberRepository = Mockito.mock(MemberRepository::class.java),
resourceTranslationJobScheduler = scheduler,
contentTranslationRepository = translations, contentTranslationRepository = translations,
detailTranslationService = AudioContentDetailTranslationService(
repository,
translations,
Mockito.mock(LanguageDetectionCacheService::class.java),
Mockito.mock(TranslationMemoryService::class.java),
Mockito.mock(TranslationReadModelMaterializer::class.java),
scheduler,
Mockito.mock(EntityManager::class.java),
transactionManager
),
s3Uploader = Mockito.mock(S3Uploader::class.java), s3Uploader = Mockito.mock(S3Uploader::class.java),
objectMapper = ObjectMapper(), objectMapper = ObjectMapper(),
audioContentCloudFront = cloudFront, audioContentCloudFront = cloudFront,
@@ -0,0 +1,273 @@
package kr.co.vividnext.sodalive.i18n.translation
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 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.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
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.transaction.annotation.Propagation
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
class CompletedContentTagRepairTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var jobScheduler: TranslationJobScheduler
@Autowired
private lateinit var memories: TranslationMemoryRepository
@Autowired
private lateinit var translations: ContentTranslationRepository
@Autowired
private lateinit var coordinator: TranslationCoordinator
private val sourceText = "#비밀,#밤"
@ParameterizedTest
@CsvSource(
value = [
"#비밀,#밤|aws|#비밀,#밤",
"#비밀, #밤|aws|#비밀, #밤",
"#비밀, #밤|''|''",
"#비밀, #밤|papago|#비밀,#밤",
"#비밀, #밤|papago|#secret, #night",
"#비밀, #밤|aws|#secret, #night"
],
delimiter = '|'
)
@DisplayName("원문과 같은 완료 태그가 유효 캐시와 정확히 일치하지 않으면 같은 작업을 즉시 재개한다")
fun shouldRestartCompletedTagsWithoutMatchingAcceptedCache(renderedTags: String, provider: String, cachedText: String) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source)
givenRenderedTags(renderedTags)
val memory = cachedText.takeIf { it.isNotEmpty() }?.let { givenCache(it, provider) }
val requestedAt = LocalDateTime.now().withNano(0)
schedule(source)
assertRepaired(job, requestedAt)
assertEquals(renderedTags, translations.findByContentIdAndLocale(10L, "en")?.renderedPayload?.tags)
assertEquals(listOfNotNull(memory?.id), memories.findAll().map { it.id })
}
@Test
@DisplayName("기존 번역 행이 있는 조회 재시작도 현재 COMPLETED 태그를 복구 후보로 검사한다")
fun shouldRestartCompletedTagsOnReadDespiteExistingRenderedRow() {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source)
givenRenderedTags("#비밀, #밤")
val memory = givenCache("#비밀, #밤")
val requestedAt = LocalDateTime.now().withNano(0)
scheduler.restartFailedResourceTranslations(source.resourceType, listOf(source.resourceId), "EN")
assertRepaired(job, requestedAt)
assertEquals(memory.id, memories.findAll().single().id)
assertEquals("#비밀, #밤", translations.findByContentIdAndLocale(10L, "en")?.renderedPayload?.tags)
}
@ParameterizedTest
@ValueSource(strings = ["#비밀,#밤", "#비밀, #밤"])
@DisplayName("잘못된 AWS 캐시가 남아 있어도 Papago로 확인된 동일 태그는 반복 수정과 조회에서 완료를 유지한다")
fun shouldPreservePapagoConfirmedIdenticalTagsAcrossRepeatedRequests(renderedTags: String) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source)
givenRenderedTags(renderedTags)
val aws = givenCache("#비밀 , #밤")
val papago = givenCache(renderedTags, "papago")
repeat(2) {
schedule(source)
scheduler.restartFailedResourceTranslations(source.resourceType, listOf(source.resourceId), "en")
}
assertPreserved(job)
assertEquals(setOf(aws.id, papago.id), memories.findAll().map { it.id }.toSet())
assertEquals(renderedTags, translations.findByContentIdAndLocale(10L, "en")?.renderedPayload?.tags)
}
@ParameterizedTest
@ValueSource(booleans = [false, true])
@DisplayName("정상 번역된 완료 태그는 AWS 캐시 유무와 관계없이 수정과 조회에서 보존한다")
fun shouldPreserveNormallyTranslatedTags(withAwsCache: Boolean) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source)
givenRenderedTags("#secret, #night")
if (withAwsCache) givenCache("#secret, #night")
schedule(source)
scheduler.restartFailedResourceTranslations(source.resourceType, listOf(source.resourceId), "en")
assertPreserved(job)
}
@ParameterizedTest
@CsvSource("CONTENT,title", "CONTENT,detail", "CHARACTER,tags", "ORIGINAL_WORK,tags", "SERIES,keywords")
@DisplayName("원문과 같아도 콘텐츠 태그 이외의 완료 필드와 리소스는 초기화하지 않는다")
fun shouldPreserveCompletedFieldsOutsideContentTags(type: LanguageTranslationTargetType, field: String) {
val source = givenSource(type, field, sourceText)
val job = givenJob(source)
givenRenderedTags("#비밀, #밤")
schedule(source)
scheduler.restartFailedResourceTranslations(type, listOf(source.resourceId), "en")
assertPreserved(job)
}
@ParameterizedTest
@EnumSource(TranslationJobStatus::class, names = ["PENDING", "RUNNING"])
@DisplayName("미번역 태그라도 진행 중 작업의 재시도 예산과 예약 시각은 유지한다")
fun shouldPreserveActiveTagJobs(status: TranslationJobStatus) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source, status)
givenRenderedTags("#비밀, #밤")
schedule(source)
scheduler.restartFailedResourceTranslations(source.resourceType, listOf(source.resourceId), "en")
assertPreserved(job)
}
@ParameterizedTest
@CsvSource("false,language", "false,hash", "true,language", "true,hash")
@DisplayName("현재 원문 언어 또는 해시가 다른 완료 태그는 수정과 조회에서 재개하지 않는다")
fun shouldPreserveCompletedTagsForDifferentCurrentSource(readRequest: Boolean, mismatch: String) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val previousSource = if (mismatch == "language") {
source.copy(sourceLanguage = "ja")
} else {
source.copy(fields = listOf(TranslationSourceField("tags", "#이전,#태그")))
}
val job = givenJob(previousSource)
givenRenderedTags("#비밀, #밤")
if (readRequest) {
scheduler.restartFailedResourceTranslations(source.resourceType, listOf(source.resourceId), "en")
} else {
schedule(source)
}
assertPreserved(job)
assertEquals(if (!readRequest && mismatch == "hash") 2L else 1L, jobs.count())
}
@ParameterizedTest
@CsvSource("false,false", "false,true", "true,false", "true,true")
@DisplayName("완료 태그의 저장 응답이 없거나 비어 있으면 캐시로 재생성할 수 있어도 작업을 재개한다")
fun shouldRestartCompletedTagsWithMissingRenderedPayload(blankTags: Boolean, withPapagoCache: Boolean) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source)
if (blankTags) givenRenderedTags("")
if (withPapagoCache) givenCache(sourceText, "papago")
val requestedAt = LocalDateTime.now().withNano(0)
schedule(source)
assertRepaired(job, requestedAt)
}
@Test
@DisplayName("완료 작업 조회 뒤 다른 트랜잭션이 RUNNING으로 선점하면 오래된 복구 요청은 초기화하지 않는다")
fun shouldPreserveClaimCommittedAfterCompletedSnapshotWasRead() {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val job = givenJob(source)
givenRenderedTags("#비밀, #밤")
val repository = Mockito.mock(
TranslationJobRepository::class.java,
AdditionalAnswers.delegatesTo<TranslationJobRepository>(jobs)
)
val claimTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = Propagation.REQUIRES_NEW.value()
}
Mockito.doAnswer {
val snapshot = jobs.findById(requireNotNull(job.id)).orElseThrow()
claimTransaction.executeWithoutResult {
val claimed = jobs.findById(requireNotNull(job.id)).orElseThrow()
claimed.status = TranslationJobStatus.RUNNING
claimed.retryCount = 4
jobs.saveAndFlush(claimed)
}
snapshot
}.`when`(repository).findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
source.resourceType,
source.resourceId,
"tags",
"en",
SourceTextNormalizer.hash(sourceText)
)
TransactionTemplate(transactionManager).executeWithoutResult {
schedule(source, TranslationJobScheduler(repository, coordinator, translations))
}
val claimed = jobs.findById(requireNotNull(job.id)).orElseThrow()
assertEquals(TranslationJobStatus.RUNNING, claimed.status)
assertEquals(4, claimed.retryCount)
assertEquals(job.lastErrorMessage, claimed.lastErrorMessage)
assertEquals(previousRetryAt, claimed.nextRetryAt)
}
private fun givenJob(
source: TranslationSource,
status: TranslationJobStatus = TranslationJobStatus.COMPLETED
): TranslationJob {
val job = failedJob(source)
job.status = status
return jobs.saveAndFlush(job)
}
private fun givenRenderedTags(tags: String) = persistRendered(
ContentTranslation(10L, "en", ContentTranslationPayload("Old title", "Old detail", tags)),
"content_translation",
"""{"title":"Old title","detail":"Old detail","tags":"$tags"}"""
)
private fun givenCache(text: String, provider: String = "aws") = persist(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", text, provider, "test")
)
private fun schedule(source: TranslationSource, scheduler: TranslationJobScheduler = jobScheduler) {
val field = source.fields.single()
scheduler.scheduleMissingTranslation(
source.resourceType,
source.resourceId,
field.fieldKey,
field.sourceText,
"KO",
"EN"
)
}
private fun assertRepaired(job: TranslationJob, requestedAt: LocalDateTime) {
val repaired = jobs.findAll().single()
assertEquals(job.id, repaired.id)
assertEquals(job.sourceHash, repaired.sourceHash)
assertEquals(job.sourceText, repaired.sourceText)
assertEquals(job.sourceLanguage, repaired.sourceLanguage)
assertEquals(TranslationJobStatus.PENDING, repaired.status)
assertEquals(0, repaired.retryCount)
assertNull(repaired.lastErrorMessage)
assertFalse(repaired.nextRetryAt.isBefore(requestedAt))
assertFalse(repaired.nextRetryAt.isAfter(LocalDateTime.now().plusSeconds(1)))
}
private fun assertPreserved(job: TranslationJob) {
val preserved = jobs.findById(requireNotNull(job.id)).orElseThrow()
assertEquals(job.status, preserved.status)
assertEquals(job.retryCount, preserved.retryCount)
assertEquals(job.lastErrorMessage, preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
}
@@ -2,7 +2,9 @@ package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.ContentType import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.content.order.OrderRepository import kr.co.vividnext.sodalive.content.order.OrderRepository
import kr.co.vividnext.sodalive.content.series.ContentSeriesDetailTranslationService
import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository
import kr.co.vividnext.sodalive.content.series.ContentSeriesService import kr.co.vividnext.sodalive.content.series.ContentSeriesService
import kr.co.vividnext.sodalive.content.series.GetSeriesGenreListResponse import kr.co.vividnext.sodalive.content.series.GetSeriesGenreListResponse
@@ -25,7 +27,9 @@ 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.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher
import java.time.LocalDateTime import java.time.LocalDateTime
import java.util.Optional
class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() { class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired @Autowired
@@ -55,6 +59,7 @@ class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() {
createdAt = LocalDateTime.of(2026, 1, 1, 0, 0) createdAt = LocalDateTime.of(2026, 1, 1, 0, 0)
} }
Mockito.`when`(repository.getSeriesDetail(10L, false, ContentType.ALL)).thenReturn(series) Mockito.`when`(repository.getSeriesDetail(10L, false, ContentType.ALL)).thenReturn(series)
Mockito.`when`(repository.findById(10L)).thenReturn(Optional.of(series))
Mockito.`when`(repository.getSeriesContentMinMaxPrice(10L)).thenReturn(GetSeriesContentMinMaxPriceResponse(0, 0)) Mockito.`when`(repository.getSeriesContentMinMaxPrice(10L)).thenReturn(GetSeriesContentMinMaxPriceResponse(0, 0))
Mockito.`when`(contents.getContentList(10L, false, ContentType.ALL, "https://cdn.test", SeriesSortType.NEWEST, 0, 5)) Mockito.`when`(contents.getContentList(10L, false, ContentType.ALL, "https://cdn.test", SeriesSortType.NEWEST, 0, 5))
.thenReturn(emptyList()) .thenReturn(emptyList())
@@ -91,7 +96,17 @@ class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() {
explorerQueryRepository = Mockito.mock(ExplorerQueryRepository::class.java), explorerQueryRepository = Mockito.mock(ExplorerQueryRepository::class.java),
seriesContentRepository = contents, seriesContentRepository = contents,
langContext = langContext, langContext = langContext,
seriesTranslationRepository = seriesTranslations, detailTranslationService = ContentSeriesDetailTranslationService(
repository,
seriesTranslations,
Mockito.mock(LanguageDetectionCacheService::class.java),
Mockito.mock(TranslationMemoryService::class.java),
Mockito.mock(TranslationReadModelMaterializer::class.java),
scheduler,
entityManager,
transactionManager
),
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
seriesGenreTranslationRepository = genreTranslations, seriesGenreTranslationRepository = genreTranslations,
contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java), contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java),
resourceTranslationJobScheduler = scheduler, resourceTranslationJobScheduler = scheduler,
@@ -0,0 +1,291 @@
package kr.co.vividnext.sodalive.i18n.translation
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
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 org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.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.AdditionalAnswers
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Import
import org.springframework.jdbc.core.JdbcTemplate
import java.time.LocalDateTime
@Import(
TranslationCoordinator::class,
TranslationReadModelMaterializer::class,
ContentTagTranslationIntegrationTest.Providers::class
)
class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var coordinator: TranslationCoordinator
@Autowired
private lateinit var materializer: TranslationReadModelMaterializer
@Autowired
private lateinit var memories: TranslationMemoryRepository
@Autowired
private lateinit var translations: ContentTranslationRepository
@Autowired
private lateinit var jdbc: JdbcTemplate
@Autowired
private lateinit var aws: TagProvider
@Autowired
private lateinit var papago: PapagoTagProvider
private val sourceText = "#힐링,#수면"
@BeforeEach
fun prepareProviders() {
aws.result = "#힐링, #수면"
aws.calls = 0
papago.result = "#Healing, #Sleep"
papago.calls = 0
papago.fail = false
}
@AfterEach
fun removeWorkerResults() {
translations.deleteAllInBatch()
memories.deleteAllInBatch()
}
@ParameterizedTest
@ValueSource(strings = ["#힐링,#수면", "#힐링, #수면", " #힐링 , #수면 "])
@DisplayName("AWS가 콘텐츠 태그 원문이나 쉼표 공백만 바꾸면 Papago로 번역하고 저장한다")
fun shouldFallbackForUnchangedAwsContentTags(awsResult: String) {
aws.result = awsResult
prepareJob()
assertTrue(worker().processNextGroup())
assertEquals(1, aws.calls)
assertEquals(1, papago.calls)
assertEquals("papago", memories.findAll().single().provider)
assertEquals("#Healing, #Sleep", renderedTags())
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single().status)
}
@Test
@DisplayName("이미 저장된 AWS 미번역 태그 캐시도 건너뛰고 Papago 결과로 응답 데이터를 조립한다")
fun shouldIgnoreUnchangedAwsMemoryDuringWorkerAndMaterialization() {
prepareJob()
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", aws.result, "aws", "test")
)
assertTrue(worker().processNextGroup())
assertEquals(1, papago.calls)
assertEquals(setOf("aws", "papago"), memories.findAll().map { it.provider }.toSet())
assertEquals("#Healing, #Sleep", renderedTags())
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single().status)
}
@Test
@DisplayName("기존 AWS 미번역 캐시 뒤 정상 AWS 결과를 얻으면 같은 캐시 행을 교체하고 응답을 조립한다")
fun shouldReplaceUnchangedAwsMemoryWithChangedAwsResult() {
prepareJob()
val previous = memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", aws.result, "aws", "test")
)
aws.result = "#Healing,#Sleep"
assertTrue(worker().processNextGroup())
val replaced = memories.findAll().single()
assertEquals("#Healing,#Sleep", replaced.translatedText)
assertEquals(previous.id, replaced.id)
assertEquals(0, papago.calls)
assertEquals("#Healing,#Sleep", renderedTags())
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single().status)
}
@Test
@DisplayName("AWS 미번역 태그 캐시만 있을 때는 정상 번역 응답으로 조립하지 않는다")
fun shouldNotMaterializeUnchangedAwsTagCache() {
givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", aws.result, "aws", "test")
)
assertFalse(materializer.materialize(LanguageTranslationTargetType.CONTENT, 10L, "en"))
assertEquals(0L, translations.count())
}
@Test
@DisplayName("Papago도 태그 원문을 반환하면 승인된 정책에 따라 완료한다")
fun shouldCompleteWithUnchangedPapagoTags() {
papago.result = sourceText
prepareJob()
assertTrue(worker().processNextGroup())
assertEquals("papago", memories.findAll().single().provider)
assertEquals(sourceText, renderedTags())
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single().status)
}
@Test
@DisplayName("AWS가 원문 태그를 반환하고 Papago가 실패하면 완료하지 않고 기존 재시도 정책을 따른다")
fun shouldRetryWhenPapagoFailsAfterUnchangedAwsTags() {
papago.fail = true
prepareJob()
assertTrue(worker().processNextGroup())
assertEquals(1, papago.calls)
assertEquals(TranslationJobStatus.PENDING, jobs.findAll().single().status)
assertEquals(1, jobs.findAll().single().retryCount)
assertEquals(0L, memories.count())
assertEquals(0L, translations.count())
}
@Test
@DisplayName("이전 완료 태그는 조회로 복구하고 Papago 동일 결과 저장 후 다음 조회에서는 다시 등록하지 않는다")
fun shouldRepairCompletedTagsOnceAcrossReadWorkerAndRead() {
prepareJob()
val job = jobs.findAll().single().apply { status = TranslationJobStatus.COMPLETED }
jobs.saveAndFlush(job)
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", aws.result, "aws", "test")
)
translations.saveAndFlush(ContentTranslation(10L, "en", ContentTranslationPayload("", "", aws.result)))
storeRenderedPayloadAsJsonObject()
papago.result = sourceText
scheduler.restartFailedResourceTranslations(LanguageTranslationTargetType.CONTENT, listOf(10L), "en")
assertEquals(TranslationJobStatus.PENDING, jobs.findAll().single().status)
assertTrue(worker().processNextGroup())
assertEquals(sourceText, renderedTags())
storeRenderedPayloadAsJsonObject()
scheduler.restartFailedResourceTranslations(LanguageTranslationTargetType.CONTENT, listOf(10L), "en")
val completed = jobs.findAll().single()
assertEquals(job.id, completed.id)
assertEquals(TranslationJobStatus.COMPLETED, completed.status)
assertEquals(1, papago.calls)
assertFalse(worker().processNextGroup())
println(
"Tag repair QA: same job=${job.id}, AWS unchanged rejected, " +
"Papago identical accepted, next read remains COMPLETED"
)
}
@Test
@DisplayName("AWS가 실제로 다른 태그를 반환하면 Papago를 호출하지 않는다")
fun shouldKeepChangedAwsTags() {
aws.result = "#Healing,#Sleep"
prepareJob()
assertTrue(worker().processNextGroup())
assertEquals(0, papago.calls)
assertEquals("aws", memories.findAll().single().provider)
assertEquals("#Healing,#Sleep", renderedTags())
}
@Test
@DisplayName("콘텐츠 제목의 원문 동일 결과에는 태그 전용 거부 정책을 적용하지 않는다")
fun shouldPreserveUnchangedTitlePolicy() {
aws.result = sourceText
prepareJob("title")
assertTrue(worker().processNextGroup())
assertEquals(0, papago.calls)
assertEquals("aws", memories.findAll().single().provider)
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single().status)
}
private fun prepareJob(fieldKey: String = "tags") {
givenSource(LanguageTranslationTargetType.CONTENT, fieldKey, sourceText)
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.CONTENT, 10L, "en")
}
private fun worker(): TranslationJobWorker {
val claimRepository = Mockito.mock(
TranslationJobRepository::class.java,
AdditionalAnswers.delegatesTo<TranslationJobRepository>(jobs)
)
Mockito.doAnswer {
jobs.findAll().filter { it.status == TranslationJobStatus.PENDING }.mapNotNull { it.id }
}.`when`(claimRepository).findNextPendingGroupJobIdsForUpdate(
Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now()
)
return TranslationJobWorker(
claimRepository,
TranslationMemoryService(memories, coordinator, transactionManager),
materializer,
transactionManager
)
}
private fun renderedTags(): String = renderedPayload().get("tags").asText()
private fun storeRenderedPayloadAsJsonObject() {
jdbc.update(
"update content_translation set rendered_payload = ? format json where content_id = 10",
renderedPayload().toString()
)
}
private fun renderedPayload(): JsonNode {
val raw = jdbc.queryForObject(
"select rendered_payload from content_translation where content_id = 10",
String::class.java
)!!
val mapper = jacksonObjectMapper()
val value = mapper.readTree(raw)
// H2 JSON은 converter가 저장한 JSON 문자열을 한 겹 감싸 반환한다.
return if (value.isTextual) mapper.readTree(value.asText()) else value
}
@TestConfiguration
class Providers {
@Bean
fun properties() = LanguageProviderProperties()
@Bean
fun aws() = TagProvider()
@Bean
fun papago() = PapagoTagProvider()
}
open class TagProvider : TranslationProvider {
override val providerId = LanguageProviderId.AWS
override val providerVersion = "test"
var result = ""
var calls = 0
var fail = false
override fun translate(request: TranslateRequest): TranslateResult {
calls += 1
if (fail) throw IllegalStateException("test provider failure")
return TranslateResult(request.texts.map { result })
}
}
class PapagoTagProvider : TagProvider() {
override val providerId = LanguageProviderId.PAPAGO
}
}
@@ -64,6 +64,7 @@ import java.util.UUID
LanguageDetectionCacheService::class, LanguageDetectionCacheService::class,
TranslationCoordinator::class, TranslationCoordinator::class,
TranslationJobWorker::class, TranslationJobWorker::class,
TranslationMemoryService::class,
TranslationReadModelMaterializer::class, TranslationReadModelMaterializer::class,
TranslationSourceExtractor::class, TranslationSourceExtractor::class,
TranslationJobScheduler::class, TranslationJobScheduler::class,
@@ -27,7 +27,12 @@ import javax.persistence.EntityManager
] ]
) )
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(QueryDslConfig::class, ResourceTranslationJobScheduler::class, TranslationJobScheduler::class) @Import(
QueryDslConfig::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class
)
@Transactional(propagation = Propagation.NOT_SUPPORTED) @Transactional(propagation = Propagation.NOT_SUPPORTED)
abstract class MetadataReadRetryTestSupport { abstract class MetadataReadRetryTestSupport {
@Autowired @Autowired
@@ -8,14 +8,38 @@ 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.configs.QueryDslConfig import kr.co.vividnext.sodalive.configs.QueryDslConfig
import kr.co.vividnext.sodalive.content.AudioContent import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentController
import kr.co.vividnext.sodalive.content.AudioContentDetailTranslationService
import kr.co.vividnext.sodalive.content.AudioContentService
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.LanguageDetectListener
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.content.hashtag.AudioContentHashTag
import kr.co.vividnext.sodalive.content.hashtag.HashTag
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.i18n.LangContext
import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.member.Member import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberAdapter
import kr.co.vividnext.sodalive.member.MemberRole import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.member.contentpreference.ViewerContentPreference
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import kr.co.vividnext.sodalive.v2.creatorname.application.CreatorLocalizedNameService
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.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Assertions.assertNull
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.NullAndEmptySource
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
@@ -24,12 +48,19 @@ import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Bean import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Import import org.springframework.context.annotation.Import
import org.springframework.core.task.SyncTaskExecutor import org.springframework.core.task.SyncTaskExecutor
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.mock.web.MockMultipartFile import org.springframework.mock.web.MockMultipartFile
import org.springframework.scheduling.annotation.EnableAsync import org.springframework.scheduling.annotation.EnableAsync
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken
import org.springframework.security.core.context.SecurityContextHolder
import org.springframework.security.web.method.annotation.AuthenticationPrincipalArgumentResolver
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import org.springframework.test.web.servlet.setup.MockMvcBuilders import org.springframework.test.web.servlet.setup.MockMvcBuilders
import org.springframework.transaction.PlatformTransactionManager import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
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
@@ -47,21 +78,45 @@ import javax.persistence.EntityManager
@Import( @Import(
QueryDslConfig::class, QueryDslConfig::class,
AdminContentService::class, AdminContentService::class,
AudioContentService::class,
AudioContentDetailTranslationService::class,
TranslationMemoryService::class,
TranslationReadModelMaterializer::class,
ExplorerQueryRepository::class,
SodaMessageSource::class,
AudioContentThemeQueryRepository::class, AudioContentThemeQueryRepository::class,
TranslationSourceExtractor::class, TranslationSourceExtractor::class,
ResourceTranslationJobScheduler::class, ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class, TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class,
LanguageTranslationListener::class, LanguageTranslationListener::class,
LanguageDetectListener::class,
MetadataTranslationHttpIntegrationTest.Configuration::class MetadataTranslationHttpIntegrationTest.Configuration::class
) )
@MockBean(
classes = [
CreatorCommunityTranslationService::class,
CreatorContentViewHistoryService::class,
CreatorLocalizedNameService::class,
HomeFollowingNewsPublishService::class,
SubtitleJobService::class
]
)
@Transactional(propagation = Propagation.NOT_SUPPORTED) @Transactional(propagation = Propagation.NOT_SUPPORTED)
class MetadataTranslationHttpIntegrationTest @Autowired constructor( class MetadataTranslationHttpIntegrationTest @Autowired constructor(
private val service: AdminContentService, private val service: AdminContentService,
private val contentService: AudioContentService,
private val localizedNames: CreatorLocalizedNameService,
private val langContext: LangContext,
private val jobs: TranslationJobRepository, private val jobs: TranslationJobRepository,
private val memories: TranslationMemoryRepository,
private val jdbc: JdbcTemplate,
private val entityManager: EntityManager, private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager transactionManager: PlatformTransactionManager
) { ) {
private val transaction = TransactionTemplate(transactionManager) private val transaction = TransactionTemplate(transactionManager).apply {
isolationLevel = TransactionDefinition.ISOLATION_REPEATABLE_READ
}
@MockBean @MockBean
private lateinit var uploader: S3Uploader private lateinit var uploader: S3Uploader
@@ -69,6 +124,113 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
@MockBean @MockBean
private lateinit var cloudFront: AudioContentCloudFront private lateinit var cloudFront: AudioContentCloudFront
@MockBean
private lateinit var detectionCache: LanguageDetectionCacheService
@MockBean
private lateinit var preferences: MemberContentPreferenceService
@ParameterizedTest
@NullAndEmptySource
@ValueSource(strings = [" \t "])
@DisplayName("언어가 없는 상세 GET은 동기 감지와 번역을 커밋하고 외부 managed entity의 언어는 변경하지 않는다")
fun shouldCommitDetectedLanguageAndTranslationBeforeDetailHttpGetReturns(languageCode: String?) {
val title = " 원문 전체 제목 "
val detail = " 원문 전체 설명은 구매 전 미리보기보다 길며 언어 감지에는 잘린 응답 대신 마지막 문장까지 모두 포함되어야 합니다. "
val (contentId, viewer) = transaction.execute {
val creator = Member(password = "test", nickname = "detect-creator", role = MemberRole.CREATOR)
val viewer = Member(password = "test", nickname = "detect-viewer")
val theme = AudioContentTheme("테마", "theme.png")
listOf(creator, viewer, theme).forEach(entityManager::persist)
val content = AudioContent(
title,
detail,
languageCode,
price = 50,
isCommentAvailable = false,
isFullDetailVisible = false
).apply {
member = creator
this.theme = theme
this.content = "output/audio.mp3"
coverImage = "cover.png"
duration = "00:01:00"
isActive = true
}
entityManager.persist(content)
listOf("#활성" to true, "#비활성" to false).forEach { (tag, active) ->
val hashTag = HashTag(tag)
entityManager.persist(hashTag)
entityManager.persist(
AudioContentHashTag().apply {
audioContent = content
this.hashTag = hashTag
isActive = active
}
)
}
requireNotNull(content.id) to viewer
}!!
val query = "원문 전체 제목 원문 전체 설명은 구매 전 미리보기보다 길며 언어 감지에는 잘린 응답 대신 마지막 문장까지 모두 포함되어야 합니다. #활성"
Mockito.`when`(detectionCache.detectWithCache(query)).thenReturn(DetectedLanguage("ko", LanguageProviderId.AWS))
listOf(title to "Full title", detail to "Full detail", "#활성" to "#Active").forEach { (source, translated) ->
val normalized = SourceTextNormalizer.normalize(source)
if (memories.findBySourceHashAndSourceLanguageAndTargetLanguageAndProviderAndNormalizationVersion(
SourceTextNormalizer.hash(normalized),
"ko",
"en",
"aws",
SourceTextNormalizer.NORMALIZATION_VERSION
) == null
) {
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(normalized), normalized, "ko", "en", translated, "aws", "test")
)
}
}
jdbc.execute("alter table content_translation alter column rendered_payload varchar(1000000)")
Mockito.`when`(preferences.resolveForQuery(viewer))
.thenReturn(ViewerContentPreference("KR", false, ContentType.ALL, false))
Mockito.`when`(cloudFront.generateSignedURL("preview/audio.mp3", 7_200_000L))
.thenReturn("https://signed.test/audio")
val principal = MemberAdapter(viewer)
SecurityContextHolder.getContext().authentication =
UsernamePasswordAuthenticationToken(principal, null, principal.authorities)
try {
transaction.executeWithoutResult {
val outerContent = entityManager.find(AudioContent::class.java, contentId)
MockMvcBuilders.standaloneSetup(
AudioContentController(contentService, preferences, localizedNames, langContext)
)
.setCustomArgumentResolvers(AuthenticationPrincipalArgumentResolver())
.build()
.perform(get("/audio-content/{id}", contentId).param("timezone", "Asia/Seoul"))
.andExpect(status().isOk)
.andExpect(jsonPath("$.success").value(true))
.andExpect(jsonPath("$.data.title").value(title))
.andExpect(jsonPath("$.data.detail").value("${detail.take(30)}..."))
.andExpect(jsonPath("$.data.tag").value("#활성"))
.andExpect(jsonPath("$.data.languageCode").value("ko"))
.andExpect(jsonPath("$.data.translated.title").value("Full title"))
.andExpect(jsonPath("$.data.translated.detail").value("Full detail"))
.andExpect(jsonPath("$.data.translated.tags").value("#Active"))
assertEquals(languageCode, outerContent.languageCode)
assertEquals(0, jobs.findAll().count { it.resourceId == contentId })
Mockito.verify(detectionCache).detectWithCache(query)
}
transaction.executeWithoutResult {
entityManager.clear()
assertEquals("ko", entityManager.find(AudioContent::class.java, contentId).languageCode)
val stored = jobs.findAll().filter {
it.resourceType == LanguageTranslationTargetType.CONTENT && it.resourceId == contentId
}
assertEquals(0, stored.size)
}
} finally {
SecurityContextHolder.clearContext()
}
}
@Test @Test
@DisplayName("관리자 multipart 수정 HTTP 요청은 커밋 후 같은 FAILED 행을 재개하고 번역 작업을 저장한다") @DisplayName("관리자 multipart 수정 HTTP 요청은 커밋 후 같은 FAILED 행을 재개하고 번역 작업을 저장한다")
fun shouldRestartFailedTranslationAfterAdminHttpUpdateCommits() { fun shouldRestartFailedTranslationAfterAdminHttpUpdateCommits() {
@@ -131,6 +293,9 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
@Bean @Bean
fun objectMapper(): ObjectMapper = jacksonObjectMapper() fun objectMapper(): ObjectMapper = jacksonObjectMapper()
@Bean
fun langContext(): LangContext = LangContext().apply { setLang(Lang.EN) }
@Bean @Bean
fun taskExecutor(): Executor = SyncTaskExecutor() fun taskExecutor(): Executor = SyncTaskExecutor()
} }
@@ -1,6 +1,7 @@
package kr.co.vividnext.sodalive.i18n.translation package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.configs.QueryDslConfig import kr.co.vividnext.sodalive.configs.QueryDslConfig
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Assertions.assertNull
@@ -34,10 +35,12 @@ import javax.persistence.EntityManager
] ]
) )
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) @AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(QueryDslConfig::class, TranslationJobScheduler::class) @Import(QueryDslConfig::class, TranslationJobScheduler::class, TranslationJobSchedulerTestConfiguration::class)
class TranslationJobRetryIntegrationTest @Autowired constructor( class TranslationJobRetryIntegrationTest @Autowired constructor(
private val repository: TranslationJobRepository, private val repository: TranslationJobRepository,
private val scheduler: TranslationJobScheduler, private val scheduler: TranslationJobScheduler,
private val coordinator: TranslationCoordinator,
private val contentTranslations: ContentTranslationRepository,
private val entityManager: EntityManager, private val entityManager: EntityManager,
private val transactionManager: PlatformTransactionManager private val transactionManager: PlatformTransactionManager
) { ) {
@@ -157,12 +160,15 @@ class TranslationJobRetryIntegrationTest @Autowired constructor(
} }
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
claimRepository, claimRepository,
TranslationMemoryService(
memoryRepository, memoryRepository,
TranslationCoordinator( TranslationCoordinator(
listOf(provider), listOf(provider),
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)), LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)),
memoryRepository memoryRepository
), ),
transactionManager
),
Mockito.mock(TranslationReadModelMaterializer::class.java), Mockito.mock(TranslationReadModelMaterializer::class.java),
transactionManager transactionManager
) )
@@ -246,7 +252,7 @@ class TranslationJobRetryIntegrationTest @Autowired constructor(
) )
try { try {
transaction.executeWithoutResult { transaction.executeWithoutResult {
schedule(TranslationJobScheduler(interleavingRepository)) schedule(TranslationJobScheduler(interleavingRepository, coordinator, contentTranslations))
} }
val claimed = repository.findAll().single() val claimed = repository.findAll().single()
@@ -1,5 +1,6 @@
package kr.co.vividnext.sodalive.i18n.translation package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotNull import org.junit.jupiter.api.Assertions.assertNotNull
import org.junit.jupiter.api.Test import org.junit.jupiter.api.Test
@@ -7,10 +8,13 @@ import org.mockito.ArgumentCaptor
import org.mockito.Mockito import org.mockito.Mockito
class TranslationJobSchedulerTest { class TranslationJobSchedulerTest {
private val coordinator = Mockito.mock(TranslationCoordinator::class.java)
private val contentTranslations = Mockito.mock(ContentTranslationRepository::class.java)
@Test @Test
fun shouldCreateOnePendingJobForMissingNormalizedText() { fun shouldCreateOnePendingJobForMissingNormalizedText() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java) val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository) val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
Mockito.`when`( Mockito.`when`(
jobRepository.findActiveJob( jobRepository.findActiveJob(
@@ -49,7 +53,7 @@ class TranslationJobSchedulerTest {
@Test @Test
fun shouldNotCreateDuplicateJobWhenSameCompletedJobAlreadyExists() { fun shouldNotCreateDuplicateJobWhenSameCompletedJobAlreadyExists() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java) val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository) val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
val sourceHash = SourceTextNormalizer.hash("제목") val sourceHash = SourceTextNormalizer.hash("제목")
Mockito.`when`( Mockito.`when`(
@@ -88,7 +92,7 @@ class TranslationJobSchedulerTest {
@Test @Test
fun shouldNotCreateJobWhenSourceLanguageIsUnsupported() { fun shouldNotCreateJobWhenSourceLanguageIsUnsupported() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java) val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository) val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
scheduler.scheduleMissingTranslation( scheduler.scheduleMissingTranslation(
resourceType = LanguageTranslationTargetType.CONTENT, resourceType = LanguageTranslationTargetType.CONTENT,
@@ -0,0 +1,22 @@
package kr.co.vividnext.sodalive.i18n.translation
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.context.annotation.Bean
@TestConfiguration
class TranslationJobSchedulerTestConfiguration {
@Bean
@ConditionalOnMissingBean(TranslationCoordinator::class)
fun translationCoordinator(memories: TranslationMemoryRepository): TranslationCoordinator = TranslationCoordinator(
listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO).map { id ->
object : TranslationProvider {
override val providerId = id
override val providerVersion = "test"
override fun translate(request: TranslateRequest): TranslateResult = error("unexpected paid translation")
}
},
LanguageProviderProperties(),
memories
)
}
@@ -35,12 +35,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, provider),
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -63,12 +58,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, provider),
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -97,12 +87,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, provider),
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -146,12 +131,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, provider),
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -186,12 +166,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, provider),
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -229,12 +204,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, provider),
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -266,12 +236,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java) val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker( val worker = TranslationJobWorker(
translationJobRepository = jobRepository, translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository, translationMemoryService = memoryService(memoryRepository, successfulProvider()),
translationCoordinator = TranslationCoordinator(
listOf(successfulProvider()),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
materializer = materializer, materializer = materializer,
transactionManager = TestTransactionManager() transactionManager = TestTransactionManager()
) )
@@ -307,6 +272,12 @@ class TranslationJobWorkerTest {
) )
} }
private fun memoryService(repository: TranslationMemoryRepository, provider: TranslationProvider) = TranslationMemoryService(
repository,
TranslationCoordinator(listOf(provider), LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)), repository),
TestTransactionManager()
)
private fun successfulProvider(): TranslationProvider { private fun successfulProvider(): TranslationProvider {
return object : TranslationProvider { return object : TranslationProvider {
override val providerId: LanguageProviderId = LanguageProviderId.PAPAGO override val providerId: LanguageProviderId = LanguageProviderId.PAPAGO
@@ -28,6 +28,7 @@ import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTestConfiguration
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor
import kr.co.vividnext.sodalive.member.Member import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole import kr.co.vividnext.sodalive.member.MemberRole
@@ -61,6 +62,7 @@ import javax.persistence.EntityManager
ResourceTranslationJobScheduler::class, ResourceTranslationJobScheduler::class,
TranslationSourceExtractor::class, TranslationSourceExtractor::class,
TranslationJobScheduler::class, TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class,
AudioContentThemeQueryRepository::class AudioContentThemeQueryRepository::class
) )
@Transactional(propagation = Propagation.NOT_SUPPORTED) @Transactional(propagation = Propagation.NOT_SUPPORTED)
@@ -729,7 +729,11 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
materializer = persistentMaterializer(sourceExtractor), materializer = persistentMaterializer(sourceExtractor),
resourceTranslationJobScheduler = ResourceTranslationJobScheduler( resourceTranslationJobScheduler = ResourceTranslationJobScheduler(
sourceExtractor, sourceExtractor,
TranslationJobScheduler(translationJobRepository), TranslationJobScheduler(
translationJobRepository,
Mockito.mock(TranslationCoordinator::class.java),
Mockito.mock(ContentTranslationRepository::class.java)
),
translationJobRepository translationJobRepository
), ),
applicationEventPublisher = applicationEventPublisher, applicationEventPublisher = applicationEventPublisher,