Compare commits

..
27 Commits
Author SHA1 Message Date
klaus 1ab4086740 Merge pull request '콘텐츠, 시리즈 번역 로직 수정' (#472) from test into main
Reviewed-on: #472
2026-11-17 06:31:44 +00:00
klaus d436fd6bff docs(i18n): 시리즈 상세 동기 번역 요구사항과 검증 결과를 기록한다 2026-11-17 14:35:28 +09:00
klaus 536a5a6fe5 feat(content): 시리즈 상세의 언어 감지와 번역을 동기로 완료한다 2026-11-17 14:35:15 +09:00
klaus 9cadaa919b docs(i18n): 연관 콘텐츠 제목 번역 요구사항과 검증 결과를 기록한다 2026-11-17 13:17:11 +09:00
klaus 0796b2b4fb fix(content): 상세 연관 콘텐츠에 요청 언어의 저장된 제목을 적용한다 2026-11-17 13:17:01 +09:00
klaus 85d6a14c40 docs(i18n): 상세 동기 번역 요구사항과 검증 결과를 기록한다 2026-11-17 12:07:17 +09:00
klaus ff30ebacc5 feat(content): 상세 조회에서 번역을 동기로 완료해 반환한다 2026-11-17 12:07:03 +09:00
klaus 2da499f716 docs(i18n): 상세 조회 언어 감지 요구사항과 검증 결과를 기록한다 2026-11-17 10:39:03 +09:00
klaus ecace9ba67 fix(content): 상세 조회에서 미감지 언어의 감지를 요청한다 2026-11-17 10:38:51 +09:00
klaus f7f6ab6864 docs(i18n): 태그 번역 정책과 복구 검증 결과를 기록한다 2026-11-17 09:56:34 +09:00
klaus 55669c4465 fix(i18n): 콘텐츠 태그 미번역을 Papago로 전환하고 완료 작업을 복구한다 2026-11-17 09:56:19 +09:00
klaus cd4667813a docs(i18n): 콘텐츠 태그 미번역 복구 요구사항과 계획을 기록한다 2026-11-17 09:56:00 +09:00
klaus d62980bff7 Merge pull request 'Test' (#471) from test into main
Reviewed-on: #471
2026-11-16 13:21:57 +00:00
klaus ba7bc81ac7 docs(i18n): 메타데이터 번역 검증 결과와 실행 명령을 기록한다 2026-11-16 21:48:38 +09:00
klaus 081f22b2c0 fix(i18n): 메타데이터 조회와 요청에서 현재 원문의 실패 번역을 재개한다 2026-11-16 21:47:54 +09:00
klaus d1c9f3a3d8 fix(content): 언어 감지와 관리자 수정 시 번역 작업 누락을 막는다 2026-11-16 21:47:05 +09:00
klaus 3ed79f2acb fix(i18n): 번역 작업을 1초 주기로 처리하고 실패 작업을 재개한다 2026-11-16 21:46:24 +09:00
klaus ed37990e2b feat(i18n): 언어 감지와 번역에 AWS를 우선 사용한다 2026-11-16 21:46:11 +09:00
klaus 309f794168 docs(i18n): 메타데이터 번역 신속 반영 요구사항과 계획을 기록한다 2026-11-16 21:46:00 +09:00
klaus eec5a80284 Merge pull request 'Test' (#470) from test into main
Reviewed-on: #470
2026-11-11 07:29:03 +00:00
klaus 5eee580aaf docs(subtitle): 컬럼 매핑 검증 결과와 배포 조건을 정정한다 2026-11-11 10:58:20 +09:00
klaus c3e5f19cb3 fix(subtitle): S3 컬럼명을 기존 스키마와 일치시킨다 2026-11-11 10:57:52 +09:00
klaus cf31c5702c docs(subtitle): 컬럼명 회귀 수정 요구사항과 검증 기록을 추가한다 2026-11-11 10:57:42 +09:00
klaus 4c1d876d5e docs(subtitle): 자막 연동 검증과 배포 조건을 기록한다 2026-11-11 08:35:29 +09:00
klaus 9c1c544e45 feat(subtitle): 업로드와 BOT 콜백 및 자막 응답을 연동한다 2026-11-11 08:34:54 +09:00
klaus e097e27ac6 feat(subtitle): 자막 작업 저장 구조와 계약을 추가한다 2026-11-11 08:33:52 +09:00
klaus cc85322eb5 docs(subtitle): 자막 연동 요구사항과 구현 계획을 기록한다 2026-11-11 08:33:40 +09:00
95 changed files with 8368 additions and 451 deletions
@@ -4,7 +4,7 @@
감지 구현체는 `PapagoLanguageDetectionProvider`와 `AwsLanguageDetectionProvider`,
번역 구현체는 `PapagoTranslationService`와 `AwsTranslationService`다.
두 기능의 production 기본 순서는 모두 `PAPAGO → AWS`다. AWS는 기존 자격 증명과 리전 설정을 재사용한다.
production 기본 순서는 감지와 번역 모두 `AWS → PAPAGO`다. AWS는 기존 자격 증명과 리전 설정을 재사용한다.
감지와 번역은 별도 capability다. 감지만 또는 번역만 제공하는 공급자도 등록할 수 있다.
두 capability에서 같은 `providerId`를 쓰는 것은 가능하지만, 한 capability 안의 ID 중복은 시작 시 거부한다.
@@ -47,12 +47,12 @@ ko/en/ja 서비스 정책은 `TranslationLanguages`에 있으며 공급자를
production 순서의 유일한 편집 지점은
`src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`다.
목록의 왼쪽부터 사용하며 기본값은 두 기능 모두 `listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)`다.
목록의 왼쪽부터 사용하며 감지와 번역의 기본 순서는 다음과 같다.
```kotlin
object LanguageProviderOrder {
val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
}
```
@@ -61,11 +61,11 @@ Spring은 `@Autowired` 기본 생성자로 위 목록을 읽는다. 문자열
테스트에서는 전역 목록을 변경하지 않고
`LanguageProviderProperties(List<LanguageProviderId>, List<LanguageProviderId>)`로 만든 테스트 bean을 주입한다.
다음은 감지만 AWS 우선으로 바꾸는 예시다. 현재 기본 순서를 뜻하지 않는다.
다음은 감지만 Papago 우선으로 바꾸는 예시다. 현재 기본 순서를 뜻하지 않는다.
```kotlin
val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
```
감지만 순서를 바꾸어도 번역 순서는 바뀌지 않는다. 반대로 번역만 바꿀 수도 있다.
@@ -99,6 +99,10 @@ coordinator/cache/worker의 DB 조회·저장 접점에서만 `providerId.code`
## 캐시와 오류 계약
콘텐츠의 `tags` 작업은 원문과 쉼표 요소별 정규화 결과가 같은 AWS 응답을 성공으로 인정하지 않고 Papago로 넘긴다.
같은 AWS 캐시도 이 필드의 worker/materializer에서는 사용하지 않는다. Papago가 원문과 같은 값을 반환하면 성공으로 인정한다.
일반 제목/본문과 다른 리소스의 필드에는 이 추가 판정을 적용하지 않으며, 원문 hash와 저장 캐시는 일괄 변경하지 않는다.
감지는 정규화/hash/normalization version을 기존과 같이 사용하고 adapter에는 원래 query를 전달한다.
설정된 모든 공급자의 캐시를 순서대로 조회한 뒤, 유효 캐시가 하나도 없을 때만 외부 호출을 시작한다.
저장은 실제 성공 공급자로 `insertIfAbsent`하고 이어지는 locking read의 승자를 반환한다.
@@ -123,7 +127,7 @@ adapter 예외·null 감지·빈 감지·번역 결과 개수 불일치·blank
| 테스트 | 검증 내용 |
|---|---|
| `LanguageProviderSpringConfigurationTest` | production 기본 생성자와 PAPAGO 우선 성공, 과거 property/env 무시, 독립 순서와 잘못된 목록의 시작 실패; fake AWS context와 실제 adapter + SDK mock context 분리 |
| `LanguageProviderSpringConfigurationTest` | production 기본 생성자와 AWS 우선 성공, 과거 property/env 무시, 독립 순서와 잘못된 목록의 시작 실패; fake AWS context와 실제 adapter + SDK mock context 분리 |
| `LanguageProviderIdTest` | 런타임 enum getter 계약, 안정적인 papago/aws code, production 기본값과 실제 adapter ID |
| `LanguageProviderPropertiesTest` | 순서 검증 및 선택되지 않은 bean을 포함한 capability 내 중복 ID 거부 |
| `LanguageDetectionProviderTest` / `TranslationCoordinatorTest` | 전체 요청 폴백, 첫 성공 중단, cache-first, 안전한 전체 실패, DB 오류 전파 |
@@ -0,0 +1,146 @@
# 자막 Phase 1 배포 게이트
**현재 판정: 배포 BLOCKED.** 이 문서는 로컬 저장 계약과 배포 전 확인 항목이며 DB 적용·AWS 배포 증거가 아니다.
기준일은 2026-11-10이며 [PRD](prd.md), [구현 계획](plan-task.md), [DDL](subtitle-schema.sql)을 함께 본다.
## 1. 검토 기준과 파일 경계
- persistence 기준 경로: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/`.
- 실제 읽은 파일: `SubtitleJob.kt`, `Subtitle.kt`, `SubtitleCallbackReceipt.kt` 및 세 repository.
- 콘텐츠 기준: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContent.kt`, `common/BaseEntity.kt`.
- `src/main/resources/application.yml`의 `MySQL8Dialect`·`ddl-auto: validate`는 로컬 설정 근거일 뿐 운영 DB 증거가 아니다.
- 문서 담당은 이 문서와 DDL만 작성한다. 병렬 Kotlin 구현의 최종 엔티티 대조는 상위 구현 게이트에서 다시 수행한다.
## 2. 저장 계약 대조
물리명은 기존 Spring snake_case 매핑 기준이다. 길이 미지정 `String`은 JPA 기본 `VARCHAR(255)`를 따른다.
`jobId`는 UUID **문자열**이며 `BINARY(16)`으로 바꾸지 않는다. `N`은 NOT NULL, `Y`는 NULL 허용이다.
| `SubtitleJob.kt` 속성 | DDL 컬럼·타입 | NULL |
|---|---|---|
| `jobId` | `job_id VARCHAR(36)` PK | N |
| `contentId` | `content_id BIGINT` signed | N |
| `sourceBucket`, `sourceKey` | `source_bucket`, `source_key VARCHAR(255)`; 전체 두 컬럼 unique | N |
| `outputKey` | `output_key VARCHAR(255)` | N |
| `status` | `status VARCHAR(32)`; enum STRING | N |
| `errorCode` | `error_code VARCHAR(255)` | Y |
| `errorMessage` | `error_message TEXT` | Y |
| `sourceUploadErrorCode` | `source_upload_error_code VARCHAR(255)` | Y |
| `sourceUploadErrorAt` | `source_upload_error_at TIMESTAMP`; 명시적 JPA TIMESTAMP | Y |
| `createdAt`, `updatedAt` | `created_at`, `updated_at TIMESTAMP` | N |
| `Subtitle.kt` 속성 | DDL 컬럼·타입 | NULL |
|---|---|---|
| `id` | `id BIGINT` signed PK AUTO_INCREMENT | N |
| `jobId` | `job_id VARCHAR(36)` FK → `subtitle_job.job_id` | N |
| `language` | `language VARCHAR(35)`; `(job_id, language)` unique | N |
| `format` | `format VARCHAR(16)` | N |
| `s3Bucket`, `s3Key` | `s3_bucket`, `s3_key VARCHAR(255)` | N |
2026-11-11 정정: 이전 정적 대조는 `s3Bucket`의 숫자 경계 명명 규칙을 놓쳤다. 기본 naming strategy가
`s3bucket`/`s3key`로 추론하므로 두 필드에 명시적 `@Column(name = "s3_bucket"/"s3_key")`가 필요하다.
`P3-R1`에서 실제 `validate` 실패를 재현한 뒤 두 이름을 명시해 H2 validation/저장/재조회를 통과했다.
독립 리뷰도 승인했다. 운영 DB에 `s3bucket` 컬럼을 추가한 것이 아니며 실 MySQL 기동은 별도 확인 대상이다.
| 기존 엔티티 속성 | DDL 컬럼·타입 | NULL |
|---|---|---|
| `SubtitleCallbackReceipt.eventId` | `event_id VARCHAR(255)` PK; UUID 제한 없음 | N |
| `SubtitleCallbackReceipt.jobId` | `job_id VARCHAR(36)` | N |
| `SubtitleCallbackReceipt.bodyHash` | `body_hash VARCHAR(64)` | N |
| `SubtitleCallbackReceipt.createdAt` | `created_at TIMESTAMP` | N |
| `AudioContent.latestSubtitleJobId` | `content.latest_subtitle_job_id VARCHAR(36)` | Y |
### 미확정 차이와 적용 전 대조
1. 마지막 정적 대조에서 `Subtitle.kt`의 테이블명·6개 컬럼·길이·nullable·IDENTITY PK·unique가 합의 계약과 일치했다.
`SubtitleJob.kt`에서도 `koKey`/`jaKey` 제거를 확인했다. `Subtitle.jobId`는 scalar이고 JPA 관계/FK 선언은 없다.
DDL의 `subtitle.job_id` FK는 합의 계약에 따른 DB 제약이며 ORM 관계 선언 확인으로 보고하지 않는다.
`subtitle_job` CREATE에 `ko_key`/`ja_key`는 넣지 않는다. 미출시 초안 교체이며 기존 데이터 이관·컬럼 삭제 SQL은 없다.
2. 최초 대조에서는 `sourceUploadErrorAt`에 `columnDefinition`이 없어 차이로 기록했다.
최종 구현은 `@Column(columnDefinition = "TIMESTAMP")`와 초 절삭을 명시했고 부모가 DDL과 다시 대조했다.
이 로컬 mapping 차이는 해소됐지만 실제 MySQL schema 적용·왕복 검증은 여전히 운영 게이트다.
3. 나머지 시각은 엔티티의 명시적 `TIMESTAMP`와 초 절삭을 따른다. DDL 소수초 정밀도는 모두 0이다.
`created_at`은 `DEFAULT CURRENT_TIMESTAMP`, job의 `updated_at`은 같은 기본값과 `ON UPDATE CURRENT_TIMESTAMP`다.
`Subtitle.kt`에는 시각이나 `BaseEntity` 상속이 없으므로 결과 행에 임의 시각 컬럼을 추가하지 않는다.
UTC 생성값과 JDBC/session timezone 및 실제 MySQL 왕복은 미검증이다.
4. `AudioContent`는 `content` 테이블이며 `BaseEntity.id: Long?`의 IDENTITY를 상속한다.
신규 `content_id`는 signed BIGINT로 맞췄지만 운영 `content.id`의 실제 타입·부호·엔진은 확인하지 않았다.
합의된 `subtitle.job_id` FK만 둔다. receipt의 jobId 및 콘텐츠 연결은 현재 scalar 매핑이므로 FK를 임의 추가하지 않는다.
FK cascade는 없으며 기본 RESTRICT다. `(job_id, language)` unique가 결과 FK와 작업별 조회 인덱스를 겸한다.
5. 현재 callback 활성화는 `ko-KR`/`ja-JP`, 형식은 `SRT`, 결과 2/1/0개의 상태 판정은 그대로다.
저장 구조만 언어별 행으로 바꾼다. 새 언어 활성화·재생성·새 관리 API·recovery 상태/테이블은 추가하지 않는다.
### 식별자와 인덱스 전제
- 세 신규 테이블과 최신 job 컬럼은 `utf8mb4_0900_bin`을 쓴다. 대소문자·후행 공백을 구별하는 NO PAD 비교다.
eventId 및 bucket/key의 정확한 식별에 case-insensitive collation이나 PAD SPACE인 `utf8mb4_bin`을 대신 쓰지 않는다.
- MySQL 8.0.17 이상 및 해당 collation의 binary/NO PAD 속성, InnoDB DYNAMIC·3072-byte 키 지원을 운영자가 확인한다.
16 KiB 이상 InnoDB page를 전제로 하며 4/8 KiB page 환경의 적합성을 주장하지 않는다.
- source unique 최대 키 데이터는 `(255 + 255) × 4 = 2040` bytes다. eventId PK는 `255 × 4 = 1020` bytes다.
결과 unique는 `(36 + 35) × 4 = 284` bytes다. 보조 인덱스의 PK 포함분도 3072 bytes 미만이다.
prefix unique나 해시 식별자로 원래 bucket/key를 대체하지 않는다.
- 경로 컬럼은 현재 UUID 기반 계약에 맞는 `VARCHAR(255)`이며 일반 S3 최대 길이 전체 지원을 뜻하지 않는다.
job의 `(content_id, created_at)` 인덱스는 현재 `findFirstByContentIdOrderByCreatedAtAsc` 조회에 대응한다.
## 3. Lambda handoff와 실제 환경 구분
아래 SHA-256은 **PRD §2의 기존 조사 기록 인용**이다. 문서 담당이 외부 저장소·ZIP·AWS를 다시 조회한 결과가 아니다.
원본 보고서 참조는 PRD에 적힌 `aws-subtitle-service/docs/FINAL_REPORT.md`다.
| 정확한 artifact | SHA-256 |
|---|---|
| `start-subtitle-transcription.zip` | `a0d0b19b2ecb24c0f89caf528bf09fd039558563a99063f082ac64418704abfd` |
| `generate-subtitle.zip` | `bfa8742ca436bace853ec2540fc5f70daa24cbab49e75315565d980189fbf209` |
로컬 artifact 일치 기록은 운영 함수 버전/alias·event routing·consumer·in-flight·Scheduler·DB 적용 증거가 아니다.
자격 증명/JWT/raw body 값은 이 문서나 증거 보고서에 기록하지 않는다.
## 4. 운영 차단 항목
| 게이트 | 현재 | 해제에 필요한 증거 |
|---|---|---|
| 최종 엔티티·DB | BLOCKED | 위 차이 해소, 운영 기존 스키마·버전·collation·인덱스 확인, 별도 DDL 승인·적용 기록 |
| consumer·조정 배포 | BLOCKED | 운영자 inventory, 실행 중일 때만 pause/drain, backend·정확한 두 Lambda의 조정 배포 기록 |
| MediaConvert·CloudFront | BLOCKED | UUID 입력의 ID 추출/출력 확장자 및 private origin·서명 URL 실환경 검증 |
| controlled live | BLOCKED | ko/ja/mixed의 실제 S3 → callback → 콘텐츠/앱 결과와 word/item 언어 증거 |
| 대표 2시간 입력 | BLOCKED·미측정 | 신뢰 가능한 duration 근거 및 대표 입력의 전체 처리 예산 실측 |
### 운영자 실행 순서: 별도 승인 후에만
1. 운영 consumer·event routing·함수 버전/alias·in-flight·기존 DB 상태를 inventory로 확정한다.
실행 중인 consumer가 있을 때만 신규 유입을 pause하고 기존 작업·callback을 drain하는 전환 구간을 조율한다.
실행 중인 대상이 없으면 그 증거와 함께 pause/drain을 생략한다. 미확인 상태를 비가동으로 간주하지 않는다.
2. 최종 JPA와 실제 `SHOW CREATE TABLE`·collation·인덱스 전제를 대조하고 DB 변경을 별도 승인받는다.
기존 동명 테이블/컬럼이 있으면 중단하고 차이를 검토한다. `IF NOT EXISTS`로 불일치를 숨기지 않는다.
additive DDL 승인·적용 확인과 Phase 1 backend/두 Lambda의 배포를 같은 전환 계획으로 조율한다.
구·신 consumer의 중복 실행이나 호환성 미확인 in-flight를 남긴 채 재개하지 않는다.
3. UUID 원본 `input/{contentId}/{UUID filename}`으로 외부 MediaConvert의 contentId 추출 규칙을 확인한다.
등록은 안전한 실제 파일 확장자를 UUID 뒤에 보존한다. 실제 START ZIP은 지원 확장자를 검사하므로
누락/미지원 확장자의 자막 성공을 주장하지 않는다. 이를 위해 기존 업로드를 거부하거나 파일을 허위 변환하지 않는다.
출력 경로·실제 확장자·완료 callback·기존 preview/알림 흐름의 호환 증거가 필요하다.
로컬 `matchesOutput`의 허용 확장자는 `aac`/`m4a`/`mp3`이나 실제 외부 출력 계약이 확인된 것은 아니다.
자막 bucket/key가 기존 private CloudFront origin/path에 정확히 매핑되고 권한 있는 사용자만 서명 URL로
열람하는지 확인한다. 두 항목 모두 현재 미검증이며 임의 prefix 허용이나 공개 S3 URL로 우회하지 않는다.
현재 Spring의 자막 bucket allowlist는 기존 `cloud.aws.s3.content-bucket` 한 개다.
Lambda `MEDIA_BUCKET`과 `SUBTITLE_BUCKET`도 이 값에 맞춰야 하며, 별도 자막 bucket을 쓰려면
allowlist와 CloudFront origin 계약을 먼저 변경·검증해야 한다. 현재 구현이 다중 bucket을 지원한다고 보지 않는다.
4. 일반 유입을 재개하기 전에 controlled ko/ja/mixed live를 수행한다.
S3 source binding, Transcribe 실제 word/item 언어, 결과 SRT, BOT callback, 언어별 콘텐츠/앱 표시를 연결해 기록한다.
mixed는 실제 word/item 언어 증거가 필수이며 synthetic fixture나 HTTP metadata 검증으로 대체할 수 없다.
유료 preview-only 사용자의 전체 자막 차단과 private 접근도 확인한다.
5. 신뢰 가능한 기존 duration의 가용성과 입력 검증 경계를 확인하고 대표 2시간 입력의 처리 예산을 실측한다.
구형/검증 불가능 원본은 수동 게이트로 남기며 임의 client duration을 신뢰하지 않는다.
2시간은 입력 목표이지 SLA/지원 보장이 아니다. 미측정 상태에서 지원 또는 재개 승인을 하지 않는다.
모든 차단 항목의 증거와 승인자를 기록한 뒤에만 일반 유입을 재개한다.
purge·데이터 정리·적용 migration 수정·Scheduler fallback·자동 복구·Translate 50-call 정책은 이 절차에 없다.
재생성 전체와 새 언어 활성화 역시 제외한다. 미해결 작업을 삭제하거나 성공 처리해 drain을 가장하지 않는다.
## 5. 문서 담당 검증 경계
문서 간 계약·실제 엔티티 속성·컬럼별 COMMENT·테이블 COMMENT·SQL 종류·공백을 read/rg로 정적으로 대조했다.
DDL은 CREATE TABLE 3개와 ALTER TABLE ADD COLUMN 1개뿐이며 23개 신규 컬럼·3개 신규 테이블에 COMMENT가 있다.
후행 공백·탭·CR·130자 초과 행은 발견하지 않았다. SQL 파싱/실행이나 물리 스키마 호환성을 검증한 결과가 아니다.
이 담당은 테스트·빌드·DB 실행·AWS 접근·외부 저장소 조회를 하지 않으며 성공 결과를 주장하지 않는다.
상위 구현 검증도 이번 작업에서 새로 작성한 테스트만 실행하도록 승인되어 있다. 기존 테스트 실행은 승인 범위가 아니다.
로컬 HTTP·새 테스트·빌드 결과는 구현 담당의 별도 증거이며, 그 성공도 위 운영 게이트를 해제하지 않는다.
@@ -0,0 +1,132 @@
# 자막 Phase 1 Spring 구현 검증 기록
> 상태: **재생성 제외 로컬 backend 구현·신규 테스트 15개·독립 리뷰 완료**. 운영 배포 완료가 아니다.
## 범위와 결정
- 이번 범위: 기존 업로드의 PENDING/source 선등록, 네 BOT 내부 endpoint, raw-body receipt, 기존 상세의 언어·권한별 자막 제공.
- 재생성은 사용자 결정으로 제외했다. 새 공개 재생성 API, 직접 START 호출, Scheduler/outbox를 만들지 않는다.
- 후속 요구로 언어별 결과는 `Subtitle` 행에 저장한다. 이번 callback 허용 언어/완료 판정은 ko/ja만 유지하며 다른 언어를 활성화하지 않는다.
- 테스트 실행은 사용자 후속 지시 이후 **이번 작업에서 새로 작성한 테스트만** 대상으로 한다. 기존 클래스에 추가한 사례도 메서드 selector로 한정한다.
## 실제 조사와 보존
- 현재 Spring에 subtitle/recovery/자막 HMAC/재생성 action이 발견되지 않았다. 제거할 해당 코드가 없으므로 실제 삭제 없음.
- 공유 member login/JWT/MemberRole.BOT, Agora HMAC, 텍스트 TranslationJob/worker, S3Uploader와 기존 MediaConvert 관련 외부 코드/설정은 보존 대상이다.
- 기존 MediaConvert 완료 API의 ADMIN/BOT 권한은 유지한다. 새 원본 UUID에 대한 source-bound 경로 검증과 기존 파일 검증을 구분한다. 실제 consumer ID 추출·출력 규칙 호환성은 운영 확인 전 배포 BLOCKED다.
- Flyway/Liquibase 의존성 및 자막 migration은 현재 프로젝트에서 발견되지 않았다. 운영/공유 환경의 적용 schema/data 상태는 조회하지 않았다. additive SQL 문서만 준비하며 DB에는 적용하지 않는다.
## Lambda와 운영 전환
명시된 `aws-subtitle-service/docs/FINAL_REPORT.md`와 실제 로컬 ZIP을 대조했다.
| 산출물 | SHA-256 |
|---|---|
| `start-subtitle-transcription.zip` | `a0d0b19b2ecb24c0f89caf528bf09fd039558563a99063f082ac64418704abfd` |
| `generate-subtitle.zip` | `bfa8742ca436bace853ec2540fc5f70daa24cbab49e75315565d980189fbf209` |
파일 hash 일치는 AWS 배포 증거가 아니다. 운영 legacy consumer/caller/in-flight/Scheduler/배포 버전은 미확인이다. AWS 호출·설정·배포·중지·삭제·재개를 수행하지 않았다. 운영자는 inventory 후 실제 가동 중인 경우에만 pause/drain하고 Phase 1 backend/Lambda를 조정 배포해야 한다. S3/DB purge나 legacy fake work API는 금지한다.
## 실행 기록
| 시점 | 명령/검증 | 관찰 결과 |
|---|---|---|
| 테스트 범위 변경 지시 전 | 기존 `AudioContentServiceTest`, `MemberLoginResponseContractTest`, `TokenProviderTest` focused baseline | 부모 실행은 kapt 단계 200초 제한 종료, 테스트 판정 없음 |
| 테스트 범위 변경 지시 전 | 구현 담당자의 격리 focused 시도 | `red-focused.log`: 41 cases 중 새 사례의 JWT key setup 1건 실패. 기능 RED로 인정하지 않음. 기존 테스트 실행은 이후 중단 |
| RED | 새 `SubtitleHttpIntegrationTest.shouldRejectActualNonBotLoginJwt` | `red-http.log`: 실제 로그인한 non-BOT의 자막 접근 차단 실패를 재현. 최종 GREEN 아님 |
| 1차 새 테스트/HTTP | 부모가 신규 `SubtitleHttpIntegrationTest` 직접 재실행 | **13 passed, failures/errors/skipped 0**. XML timestamp `2026-11-10T14:33:59`, `BUILD SUCCESSFUL in 2m 21s` |
| bootJar/변경 범위 lint | 구현 담당 실제 실행 및 부모 같은 코드 재확인 | `build-lint.log`: `BUILD SUCCESSFUL in 1m 28s`; 부모 재확인은 UP-TO-DATE |
| 리뷰 수정 RED | 신규 HTTP 2개 | 빈 body 422 기대/200 실제, DB 실패 500 기대/200 실제 확인 |
| 최종 새 테스트/빌드/lint | `P1-R1` 수정 후 신규 자막 클래스 전체 | **15 passed, failures/errors/skipped 0**, bootJar/변경 lint 실제 실행 성공, 7m44s |
| 부모 최종 HTTP 재검증 | 추가된 새 2개 메서드만 직접 실행 | **2 passed**, 422/500 및 전체 rollback 확인. XML timestamp `2026-11-10T15:34:43`, 4m55s |
| 독립 리뷰 | 1차 REQUEST_CHANGES 1건 수정 후 delta 재검토 | **REV-P1-001 ADDRESSED / 로컬 backend APPROVE**, 추가 blocker 없음 |
테스트 fixture는 로컬 합성 데이터와 H2, 실제 localhost HTTP, 외부 S3/서명 경계 대체를 사용한다. 실제 음성 또는 live S3 품질 검증이 아니다. LSP diagnostics 도구가 제공되지 않아 실제 Kotlin compile/lint 결과를 대체 증거로 기록했으며 LSP 성공을 주장하지 않는다.
실제 검증한 HTTP 결과: BOT 허용 및 non-BOT 403/익명 401, unknown 404, callback 수락/replay 200,
같은 eventId의 변경 body 422, terminal 다른 결과 409, 동시 receipt 경합 200/422 및 loser rollback.
기존 콘텐츠 상세에서 preview-only의 자막 null, 구매/소유자/무료 및 공개 시점별 ko/ja 선택을 검증했다.
동일 job 결과는 언어별 행 ID를 보존하며, 이전 job 완료가 최신 선택값을 바꾸지 않는 것을 확인했다.
실제 HTTP 증거는 테스트 JVM PID `23390`, Tomcat `127.0.0.1:59074`, XML timestamp
`2026-11-10T14:33:59`다. 실행 후 `ps -p 23390,20950,22207`, `lsof -iTCP:59074 -sTCP:LISTEN`,
작업 root를 대상으로 한 `pgrep`에서 남은 프로세스/listener가 없음을 확인했다. 임시 산출물은 리뷰 후 정리했다.
후속 HTTP 검증은 PID `44707`, Tomcat port `59977`에서 실행했다. 빈 callback/started는 422이고,
receipt 저장 실패는 `{"error":"Subtitle request failed"}`와 500을 반환하며 상태/오류/결과/receipt가 rollback된다.
구현 담당의 첫 GREEN은 컴파일 600초 제한으로 종료됐으나 캐시 재사용 후 성공했다. 실패 이력은 삭제하지 않았다.
후속 PID `44707`/`28638`/`37727`/`39291`, port `59977`, 작업 root 참조 프로세스의 부재도 확인했다.
## 내부 API와 저장 구조
| Method | Path |
|---|---|
| GET | `/internal/api/subtitle-jobs/resolve` |
| GET | `/internal/api/subtitle-jobs/{jobId}` |
| POST | `/internal/api/subtitle-jobs/{jobId}/started` |
| POST | `/internal/api/subtitle-jobs/callback` |
네 API는 기존 로그인 JWT와 활성 DB BOT role을 요구한다. 조회는 최소 DTO이며 callback은 원문 bytes hash를 사용한다.
`subtitle_job`, 언어별 `subtitle`, `subtitle_callback_receipt`와 `content.latest_subtitle_job_id`의
additive SQL만 작성했다. 실제 DB 적용은 하지 않았다. 미래 언어는 결과 행으로 저장할 수 있지만
현재 허용 언어는 ko/ja뿐이고 향후 Lambda·API·조회 정책 변경 없이 새 언어가 자동 활성화되지는 않는다.
공유 로그인/JWT/업로드/MediaConvert는 보존했다. 현재 저장소에는 삭제할 자막 recovery code가 없어서 삭제 파일은 0개다.
외부 프로젝트, AWS 리소스, 적용 migration 및 운영 데이터는 변경하지 않았다. commit/push도 수행하지 않았다.
전체 변경 경로·신규 case 이름·재현 명령·실패/수정 이력은 [implementation-report.md](implementation-report.md)에 있다.
로컬 mapping의 업로드 오류 시각 TIMESTAMP 불일치는 수정·대조했으나 운영 MySQL 실행 증거는 아니다.
테스트 전체 Spring context에서 기존 worker의 H2/MySQL 구문 차이 로그가 발생했다. 해당 worker 성공을 주장하지 않는다.
## 외부 차단 항목
| 항목 | 상태와 재개 조건 |
|---|---|
| 운영 DB | BLOCKED: 기존 schema 확인 및 additive DDL 승인·적용 필요 |
| old consumer coordination | BLOCKED: 원격 배포/사용/in-flight 조사와 운영자 조정 필요 |
| MediaConvert/CloudFront | BLOCKED: UUID ID 추출·출력 key 규칙 및 자막 private origin/서명 접근 확인 필요 |
| live ko/ja/mixed | BLOCKED: 승인된 실제 S3 입력부터 callback/콘텐츠/앱 표시 검증 필요. mixed는 실제 word/item 언어 evidence 필수 |
| 2시간 입력 목표 | BLOCKED: 실제 처리 시간/예산 미측정. 상한을 내리거나 SLA/지원 성공을 주장하지 않음 |
전체 테스트는 실행하지 않는다. 사용자가 별도로 전체 검증을 원하면 `./gradlew test`를 실행할 수 있다. 기존 회귀 미실행에 따른 잔여 위험은 새 기능 테스트 성공과 구분한다.
## 종료 정리와 재현
2026-11-11 리뷰 승인 후 이번 작업 소유 임시 root `subtitle-phase1.wiRcAJ`와 그 안의 build/cache/log/JAR를 제거했다.
`test ! -e` exit0으로 부재를 확인했고 공유 캐시·기존 worker는 변경하지 않았다. 위 임시 경로는 과거 검증 위치이며,
검증 결과와 실패 이력은 이 문서 및 구현/리뷰 보고서에 보존했다.
정상 개발 환경에서 이번에 작성한 테스트만 다시 실행하는 명령:
```bash
./gradlew test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest'
```
## 후속 완료: generate-url 자막 응답
2026-11-11 요청에 따라 `GET /audio-content/{id}/generate-url`에도 상세와 동일한 nullable `subtitle`을 추가했다.
기존 `contentUrl`과 활성 구매 검사/음원 URL 동작은 유지하며 자막만 요청 언어·완료 상태·공개 시점 조건을 따른다.
이번 후속에서 새로 작성한 HTTP3개만 실행했고 부모 재실행도 3/0/0/0으로 통과했다. 독립 리뷰 APPROVE다.
컴파일/bootJar/테스트 lint는 성공했으나 production lint는 시작 전부터 있던 서비스 EOF 공백1건을 지적해 보존했다.
이 결과를 기존15개를 포함한 클래스 전체 재실행 성공으로 표현하지 않는다.
상세 명령/선택자/응답 예시/잔여 게이트는 [generate-url-report.md](generate-url-report.md)에 있다.
## 후속 회귀: s3 컬럼 schema-validation
2026-11-11 실제 기동의 missing `[s3bucket]` 오류를 독립 H2 table과 Hibernate `validate`로 재현했다.
기본 명명전략이 숫자 경계를 분리하지 않는 것을 기존 정적 대조와 create-drop 테스트가 놓친 문제다.
`Subtitle`의 두 Column 이름만 `s3_bucket`, `s3_key`로 명시했고 DDL/운영 DB/JSON 계약은 바꾸지 않았다.
신규 회귀 테스트1개에서 validation과 Hibernate/JDBC 저장·재조회가 통과했으며 bootJar/변경 lint 및 독립 리뷰 APPROVE다.
실제 운영 MySQL 재기동은 수행하지 않았다. 상세 원인·검증은 [schema-validation-report.md](schema-validation-report.md)에 기록했다.
## 커밋 검증 후속 기록
2026-11-11 별도 사용자 `/commit-with-validation` 요청으로 변경을 커밋했다.
기능 연동 커밋은 pre-commit `ktlintCheck`에서 위에 기록된 서비스 EOF 빈 줄 1건으로 처음 거부됐다.
해당 빈 줄만 제거한 뒤 재시도하여 staged Kotlin 대상 lint, `git diff --staged --check` 및
`work/scripts/check-commit-message-rules.sh`의 커밋 직전·직후 검증이 통과했다.
기존 EOF 미해결 기록은 당시 상태이며 이 커밋 준비 과정에서 해소됐다.
이번 커밋 작업에서는 기능 테스트·전체 테스트·bootJar를 재실행하지 않았다.
기존 테스트 결과는 위 실행 시점의 기록이며 운영 배포 BLOCKED는 유지한다.
사용자가 전체 테스트를 실행할 때의 명령은 `./gradlew test`다.
@@ -0,0 +1,101 @@
# generate-url 자막 후속 구현 검증
## 범위와 결과
- 기준: `prd.md` §7, `plan-task.md` `P2-T1`. Phase 1은 재구현하지 않았다.
- 이번 production 변경은 `content/GenerateUrlResponse.kt`의 기존 DTO import/nullable 필드 추가와 `content/AudioContentService.kt`의 `generateUrl` 본문뿐이다. DTO는 `GenerateUrlResponse(contentUrl: String, subtitle: ContentSubtitleResponse? = null)`이다.
- 기존 `orderRepository.isExistOrdered`를 그대로 사용한다. 구매 없는 소유자/무료, 비활성 KEEP, 만료 RENTAL은 빈 `contentUrl`과 명시적 null `subtitle`이다. 활성 구매의 기존 음원 경로/만료 기간/envelope는 유지했다.
- 구매자는 하나의 `expirationTime`을 음원 서명과 `SubtitleJobService.subtitle(audioContent, langContext.lang, expirationTime)`에 전달한다. 자막만 미지정/도래한 공개일 또는 소유자 조건을 적용한다. 예약 구매자의 기존 음원 URL은 유지한다.
- 기존 `SubtitleHttpIntegrationTest`의 15개 메서드/도우미를 보존하고 HTTP 테스트 3개와 세 테스트가 공용으로 사용하는 요청 도우미 1개만 추가했다. 다른 dirty 파일, PRD/plan/final-report, controller/DB/Lambda는 수정하지 않았다.
## 새 HTTP 테스트
클래스: `kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest`. 실행은 아래 세 메서드 selector만 사용했다.
1. `shouldIncludeRequestedSubtitleInGenerateUrl`: 활성 KEEP 구매/공개 완료 ko·ja, 정확한 `{contentUrl,subtitle}` 및 자막 3필드, 상세와 동일한 자막, 음원/SRT 경로와 같은 14,400,000ms 서명 인자, 기존 success envelope.
2. `shouldReturnNullSubtitleInGenerateUrlWhenUnavailable`: PENDING/최신 job 미등록/부분 완료 ko 누락/미지원 en의 명시적 null과 음원 URL 보존, 부분 완료 ja 정상 제공.
3. `shouldPreserveGenerateUrlPurchaseAndReleaseRestrictions`: 미구매자·소유자·무료 및 비활성/만료 주문 차단, 활성 RENTAL 구매자의 예약 음원 URL 보존/자막 차단, 활성 구매 소유자의 예약 예외, 공개일 null/과거 허용, 익명 401.
실제 EMAIL 로그인/JWT, RANDOM_PORT Tomcat HTTP, H2와 기존 fixture/callback 도우미를 사용했다. 외부 S3/CloudFront 경계만 기존 mock을 재사용했다. 서명 URL은 전달 경로/만료 인자 검증이며 실제 CloudFront 암호학적 서명이나 다운로드 검증은 아니다.
## 명령과 증거
소유 root는 아래 `VERIFY_ROOT`다. build/project-cache/TMPDIR/Node/Bun 캐시를 격리했으며 init script는 production 소스를 필터링하지 않는다. 테스트 compile만 이 클래스와 필요한 support 3파일로 한정한다. `test.outputs.upToDateWhen { false }`로 실제 실행을 강제한다.
```bash
export VERIFY_ROOT=/var/folders/yh/8xsbvpsj5wg2qnxzxdp11_gm0000gn/T/opencode/generate-url-subtitle.fSBkJM/implementer
export TMPDIR="$VERIFY_ROOT/tmp" NODE_COMPILE_CACHE="$VERIFY_ROOT/node-cache"
export npm_config_cache="$VERIFY_ROOT/node-cache" BUN_INSTALL_CACHE_DIR="$VERIFY_ROOT/bun-cache"
export AWS_EC2_METADATA_DISABLED=true
G=(./gradlew --offline --no-daemon --max-workers=2
-Pkotlin.compiler.execution.strategy=in-process -Dorg.gradle.jvmargs=-Xmx4g
--project-cache-dir "$VERIFY_ROOT/project-cache"
--init-script "$VERIFY_ROOT/verification.init.gradle")
S=(--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldIncludeRequestedSubtitleInGenerateUrl'
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldReturnNullSubtitleInGenerateUrlWhenUnavailable'
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldPreserveGenerateUrlPurchaseAndReleaseRestrictions')
# RED: production 변경 전
"${G[@]}" test "${S[@]}" > "$VERIFY_ROOT/red-assertions.log" 2>&1
# 첫 GREEN
"${G[@]}" test "${S[@]}" ktlintCheck bootJar > "$VERIFY_ROOT/green-build-lint.log" 2>&1
# 입력 3파일을 고정/확인한 production+test lint
"${G[@]}" verifyLintScope ktlintCheck bootJar > "$VERIFY_ROOT/final-verified-scope-lint-build.log" 2>&1
# 기존 dirty EOF 보존 후 최종 HTTP/컴파일/테스트 lint/bootJar
"${G[@]}" test "${S[@]}" verifyLintScope ktlintTestSourceSetCheck bootJar > "$VERIFY_ROOT/final-green-build-test-lint.log" 2>&1
```
| 검증 | 결과/증거 |
|---|---|
| RED | exit 1, 50초, 3 tests/3 failures/0 errors/0 skipped. 모두 `has("subtitle")`에서 expected true/actual false. `red-assertions.log`, `red-summary.log` |
| 첫 GREEN | exit 0, `BUILD SUCCESSFUL in 3m 35s`, HTTP 3개 통과 및 compile/bootJar. lint의 정확한 입력 증거는 이후 고정한 실행을 기준으로 한다. |
| 정확한 변경 lint | 입력은 production 2파일+이 테스트 1파일, Kotlin script 0개임을 `verifyLintScope` assertion으로 확인. production lint는 **기존 EOF 빈 줄 1건 실패**: `AudioContentService.kt:1482:1 Needless blank line(s)`. 그 외 지적 없음. `final-verified-scope-lint-build.log` |
| 최종 GREEN | exit 0, `BUILD SUCCESSFUL in 3m 30s`, compileKotlin/compileTestKotlin/bootJar 실제 실행, 테스트 lint 통과. HTTP XML 3 tests/0 failures/0 errors/0 skipped, timestamp `2026-11-10T22:07:38` (UTC). `final-green-build-test-lint.log`, `green-summary.log` |
최초 임시 init의 상대 source 경로로 `test NO-SOURCE`가 된 `red.log`는 RED 증거가 아니다. `project.file`로 수정 후 실제 assertion RED를 확인했다. `final-scope-lint-build.log`도 lint scope introspection assertion 실패 기록이며 HTTP 실패가 아니다. 이후 init에서 lint 입력 파일을 명시적으로 고정하고 검증했다. 이 이력과 로그를 삭제하지 않았다.
## 보존 사항과 남은 게이트
- 시작 전 `git diff`에도 있던 서비스 EOF 빈 줄은 타 dirty 변경 보존 지시에 따라 유지했다. `git diff --check` 역시 같은 EOF 1건을 지적하므로 lint 전체 clean을 주장하지 않는다. 테스트/새 DTO lint 오류는 없다.
- LSP 도구는 제공되지 않았다. Kotlin compile과 실제 3파일 ktlint 결과로 대체했다. 기존 Kotlin 경고와 테스트 종료 중 Redis reconnect 경고가 있으나 새 테스트 실패/오류는 없다.
- 기존 15개 테스트/기타 기존 테스트/전체 test/check/build는 실행하지 않았다. 사용자 전체 테스트 명령은 `./gradlew test`이며 이번 승인된 자동 검증 범위 밖이다.
- RED PID 14462/HTTP 50806, 첫 GREEN PID 15417/HTTP 50833, 최종 GREEN PID 16741/HTTP 50879는 테스트 종료로 정상 종료했다. 세 PID와 HTTP/Redis port 50806/50833/50879/50803/50831/50877에 `ps`/`lsof` 조회 결과가 없었다. 공유 프로세스를 종료하거나 task 취소를 호출하지 않았다. 부모 재검증을 위해 소유 root/init/log/JAR는 남겼다.
- AWS/외부 저장소/운영 DB/배포/live ko·ja·mixed/2h 처리/앱/실제 CloudFront 다운로드는 미검증이다. 부모 재검증과 독립 리뷰도 이 보고서의 완료 주장에 포함하지 않는다. credential/JWT/request body는 로그/보고서에 출력하지 않았으며 최종 XML과 로그의 관련 패턴 검색 결과도 없었다.
## 부모 재검증
- 같은 격리 init 및 정확히 새 메서드 3개 selector로 직접 재실행했다. `parent-verification.log`의 결과는 exit0,
`BUILD SUCCESSFUL in 37s`이며 test는 실제 실행, bootJar/테스트 lint는 동일 코드의 UP-TO-DATE 확인이다.
- XML: 3 tests/0 failures/0 errors/0 skipped, UTC timestamp `2026-11-10T22:12:51`. 실제 Tomcat PID17759, HTTP port50914다.
- 부모가 DTO·generateUrl의 전후 diff 및 추가 테스트 전체를 읽었다. 공유 자막 조회와 기존 구매 판정·음원 URL이 유지된다.
- 독립 리뷰와 임시 자원 정리는 아래 후속 기록으로 남긴다. 기존 production EOF lint1건은 성공으로 덮어쓰지 않는다.
## 독립 리뷰 및 사용 계약
- 제한 독립 리뷰 `ses_e387b1e8fffensjb6dnoRk82ST`: **APPROVE**. 이번 production delta의 명세·품질 blocker나 새 회귀 없음.
- `data.contentUrl`과 기존 envelope는 유지하며 `data.subtitle`만 추가된다. 요청 언어는 기존 `Accept-Language`/`LangContext`를 따른다.
- 자막 응답 예시:
```json
{
"contentUrl": "https://cdn.example.com/audio-signed-url",
"subtitle": {
"language": "ko-KR",
"format": "SRT",
"url": "https://cdn.example.com/subtitle-signed-url"
}
}
```
- 구매/공개 조건을 충족하지 못하거나 미완료·해당 언어 자막이 없으면 `subtitle`은 명시적 null이다. 기존 URL 권한을 확대하지 않는다.
- 부모 HTTP PID17759 및 자식 PID14462/15417/16741, port50914, 소유 root 참조 프로세스는 `ps`/`lsof`/`pgrep`에서 부재를 확인했다.
- 리뷰 승인/결과 문서 보존 후 작업 소유 root `generate-url-subtitle.fSBkJM`과 하위 build/cache/log/JAR를 제거했고 `test ! -e` exit0으로 확인했다. 위 임시 log/init 경로는 과거 검증 위치이며 공유 캐시는 건드리지 않았다.
일반 개발 환경에서 이번 후속 테스트만 실행하는 명령:
```bash
./gradlew test \
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldIncludeRequestedSubtitleInGenerateUrl' \
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldReturnNullSubtitleInGenerateUrlWhenUnavailable' \
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldPreserveGenerateUrlPurchaseAndReleaseRestrictions'
```
@@ -0,0 +1,192 @@
# 자막 Phase 1 Kotlin 구현 보고
## 결과와 검증 경계
- 재생성을 제외한 기존 업로드 등록, 네 BOT 내부 API, callback 원자 저장, 기존 콘텐츠 상세의 권한별 ko/ja 자막 조회를 구현했다.
- 새로 작성한 `SubtitleHttpIntegrationTest` 13개는 실제 RANDOM_PORT localhost HTTP/H2에서 전부 통과했다. 외부 AWS 클라이언트와 서명 URL 생성만 대체하고, 회원 서비스·로그인·비밀번호 검증·JWT·DB principal/role은 실제 경로를 사용했다.
- `bootJar`와 변경 Kotlin 파일에 한정한 `ktlintCheck`가 성공했다. LSP 도구는 제공되지 않아 실행하지 않았으며 실제 Kotlin/JPA 생성 코드·테스트 컴파일과 lint로 대체했다.
- PRD/계획과 SQL/deployment 문서는 병렬 담당자 소유다. 이 담당자는 해당 문서를 수정하지 않았으며 전체 Phase gate/독립 리뷰 완료를 대신 선언하지 않는다.
## 구현 선택
1. `AudioContentService.createAudioContent` 두 overload와 AI 관리자 create orchestration은 `NOT_SUPPORTED`다. 필수 주입된 transaction manager의 `TransactionTemplate(REQUIRES_NEW)`가 content·tags·cover·source/job·latest pointer를 commit한 뒤 원본 S3 업로드를 시작한다. 업로드 후 content의 input 경로를 다시 대입하지 않으므로 조기 MediaConvert 완료 경로를 되돌리지 않는다. 성공 후 기존 언어 이벤트는 별도의 짧은 실제 쓰기 트랜잭션에서 발행한다.
2. 원본은 `input/{contentId}/{canonical UUID}.{safe actual extension}`이다. multipart filename의 경로는 버리고 영문/숫자 1~16자리 실제 확장자만 소문자로 보존한다. 예를 들어 `C:\client\dir/file.MP3`는 UUID `.mp3`로 등록된다. 확장자가 없거나 안전하게 보존할 수 없으면 UUID만 사용한다. 업로드 자체를 새로 거부하거나 `.mp3`로 허위 변경하지 않는다. 확장자는 형식 hint일 뿐 실제 오디오 검증 증거가 아니다.
3. `SubtitleJob.outputKey`는 확장자를 제외한 `output/{contentId}/{same UUID}` stem이다. 새 등록의 upload-complete는 이 정확한 stem과 `aac`/`m4a`/`mp3` 확장자 조합만 수락한다. 다른 콘텐츠, 다른 UUID, 추가 suffix, 임의 디렉터리, 비오디오 확장자는 거부한다. source가 없는 기존 콘텐츠의 동작은 기존 prefix 검증을 유지한다. 실제 consumer의 basename·ID 추출 호환성은 여전히 배포 전 확인 대상이다.
4. 언어 결과는 `Subtitle` 행에 저장한다. `jobId` scalar와 `unique(job_id, language)`, 실제 `language`·`format`·`s3Bucket`·`s3Key`를 보존한다. callback 허용 언어는 여전히 ko-KR/ja-JP이며 상태 규칙은 2/1/0개 그대로다. 미래 언어 활성화/새 provider framework는 추가하지 않았다.
5. callback은 원래 HTTP `ByteArray` SHA-256을 receipt와 함께 저장한다. `REQUIRES_NEW`/`READ_COMMITTED`에서 receipt를 먼저 조회하고 job lock 뒤 다시 조회한다. 기존 eventId로 unknown job을 보낸 변경 body도 422다. receipt는 JPA `Persistable.isNew=true`로 insert하여 merge가 경합한 다른 receipt를 update하지 못하게 했다. unique 경합은 rollback 종료 후 새 트랜잭션에서 receipt를 읽어 200/422를 판정한다. terminal의 동일 결과는 행 ID를 보존하고, 다른 결과는 409다.
## 변경 경로
### 신규 production
```text
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/domain/SubtitleJobStatus.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/dto/SubtitleJobDtos.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/SubtitleJob.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/SubtitleJobRepository.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/Subtitle.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/SubtitleRepository.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/SubtitleCallbackReceipt.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/SubtitleCallbackReceiptRepository.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/application/SubtitleJobService.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/web/SubtitleJobController.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/web/SubtitleRequestParser.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/web/SubtitleExceptionHandler.kt
```
### 기존 production 연결
```text
src/main/kotlin/kr/co/vividnext/sodalive/configs/SecurityConfig.kt
src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContent.kt
src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt
src/main/kotlin/kr/co/vividnext/sodalive/content/GetAudioContentDetailResponse.kt
src/main/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/AiCharacterAdminAudioContentFacade.kt
```
### 테스트와 보고
```text
src/test/kotlin/kr/co/vividnext/sodalive/v2/subtitle/SubtitleHttpIntegrationTest.kt
src/test/kotlin/kr/co/vividnext/sodalive/content/AudioContentServiceTest.kt
src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/AiCharacterAdminAudioContentCreateTest.kt
src/test/kotlin/kr/co/vividnext/sodalive/v2/api/admin/aicharacter/content/LegacyCreatorAdminAudioContentCharacterizationTest.kt
docs/20261110_자막Phase1연동/implementation-report.md
```
- 기존 수동 `AudioContentService` 생성자는 필수 자막 서비스/transaction manager 인자를 반영했다.
- 기존 생성 통합 테스트의 성공 fixture는 등록 전에 실제 commit되도록 조정했다. audio 업로드/후속 이벤트 실패 테스트는 이미 commit된 등록을 보존한다는 새 승인 계약에 맞췄다. 실패 테스트를 삭제하거나 성공 assertion을 느슨하게 하지 않았다.
- 이 기존 테스트들은 후속 사용자 지시 이후 **실행하지 않았다**. 관련 기존 5개 클래스는 새 테스트 실행의 컴파일 입력에 포함했지만 실행 selector는 신규 자막 패키지뿐이다.
- production 파일 삭제, 기존 JWT/member/텍스트 TranslationJob worker 변경, 외부 프로젝트 변경, 신규 AWS SDK 의존성, 재생성 API/START 호출은 없다.
## 새 테스트 selector
전체 신규 클래스만 실행하는 selector:
```bash
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest'
```
개별 selector는 아래 클래스명 뒤에 각 메서드를 붙인다. 모두 이번 작업에서 새로 작성한 case다.
```text
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldRejectActualNonBotLoginJwt
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldUseRealBotJwtAndStoreCallbackBeforeStartedWithExactByteReplay
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldStartMonotonicallyAndAcceptPartialAndFailedResults
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldReturn404WithoutDiscoveryAndCheckCurrentDatabaseRole
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldRejectMalformedContractsWithoutPersistingAnything
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldSerializeConcurrentCallbacksAndRollbackLosingJob
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldRollbackResultsAndStatusWhenReceiptInsertFails
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldKeepLatestPointerWhenOlderJobCompletes
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldCommitRegistrationBeforeUploadAndNeverRevertEarlyMediaConvertOutput
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldKeepAcceptedSourceAndTerminalResultWhenUploadReturnFails
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldPreserveOnlySafeActualSourceExtensionsWithoutClaimingConversion
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldExposeLanguageSubtitleOnlyWithReleasedOriginalAccessInExistingDetail
kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldReadOnlyPersistedLanguageOfMatchingLatestCompletedJob
```
## 재현 명령과 아티팩트
작업 전용 root는 삭제하지 않고 부모 검증에 인계한다.
```bash
ROOT=/var/folders/yh/8xsbvpsj5wg2qnxzxdp11_gm0000gn/T/opencode/subtitle-phase1.wiRcAJ/backend.HX0j0B
export TMPDIR="$ROOT"
export NODE_COMPILE_CACHE="$ROOT/node"
export BUN_RUNTIME_TRANSPILER_CACHE_PATH="$ROOT/bun"
./gradlew --no-daemon --max-workers=2 \
-Pkotlin.compiler.execution.strategy=in-process -Dorg.gradle.jvmargs=-Xmx4g \
--project-cache-dir "$ROOT/gradle-cache" -I "$ROOT/isolation.gradle" \
test --tests 'kr.co.vividnext.sodalive.v2.subtitle.*'
./gradlew --no-daemon --max-workers=2 \
-Pkotlin.compiler.execution.strategy=in-process -Dorg.gradle.jvmargs=-Xmx4g \
--project-cache-dir "$ROOT/gradle-cache" -I "$ROOT/isolation.gradle" \
bootJar ktlintCheck
```
- 임시 init script는 build 출력과 Gradle project cache를 공유 출력에서 격리한다. 테스트 Kotlin 컴파일 입력은 신규 자막/직접 영향 기존 5개 클래스/support이며, lint filter도 변경 Kotlin 파일만 대상으로 한다. 전역 설정이나 저장소 build 설정은 변경하지 않았다.
- 성공 테스트: `$ROOT/green-new-tests-cached.log`, `BUILD SUCCESSFUL in 1m 32s`. 임시 script의 사용하지 않는 JWT 기본값을 제거한 뒤 다시 실행한 최종 `$ROOT/final-new-tests.log`도 `BUILD SUCCESSFUL in 2m 25s`다. XML: `$ROOT/build/test-results/test/TEST-kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.xml`, `tests=13`, `failures=0`, `errors=0`, `skipped=0`.
- 실제 두 job의 동일 eventId 경합에서 H2 SQLState `23505` unique 위반이 관찰됐고, 최종 HTTP 200/422와 loser job의 PENDING/결과 행 없음 assertion이 통과했다. 별도의 receipt 쓰기 실패 주입에서도 identity 생성으로 flush된 결과 행까지 rollback됨을 확인했다.
- 성공 빌드/lint: `$ROOT/build-lint.log`, `BUILD SUCCESSFUL in 1m 28s`. 실행 가능한 boot JAR은 `$ROOT/build/libs/sodalive-0.0.1-SNAPSHOT.jar`다. `jar tf`에서 새 컨트롤러/서비스/엔티티/repository/DTO가 `BOOT-INF/classes`에 포함된 것을 확인했다.
- 검증 완료 후 root를 참조하는 작업 소유 Gradle/HTTP/Redis 프로세스는 관찰되지 않았다. 기존 공유 worker PID `55393`과 그 Redis PID `55452`는 이 작업 소유가 아니며 종료하지 않았다. 테스트 실행 중 관찰된 작업 소유 executor PID `20950`과 최종 executor PID `22207`은 종료됐다.
## RED와 실패 이력
- 첫 baseline/신규 RED 명령은 테스트 컴파일 중 600초 제한으로 종료됐다(`red.log`). 테스트 결과가 아니며 RED로 인정하지 않았다.
- `red-focused.log`는 이전 지시에 따른 기존 3개 회귀 클래스와 신규 1개 case 실행이다. 총 41개 중 1개가 테스트 JWT key setup에서 실패했다. 이를 기능 RED로 인정하지 않았다. 이 명령은 기존 테스트 실행 금지라는 후속 사용자 지시 전의 기록이며 현재 구현의 회귀 성공 증거로 사용하지 않는다.
- 테스트 전용 `DynamicPropertySource`로 유효 길이의 비운영 JWT key를 지정한 뒤 `red-http.log`에서 실제 로그인 성공 후 `403 기대 / 404 실제`를 확인했다. BOT 전용 경로가 없던 동작의 실제 RED다.
- 초기 `red-binding.log`는 JPA unique constraint의 logical/physical column 이름 오류로 context가 뜨지 못했다. 이를 RED로 인정하지 않고 엔티티에 명시적 column 이름을 붙였다.
- `red-binding-assertions.log`에서 새 두 case가 실제 assertion으로 실패했다: source 확장자 보존 실패, 기존 eventId의 unknown job 변경에 대해 `422 기대 / 404 실제`. 확장자 전달과 receipt 선조회/명시적 isolation 변경 후 같은 두 case를 포함한 13개 전체 신규 case가 GREEN이다.
- `green-first.log`는 사용자 지시 갱신을 위한 중단으로 완료 결과가 없다. `green-new-tests.log`는 compile을 통과한 뒤 test 시작 시점에 600초 도구 제한으로 종료됐다. 공유 프로세스를 종료하지 않고 같은 격리 경로의 캐시를 재사용한 `green-new-tests-cached.log`에서 완료 결과를 얻었다.
- `format.log`의 첫 변경 파일 format 실행은 길이 위반을 보고했다. 해당 새 줄만 정리한 뒤 최종 `ktlintCheck`가 통과했다.
## 외부 게이트와 남은 미검증
1. 실제 MediaConvert consumer가 기존 contentId filename prefix를 읽는지, UUID basename·출력 확장자·디렉터리를 어떻게 구성하는지 운영 증거가 없다. 로컬에서는 정확한 UUID stem과 AAC/M4A/MP3 경로 검증만 확인했다. consumer의 운영 호환성을 확인하기 전 배포 전환은 BLOCKED다.
2. 부모가 승인된 ZIP에서 확인한 Transcribe 지원 확장자는 amr/flac/m4a/mp3/mp4/ogg/webm/wav다. Spring은 AAC/opus 등 기존 업로드를 임의로 거부하지 않는다. 이들 또는 누락/불안전 확장자에 대한 자막 성공은 보장하지 않으며 Lambda의 명시적 unsupported 결과/수동 확인 대상이다. 테스트의 한 바이트 파일은 source binding/transaction fixture일 뿐 실제 미디어 증거가 아니다.
3. S3 putObject 수락 후 getUrl 실패는 성공으로 숨기지 않는다. 원래 예외를 호출자에게 전파하고 `SOURCE_UPLOAD_UNCERTAIN` 및 초 정밀도 TIMESTAMP를 별도 기록한다. 이미 완료된 자막 상태/metadata와 content를 삭제하거나 회귀시키지 않는다. 실제 객체/MediaConvert 상태는 운영자 수동 확인이 필요하다.
4. 운영 MySQL DDL 적용, case-sensitive/NO PAD collation 및 FK/인덱스 검증, private CloudFront origin과 실제 SRT 서명 접근, 실서버 권한/앱 표시, live ko/ja/mixed 및 실제 duration/2시간 처리 예산은 미검증이다. AWS 호출·배포·DB 적용은 수행하지 않았다.
5. 전체 테스트와 후속 지시 이후의 기존 회귀 case 실행은 수행하지 않았다. H2 전체 Spring context의 기존 charge/translation scheduler는 MySQL `FOR UPDATE SKIP LOCKED` 구문 때문에 로그 오류를 남겼다. 이번 신규 case는 모두 통과했지만 그 worker 기능의 성공 증거는 아니다. 사용자가 별도로 전체 테스트를 원할 때만 `./gradlew test`를 실행한다.
## 20261111 P1 후속 수정: body/DB 실패의 HTTP 200 오인 방지
### 수정 범위와 계약
- `SubtitleExceptionHandler.kt`의 기존 `SubtitleJobController` 전용 scope와 우선순위를 유지했다. `HttpMessageNotReadableException`은 HTTP 422와 기존 일반화된 거절 body로, 그 외 예상하지 못한 `Exception`은 HTTP 500과 `{"error":"Subtitle request failed"}`로 응답한다.
- 기존 `ResponseStatusException`의 404/409/422 처리는 변경하지 않았다. 공통 `SodaExceptionHandler`, JWT, 컨트롤러, 서비스 및 DB 저장 로직은 변경하지 않았으며 예외 원문·요청·토큰 로그도 추가하지 않았다.
- 수정 파일은 자막 advice, `SubtitleHttpIntegrationTest.kt` 및 이 보고서의 추가 기록뿐이다. 기존 직접 서비스 롤백 테스트 `shouldRollbackResultsAndStatusWhenReceiptInsertFails`와 기존 assertion은 그대로 보존했다. 부모 소유 PRD/계획/final-report는 수정하지 않았다.
### 새 HTTP 두 사례
1. `shouldRejectEmptyCallbackAndStartedBodiesWithoutPersistingAnything`: 실제 BOT 로그인/JWT로 빈 callback·started body를 모두 전송해 422를 확인한다. job/receipt/결과 행 수, PENDING 상태, 갱신 시각 및 오류 필드가 변경되지 않고 해당 job 결과도 없음을 검증한다.
2. `shouldReturn500AndRollbackWhenReceiptInsertFailsOverHttp`: 실제 HTTP callback에서 기존 receipt repository SpyBean의 `saveAndFlush`에 DB 예외를 주입한다. ko-KR partial callback을 사용하여 상태뿐 아니라 오류 필드도 변경 대상에 포함하고, 일반화된 500 body 및 receipt·결과 부재, PENDING/갱신 시각/오류 필드 롤백을 DB 재조회로 확인한다.
### RED/GREEN 명령과 증거
위 격리 `ROOT`와 `TMPDIR`/Node/Bun cache 환경을 그대로 사용했다. 외부 의존성 다운로드를 막는 `--offline`과 부모의 `verification.gradle`을 추가하여 테스트만 강제로 다시 실행했다. `clean` 및 무필터 test/check/build는 실행하지 않았다.
advice 수정 전 RED와 수정 후 두 사례 GREEN에 사용한 동일 selector/명령:
```bash
./gradlew --offline --no-daemon --max-workers=2 \
-Pkotlin.compiler.execution.strategy=in-process -Dorg.gradle.jvmargs=-Xmx4g \
--project-cache-dir "$ROOT/gradle-cache" \
-I "$ROOT/isolation.gradle" -I "$ROOT/../verification.gradle" \
test \
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldRejectEmptyCallbackAndStartedBodiesWithoutPersistingAnything' \
--tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.shouldReturn500AndRollbackWhenReceiptInsertFailsOverHttp'
```
- RED: `$ROOT/p1-red-two-http.log`, `BUILD FAILED in 4m 16s`, 정확히 2개 실행/2개 assertion 실패다. `$ROOT/p1-red-assertions.log`에 XML의 실패 증거를 보존했다. 빈 body는 `expected [422, 422] / actual [200, 200]`, DB 실패는 `expected 500 / actual 200`이었다.
- 첫 GREEN 시도 `$ROOT/p1-green-two-http.log`는 `compileKotlin` 도중 600초 도구 제한으로 종료됐다. 테스트가 실행되지 않아 GREEN으로 계산하지 않았다. 작업 소유 프로세스가 남지 않은 것을 확인한 후 같은 캐시와 1200초 제한으로 재실행했다.
- 두 사례 GREEN: `$ROOT/p1-green-two-http-retry.log`, `BUILD SUCCESSFUL in 13m 29s`. `$ROOT/p1-green-two-assertions.log`는 `tests=2`, `failures=0`, `errors=0`, `skipped=0`이다.
이후 자막 신규 클래스 15개 전체와 기존 격리 script의 변경 Kotlin 파일 lint 및 boot JAR를 함께 검증했다:
```bash
./gradlew --offline --no-daemon --max-workers=2 \
-Pkotlin.compiler.execution.strategy=in-process -Dorg.gradle.jvmargs=-Xmx4g \
--project-cache-dir "$ROOT/gradle-cache" \
-I "$ROOT/isolation.gradle" -I "$ROOT/../verification.gradle" \
test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest' \
bootJar ktlintCheck
```
- 최종 `$ROOT/p1-green-15-build-lint.log`: `BUILD SUCCESSFUL in 7m 44s`. production/test 컴파일은 `UP-TO-DATE`였으며 test, bootJar, main/test 변경 파일 lint는 실제 실행됐다.
- 최종 XML `$ROOT/build/test-results/test/TEST-kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest.xml`: `tests=15`, `failures=0`, `errors=0`, `skipped=0`. 실제 RANDOM_PORT HTTP에서 새 422/500과 기존 404/409/422 및 직접 서비스 롤백 case가 모두 통과했다. 기존 회귀 클래스는 컴파일 입력일 뿐 실행하지 않았다.
- `$ROOT/build/libs/sodalive-0.0.1-SNAPSHOT.jar`에 수정된 `SubtitleExceptionHandler.class`가 포함됨을 `jar tf`로 확인했다. LSP 도구는 제공되지 않아 사용하지 못했으며 Kotlin 컴파일과 변경 파일 lint를 확인했다.
- RED/GREEN/최종 테스트 executor PID `28638`/`37727`/`39291`은 모두 종료됐다(`$ROOT/p1-test-process-status.log`는 header만 존재). 완료 후 작업 root를 사용하는 Gradle/HTTP/Redis 프로세스는 관찰되지 않았다. 기존 공유 PID `55393`/`55452`는 그대로이며 어떤 task도 취소하거나 프로세스를 수동 종료하지 않았다. root와 로그는 부모 재검증용으로 보존했다.
### 남은 검증 경계
- 기존 Kotlin 경고, Gradle deprecation, H2의 기존 charge/translation scheduler SQL 오류와 Redis 종료 시 재접속 경고는 관찰됐으나 수정 범위 밖이다. 신규 자막 15개 assertion은 전부 통과했다.
- 기존 회귀/전체 테스트, 운영 MySQL, AWS·MediaConvert·Lambda 실연동 및 배포 검증은 수행하지 않았다. 앞 절의 외부 게이트는 그대로 남으며, 전체 테스트 사용자 실행 명령은 `./gradlew test`다.
## 부모 최종 검증·정리 추가 기록
- 부모가 처음 신규13개 및 P1의 두 HTTP 사례를 각각 직접 재실행해 모두 통과했고, 독립 리뷰의 유일 finding은 ADDRESSED 및 로컬 backend APPROVE 판정을 받았다.
- 부모의 P1 재실행은 `BUILD SUCCESSFUL in 4m 55s`, 실제 XML2/0/0/0, timestamp `2026-11-10T15:34:43`이다.
- 2026-11-11 작업 소유 PID/listener 부재를 확인한 후 위 임시 ROOT 전체를 제거했다. 따라서 ROOT 기반 로그·init script·JAR 경로는 과거 검증 위치이며 현재 파일로 남아 있지 않다. 명령/결과/실패 이력은 본 보고서와 final-report에 보존했다.
- 일반 개발 환경의 재현 명령은 `./gradlew test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleHttpIntegrationTest'`다. 기존 테스트는 실행하지 않는 selector다.
@@ -0,0 +1,217 @@
# 자막 Phase 1 Spring 연동 구현 계획
**Goal:** 기존 업로드와 권한을 보존하면서 자막 작업 등록, 네 BOT 내부 API, 언어별 안전한 자막 조회를 제공한다.
**Architecture:** 기존 Kotlin/Spring/JPA와 member JWT를 재사용한다. 신규 자막 기능은 `v2.subtitle` 하위에 두고 기존 콘텐츠 서비스의 업로드 및 상세에만 연결한다. 원본 S3 쓰기 이전 commit과 callback receipt/status/metadata의 원자성을 보장한다.
**Tech Stack:** Kotlin 1.6.21, Java 17, Spring Boot 2.7.14, JPA, MySQL 운영 DDL, H2 테스트.
**Spec:** [prd.md](prd.md). 사용자 승인 범위이며 재생성 기능은 제외한다.
## 현재 상태
- Phase 1/2 완료 이력 유지. Phase3 컬럼 매핑 수정·신규 테스트·독립 리뷰·소유 임시 자원 정리 완료. 활성 로컬 Goal 없음. 운영 DB/외부 게이트는 별도 검증 대상이다.
- 실행: subagent-driven-development, 공유 Kotlin 구현은 단일 담당자가 순차 처리한다. 엔티티 계약이 확보된 additive DDL·운영 문서는 별도 담당자가 병렬 준비하고 마지막에 대조한다.
- 새 worktree는 만들지 않는다. 기존 `test` 작업 트리는 조사 시 clean이며 main/master가 아니다.
- commit/push/배포/DB 적용은 이 계획의 실행 항목이 아니다.
## 전역 제약
- PRD의 네 endpoint/payload/상태/경로와 BOT 인증을 그대로 구현한다. 공개 재생성 API와 직접 START 호출은 금지한다.
- 기존 upload/MediaConvert/preview/알림/JWT/텍스트 번역 worker를 보존한다. 기존 테스트를 삭제하거나 완화하지 않는다.
- additive DDL만 작성한다. 적용 migration 편집/삭제와 데이터 DROP 금지.
- 이번 작업에서 새로 작성한 테스트만 실행하며 `bootJar`로 빌드를 별도 확인한다. 기존 클래스에 추가한 새 테스트는 메서드 selector로 지정한다. 기존 focused 회귀도 실행하지 않는다. 전체 테스트 명령은 사용자용 `./gradlew test`다.
- AWS/live/mixed/2h/운영 DB/consumer 미검증을 성공으로 보고하지 않는다.
## Review Focus
1. 외부 호출자가 트랜잭션을 가지고 있어도 S3 이벤트 시점에는 job/source가 commit되어 있어야 한다.
2. UUID 파일명 변경 후 기존 MediaConvert 완료 콜백을 수락하되 다른 콘텐츠/경로를 허용하지 않아야 한다.
3. callback 중복/경합 때 receipt와 상태 및 자막이 원자 반영되고 older 결과가 최신을 덮지 않아야 한다.
4. JSON 숫자 coercion/누락 nullable 필드/추가 필드 및 raw-body 재직렬화로 계약이 약화되지 않아야 한다.
5. preview-only 사용자에게 전체 자막이 노출되거나 BOT 변경으로 기존 역할 권한이 넓어지지 않아야 한다.
## Phase 1: 업로드부터 자막 조회까지
### Task 1.1: 자막 backend 연결
**Goal `P1-T1`:** 기존 콘텐츠 흐름에 durable source/job 등록과 네 내부 API, 안전한 자막 조회가 연결된다.
- 시작 조건: 재생성 제외 승인, PRD 작성 완료, 업로드 transaction 경계 검토 완료.
- 완료 증거: 아래 RED/GREEN 기록과 5개 기능 그룹을 검증하는 새 테스트 통과. 기존 콘텐츠/로그인 테스트는 코드 대조만 하고 미실행으로 보고.
- 범위 밖: Lambda 코드, 앱 코드, 인프라, 재생성, 자동 복구.
- 신규 구현 파일은 `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/` 아래 `application`, `domain`, `adapter`, `dto` 책임별로 배치한다. 과도한 port/wrapper는 만들지 않는다.
**Files:**
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/domain/SubtitleJobStatus.kt`
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/SubtitleJob.kt`, `SubtitleJobRepository.kt`, `SubtitleCallbackReceipt.kt`, `SubtitleCallbackReceiptRepository.kt` 및 필요한 최소 subtitle metadata 저장 타입.
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/Subtitle.kt`, `SubtitleRepository.kt`. 결과 행은 auto-increment Long PK와 `jobId`(36), `language`(35), `format`(16), `s3Bucket`(255), `s3Key`(255)를 저장하며 `(jobId, language)` unique와 job FK를 둔다. `findAllByJobId(jobId)` 및 `findByJobIdAndLanguage(jobId, language)`로 callback/조회에서 재사용한다. 언어별 컬럼을 제거하되 아직 미배포인 이번 draft만 교체하고 기존 적용 schema/data는 건드리지 않는다.
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/application/SubtitleJobService.kt`
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/web/SubtitleJobController.kt`
- Create: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/dto/SubtitleJobDtos.kt`
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt`, `AudioContent.kt`, `GetAudioContentDetailResponse.kt` 및 필요한 기존 호출자.
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/configs/SecurityConfig.kt`와 필요한 자막 전용 설정.
- Create: `docs/20261110_자막Phase1연동/subtitle-schema.sql`.
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/subtitle/`의 기능 통합 테스트 및 기존 `content/AudioContentServiceTest.kt`, `member/MemberLoginResponseContractTest.kt`, `jwt/TokenProviderTest.kt` 관련 회귀.
**Interfaces:**
- Consumes: 기존 `AudioContent`, `S3Uploader`, `AudioContentCloudFront`, `LangContext`, member JWT/role 및 PRD의 exact Lambda HTTP 계약.
- Produces: PRD의 네 내부 HTTP endpoint; 기존 콘텐츠 상세의 nullable 자막 정보. source lookup은 최초 업로드 binding에 고정한다.
- 내부 함수/저장 형태는 기존 패턴과 transaction 검토에 맞추며 실제 파일/이름은 구현 기록에 갱신한다. 공개 계약은 변경하지 않는다.
- [x] **RED:** 기존 관련 테스트의 의도를 먼저 읽고 새 실제 HTTP 테스트를 작성했다. 지시 이후 기존 baseline은 실행하지 않았다.
- [x] **RED 확인:** 실제 로그인 후 403 기대/404 실제, source 확장자 보존 실패 및 기존 eventId/unknown job의 422 기대/404 실제를 확인했다. compile/setup 실패는 RED로 인정하지 않았다.
- [x] **GREEN:** 최소 persistence/업로드 commit 경계/API/상세 연결 및 additive DDL을 구현했다. 언어별 결과는 `Subtitle` 행이다.
- [x] **GREEN 확인:** 부모 직접 실행에서 신규 `SubtitleHttpIntegrationTest` 13개 통과, 실패·오류·skip 0.
- [x] **REFACTOR:** Kotlin/JPA·직접 영향 test compile, 변경 파일 ktlint 및 bootJar 성공을 확인했다. 기존 회귀 case는 실행하지 않았다.
검증 상세: [implementation-report.md](implementation-report.md). 부모 재실행 `parent-verification.log`는
`BUILD SUCCESSFUL in 2m 21s`, XML timestamp `2026-11-10T14:33:59`, 13/0/0/0이다.
### Task 1.2: 실제 HTTP와 독립 리뷰
**Goal `P1-T2`:** 구현 결과를 실제 HTTP 표면과 독립 검토로 확인하고 외부 미검증을 구분한다.
- 시작 조건: `P1-T1` 구현 및 focused test 완료.
- 완료 증거: 실제 HTTP status/body assertion, `bootJar`, 변경 범위 lint/compile, 독립 리뷰의 blocker 해소.
- 범위 밖: 외부 AWS 환경에 대한 실제 운영 검증 및 전체 테스트.
- TDD 예외 사유: 검증/보고 task다. 대체 검증은 HTTP 실행과 코드/DDL/테스트 대조다.
- [x] 실제 localhost HTTP로 EMAIL BOT 로그인, 네 endpoint, 중복/경합/오류 및 기존 콘텐츠 상세를 실행했다. H2와 외부 S3/서명 경계 대체를 사용했다.
- [x] `bootJar`, 변경 파일 `ktlintCheck`, 신규 HTTP 테스트를 실행했다. LSP 미제공이며 Kotlin compile/lint를 대체 증거로 기록했다.
- [x] 독립 리뷰에서 HTTP 오류 경계 1건을 발견·수정하고, 제한 delta 재검토에서 ADDRESSED 및 로컬 backend APPROVE를 받았다.
- [x] `final-report.md`에 실제 수정·삭제·보존 경로, 명령/결과, DB 적용 및 consumer 상태, fixture 출처, live/mixed/2h BLOCKED를 기록했다.
### Task 1.R1: 리뷰 회귀 수정
**Goal `P1-R1`:** 자막 API의 빈 body/저장 실패가 HTTP 200으로 숨겨지지 않는다.
- 시작 조건: 독립 리뷰 P1 finding 및 `SodaExceptionHandler.kt`의 기존 HTTP200 변환 확인.
- 완료 증거: 새 실제 HTTP 테스트에서 빈 callback/started 422 및 DB 실패 5xx, receipt/status/results rollback 확인.
- 범위 밖: 기존 공통 exception handler나 다른 API 응답 변경.
- Files: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/web/SubtitleExceptionHandler.kt`,
`src/test/kotlin/kr/co/vividnext/sodalive/v2/subtitle/SubtitleHttpIntegrationTest.kt`.
- [x] **RED:** 빈 body와 receipt 저장 실패의 실제 HTTP 테스트 2개를 추가했다.
- [x] **RED 확인:** `[422,422]` 기대에 `[200,200]`, `500` 기대에 `200` 실패를 확인했다.
- [x] **GREEN:** 자막 전용 advice에서 body 읽기 오류는 422, 예상치 못한 서버 오류는 일반화된 500으로 반환한다.
- [x] **GREEN 확인:** 신규 자막 15개 통과, 부모의 추가 두 HTTP 사례 재실행도 통과했다. 기존 서비스 직접 호출 rollback 테스트를 유지했다.
- [x] **REFACTOR:** 변경 lint/build 및 부모 HTTP 재검증 후 제한 delta 리뷰가 승인했다. 원 reviewer session 유실로 대체 reviewer가 기존 판정과 수정분만 재검토했다.
### Phase 1 Gate
**Goal `P1-GATE`:** 로컬 backend 완료와 운영 배포 준비 상태가 증거로 구분된다.
- [x] `P1-T1`, `P1-T2`, `P1-R1` 완료 증거 확인.
- [x] 임시 QA 프로세스/listener 부재와 작업 소유 build/cache/log root 제거를 확인했다. 공유 프로세스·캐시는 변경하지 않았다.
- [x] 재생성 URI/worker/HMAC/파괴적 SQL/외부 프로젝트 변경이 없음을 diff 확인했다.
- [x] 운영 반영은 consumer inventory, DB additive DDL 검토, 조정 배포, controlled live ko/ja/mixed와 2h 측정이 필요하다고 보고했다.
## Phase 2: generate-url 자막 응답
### Task 2.1: 기존 URL 권한을 유지한 자막 제공
**Goal `P2-T1`:** 구매자의 generate-url 응답에 상세와 동일한 요청 언어 자막이 포함되고 기존 contentUrl 계약이 보존된다.
- 시작 조건: PRD §7 사용자 요청 확정, 기존 generateUrl/공유 subtitle 조회 및 새 HTTP fixture 확인.
- 범위 밖: 기존 구매 판정 확대, URI/DB/Lambda 변경, 재생성, 기존 테스트/전체 테스트 실행.
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/content/GenerateUrlResponse.kt`.
- Modify: `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt`의 `generateUrl`만.
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/subtitle/SubtitleHttpIntegrationTest.kt`에 이번 후속용 HTTP 사례 추가.
- Consumes: `SubtitleJobService.subtitle(content, lang, expirationTime)`, 기존 `LangContext`, 구매 검사와 `AudioContentCloudFront`.
- Produces: `data.contentUrl` 유지 + nullable `data.subtitle`의 language/format/url.
- 완료 증거: 아래 세 시나리오의 새 HTTP 사례 RED/GREEN, 컴파일/변경 lint, 범위 한정 독립 리뷰와 임시 자원 정리.
시나리오:
1. 구매·공개 완료 콘텐츠: `Accept-Language: ko/ja` 각각에 해당 SRT 정보와 기존 음원 URL, 기존 envelope가 반환된다.
2. 미완료 job/해당 언어 없음/미지원 언어/자막 미등록: 음원 URL은 유지하고 subtitle은 명시적 null이다.
3. 미구매자(소유자·무료 포함)는 기존 빈 contentUrl과 null 자막을 받는다. 예약 공개 구매자의 subtitle은 공개 전 null이며 공개 후 제공된다. 기존 URL 반환은 그대로다.
- [x] **RED:** 기존 HTTP fixture를 재사용한 새 메서드 3개만 추가했다.
- [x] **RED 확인:** 실제 응답의 `has("subtitle")`에서 3개 모두 assertion 실패함을 확인했다.
- [x] **GREEN:** DTO field와 generateUrl의 공유 자막 조회 연결만 구현했다.
- [x] **GREEN 확인:** 이번 새 HTTP 메서드 3개 통과, 부모 직접 재실행도 3/0/0/0. 이전 15개와 클래스 전체는 실행하지 않았다.
- [x] **REFACTOR:** 컴파일/bootJar/테스트 lint 및 제한 독립 리뷰 APPROVE를 확인했다. production lint의 기존 EOF 빈 줄1건을 별도 기록하고 dirty 변경을 보존했다. 자원 정리는 Phase2 Gate에서 확인한다.
### Phase 2 Gate
**Goal `P2-GATE`:** 추가 응답의 HTTP·권한·호환성 증거가 확보된다.
- [x] 새 HTTP3개 통과와 독립 리뷰 APPROVE 확인.
- [x] 기존 코드 변경은 DTO와 generateUrl 본문뿐임을 실제 전후 diff로 대조했다.
- [x] 결과 보고를 보존하고 소유 테스트 PID/listener 및 임시 build/cache/root 부재를 확인했다.
## Phase 3: Schema-validation 회귀 수정
### Task 3.R1: s3 컬럼 물리명 일치
**Goal `P3-R1`:** 기존 `subtitle.s3_bucket`/`s3_key` 테이블을 Hibernate가 검증하고 정상 저장·조회한다.
- 시작 조건: 실제 사용자 에러, 명시적 이름이 없는 엔티티와 DDL 차이 확인.
- Files: `src/main/kotlin/kr/co/vividnext/sodalive/v2/subtitle/adapter/persistence/Subtitle.kt`.
- Test: `src/test/kotlin/kr/co/vividnext/sodalive/v2/subtitle/SubtitleSchemaValidationTest.kt` 신규.
- 범위 밖: DDL 수정·운영 DB 접속/컬럼 추가·자동 update·전역 naming strategy·JSON/property rename·기존 테스트 실행.
- 시나리오: 독립적으로 만든 s3_bucket/s3_key 테이블에 실제 Boot 기본 naming strategy를 사용한 Hibernate validate 성공, 두 값의 persist/reload/JDBC column 확인 성공.
- [x] **RED:** 엔티티 자동 DDL 생성 없이 기존 컬럼명의 H2 table을 준비하고 실제 schema validate를 수행하는 새 테스트를 작성했다.
- [x] **RED 확인:** 사용자 보고와 동일한 missing s3bucket 에러로 1개 실패를 확인했다. 컴파일 오류가 아니다.
- [x] **GREEN:** `@Column(name = "s3_bucket")`, `@Column(name = "s3_key")`를 기존 속성에 명시했다.
- [x] **GREEN 확인:** 새 테스트1개만 실행해 validation 및 Hibernate 저장/새 Session 조회/JDBC 두 컬럼 조회 성공을 확인했다.
- [x] **REFACTOR:** 변경 compile/bootJar/lint와 독립 리뷰 APPROVE, 검증 기록 보존 및 소유 임시 자원 제거·부재 확인을 완료했다.
## 이전 기능 실행 검증 이력
```bash
./gradlew test --tests 'kr.co.vividnext.sodalive.v2.subtitle.*'
./gradlew bootJar
```
기존 클래스에 추가한 새 테스트는 실제 메서드명을 `--tests`에 지정한다. 기존 테스트 클래스 전체는 실행하지 않는다. 수동 전체 검증은 사용자 실행 `./gradlew test`다. 실제 명령/추가 영향 테스트/결과는 아래에 누적한다.
## Progress
- 2026-11-11 `P3-R1` 종료: 작업 root를 참조하는 프로세스가 없고 실제 디렉터리/symlink 아님을 확인한 뒤 소유 `subtitle-schema-fix.XcftjN`만 제거했다. `test ! -e` exit0, 공유캐시 미변경. 결과/명령/리뷰는 문서로 보존했다. 운영 재시작/DB 변경/커밋은 하지 않았다.
- 2026-11-11 `P3-R1` 독립 리뷰 APPROVE: 명세/품질 blocker 없음. 두@Column만 바뀌었고 기존 SQL/JSON 계약은 유지된다. 독립DDL+actualvalidate+새Session/JDBC 조회와 RED/GREEN 증거가 확인됐다. 실제MySQL/전체Spring검증은 별도 게이트다.
- 2026-11-11 `P3-R1` RED/GREEN: 실제 Hibernate validation의 missing[s3bucket] 실패를 수정 전 재현했다(1fail, 3m49s). 두@Column만 수정한 뒤 신규 테스트1/0/0/0, Kotlin compile/bootJar/변경2파일 lint 성공(3m29s). 실제 운영 DB는 조회·변경하지 않았다. `schema-validation-report.md`에 원인과 기존 create-drop 검증 공백을 기록했다. 독립 한정 리뷰 진행 중.
- 2026-11-11 `P3-R1` 등록: 사용자 보고 missing `[s3bucket]` 재현/수정. 기존 기본 명명전략이 숫자-대문자 경계에서 underscore를 넣는다고 가정한 정적 대조와 엔티티 생성 H2 테스트의 검증 공백을 기록한다. 기존 DDL은 유지하고 실제 validate 회귀 검증으로 보완한다.
- 2026-11-11 별도 사용자 `/commit-with-validation` 요청으로 커밋 진행. 기능 연동 커밋의 pre-commit `ktlintCheck`가 기존 `AudioContentService.kt` EOF 빈 줄 1건으로 실패하여 해당 빈 줄만 제거했다. 재시도에서 staged Kotlin 대상 lint와 `git diff --staged --check`, 커밋 직전·직후 메시지 검증이 통과했다. 이번 커밋 작업에서는 기능/전체 테스트 및 bootJar를 재실행하지 않았으며 기존 실행 이력과 외부 배포 BLOCKED는 유지한다. 전체 테스트 사용자 명령은 `./gradlew test`다.
- 2026-11-11 `P2-GATE` 종료: 부모 직접 HTTP3개 재실행 성공과 독립 승인 후 소유 root `generate-url-subtitle.fSBkJM`의 디렉터리/symlink 여부를 확인해 제거했다. `test ! -e` exit0이며 공유 캐시/다른 dirty 파일은 건드리지 않았다. 원래 EOF lint1건은 별도 미해결 관찰로 남긴다. 검증 로그 경로는 과거 위치이며 결과/명령/실패 이력은 보고서에 보존했다.
- 2026-11-11 `P2-T1` 독립 리뷰 APPROVE: 기존 contentUrl/envelope/활성 구매 정책과 서명 만료 인자 유지, 자막만 공개 시점·언어·최신 결과 조건 적용, 새 HTTP3개 증거를 확인했다. 이번 delta blocker/새 회귀 없음. production EOF 공백은 작업 시작 전 dirty 상태의 잔여사항이며 전체 lint clean을 주장하지 않는다.
- 2026-11-11 `P2-T1` 구현: DTO nullable field 및 generateUrl 본문만 수정. 새 HTTP3개 RED/GREEN 후 부모가 정확히 새3method selector로 직접 실행해 3 tests/0 failures/errors/skipped, `BUILD SUCCESSFUL in 37s`, XML UTC `2026-11-10T22:12:51` 확인. 실제 Tomcat PID17759/port50914. Kotlin compile/bootJar 및 테스트 lint 성공. 두 production 파일 lint에서는 작업 전부터 있던 서비스 EOF 빈 줄1건만 실패하므로 다른 dirty 변경으로 보존했다. 상세는 `generate-url-report.md`. 범위 한정 독립 리뷰 진행 중.
- 2026-11-11 후속 요청: generate-url에도 상세와 같은 자막 응답 추가. `GenerateUrlResponse`는 현재 contentUrl만 있고 기존 URL 권한은 구매 검사다. `P2-T1`에서 additive field/공유 조회만 연결한다. 기존 Phase1 완료·검증 기록은 유지한다. 시작 시 추가 dirty 파일(기존 관리자 controller/query 테스트 등)을 발견했으며 다른 작업으로 보고 변경하지 않는다.
- 2026-11-11 종료 정리: 소유 root `subtitle-phase1.wiRcAJ`가 실제 디렉터리이며 symlink가 아님을 확인한 후 제거했고 `test ! -e` exit0으로 부재 확인했다. 작업 소유 테스트 PID/HTTP port의 종료는 먼저 확인했다. 결과·명령·실패 이력·리뷰 판정은 저장소 문서에 보존했으며 임시 log/init/JAR 경로는 과거 검증 위치다. 모든 로컬 Goal 완료, 외부 배포 게이트는 별도 BLOCKED로 유지한다.
- 2026-11-11 최종 제한 리뷰: `REV-P1-001 ADDRESSED`, 로컬 backend gate `APPROVE`. 신규 blocker 없음. 원 reviewer session 유실 때문에 기존 전체 리뷰 판정과 오류 advice/두 테스트 delta만 대체 reviewer가 확인했으며 전체 리뷰를 반복하지 않았다. 재생성·AWS·운영 DB·live·2h는 구현/승인 범위에서 분리했다.
- 2026-11-11 `P1-R1` 검증: 2개 HTTP RED 후 수정, 신규 자막 15개 전체와 bootJar/변경 lint 통과 (`p1-green-15-build-lint.log`, 7m44s). 부모는 수정한 두 새 HTTP 사례만 재실행해 2/0/0/0 및 `BUILD SUCCESSFUL in 4m 55s` 확인. 실제 Tomcat port 59977/PID44707, XML timestamp `2026-11-10T15:34:43`. 기존 reviewer session continuation이 유실돼 이전 판정과 수정 delta만 전달한 단일 재리뷰를 진행 중이다. 같은 기능을 재설계하거나 전체 리뷰를 반복하지 않는다.
- 2026-11-10 독립 gate 리뷰: REQUEST_CHANGES 1건. 자막 advice가 ResponseStatusException만 처리하므로 빈 body/저장 실패가 기존 공통 advice에서 HTTP200으로 변환될 수 있다. 부모가 실제 공통 handler를 확인했고 전용 advice+새 HTTP 사례의 `P1-R1`로 수정한다. 나머지 저장/권한/언어별 구조/업로드/DDL 범위는 reviewer가 부합 판정했다.
- 2026-11-10 부모 검증: 격리 build/cache에서 신규 HTTP 13개를 up-to-date 무시하고 직접 재실행, 13 passed/0 failed/0 errors/0 skipped, `BUILD SUCCESSFUL in 2m 21s`. 같은 코드의 bootJar와 ktlint는 up-to-date 확인이며 구현 담당의 실제 실행 로그 `build-lint.log`는 `BUILD SUCCESSFUL in 1m 28s`다. 로컬 mapping의 `sourceUploadErrorAt` TIMESTAMP 차이는 해소했다. 기존 독립 reviewer 결과 회수 실패 및 session 유실로 승인을 주장하지 않고 대체 단일 reviewer를 실행 중이다.
- 2026-11-10 실제 ZIP 계약 대조: `unzip -p .../start-subtitle-transcription.zip common/transcribe.py`로 확장자 없는 원본 key가 `UNSUPPORTED_MEDIA`임을 확인했다. `common/runtime.py::source_content`는 UUID 뒤 확장자를 허용한다. 원본의 안전한 확장자를 보존하도록 등록 seam/새 테스트를 수정한다. 이는 기존 artifact의 read-only 계약 확인이며 Lambda 변경·실행·AWS 호출이 아니다. 확장자는 형식 보장이 아니며 기존 업로드/MediaConvert 동작을 미지원 자막 형식 때문에 막지 않는다.
- 2026-11-10 후속 설계 조정: 사용자에게 향후 언어 추가 가능성이 확인되어 고정 `koKey`/`jaKey` 대신 `Subtitle` 결과 행을 둔다. 현재 API 허용 언어/상태 판정은 ko/ja 고정 그대로다. 구현 담당과 DDL 담당을 잠시 중단하고 같은 session으로 갱신 계약을 전달한다. callback 원자성/terminal replay/조회 권한 새 테스트를 같은 구조로 갱신한다. 아래 Oracle의 고정 컬럼 권고는 당시 두 언어 고정 가정의 기록이며 이 결정으로 대체한다.
- 2026-11-10 후속 지시: 테스트는 이번에 작성한 것만 실행. 지시 반영을 위해 실행 중 implementer를 일시 중단하고 같은 session으로 재개한다. Kotlin 공유 파일은 기존 담당자가 소유하고 DDL/운영 문서만 병렬 분리한다. 이전 baseline 실행 이력은 아래에 보존하되 재실행하지 않는다.
- 2026-11-10: 현재 상태 조사 완료. Spring 자막/recovery 구현 없음, 기존 BOT 인증/업로드 보존. Phase 1 Lambda ZIP hash 대조 완료, AWS 상태는 미확인. 사용자 결정으로 재생성 전체 제외.
- 2026-11-10: PRD/계획 준비. 아직 production 코드 수정 및 테스트 실행 전이며 성공 결과를 주장하지 않는다.
- 2026-11-10: Oracle 경계 검토 완료. create orchestration은 `NOT_SUPPORTED`, 실제 등록은 필수 주입 `TransactionTemplate(REQUIRES_NEW)`로 분리한다. AI 관리자 create 바깥 transaction도 조정한다. content/source/job/최신 선택값을 한 번 저장한 뒤 S3 원본 업로드하고 후속 input 경로 재대입은 제거한다. 업로드 예외는 객체 생성 여부가 불명확하므로 처리 상태를 terminal로 덮지 않고 별도 업로드 오류만 기록해 수동 확인 대상으로 남긴다.
- 2026-11-10: 고정 두 언어 metadata는 job의 nullable 컬럼으로 최소 저장하고 별도 번역/checkpoint 구조는 만들지 않는다. receipt eventId는 case-sensitive unique, callback/started는 동일 job lock을 사용한다. 다른 job 사이 eventId 경합은 rollback 후 receipt 재조회로 판정한다.
- 2026-11-10: UUID 파일명 변경은 외부 MediaConvert의 ID 추출/output 명명 규칙 확인 전 **배포 BLOCKED**다. 현재 저장소에 외부 consumer의 운영 계약 증거가 없으며, 임의 prefix 완화로 숨기지 않는다. 자막 S3 bucket의 private CloudFront origin/서명 접근도 운영 확인 게이트다.
- 2026-11-10: baseline 명령 `./gradlew test --tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' --tests 'kr.co.vividnext.sodalive.member.MemberLoginResponseContractTest' --tests 'kr.co.vividnext.sodalive.jwt.TokenProviderTest'`는 `kaptGenerateStubsKotlin` 단계에서 200초 도구 제한으로 종료. 테스트 결과 없음. 기존 다른 Gradle 작업이 관찰되어 타 작업을 종료하지 않고 이 작업 전용 build/cache 경로로 검증을 격리한다.
## Schema-validation 커밋 전 재검증
- 2026-11-11 별도 `/commit-with-validation` 요청으로 `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleSchemaValidationTest'`를 실행했다.
- 결과: `BUILD SUCCESSFUL in 46s`, 테스트 1개, 실패/오류/건너뜀 0개. 기존 컬럼명의 Hibernate validation과 저장·재조회를 재확인했다.
- 전체 테스트와 실제 MySQL 기동은 실행하지 않았다. 사용자 전체 테스트 명령은 `./gradlew test`다.
+150
View File
@@ -0,0 +1,150 @@
# 자막 Phase 1 Spring 연동 PRD
## 문서 정보
- 작성일: 2026-11-10
- 상태: 재생성 제외 로컬 backend 구현·검증 완료. 운영 배포/외부 게이트는 별도 차단 상태.
- 구현 계획: [plan-task.md](plan-task.md)
- 기준: 사용자 제공 Phase 1 계약 및 후속 결정 "이번 스코프에 재생성 기능은 추가하지 않고 나머지만 진행"
## 1. 목표와 범위
기존 콘텐츠 업로드에 자막 원본 binding과 PENDING 작업을 연결하고, 기존 BOT JWT로 보호한 네 내부 API를 통해 Lambda 결과를 저장한다. 기존 콘텐츠 상세에서 요청 언어와 원본 열람 권한에 맞는 자막 정보만 반환한다.
Spring은 업로드/작업 등록/결과 저장/콘텐츠 접근 제어를 맡는다. Lambda의 S3 이벤트, Transcribe, 번역, SRT 생성은 이미 별도 구현되어 있으므로 다시 구현하지 않는다. 앱 플레이어 구현은 이 Spring 저장소의 변경 대상이 아니며 실제 앱 표시 검증은 외부 게이트다.
### 제외
- 사용자 결정에 따라 자막 재생성 전체: 새 공개 API, 새 job 생성 business action, START 직접 비동기 호출 모두 제외.
- Scheduler discovery, recovery/lease/fence/checkpoint/outbox/자동 복구, HMAC 인증, 신규 로그인/refresh 계약.
- 외부 프로젝트 수정, AWS 설정/배포/실데이터 변경, DB DROP, 적용 migration 편집/삭제.
- MediaConvert/AAC/preview/기존 알림의 기능 변경과 2GB 다운로드/probe pipeline.
## 2. 실제 현재 상태
| 영역 | 확인 결과 | 처리 |
|---|---|---|
| Spring 작업 트리 | `test`, 조사 기준 `fe620aa9`, 변경 없음 | 현 작업 트리에서 최소 변경 |
| 로그인/JWT/BOT | `MemberService.login`, `MemberRole.BOT`, `JwtFilter`, `TokenProvider` 존재 | 재사용, 공유 인증 약화 금지 |
| 콘텐츠 | `AudioContent`의 numeric PK, 기존 multipart 업로드와 상세/서명 URL 존재 | 보존 및 필요한 연결만 추가 |
| 업로드 | `AudioContentService.createAudioContent` 트랜잭션 안에서 S3 업로드 | S3 이벤트 전에 committed PENDING/source가 보이도록 조정 |
| 업로드 완료 | `uploadComplete`가 파일명의 contentId prefix 검사 후 경로/duration/알림 처리 | 기존 파일은 유지, 새 UUID 원본과의 정확한 연결 검증 필요 |
| 자막/recovery | 자막 API/job/worker/HMAC 및 자막 migration 검색 결과 없음 | 실제 삭제 대상 없음, 공유 텍스트 TranslationJob/JWT/Agora 보존 |
| DB 관리 | Flyway/Liquibase 의존성 없음, 기존 문서 SQL 관례 | additive MySQL DDL 문서만 작성, 운영 적용 여부 미확인 |
| 재생성 | 기존 action 없음. `generate-url`은 재생 URL 발급 | 이번 범위 제외 |
### Lambda handoff 확인
참조는 `/Users/klaus/Develop/sodalive/Lambda/generate-subtitle/aws-subtitle-service/docs/FINAL_REPORT.md`다. 실제 로컬 ZIP hash가 보고서 및 manifest와 일치함을 조사했다.
- `start-subtitle-transcription.zip`: `a0d0b19b2ecb24c0f89caf528bf09fd039558563a99063f082ac64418704abfd`
- `generate-subtitle.zip`: `bfa8742ca436bace853ec2540fc5f70daa24cbab49e75315565d980189fbf209`
이는 AWS 배포 상태의 증거가 아니다. 현재 운영 consumer/in-flight/Scheduler/DB 상태는 미확인이다. 이 저장소에 삭제할 legacy 자막 consumer는 발견되지 않았으며 외부 consumer 삭제/중지/교체는 하지 않는다.
## 3. 고정 계약
### 식별자와 저장 경로
- `contentId`: 기존 Long PK, JSON number. `jobId`: Spring 생성 UUID string.
- 원본: `input/{contentId}/{UUID filename}`, 같은 key 덮어쓰기 금지. VersionId 생성/사용 없음.
- 원본 파일의 안전한 확장자를 UUID 뒤에 보존한다(예: `{UUID}.mp3`). 실제 Phase 1 START ZIP의 `common/transcribe.py::validate_binding`은 `amr/flac/m4a/mp3/mp4/ogg/webm/wav` 확장자를 요구하며, 확장자 없는 key는 `UNSUPPORTED_MEDIA`다. 확장자는 형식 힌트일 뿐 실제 미디어 검증을 대신하지 않는다. 기존 업로드 허용 동작을 임의로 축소하지 않고 미지원 형식은 자막 실패와 기존 업로드를 구분한다.
- transcript: `transcripts/{contentId}/{jobId}/transcript.json`.
- 자막: `subtitles/{contentId}/{jobId}/ko.srt`, `subtitles/{contentId}/{jobId}/ja.srt`.
- 상태: `PENDING`, `PROCESSING`, `COMPLETED`, `PARTIAL_COMPLETED`, `FAILED`.
- 등록과 원본 binding은 S3 원본 업로드 전에 commit한다. 업로드 실패를 성공으로 숨기지 않으며 이미 commit된 job의 실패를 기록한다. 자동 복구는 추가하지 않는다.
### 내부 API: 정확히 네 개
모든 요청은 기존 `/member/login`에서 발급된 JWT의 BOT 권한을 검증한다. 일반 USER/CREATOR/ADMIN만으로 허용하지 않는다. unknown job/source는 404이며 조회 중 job을 만들지 않는다.
| Method | Path | 계약 |
|---|---|---|
| GET | `/internal/api/subtitle-jobs/resolve?bucket=...&key=...` | 업로드의 정확한 source binding 조회 |
| GET | `/internal/api/subtitle-jobs/{jobId}` | UUID job 조회 |
| POST | `/internal/api/subtitle-jobs/{jobId}/started` | 정확히 `transcribeJobName`, `status` |
| POST | `/internal/api/subtitle-jobs/callback` | 정확히 아래 8개 필드 |
조회 응답은 envelope 없이 `jobId`, numeric `contentId`, `status`, `source:{bucket,key,versionId:null}`다. recovery/provider/lease 정보는 노출하지 않는다.
started의 이름은 `subtitle-{jobId}`, status는 `PROCESSING`만 허용한다. PENDING만 PROCESSING으로 전이하고 같은 PROCESSING 및 terminal은 no-op이다. 성공은 200 `{}` 또는 204 empty다.
callback은 `eventId`, `jobId`, numeric `contentId`, `transcribeJobName`, `status`, `subtitles`, `errorCode`, `errorMessage`만 받는다. `eventId`는 비어 있지 않은 문자열로 UUID 제한을 하지 않는다. subtitle 항목은 `language`, `format`, `s3Bucket`, `s3Key`만 받는다. 언어는 `ko-KR`/`ja-JP`, format은 `SRT`, 언어 중복은 금지한다. 이름/job/content/configured bucket allowlist/정확한 자막 key를 검증한다.
- 2개 자막이면 COMPLETED, 1개면 PARTIAL_COMPLETED, 0개면 FAILED만 허용한다.
- COMPLETED의 errorCode/errorMessage는 명시적 null, partial/failed는 구체적 비어 있지 않은 오류를 요구한다. nullable 필드도 요청에서 생략하지 않는다.
- started 전 callback도 허용한다. callback 검증은 SRT 내용 검사로 위장하지 않는다. 실제 빈 파일/무음 방지는 기존 Lambda 및 live 검증 책임이다.
- receipt의 eventId와 **원래 HTTP body bytes의 SHA-256**을 상태/자막 metadata와 같은 DB 트랜잭션으로 저장한다. hash는 인증이 아니다.
- 같은 eventId/hash는 200, 같은 eventId/다른 hash는 422, terminal job의 다른 결과는 409다. 회귀 및 부분 반영 금지.
- 오래된 job의 결과는 자체 저장하되 콘텐츠 최신 선택 결과를 대체하지 않는다. 재생성 API가 제외되어도 이 저장 불변식은 유지한다.
### 로그인/권한/개인정보
기존 login 요청의 `isAdmin:false`, `isCreator:false`와 기존 `data.token` 응답을 바꾸지 않는다. 활성 EMAIL BOT의 DB role과 발급 JWT를 실제 인증 경로 테스트로 확인한다. Lambda의 success envelope/401 1회 갱신/403 갱신 금지 구현은 재작성하지 않는다.
credentials/JWT/body를 코드/로그/보고서에 출력하지 않는다. BOT 운영 계정 준비는 운영자 책임이다. 기존 JWT 등록/회원 권한/다른 role 경로는 그대로 보존한다.
### 언어별 저장 구조
추후 언어 추가 가능성을 반영해 `SubtitleJob`에 `koKey`/`jaKey` 같은 언어별 컬럼을 두지 않는다. `Subtitle` 결과 행에 `jobId`, `language`, `format`, `s3Bucket`, `s3Key`를 저장하고 `(jobId, language)` unique로 중복을 방지한다. 작업 상태/원본/오류는 `SubtitleJob`, callback 중복 방지는 receipt가 담당한다. callback transaction에서 결과 행도 함께 저장한다.
이번 Phase 1의 외부 계약은 그대로 유지한다. callback은 `ko-KR`/`ja-JP`만 허용하며 2개/1개/0개 결과의 상태 판정도 변경하지 않는다. 다른 언어 활성화, 언어 관리 API, 동적 provider 설정은 구현하지 않는다. 새 언어는 향후 계약·Lambda·조회 정책 변경이 필요하지만 언어별 DB 컬럼 추가는 필요 없도록 한다.
### 콘텐츠 상세 응답
기존 상세 API 응답에 nullable 자막 정보를 additive하게 제공한다. 기존 `LangContext`의 한국어/일본어에 맞는 완료 자막만 선택한다. 미지원 언어/미완료/없는 언어는 null이며 원문 복사 fallback을 만들지 않는다.
원본 재생이 가능한 구매/소유자/무료 조건과 공개 시점 등 기존 접근 제한을 통과한 경우에만 서명된 SRT URL을 제공한다. 유료 preview만 볼 수 있는 사용자는 전체 자막을 받지 않는다. 새로운 공개 download URI를 만들지 않는다.
## 4. 검증 시나리오
| 그룹 | 통과 조건 | 증거 |
|---|---|---|
| 1. 등록/조회 | S3 upload 경계에서 별도 transaction으로 PENDING/source 조회 가능, UUID/숫자 JSON 및 404 정확 | Spring DB/HTTP 테스트, upload 경계 assertion |
| 2. started | 단조 전이, duplicate/terminal no-op, 잘못된 이름/status 거부 | DB/HTTP 테스트 |
| 3. callback | complete/partial/fail, exact body hash replay, 422/409, callback-before-started, atomic rollback, older/latest guard | DB/HTTP 및 동시성 테스트 |
| 4. 로그인/보안 | 실제 active EMAIL BOT 로그인/JWT로 네 API 허용, 다른 role/익명 거부, 기존 envelope 보존 | 기존 로그인/JWT 회귀 및 통합 테스트 |
| 5. 콘텐츠 | ko/ja 선택 및 구매/소유자/무료/preview 권한 유지, 기존 업로드 완료/알림 회귀 없음 | 기존 콘텐츠 테스트와 추가 회귀 |
실제 서버 HTTP 요청으로 핵심 endpoint를 검증하고, 이번 작업에서 새로 작성한 테스트와 `bootJar`를 분리 실행한다. 기존 테스트는 읽어 계약을 보존하되 실행하지 않는다. 기존 클래스에 새 테스트를 추가한 경우 해당 메서드만 지정한다. 전체 테스트는 사용자 실행 `./gradlew test`로 남긴다. LSP 도구가 제공되지 않으면 Kotlin compile/lint 대체 결과와 미실행 사실을 명시한다.
## 5. 외부 게이트와 미검증
- AWS 접근/배포는 승인 없이 하지 않는다. 기존 consumer 운영 여부가 미확인이므로 삭제/전환/재개는 BLOCKED다.
- live ko/ja/mixed S3 -> callback -> 콘텐츠/앱 검증은 별도 승인 및 환경 필요. 실제 word/item 언어 evidence 없는 mixed 결과는 통과 불가. synthetic fixture는 대체 증거가 아니다.
- 2시간은 입력 목표이며 SLA/지원 보장이 아니다. 기존 신뢰 가능한 duration의 가용성과 검증 경계를 확인한다. 구형 또는 검증 불가능한 원본은 수동 게이트로 남기고 임의 client 값을 신뢰하지 않는다.
- 대표 2시간 처리 예산은 미측정이며 지원 검증 BLOCKED. 분할/상한 하향/Translate 50-call 제한을 추가하지 않는다.
- 운영 DB 적용 상태 미확인. DDL 적용/기존 데이터/미확인 환경에 대한 삭제는 하지 않는다.
## 6. Decision Log
| 날짜 | 결정 | 근거 |
|---|---|---|
| 2026-11-10 | 자막 재생성 기능 전체 제외, 나머지 진행 | 사용자 명시 결정 |
| 2026-11-10 | 현재 Spring 중심, 외부 참조는 명시된 Lambda handoff에 한정 | 사용자 범위 확인 |
| 2026-11-10 | 이미 있는 로그인/JWT/Lambda 재구현 금지, 자막 recovery 삭제 없음 | 실제 코드/ZIP 조사 |
| 2026-11-10 | 실행 테스트는 이번 작업에서 새로 작성한 사례만. 기존 focused 회귀 및 전체 테스트 실행 금지 | 사용자 후속 지시 |
| 2026-11-10 | 향후 언어 추가를 고려해 언어별 결과 행으로 저장, 이번 API는 ko/ja만 유지 | 사용자 확장 가능성 제시 및 중단 없이 진행 지시에 따른 최소 저장 구조 조정 |
## 7. 후속 범위: generate-url 자막 응답
2026-11-11 사용자 요청에 따라 기존 `GET /audio-content/{id}/generate-url` 응답에도 콘텐츠 상세와 동일한
nullable `subtitle`을 추가한다. 기존 `ApiResponse` envelope와 `data.contentUrl` 이름·타입·URL 생성 동작은 유지한다.
- `GenerateUrlResponse`에 `subtitle: ContentSubtitleResponse? = null`을 추가한다. 필드는 `language`, `format`, `url`이다.
- 기존 `orderRepository.isExistOrdered` 검사를 유지한다. 구매가 없으면 기존처럼 `contentUrl`은 빈 문자열이며 `subtitle`은 null이다.
- 상세와 달리 현재 generate-url은 소유자/무료 콘텐츠만으로 구매 검사를 우회하지 않는다. 이 요청으로 기존 URL 권한을 확대하지 않는다.
- 구매가 확인된 사용자의 자막은 상세와 같은 공개 시점 조건(미지정/도래 또는 소유자)을 적용한다. 기존 `contentUrl` 동작은 바꾸지 않는다.
- `SubtitleJobService.subtitle`을 재사용해 요청 `LangContext`의 ko/ja, 최신 job, 완료/부분 완료 및 해당 언어 존재 여부를 처리한다.
- 자막 미완료·누락·미지원 언어면 null이며 원문 fallback이나 새 자막 생성은 하지 않는다. 음원과 자막 서명 URL에는 같은 만료 기간을 전달한다.
- 컨트롤러 URI/인증·DB 스키마·Lambda·재생성은 변경하지 않는다. 검증은 이번 후속 작업에서 새로 작성한 HTTP 테스트만 실행한다.
## 8. Schema-validation 회귀 수정
2026-11-11 실제 기동에서 `Schema-validation: missing column [s3bucket] in table [subtitle]`가 보고됐다.
공개된 DDL의 `s3_bucket`/`s3_key`를 기준으로 엔티티의 물리 컬럼 이름을 명시한다.
Kotlin 속성 및 JSON 이름 `s3Bucket`/`s3Key`는 바꾸지 않고 DB 컬럼 추가/rename이나 전역 naming strategy 변경도 하지 않는다.
기존 테스트의 `ddl-auto:create-drop`은 잘못 추론된 이름으로 테이블을 함께 생성해 이 불일치를 가렸다.
신규 회귀 검증은 엔티티와 독립적으로 기존 DDL 컬럼 이름의 H2 테이블을 먼저 생성하고 실제 Hibernate
`validate` 및 저장/재조회로 두 필드를 확인한다. 실제 운영 MySQL 재기동을 검증했다고 주장하지 않는다.
@@ -0,0 +1,47 @@
# 자막 Phase 1 Backend Gate 리뷰
## 1. 리뷰 정보
- 일자: 2026-11-10
- 대상: `test` working tree의 신규 `v2.subtitle` 및 기존 업로드/상세/보안 연결
- 기준: [PRD](../prd.md), [계획](../plan-task.md), [구현 보고](../implementation-report.md)
- 리뷰어: 독립 Oracle (`ses_e3a1e039bffeXbBb7Nx0V7Hvk8`)
- 상태: 회귀 수정 검증 완료, 로컬 backend APPROVE
- 검토 제외: AWS/운영 DB/실음성/2시간 성능, 기존 전체 회귀 실행
## 2. 근거와 판정
부모 직접 실행의 실제 localhost HTTP 신규 테스트 13개가 0 failure/error/skip으로 통과했다.
reviewer는 코드·신규 테스트·실행 로그·DDL을 읽었고 테스트를 재실행하지 않았다.
저장/권한/언어별 결과/업로드/스키마는 부합 판정이나 HTTP 오류 경계 한 건으로 REQUEST_CHANGES다.
| ID | 심각도 | 상태 | 내용 | 수정 Goal |
|---|---|---|---|---|
| REV-P1-001 | High | 수정 완료 / ADDRESSED | 자막 빈 body/저장 실패가 공통 advice에서 HTTP200으로 변환 | P1-R1 |
## 3. REV-P1-001
- `SubtitleExceptionHandler.kt`는 ResponseStatusException만 처리한다.
- 기존 `common/SodaExceptionHandler.kt:73`과 `:94`는 DB 예외/일반 예외에 HTTP 상태 없이 ApiResponse.error를 반환한다.
- 필수 body가 비면 strict parser 이전에 HttpMessageNotReadableException이 발생한다.
- receipt 실패의 기존 새 테스트는 서비스 직접 호출 rollback만 검증하므로 HTTP200 문제를 포착하지 못했다.
- 영향: 결과가 저장되지 않았어도 Lambda가 HTTP 성공으로 해석할 수 있다.
최소 수정은 자막 controller에 한정된 advice에서 body 읽기 오류를 422, 예상하지 못한 서버 오류를
민감정보 없는 500으로 반환하는 것이다. 기존 404/409/422 및 공유 API 동작을 보존한다.
## 4. 수정 검증 조건
1. 빈 callback/started 요청이 200이 되는 RED를 실제 HTTP로 확인한다.
2. receipt 실패 callback이 200이 되는 RED와 전체 DB rollback을 확인한다.
3. 수정 후 422/500 및 무부분반영을 검증하고 이번 작성 테스트만 재실행한다.
4. 같은 reviewer가 수정 delta와 새 증거를 재검토한다.
## 5. 판정 기록
- 1차: REQUEST_CHANGES 1건. 부모가 공통 handler 코드를 직접 확인하고 `P1-R1`에 반영했다.
- 2026-11-11 수정 검증: 전용 advice만 수정하고 신규 HTTP 두 사례의 RED/GREEN을 확인했다. 이후 신규 자막15개·bootJar·변경 lint가 통과했고, 부모 직접 두 HTTP 사례 재실행도 2/0/0/0으로 통과했다. 기존 공통 handler와 직접 서비스 rollback 테스트는 보존했다. reviewer session continuation 유실로 기존 판정과 delta만 전달한 단일 재검토를 진행 중이다.
- 운영 배포는 코드 리뷰와 별개이며 [배포 게이트](../deployment-gates.md)의 차단 상태를 유지한다.
- 최종 제한 delta 리뷰 (`ses_e39e64c42ffeCOGUZjgeM4P1jf`): **REV-P1-001 ADDRESSED / 로컬 backend APPROVE**.
전용 advice의 422/500, 기존 404/409/422 유지, 실제 HTTP 및 rollback RED/GREEN 증거를 확인했다.
수정 delta에서 신규 버그/blocker는 발견하지 못했다. 추가 코드 수정 불필요 판정이며 전체 리뷰 반복이나 기존 테스트 실행은 하지 않았다.
@@ -0,0 +1,16 @@
# generate-url 자막 응답 제한 리뷰
- 일자: 2026-11-11
- 범위: `P2-T1`, `GenerateUrlResponse`와 `AudioContentService.generateUrl`, 새 HTTP 테스트3개.
- 기준: PRD §7, plan-task P2, 실제 메서드/DTO 전후 diff 및 `generate-url-report.md`의 RED/GREEN 증거.
- 리뷰어: `ses_e387b1e8fffensjb6dnoRk82ST`, read-only. 기존 Phase1 전체는 다시 리뷰하지 않았다.
- 판정: **APPROVE**, 이번 범위의 확정 finding/blocker/새 회귀 없음.
확인한 기준:
1. contentUrl과 ApiResponse envelope 유지, 공유 nullable subtitle만 additive 추가.
2. 활성 구매(KEEP/유효 RENTAL) 정책 유지, 소유자·무료만으로 우회하지 않음.
3. 음원 URL은 기존대로이며 자막에만 상세와 동일한 공개일/소유자 조건 적용.
4. 동일 expirationTime 전달 및 공유 latest/언어/상태별 자막 조회 재사용.
5. 새 HTTP3개 RED → GREEN 및 부모 재실행3/0/0/0, 실제 localhost HTTP/JWT/H2 증거 확인.
잔여사항: production lint의 기존 서비스 EOF 빈 줄1건은 보존했다. 기존 테스트/전체 테스트/LSP 및 실제 AWS 서명·다운로드/운영 배포는 이번 검증이 아니다. 수정 Task로 전환할 새로운 발견 사항은 없다.
@@ -0,0 +1,15 @@
# Subtitle 물리 컬럼명 회귀 리뷰
- 일자: 2026-11-11
- 범위: `P3-R1`, Subtitle의 두 Column annotation과 신규 ORM schema-validation 테스트.
- 기준: PRD §8, plan-task Phase3, 실제 RED/GREEN 로그와 production diff.
- 리뷰어: `ses_e37b4db2bffeUyLw5vO2EtHHuG`, read-only.
- 판정: **APPROVE**, 범위 내 확정 finding/blocker 없음.
검토 결과: `s3Bucket`/`s3Key`의 기본 추론 이름을 기존 DDL의 `s3_bucket`/`s3_key`로 명시했다.
Kotlin/JSON 이름·타입/길이/nullable, DDL과 전역 전략은 그대로다. 신규 테스트는 독립 테이블에서 실제
Hibernate validate, commit 후 새 Session 및 직접 JDBC 컬럼 조회를 수행한다. RED missing[s3bucket]과
GREEN1/0/0/0, bootJar 및 변경 lint 성공을 확인했다. 기존 create-drop 테스트의 한계를 반복하지 않는다.
미검증: 실제 MySQL 기동/collation/FK, 전체 Spring 연동, 기존 테스트/전체 테스트, LSP.
추가 수정 Task 없음. 운영 DB 변경이나 배포 승인을 의미하지 않는다.
@@ -0,0 +1,86 @@
# Subtitle 컬럼명 schema-validation 회귀
## 원인과 범위
사용자가 보고한 `Schema-validation: missing column [s3bucket] in table [subtitle]`를 실제 Hibernate로 재현했다.
`Subtitle.s3Bucket`/`s3Key`에 물리 컬럼 이름이 없었고, 기본 naming strategy는 숫자 `3` 다음 대문자 앞에
underscore를 넣지 않아 `s3bucket`/`s3key`로 변환한다. 기존 DDL은 `s3_bucket`/`s3_key`이므로 불일치했다.
production 수정은 `Subtitle.kt`의 두 annotation뿐이다:
```kotlin
@Column(name = "s3_bucket", nullable = false, length = 255)
val s3Bucket: String,
@Column(name = "s3_key", nullable = false, length = 255)
val s3Key: String
```
Kotlin/JSON 필드명, 기존 DDL, 전역 naming strategy, 운영 DB는 변경하지 않는다.
잘못 추론된 이름의 DB 컬럼을 새로 만들거나 `ddl-auto`를 update/none으로 바꿔 오류를 숨기지 않는다.
## 기존 검증의 공백
기존 HTTP 테스트는 `ddl-auto:create-drop`으로 엔티티 기준 테이블을 자동 생성했으므로 잘못된 컬럼명으로
테이블과 ORM이 동시에 일치했다. 앞선 정적 DDL/JPA 대조도 숫자-대문자 경계의 이름 변환을 놓쳤다.
해당 완료 이력은 보존하되 이번 재현으로 그 검증 한계를 명확히 정정한다.
## 신규 회귀 테스트
`SubtitleSchemaValidationTest.shouldValidateAndUseExistingS3Columns` 한 개만 실행한다.
1. 엔티티와 독립적으로 H2에 `s3_bucket`/`s3_key`를 포함한 테이블을 직접 생성한다.
2. `HibernateProperties`/`HibernateSettings`로 Boot 기본 설정을 얻고 실제 Hibernate의 `hbm2ddl.auto=validate`를 실행한다.
3. `Subtitle`을 저장하고 새 Session 및 직접 JDBC SELECT로 두 컬럼의 값을 확인한다.
전체 Spring context/Redis/AWS 및 mock 없이 ORM 저장 표면을 검증한다. DB는 테스트 전용 메모리 H2이며
실제 MySQL collation/FK/운영 기동 전부를 검증하는 테스트는 아니다.
## 실행 기록
- RED: 새 테스트1개/실패1개/오류0/skip0, XML UTC `2026-11-11T01:42:01`.
- 실제 실패: `SchemaManagementException: Schema-validation: missing column [s3bucket] in table [subtitle]`.
- RED 빌드 결과: `BUILD FAILED in 3m 49s`. 컴파일 오류가 아닌 보고된 운영 오류와 동일한 validation 실패다.
- GREEN: 새 테스트1개/실패0/오류0/skip0, XML UTC `2026-11-11T01:46:49`.
- 실제 Hibernate validation 성공 후 저장/new Session 조회/직접 JDBC 두 컬럼 조회가 통과했다.
- `bootJar` 및 변경 엔티티/신규 테스트에 한정한 `ktlintCheck` 성공, `BUILD SUCCESSFUL in 3m 29s`.
- LSP 도구 미제공으로 Kotlin 컴파일·변경 파일 lint를 사용했다.
- 독립 한정 리뷰 `ses_e37b4db2bffeUyLw5vO2EtHHuG`: **APPROVE**. 두 annotation만 변경됐고 독립 DDL/실제 ORM roundtrip 테스트가 원인에 맞는 것을 확인했다. 신규 blocker 없음.
일반 환경의 신규 테스트 실행 명령:
```bash
./gradlew test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleSchemaValidationTest'
```
격리 실행은 작업 소유 root `subtitle-schema-fix.XcftjN`의 init script로 build/project-cache와 테스트 compile/lint
입력을 이 변경에 한정한다. production source는 필터링하지 않는다. 기존 테스트와 전체 테스트는 실행하지 않는다.
실제 격리 실행 명령(RED는 `test`까지만, GREEN은 아래 전체):
```bash
export VERIFY_ROOT=/var/folders/yh/8xsbvpsj5wg2qnxzxdp11_gm0000gn/T/opencode/subtitle-schema-fix.XcftjN
export TMPDIR="$VERIFY_ROOT" NODE_COMPILE_CACHE="$VERIFY_ROOT/node-compile-cache"
export BUN_RUNTIME_TRANSPILER_CACHE_PATH="$VERIFY_ROOT/bun-transpiler"
./gradlew --offline --no-daemon --max-workers=2 \
-Pkotlin.compiler.execution.strategy=in-process -Dorg.gradle.jvmargs=-Xmx4g \
--project-cache-dir "$VERIFY_ROOT/project-cache" --init-script "$VERIFY_ROOT/verification.init.gradle" \
test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleSchemaValidationTest' bootJar ktlintCheck
```
로그는 위 root의 `red.log`, `green.log`다. 실제 운영 DB 접속·DDL 변경·서버 배포/재시작·기존 테스트 실행은 하지 않았다.
## 정리
검증·리뷰 후 작업 root를 참조하는 프로세스의 부재를 확인하고 소유 root/build/cache/log/JAR를 제거했다.
`test ! -e` exit0으로 확인했으며 위 임시 경로는 과거 검증 위치다. 공유 캐시/다른 작업은 변경하지 않았다.
새 테스트/원인/명령/결과와 리뷰 기록은 저장소에 남겼고 이번 수정은 커밋하지 않았다.
## 후속 커밋 검증
2026-11-11 별도 `/commit-with-validation` 요청으로 요구사항·계획은 `cf31c570`, 수정·회귀 테스트는
`c3e5f19c`에 커밋했다. 두 커밋 모두 저장소 메시지 검증 스크립트의 직전·직후 검증을 통과했다.
수정 커밋의 pre-commit hook에서 변경 Kotlin 2개 파일의 `ktlintCheck`도 통과했다.
`./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.v2.subtitle.SubtitleSchemaValidationTest'`를
재실행해 `BUILD SUCCESSFUL in 46s`, 테스트 1개/실패 0/오류 0/건너뜀 0을 확인했다.
전체 테스트·실제 MySQL 기동·bootJar는 이번 커밋 작업에서 실행하지 않았다. 전체 테스트 사용자 명령은 `./gradlew test`다.
@@ -0,0 +1,53 @@
-- 자막 Phase 1 미출시 초안. 운영 DB 적용/호환성은 확인하지 않았다.
-- 실행 전 deployment-gates.md의 엔티티 대조 및 운영 DB 게이트 승인이 필요하다.
-- MySQL 8.0.17 이상, utf8mb4_0900_bin(NO PAD), InnoDB 3072-byte 인덱스 지원이 전제다.
-- 대소문자와 후행 공백을 보존하여 eventId 및 S3 bucket/key를 정확히 구별한다.
-- source_upload_error_at은 최종 JPA의 TIMESTAMP 선언과 초 단위 정밀도를 맞췄다.
CREATE TABLE subtitle_job (
job_id VARCHAR(36) NOT NULL COMMENT 'Spring 생성 자막 작업 UUID',
content_id BIGINT NOT NULL COMMENT '기존 콘텐츠 Long 식별자',
source_bucket VARCHAR(255) NOT NULL COMMENT '최초 등록 원본 S3 버킷',
source_key VARCHAR(255) NOT NULL COMMENT '최초 등록 원본 S3 객체 키',
output_key VARCHAR(255) NOT NULL COMMENT 'MediaConvert 출력 객체 키의 확장자 제외 경로',
status VARCHAR(32) NOT NULL COMMENT '자막 작업 상태',
error_code VARCHAR(255) NULL COMMENT '자막 처리 오류 코드',
error_message TEXT NULL COMMENT '자막 처리 오류 설명',
source_upload_error_code VARCHAR(255) NULL COMMENT '원본 업로드 불확실성 오류 코드',
source_upload_error_at TIMESTAMP NULL DEFAULT NULL COMMENT '원본 업로드 오류 기록 시각',
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '수정 시각',
PRIMARY KEY (job_id),
UNIQUE KEY uk_subtitle_job_source (source_bucket, source_key),
KEY ix_subtitle_job_content_created (content_id, created_at)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC
DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin
COMMENT='원본 binding과 자막 작업 상태 및 오류';
CREATE TABLE subtitle (
id BIGINT NOT NULL AUTO_INCREMENT COMMENT '언어별 자막 결과 Long 식별자',
job_id VARCHAR(36) NOT NULL COMMENT '소속 자막 작업 UUID',
language VARCHAR(35) NOT NULL COMMENT '자막 언어 태그',
format VARCHAR(16) NOT NULL COMMENT '자막 파일 형식',
s3_bucket VARCHAR(255) NOT NULL COMMENT '자막 결과 S3 버킷',
s3_key VARCHAR(255) NOT NULL COMMENT '자막 결과 S3 객체 키',
PRIMARY KEY (id),
UNIQUE KEY uk_subtitle_job_language (job_id, language),
CONSTRAINT fk_subtitle_job FOREIGN KEY (job_id) REFERENCES subtitle_job (job_id)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC
DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin
COMMENT='작업별 언어별 자막 결과';
CREATE TABLE subtitle_callback_receipt (
event_id VARCHAR(255) NOT NULL COMMENT 'callback 중복 방지 이벤트 식별자',
job_id VARCHAR(36) NOT NULL COMMENT 'callback 대상 자막 작업 UUID',
body_hash VARCHAR(64) NOT NULL COMMENT '원래 HTTP body bytes의 SHA-256 소문자 16진수',
created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '생성 시각',
PRIMARY KEY (event_id)
) ENGINE=InnoDB ROW_FORMAT=DYNAMIC
DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin
COMMENT='callback 이벤트와 원본 요청 본문 해시 수신 기록';
ALTER TABLE content
ADD COLUMN latest_subtitle_job_id VARCHAR(36)
CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_bin NULL DEFAULT NULL COMMENT '최신 선택 자막 작업 UUID';
@@ -0,0 +1,471 @@
# 메타데이터 자동 번역 신속 반영 구현 계획
| 항목 | 내용 |
|---|---|
| 상태 | 시리즈 상세 동기 번역 포함 구현·기능 검증·독립 리뷰 완료 |
| 작성일 | 2026-11-16 |
| 요구사항 | [prd.md](prd.md) |
| 현재 활성 Goal | 없음 |
| 다음 Goal | 없음 |
## 목표와 제약
기존 DB 큐에서 감지 후 작업 등록, 최초+5회 재시도, 요청 시 실패 재개, AWS 번역 우선과 1초 워커를 제공한다.
Kotlin 1.6.21, Java 17, Spring Boot 2.7.14와 기존 패키지/스키마/API/캐시를 유지한다.
새 worktree, 커밋, 배포, 외부 유료 호출은 만들지 않는다. 시작 작업 트리는 깨끗했고 현재 브랜치는 test다.
단일 구현 Goal 안에서 파일이 겹치지 않는 작업을 분담하며, Gradle 실행은 부모가 직렬로 관리한다.
전체 테스트는 사용자 실행 `./gradlew test`이며 에이전트는 기능별 테스트, ktlintCheck, bootJar만 실행한다.
## Phase 1: 번역 수명주기와 요청 연결
- [x] **Task 1.1: 순서·재시도·신속 처리 구현**
**Goal P1-T1:** 감지 성공부터 실패 소진 후 재요청까지 번역 상태가 요구사항대로 이어진다.
- 시작 조건: MT-001~007 확정, PRD와 이 계획 준비.
- 완료 증거: 아래 RED/GREEN, 트랜잭션 저장/롤백과 재개 검증, 기능별 회귀 통과.
- 범위 밖: 감지 자체 새 재시도, 외부 API/브로커 추가, 운영 데이터 일괄 변경, 응답 스키마 변경.
### 작업 A: 공통 큐와 워커
파일:
- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRepository.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorker.kt`
- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobSchedulerTest.kt`
- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobWorkerTest.kt`
- 같은 테스트 패키지의 DB 재시도 통합 테스트.
계약: 기존 scheduleMissingTranslation 시그니처를 유지한다. 기존 FAILED 행만 원자적으로 재개하고 현재 원문 해시를 사용한다.
진행 중 작업과 완료 작업은 요청으로 초기화하지 않는다. 워커는 최초 실행 뒤 5회 재시도하며 1/5/15/15/15분 지연을 사용한다.
기본 fixedDelay는 1000ms이며 5개 그룹 처리와 SKIP LOCKED claim을 유지한다.
재개 DB 경계는 `TranslationJobRepository.restartFailedJob(jobId: Long, now: LocalDateTime): Int` 조건부 update다.
id와 FAILED 조건으로 4개 필드를 함께 변경하며 persistence context를 자동 clear하지 않는다.
- [x] **RED:** 기존 행의 상태별 재개, 동시 재개, 5회 재시도 경계와 1초 설정의 실패 테스트 작성.
- [x] **RED 확인:** `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest'`에서 의도한 assertion 실패 확인.
- [x] **GREEN:** 기존 상태 전이와 DB 경합 경계에서 최소 구현.
- [x] **GREEN 확인:** 동일 focused 테스트와 추가 DB 통합 테스트 통과.
- [x] **REFACTOR:** 새 중복만 정리하고 캐시/부분 실패 회귀를 기능별 실행.
### 작업 B: 언어 감지와 콘텐츠 수정
파일:
- `src/main/kotlin/kr/co/vividnext/sodalive/content/LanguageDetectEvent.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/admin/content/AdminContentService.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/creator/admin/content/CreatorAdminContentService.kt`
- 직접 생성자를 쓰는 해당 기능의 테스트 fixture.
- `src/test/kotlin/kr/co/vividnext/sodalive/content/`의 감지 트랜잭션 통합 테스트 및 관련 관리자 수정 테스트.
계약: 일반 메타데이터 감지 성공 후 ResourceTranslationJobScheduler를 같은 트랜잭션에서 직접 호출한다.
커뮤니티의 기존 revision/hash 검증과 after-commit 경로는 보존한다.
관리자 제목/설명 변경과 크리에이터 관리자 태그 없는 제목/설명 변경도 커밋 후 번역 이벤트를 발행한다.
- [x] **RED:** 실제 DB로 감지 후 작업 존재/롤백, 태그 없는 관리자 텍스트 수정의 작업 요청 누락을 재현.
- [x] **RED 확인:** 해당 신규 감지 테스트와 관련 관리자 기능 테스트에서 의도한 실패 확인.
- [x] **GREEN:** 기존 서비스/리스너에 최소 연결 수정.
- [x] **GREEN 확인:** 감지·관리자 수정 focused 테스트 통과.
- [x] **REFACTOR:** 커뮤니티 감지/동시성 기능 회귀를 별도 실행하고 기존 보호 확인.
### 작업 C: 공급자 기본 순서
파일:
- `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`
- `src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderSpringConfigurationTest.kt`
- 필요한 production 기본값 소유 테스트.
- `docs/20261109_감지번역공급자공통화/provider-guide.md`
계약: 번역 AWS/Papago, 감지 Papago/AWS. 기존 캐시와 fallback 유지.
- [x] **RED:** 기본 Spring 설정에서 실제 coordinator가 AWS 번역을 선택하고 감지는 Papago를 선택하는 실패 테스트.
- [x] **RED 확인:** `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderSpringConfigurationTest'`의 선택 결과 실패 확인.
- [x] **GREEN:** production 순서와 현재 가이드 변경.
- [x] **GREEN 확인:** 같은 테스트 및 provider/coordinator 관련 기능 회귀 통과.
- [x] **REFACTOR:** 과거 이력은 보존하고 현재 실행 안내만 정합성 확인.
### 작업 D: 조회 시 실패 재개
파일:
- `src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt`
- `src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt`
- 해당 기능의 기존/신규 focused 테스트.
최종 HTTP/DB 연결 확인 파일:
`src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataTranslationHttpIntegrationTest.kt`.
실제 관리자 controller multipart 요청과 Spring 서비스/이벤트/DB를 실행하고 동일 FAILED 행 재개와 필드별 작업 저장을 검증한다.
외부 공급자는 호출하지 않고 비동기 executor를 테스트에서 동기 실행하여 커밋 후 동작을 결정적으로 확인한다.
계약: 기존 번역 요청 진입점에서 현재 원문과 대상 locale의 FAILED를 재개한다. 이전 번역 행이 있어도 요청이 전달된다.
원문 fallback과 기존 번역 응답을 유지하고, 관계없는 목록 전체에 번역 요청을 추가하지 않는다.
추가 공통 파일: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt`.
읽기 전용 상위 트랜잭션에서도 저장 가능한 `restartFailedResourceTranslations(resourceType, resourceIds: Collection<Long>, targetLanguage)`
REQUIRES_NEW 진입점을 사용한다. FAILED 후보가 없으면 원문을 불필요하게 추출하지 않으며, 현재 원문에 해당하는 작업만 재개한다.
커뮤니티 쓰기 잠금 안에서는 이 REQUIRES_NEW 읽기 진입점을 호출하지 않고 기존 REQUIRED 예약으로 처리한다.
계획 검토에서 제안된 모든 projection/list의 광범위한 변경은 채택하지 않고 PRD의 기존 번역 요청 경계로 한정한다.
- [x] **RED:** 이전 번역이 존재하는 상태에서도 조회가 현재 원문의 FAILED를 재개하는 실패 테스트.
- [x] **RED 확인:** 변경 기능의 focused 테스트에서 의도한 실패 확인.
- [x] **GREEN:** 기존 요청 분기의 예약 위치를 조정한다.
- [x] **GREEN 확인:** 각 기능 focused 테스트 통과.
- [x] **REFACTOR:** 실제 DB 재개 주기와 기존 응답 유지 확인.
### Phase 1 Gate
**Goal P1-GATE:** MT-001~007과 직접 영향 기능의 검증/리뷰 증거를 판정한다.
- 시작 조건: P1-T1의 구현과 focused RED/GREEN 완료.
- TDD 예외 사유: Gate는 기존 구현 검증/리뷰이며 새 동작을 추가하지 않는다.
- 완료 증거: 기능별 테스트, lint/bootJar, DB 동작 QA, 단일 독립 리뷰와 문서 갱신.
- 범위 밖: 전체 테스트, 실 AWS/Papago/IAM 및 운영 MySQL/배포 검증.
- [x] 번역 공통 패키지 및 언어 감지 캐시 기능 회귀.
- [x] 콘텐츠/관리자 수정·시리즈·테마·카테고리·캐릭터/원작·커뮤니티의 직접 영향 기능별 회귀.
- [x] `./gradlew --no-daemon ktlintCheck bootJar` 통과.
- [x] 실제 트랜잭션의 저장/롤백, 실패 소진 후 조회/수정 재개, 캐시 재사용 QA.
- [x] 한 명의 리뷰어가 요구사항/동시성/테스트 증거 검토, 지적 사항 해결.
- [x] PRD/계획 완료 상태와 미검증 범위 기록.
## 검증 기록
### 후속 Goal P1-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 우선으로 전환
- 시작 조건: 사용자가 기존 감지 캐시 유지와 AWS/Papago 순서를 승인했다.
- 완료 증거: Spring 기본 감지 AWS 선택, 실제 AWS adapter SDK 응답 처리, AWS 실패 시 Papago, 기존 Papago 캐시 무호출 재사용.
- 범위 밖: 감지 알고리즘/confidence/지원 언어/캐시 무효화/번역·재시도 재설계.
- production 파일: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/LanguageProviderOrder.kt`.
- 테스트 파일: 같은 i18n/translation 테스트 패키지의 `LanguageProviderSpringConfigurationTest.kt`, `LanguageProviderIdTest.kt`, `LanguageDetectionProviderTest.kt`, `LanguageProviderCacheEndToEndTest.kt`.
- 문서: 기존 PRD 및 `docs/20261109_감지번역공급자공통화/provider-guide.md`.
- [x] **RED:** 기본 설정의 AWS 감지와 fallback/cache 회귀 기대를 작성하고 의도한 실패 확인.
- [x] **GREEN:** detectionOrder만 AWS/Papago로 변경하고 관련 감지·설정·캐시 테스트 통과.
- [x] **REFACTOR:** 현재 가이드 갱신, ktlintCheck/bootJar, 후속 delta 리뷰와 임시 자원 정리.
- 검증 명령: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProvider*Test' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageDetectionProviderTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageDetectionProviderTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.PapagoLanguageDetectionProviderTest' --tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest'`.
### 후속 회귀 Goal P1-R1: 다른 원문 언어의 FAILED 보존
- 시작 조건: gate reviewer가 MT-003의 현재 원문 한정 재개 누락을 확인했다.
- 완료 증거: 같은 해시/다른 원문 언어 작업은 직접 예약과 번역 행 없는 조회 모두에서 재개되지 않는다.
- 범위 밖: 작업 고유 키/스키마 변경, 이전 언어 데이터 변환, materializer 재설계.
- 파일: `src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobScheduler.kt`,
`src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/TranslationJobRetryIntegrationTest.kt`,
`src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt`.
- [x] **RED:** 두 경로의 다른 원문 언어 FAILED 보존 회귀 테스트 추가.
- [x] **RED 확인:** 두 테스트 클래스에서 FAILED 기대/PENDING 실제 실패 확인.
- [x] **GREEN:** FAILED 재개 조건에 정규화된 현재 원문 언어 일치 추가.
- [x] **GREEN 확인:** 두 테스트 클래스 및 직접 영향 scheduler/read/HTTP 테스트 통과.
- [x] **REFACTOR:** lint/build 및 차단 사항 delta 재검토 완료.
- 2026-11-16 기준 상태: Java 17.0.15, 작업 트리 깨끗함, 기존 브랜치 test에서 작업한다.
- 구현 전 `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderSpringConfigurationTest'`: exit 0, 16초. 기존 Gradle 9 호환성 deprecation 안내가 출력됐다.
- 전체 테스트는 미실행이며 사용자 실행 명령은 `./gradlew test`다.
- 2026-11-16 RED: worker/scheduler/retry DB/provider Spring/provider ID/coordinator 43건 중 14건이 의도한 assertion으로 실패했다. 기본 600000ms, 조기 FAILED, 기존 FAILED 미재개, Papago 우선이 각 실패 원인이며 컴파일은 성공했다.
- 2026-11-16 공급자 GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderSpringConfigurationTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderIdTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinatorTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProviderCacheEndToEndTest'`: exit 0, 37초. 기본 AWS 선택, Papago 감지 유지, fallback와 실제 H2 캐시/조회 결과 보존을 확인했다.
- 2026-11-16 연결 RED와 큐 GREEN: `./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' --tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*' --tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorkerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest'`: exit 1, 감지 10건·조회 10건·관리자 수정 8건이 의도한 assertion으로 실패했다. 같은 실행의 worker 13건/scheduler 3건/retry DB 9건은 모두 통과했다. H2에서 기존 FAILED 재개, 동시 요청, RUNNING 선점 뒤 오래된 요청 보호, 자동 재개 금지를 확인했다. H2 claim은 운영 쿼리의 SKIP LOCKED 옵션만 제거한 테스트이며 MySQL 잠금 동작 검증이 아니다.
- 2026-11-16 연결 GREEN: 감지 10건, 조회 15건, 관리자 수정 8건, HTTP 1건 통과. 이후 번역/감지 회귀 191건과 직접 영향 기능 회귀 67건(HTTP 1건 중복)을 실행해 총 257개 고유 사례에서 실패/오류/skip 0을 확인했다.
- 2026-11-16 최종 lint/build: 첫 main/test 인자 줄바꿈 위반을 변경 부분에서 수정한 뒤 ktlintCheck/bootJar 및 직접 수정 기능 49건을 함께 실행해 exit 0을 확인했다. HTTP test는 이벤트 발행을 끊는 변이로 DB assertion RED도 확인하고 원상 복구했다.
- 정확한 회귀 명령·QA 관찰값·원본 증거 경로·H2/Redis 로그 한계는 [검증 기록](reviews/verification.md)에 보존한다. 현재 단일 독립 reviewer 판정 대기다.
- 2026-11-16 P1-R1: reviewer가 일반 예약 경로에서 이전 원문 언어의 FAILED도 재개하는 누락을 확인했다. 직접 scheduler와 번역 행 없는 원작 조회 2건의 RED를 확인하고 원문 언어 일치 guard를 추가했다. 직접 영향 74건과 ktlintCheck/bootJar는 exit 0이며 추가 2건을 포함한 고유 검증 사례는 259건이다. delta 재검토 대기.
- 2026-11-16 최종 Gate: 동일 독립 reviewer가 P1-R1 수정과 RED/GREEN/XML 74건 및 lint/build 증거를 대조해 APPROVE했다. 차단 사항 없음. 전체 테스트와 운영 MySQL/외부 공급자 검증은 별도이며 커밋·배포는 하지 않았다.
- 2026-11-16 P1-T2: 감지 AWS 우선 변경 전 기본값/실제 SDK adapter/기존 캐시 관련 7개 assertion RED를 확인했다. detectionOrder 한 줄 변경 후 명시된 감지·공급자·캐시 기능 테스트 49건(8개 클래스, 실패/오류/skip 0) 및 ktlintCheck/bootJar가 exit 0이다. 후속 delta 리뷰 대기.
- 2026-11-16 P1-T2 최종: 독립 reviewer APPROVE. 현재 가이드의 잔여 PAPAGO 우선 테스트 설명도 AWS로 정정했다. 이전 기능 검증 기록과 완료 상태를 보존하며, 후속 감지 변경까지 완료했다.
- 2026-11-16 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-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`다.
@@ -0,0 +1,71 @@
# 메타데이터 자동 번역 신속 반영 PRD
| 항목 | 내용 |
|---|---|
| 작성일 | 2026-11-16 |
| 상태 | 콘텐츠·시리즈 상세 동기 번역 및 연관 제목 번역 구현·기능 검증·독립 리뷰 완료 |
| 구현 계획 | [plan-task.md](plan-task.md) |
| 결정권자 | 사용자 |
## 목적과 현재 문제
콘텐츠, 시리즈, 테마 등 기존 메타데이터 번역의 작업 등록 누락과 10분 대기를 줄인다.
언어 감지 결과 저장 전 별도 비동기 번역 이벤트가 실행될 수 있고, 관리자 콘텐츠 수정에는 이벤트 미발행 경로가 있다.
기존 FAILED 작업은 같은 원문으로 요청해도 재개되지 않으며, 워커는 기본 10분 간격이다.
## 확정 요구사항
| ID | 요구사항 | 수용 기준 |
|---|---|---|
| MT-001 | 언어 감지 성공 후 번역 작업을 등록한다. | 기존 일반 메타데이터 감지 경로는 감지된 languageCode와 translation_job을 같은 트랜잭션에 저장한다. 작업 등록 실패 시 언어 저장도 롤백한다. 커뮤니티의 기존 revision/hash 검증은 보존한다. |
| MT-002 | 최초 번역 후 최대 5회 재시도한다. | 한 주기는 최초 시도 1회와 재시도 5회, 총 6회다. 6번째 실패 후 FAILED로 멈춘다. 자동 재시도 지연은 1분, 5분, 이후 15분이다. |
| MT-003 | 소진 후 조회/수정 요청으로 다시 최대 5회 재시도한다. | 현재 원문에 해당하는 기존 FAILED 행을 PENDING, retryCount=0, lastErrorMessage=null, nextRetryAt=요청 시각으로 재개한다. PENDING/RUNNING/COMPLETED는 요청으로 초기화하지 않는다. 중복 요청이 실행 중 재시도 예산을 늘리지 않는다. |
| MT-004 | AWS 감지와 번역을 먼저 사용한다. | 새 외부 감지·번역은 모두 AWS 다음 Papago다. 기존 Papago 포함 유효 캐시를 우선 재사용한다. |
| MT-005 | 번역을 빠르게 반영한다. | 워커 기본 fixedDelay는 1000ms, 실행당 최대 5개 그룹을 유지한다. 실제 완료 시간은 대기량과 외부 API 처리 시간에 좌우된다. |
| MT-006 | 콘텐츠 수정과 기존 조회 흐름을 연결한다. | 일반 관리자 제목/상세 수정과 크리에이터 관리자 태그 없는 제목/상세 수정도 작업을 요청한다. 기존 번역 응답이 남아 있어도 관련 조회 요청은 현재 원문의 FAILED 작업을 재개할 수 있다. |
| MT-007 | 기존 계약과 경쟁 처리를 유지한다. | ko/en/ja, 공개 API/원문 fallback, provider별 캐시, SKIP LOCKED 작업 claim, 커뮤니티 revision 보호를 유지한다. job 등록/재개와 워커의 상태 경쟁을 DB 조건 또는 잠금으로 보호한다. |
| 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 복구 경로를 사용한다. 시리즈 원문 필드, 장르, 권한, 응답 스키마를 유지한다. 하위 콘텐츠 목록은 저장된 제목 번역만 사용하며 신규 동기 번역을 생성하지 않는다. 동시 원문 변경을 덮어쓰지 않는다. |
## 구현 결정
- 새 메시지 브로커, 외부 API, 의존성, DB 스키마를 추가하지 않고 기존 scheduler/worker를 사용한다.
- 최초 시도와 별도로 재시도 5회를 부여하는 것으로 사용자 문구를 해석한다. 이 해석은 실행 시작 시 사용자에게 명시했다.
- 감지 실패 시 번역은 실행하지 않는다. 감지 자체의 새 재시도 시스템과 운영 데이터 일괄 복구는 이번 범위가 아니다.
- 기존 번역을 즉시 삭제하지 않고 작업 완료 시 교체한다. 원문 변경 후 조회 fallback 계약은 유지한다.
- 조회/수정은 기존 번역 기능 진입점에서 처리한다. 관계없는 모든 목록 API에 새 번역 작업 생성을 강제하지 않는다.
- 주기적 워커는 FAILED를 자동으로 되살리지 않는다. 현재 원문에 대한 명시적인 조회/수정 요청만 새 주기를 연다.
## 검증
- 재시도 경계, 소진 후 요청 재개, 진행 중 작업 예산 보존, 동시 요청, 1초 설정과 AWS 우선/fallback/cache를 검증한다.
- 실제 DB 트랜잭션으로 언어 감지 이후 job 저장과 실패 시 롤백을 검증한다.
- 관련 콘텐츠/시리즈/테마 및 직접 영향받는 번역 조회 기능을 기능별로 검증한다.
- 실제 유료 AWS/Papago 호출, 운영 DB/배포, 전체 테스트는 실행하지 않는다. 전체 테스트는 사용자 명령 `./gradlew test`로 구분한다.
## 결정 기록
- 2026-11-16: 사용자가 언어 감지 후 번역, FAILED 재시도, AWS 번역 우선, 빠른 반영을 요청했다.
- 2026-11-16: 기존 DB 큐와 1초 워커, 동일 트랜잭션 작업 등록안을 제시했다. 사용자가 재시도는 5회로 제한하고 소진 후 조회/수정 요청 때 다시 5회로 재개하도록 확정했다.
- 2026-11-16: 구현 후 기능별 고유 사례 259건, ktlintCheck/bootJar를 검증했다. 독립 리뷰의 원문 언어 일치 누락을 회귀 테스트로 보완한 뒤 APPROVE 판정을 받았다. 상세 명령과 미검증 범위는 [검증 기록](reviews/verification.md)에 있다.
- 2026-11-16 후속 승인: 사용자가 감지도 AWS 우선으로 변경하는 데 동의했다. 초기의 Papago 우선 감지 정책을 정정하고, 기존 감지 캐시는 그대로 재사용한다. P1-T2로 검증한다.
- 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 검증은 포함하지 않는다.
@@ -0,0 +1,166 @@
# 메타데이터 번역 검증 기록
## 환경과 범위
- 2026-11-16, macOS x64, Java 17.0.15, Gradle Wrapper 8.1.1.
- 커밋하지 않은 작업 트리의 구현을 부모 세션에서 검증했다.
- 실제 Spring/JPA/H2 및 MockMvc controller 요청을 실행했다. 외부 AWS/Papago 호출은 SDK/공급자 경계의 테스트 대역으로 대체했다.
- 실제 운영 DB, 배포 환경변수, IAM, 외부 공급자의 지연/품질/과금은 미검증이다.
- LSP 도구가 없어 Kotlin 컴파일과 ktlint로 진단했다. 전체 테스트는 저장소 정책대로 사용자 실행 `./gradlew test`다.
## QA 결과
| 시나리오 | 실행 경계 | 기대 결과 | 관찰 결과 |
|---|---|---|---|
| 감지 후 작업 등록 | MetadataLanguageDetectTransactionTest, Spring/JPA | 콘텐츠/캐릭터/시리즈/원작/카테고리의 languageCode와 en/ja 필드 작업이 함께 저장 | 5개 대상 모두 커밋 전/후 저장 일치 |
| 작업 저장 실패 | 같은 테스트, H2 CHECK로 ja INSERT 거부 | 선행 en 작업과 languageCode 함께 롤백 | 5개 대상 모두 null 언어/작업 0개 |
| 최초+5회 재시도 | TranslationJobWorkerTest | 실패 1~5회 PENDING, 1/5/15/15/15분, 실패 6회 FAILED | 경계 6사례 및 마지막 재시도 성공 사례 통과 |
| FAILED 요청 재개 | TranslationJobRetryIntegrationTest, H2 | 동일 ID 재개, count 0/error null/due now, active/completed 보호 | 기존 3회/6회 FAILED 및 동시 요청/오래된 조회 후 RUNNING 보호 통과 |
| 조회 응답 유지 | 6개 ReadRetryTest 클래스, H2 | 기존 번역/원문 fallback 유지하며 현재 원문의 FAILED만 재개 | 15건 통과, 이전 해시/다른 언어/다른 대상 locale/제외 테마 보호 |
| 관리자 HTTP 수정 | MetadataTranslationHttpIntegrationTest, MockMvc + 실제 서비스/이벤트/JPA | HTTP 200, 커밋 후 동일 FAILED 행 재개와 4개 필드 작업 | 아래 실제 출력, PENDING/count 0/error null 및 title/detail × en/ja 4개 확인 |
| 공급자 기본값 | LanguageProviderSpringConfigurationTest/TranslationCoordinatorTest | 감지 Papago 우선, 번역 AWS 우선, 실패 시 Papago, 기존 캐시 재사용 | 실제 Spring 기본 설정과 공급자 선택/캐시 모두 통과 |
| 워커 주기 | TranslationJobWorkerTest | 기본 1000ms, 실행당 최대 5개 그룹 | 기본 스케줄 계약과 실행 상한 통과 |
HTTP QA 출력:
```text
HTTP QA: status=200, body={"success":true,"message":null,"data":{},"errorProperty":null}, contentId=1, restartedJobId=1
```
HTTP 증거 파일은 `build/test-results/test/TEST-kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest.xml`이다.
MockMvc standalone controller는 인증 필터 검증이 아니라 multipart 입력부터 실제 서비스/커밋 이벤트/DB까지의 연결 검증이다.
동기 테스트 executor로 커밋 후 실행을 결정적으로 검증했으며 실제 스레드 스케줄링 지연은 측정하지 않았다.
H2 worker claim 검증은 운영 SQL에서 SKIP LOCKED 옵션만 제거했으므로 MySQL 잠금 동시성 검증으로 해석하지 않는다.
## 실패를 잡는 증거
- 변경 전 기준 worker/scheduler/provider 테스트는 통과했다.
- 최초 RED: 43건 중 14건 실패. 기존 10분 기본값, 3회 실패 종료, FAILED 미재개, Papago 우선이 예상 assertion 실패로 나타났다.
- 연결 RED: 감지 10건, 조회 10건, 관리자 수정 8건이 예상 assertion으로 실패했고 컴파일은 성공했다.
- HTTP 테스트 추가 검증: 관리자 이벤트 발행 조건만 일시적으로 false로 바꾸자 HTTP 요청은 성공하더라도 `PENDING` 기대에서 실패했다. 조건을 원래 수정본으로 복원한 뒤 같은 테스트가 통과했다. 변이는 남기지 않았다.
## 통과한 실행
### 번역·언어 감지 회귀: 191건
```bash
./gradlew --no-daemon test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.*' \
--tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' \
--tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest'
```
25개 클래스, failures/errors/skipped 모두 0. 공급자 adapter/캐시, retry, read, HTTP, 감지 원자성 포함.
### 직접 영향 기능 회귀: 67건
```bash
./gradlew --no-daemon test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' \
--tests 'kr.co.vividnext.sodalive.admin.content.AdminContentServiceTest' \
--tests 'kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterControllerTest' \
--tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectTest' \
--tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectionCacheConcurrencyTest' \
--tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \
--tests 'kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityTranslationEndToEndTest' \
--tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*'
```
9개 클래스, failures/errors/skipped 모두 0. 위 191건과 HTTP 1건이 중복되므로 합계는 257개 고유 사례다.
### 포맷 수정 후 최종 체크: 49건 + lint/build
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \
--tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*'
```
exit 0. 앞선 lint 실행에서 새 호출의 인자 줄바꿈과 테스트 한 줄 길이 위반을 발견해 변경 줄만 수정했다.
운영/테스트 Kotlin 컴파일, ktlintCheck, bootJar 및 수정된 기능 49건이 통과했다. Gradle 9 호환성 deprecation 안내는 기존 상태다.
기능 회귀의 전체 Spring context에서는 기존 MySQL 전용 SKIP LOCKED 쿼리를 H2 스케줄러가 실행해 SQL 구문 오류가 로그에 남았다.
테스트 assertion 실패는 없지만 이 실행을 운영 MySQL 워커 claim 검증으로 간주하지 않는다. 쿼리는 이번 변경에서 수정하지 않았다.
embedded Redis 종료 시 기존 연결의 재접속 WARN도 출력됐다. 실행 후 Gradle test worker/redis-server 잔존 프로세스는 없었다.
별도의 기존 Gradle daemon PID 1396은 이번 --no-daemon 실행의 소유 프로세스가 아니므로 종료하지 않았다.
## P1-R1 리뷰 후 회귀 보완
reviewer는 공통 예약 경로에서 이전 원문 언어의 FAILED도 재개하는 누락을 확인했다.
직접 예약 및 기존 번역 행 없는 원작 조회의 2개 테스트가 FAILED 기대/PENDING 실제로 실패하는 것을 확인했다.
`TranslationJobScheduler`의 FAILED 재개 조건에 `existingJob.sourceLanguage == normalizedSourceLanguage`를 추가했다.
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.*ReadRetryTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.MetadataTranslationHttpIntegrationTest' \
--tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' \
--tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectTest' \
--tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectionCacheConcurrencyTest' \
--tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \
--tests 'kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityTranslationEndToEndTest'
```
14개 클래스 74건, failures/errors/skipped 모두 0, lint/build exit 0.
원문 언어 불일치 직접 예약/번역 없는 조회 2건이 추가되어 이번 작업의 고유 검증 사례는 259건이다.
마지막 XML에서도 HTTP 200과 동일 ID FAILED 재개를 재확인했다. 차단 사항 delta 재검토 대기.
## 최종 판정과 운영 확인 범위
- 독립 gate reviewer의 첫 판정은 원문 언어 불일치 재개의 P1 차단 사항으로 REJECT였다. 두 회귀 테스트와 guard 추가 후 delta 재검토는 APPROVE다. 최종 차단 사항 없음.
- 운영의 `sodalive.translation-job.fixed-delay-ms` override가 있으면 새 기본값을 덮어쓴다. 운영 설정과 실제 공급자 지연/쿼터는 배포 시 확인 대상이다.
- 큐가 비어 있을 때의 1초 polling 기준을 바꿨으며 번역 완료 1초 SLA를 주장하지 않는다.
- 정리 완료: 독립 리뷰가 원본 로그를 읽고 승인한 후 이번 실행의 임시 디렉터리 `translation-ulw.jWBKaK`와 하위 로그/메모를 삭제하고 경로 부재를 확인했다. 영속 검증 기록은 이 문서와 계획에 남겼다. 소유 test worker/Redis 프로세스는 남아 있지 않으며 공유 캐시와 기존 Gradle daemon은 건드리지 않았다. 최종 `git diff --check`도 통과했다.
## 후속 P1-T2: 감지 AWS 우선
사용자 후속 승인에 따라 감지도 AWS/Papago 순서로 정정했다. 이전 절의 Papago 감지 유지 검증은 초기 요구사항에 대한 이력이다.
새 기본값의 Spring 감지 선택, 실제 AWS adapter의 SDK 응답 사용, AWS 예외/null/blank 뒤 Papago 전환,
기존 Papago 감지 캐시의 외부 호출 없는 재사용을 검증했다. 번역 우선순위와 명시적 테스트 순서 설정은 유지했다.
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageProvider*Test' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.LanguageDetectionProviderTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageDetectionProviderTest' \
--tests 'kr.co.vividnext.sodalive.i18n.translation.PapagoLanguageDetectionProviderTest' \
--tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest'
```
변경 전 7개 assertion RED, 변경 후 8개 클래스 49건의 실패/오류/skip 0 및 lint/build exit 0.
H2 E2E는 전체 원문별 AWS 감지 캐시 2개 저장 및 반복 요청의 SDK 무호출을 검증한다.
실제 외부 API 호출/정확도 비교/IAM과 전체 테스트는 실행하지 않았다. 후속 delta 리뷰 대기.
후속 delta 최종 판정은 APPROVE다. reviewer가 코드·Spring/SDK 경계·H2 캐시·RED/GREEN과 49건 XML을 확인했다.
비차단 지적이었던 현재 가이드의 테스트 설명도 AWS 우선으로 정정했다.
승인 후 `detection-aws.4a18xV` 임시 루트와 로그/메모를 삭제하고 경로 부재를 확인했다.
소유 test worker/Redis 프로세스는 없으며, 공유 캐시는 보존했다. 후속 `git diff --check`도 통과했다.
## 커밋 전 재검증
2026-11-16 사용자 커밋 요청에 따라 최종 변경 상태에서 다음 명령을 실행했다.
```bash
./gradlew --no-daemon ktlintCheck bootJar test \
--tests 'kr.co.vividnext.sodalive.i18n.translation.*' \
--tests 'kr.co.vividnext.sodalive.content.LanguageDetectionCacheServiceTest' \
--tests 'kr.co.vividnext.sodalive.content.MetadataLanguageDetectTransactionTest' \
--tests 'kr.co.vividnext.sodalive.content.AudioContentServiceTest' \
--tests 'kr.co.vividnext.sodalive.admin.content.AdminContentServiceTest' \
--tests 'kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterControllerTest' \
--tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectTest' \
--tests 'kr.co.vividnext.sodalive.content.CreatorCommunityLanguageDetectionCacheConcurrencyTest' \
--tests 'kr.co.vividnext.sodalive.v2.creator.channel.community.translation.CreatorCommunityTranslationServiceTest' \
--tests 'kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityTranslationEndToEndTest' \
--tests 'kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content.LegacyCreatorAdminAudioContentCharacterizationTest.shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags*'
```
- exit 0, `BUILD SUCCESSFUL in 2m 3s`. 테스트를 새로 실행했고 ktlintCheck/bootJar는 UP-TO-DATE다.
- `build/test-results/test/TEST-*.xml` 33개 클래스 261건에서 failures/errors/skipped 모두 0을 확인했다.
- 전체 테스트와 운영 MySQL/외부 공급자 검증은 미실행이다. 전체 테스트 사용자 실행 명령은 `./gradlew test`다.
+6
View File
@@ -22,6 +22,12 @@
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageDetectionProviderTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsTranslationServiceTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.AwsLanguageProviderConfigurationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.i18n.translation.TranslationJobRetryIntegrationTest'
./gradlew --no-daemon test --tests 'kr.co.vividnext.sodalive.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.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 ktlintCheck
./gradlew ktlintFormat
@@ -9,8 +9,11 @@ import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.main.tab.GetContentMainTabItem
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.utils.generateFileName
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.domain.Pageable
import org.springframework.data.repository.findByIdOrNull
import org.springframework.stereotype.Service
@@ -26,6 +29,7 @@ class AdminContentService(
private val contentMainTabRepository: AdminContentMainTabRepository,
private val objectMapper: ObjectMapper,
private val s3Uploader: S3Uploader,
private val applicationEventPublisher: ApplicationEventPublisher,
@Value("\${cloud.aws.s3.bucket}")
private val bucket: String
) {
@@ -158,6 +162,16 @@ class AdminContentService(
}
audioContent.settlementRatio = request.settlementRatio
}
if (request.title != null || request.detail != null) {
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = request.id,
targetType = LanguageTranslationTargetType.CONTENT,
waitTransactionCommit = true
)
)
}
}
fun getContentMainTabList(): List<GetContentMainTabItem> {
@@ -186,6 +186,11 @@ class ChatCharacterController(
var translated: TranslatedAiCharacterDetail? = null
if (langContext.lang.code != character.languageCode) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CHARACTER,
listOf(characterId),
langContext.lang.code
)
val existing = aiCharacterTranslationRepository
.findByCharacterIdAndLocale(character.id!!, langContext.lang.code)
@@ -28,8 +28,15 @@ class OriginalWorkTranslationService(
return null
}
val originalWorkId = requireNotNull(originalWork.id)
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.ORIGINAL_WORK,
listOf(originalWorkId),
target
)
// 기존 번역 조회
val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWork.id!!, target)
val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWorkId, target)
val existedPayload = existed?.renderedPayload
if (existedPayload != null) {
val t = existedPayload.title.trim()
@@ -51,7 +58,7 @@ class OriginalWorkTranslationService(
resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.ORIGINAL_WORK,
resourceId = originalWork.id!!,
resourceId = originalWorkId,
targetLanguage = target
)
return null
@@ -157,6 +157,13 @@ class SecurityConfig(
JwtFilter::class.java
)
.authorizeRequests()
.antMatchers("/internal/api/subtitle-jobs/**")
.access(
"hasRole('BOT') and " +
"principal instanceof T(kr.co.vividnext.sodalive.member.MemberAdapter) and " +
"principal.member.role == T(kr.co.vividnext.sodalive.member.MemberRole).BOT and " +
"principal.member.isActive"
)
.antMatchers("/readyz").permitAll()
.requestMatchers(EndpointRequest.toAnyEndpoint()).permitAll()
.antMatchers("/member/check/email").permitAll()
@@ -52,6 +52,9 @@ data class AudioContent(
var content: String? = null
var coverImage: String? = null
@Column(length = 36)
var latestSubtitleJobId: String? = null
@OneToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "theme_id", nullable = false)
var theme: AudioContentTheme? = null
@@ -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.translation.ContentThemeTranslationRepository
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.extensions.convertLocalDateTime
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.translation.LanguageTranslationEvent
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.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
@@ -43,15 +41,20 @@ import kr.co.vividnext.sodalive.utils.generateFileName
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.slf4j.LoggerFactory
import org.springframework.beans.factory.annotation.Value
import org.springframework.cache.annotation.Cacheable
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.repository.findByIdOrNull
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.TransactionSynchronization
import org.springframework.transaction.support.TransactionSynchronizationManager
import org.springframework.transaction.support.TransactionTemplate
import org.springframework.web.multipart.MultipartFile
import java.text.SimpleDateFormat
import java.time.LocalDateTime
@@ -78,8 +81,8 @@ class AudioContentService(
private val pinContentRepository: PinContentRepository,
private val memberRepository: MemberRepository,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler,
private val contentTranslationRepository: ContentTranslationRepository,
private val detailTranslationService: AudioContentDetailTranslationService,
private val s3Uploader: S3Uploader,
private val objectMapper: ObjectMapper,
@@ -93,6 +96,8 @@ class AudioContentService(
private val contentThemeTranslationRepository: ContentThemeTranslationRepository,
private val homeFollowingNewsPublishService: HomeFollowingNewsPublishService,
private val memberContentPreferenceService: MemberContentPreferenceService,
private val subtitleJobService: SubtitleJobService,
transactionManager: PlatformTransactionManager,
@Value("\${cloud.aws.s3.content-bucket}")
private val audioContentBucket: String,
@@ -104,6 +109,9 @@ class AudioContentService(
private val coverImageHost: String
) {
private val log = LoggerFactory.getLogger(javaClass)
private val registrationTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
@Transactional
fun audioContentLike(request: PutAudioContentLikeRequest, member: Member): PutAudioContentLikeResponse {
@@ -220,7 +228,7 @@ class AudioContentService(
pinContent?.isActive = false
}
@Transactional
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun createAudioContent(
contentFile: MultipartFile?,
coverImage: MultipartFile?,
@@ -245,7 +253,7 @@ class AudioContentService(
return createAudioContent(contentFile, coverImage, request, releaseDate, member)
}
@Transactional
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun createAudioContent(
contentFile: MultipartFile?,
coverImage: MultipartFile?,
@@ -260,115 +268,118 @@ class AudioContentService(
throw SodaException(messageKey = "content.error.content_required")
}
validatePreviewTime(request.previewStartTime, request.previewEndTime)
val registration = requireNotNull(
registrationTransaction.execute {
validatePreviewTime(request.previewStartTime, request.previewEndTime)
// 테마 체크
val theme = themeQueryRepository.findThemeByIdAndActive(id = request.themeId)
?: throw SodaException(messageKey = "content.error.invalid_theme")
// 테마 체크
val theme = themeQueryRepository.findThemeByIdAndActive(id = request.themeId)
?: throw SodaException(messageKey = "content.error.invalid_theme")
if ((request.themeId == 12L || request.themeId == 13L || request.themeId == 14L) && request.price < 5) {
throw SodaException(messageKey = "content.error.alarm_theme_price_min")
}
if ((request.themeId == 12L || request.themeId == 13L || request.themeId == 14L) && request.price < 5) {
throw SodaException(messageKey = "content.error.alarm_theme_price_min")
}
if (request.price in 1..4) throw SodaException(messageKey = "content.error.minimum_price")
if (request.price in 1..4) throw SodaException(messageKey = "content.error.minimum_price")
val isFullDetailVisible = if (request.price >= 50) {
request.isFullDetailVisible
} else {
true
}
val isFullDetailVisible = if (request.price >= 50) {
request.isFullDetailVisible
} else {
true
}
val purchaseOption = if (request.themeId == 12L || request.themeId == 13L || request.themeId == 14L) {
PurchaseOption.BUY_ONLY
} else {
request.purchaseOption
}
val purchaseOption = if (request.themeId == 12L || request.themeId == 13L || request.themeId == 14L) {
PurchaseOption.BUY_ONLY
} else {
request.purchaseOption
}
val isOnlyRental = if (
(request.limited != null && request.limited > 0) ||
purchaseOption == PurchaseOption.BUY_ONLY
) {
false
} else if (request.purchaseOption == PurchaseOption.RENT_ONLY) {
true
} else {
request.isOnlyRental
}
val isOnlyRental = if (
(request.limited != null && request.limited > 0) ||
purchaseOption == PurchaseOption.BUY_ONLY
) {
false
} else if (request.purchaseOption == PurchaseOption.RENT_ONLY) {
true
} else {
request.isOnlyRental
}
// DB에 값 추가
val audioContent = AudioContent(
title = request.title.trim(),
detail = request.detail.trim(),
languageCode = request.languageCode,
price = if (request.price > 0) {
request.price
} else {
0
},
releaseDate = releaseDate,
limited = request.limited,
remaining = request.limited,
isAdult = request.isAdult,
purchaseOption = purchaseOption,
isGeneratePreview = request.isGeneratePreview,
isOnlyRental = isOnlyRental,
isPointAvailable = request.isPointAvailable,
isCommentAvailable = request.isCommentAvailable,
isFullDetailVisible = isFullDetailVisible
)
audioContent.theme = theme
audioContent.member = member
repository.save(audioContent)
// 태그 분리, #추가, 등록
if (request.tags.isNotBlank()) {
val tags = request.tags
.replace("#", " #")
.split(" ")
.asSequence()
.map { it.trim() }
.filter { it.isNotBlank() }
.map {
val tag = if (!it.startsWith("#")) {
"#$it"
// DB에 값 추가
val audioContent = AudioContent(
title = request.title.trim(),
detail = request.detail.trim(),
languageCode = request.languageCode,
price = if (request.price > 0) {
request.price
} else {
it
}
0
},
releaseDate = releaseDate,
limited = request.limited,
remaining = request.limited,
isAdult = request.isAdult,
purchaseOption = purchaseOption,
isGeneratePreview = request.isGeneratePreview,
isOnlyRental = isOnlyRental,
isPointAvailable = request.isPointAvailable,
isCommentAvailable = request.isCommentAvailable,
isFullDetailVisible = isFullDetailVisible
)
audioContent.theme = theme
audioContent.member = member
repository.save(audioContent)
val hashTag = hashTagRepository.findByTag(tag)
?: hashTagRepository.save(HashTag(tag))
// 태그 분리, #추가, 등록
if (request.tags.isNotBlank()) {
val tags = request.tags
.replace("#", " #")
.split(" ")
.asSequence()
.map { it.trim() }
.filter { it.isNotBlank() }
.map {
val tag = if (!it.startsWith("#")) {
"#$it"
} else {
it
}
val audioContentHashTag = AudioContentHashTag()
audioContentHashTag.audioContent = audioContent
audioContentHashTag.hashTag = hashTag
val hashTag = hashTagRepository.findByTag(tag)
?: hashTagRepository.save(HashTag(tag))
audioContentHashTag
}.toList()
val audioContentHashTag = AudioContentHashTag()
audioContentHashTag.audioContent = audioContent
audioContentHashTag.hashTag = hashTag
audioContent.audioContentHashTags.addAll(tags)
}
audioContentHashTag
}.toList()
var metadata = ObjectMetadata()
metadata.contentLength = coverImage.size
audioContent.audioContentHashTags.addAll(tags)
}
// 커버 이미지 파일명 생성
val coverImageFileName = generateFileName(prefix = "${audioContent.id}-cover")
val metadata = ObjectMetadata()
metadata.contentLength = coverImage.size
// 커버 이미지 업로드
val coverImagePath = s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = coverImageBucket,
filePath = "audio_content_cover/${audioContent.id}/$coverImageFileName",
metadata = metadata
// 커버 이미지 파일명 생성
val coverImageFileName = generateFileName(prefix = "${audioContent.id}-cover")
// 커버 이미지 업로드
val coverImagePath = s3Uploader.upload(
inputStream = coverImage.inputStream,
bucket = coverImageBucket,
filePath = "audio_content_cover/${audioContent.id}/$coverImageFileName",
metadata = metadata
)
audioContent.coverImage = coverImagePath
audioContent to subtitleJobService.register(audioContent, contentFile.originalFilename)
}
)
audioContent.coverImage = coverImagePath
// 콘텐츠 파일명 생성
val contentFileName = generateFileName(prefix = "${audioContent.id}-content")
val (audioContent, subtitleJob) = registration
// 콘텐츠 파일 업로드
metadata = ObjectMetadata()
val metadata = ObjectMetadata()
metadata.contentLength = contentFile.size
metadata.addUserMetadata(
"generate_preview",
@@ -384,38 +395,45 @@ class AudioContentService(
metadata.addUserMetadata("preview_end_time", request.previewEndTime)
}
val contentPath = s3Uploader.upload(
inputStream = contentFile.inputStream,
bucket = audioContentBucket,
filePath = "input/${audioContent.id}/$contentFileName",
metadata = metadata
)
audioContent.content = contentPath
// 언어 코드가 지정되지 않은 경우, 파파고 언어 감지 API를 통해 비동기로 언어를 식별한다.
if (audioContent.languageCode.isNullOrBlank()) {
val papagoQuery = listOf(
request.title.trim(),
request.detail.trim(),
request.tags.trim()
)
.filter { it.isNotBlank() }
.joinToString(" ")
applicationEventPublisher.publishEvent(
LanguageDetectEvent(
id = audioContent.id!!,
query = papagoQuery
try {
contentFile.inputStream.use { inputStream ->
s3Uploader.upload(
inputStream = inputStream,
bucket = audioContentBucket,
filePath = subtitleJob.sourceKey,
metadata = metadata
)
)
} else {
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = audioContent.id!!,
targetType = LanguageTranslationTargetType.CONTENT
}
} catch (exception: Exception) {
subtitleJobService.recordUploadError(subtitleJob.jobId)
throw exception
}
registrationTransaction.executeWithoutResult {
// 언어 코드가 지정되지 않은 경우, 파파고 언어 감지 API를 통해 비동기로 언어를 식별한다.
if (audioContent.languageCode.isNullOrBlank()) {
val papagoQuery = listOf(
request.title.trim(),
request.detail.trim(),
request.tags.trim()
)
)
.filter { it.isNotBlank() }
.joinToString(" ")
applicationEventPublisher.publishEvent(
LanguageDetectEvent(
id = audioContent.id!!,
query = papagoQuery
)
)
} else {
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = audioContent.id!!,
targetType = LanguageTranslationTargetType.CONTENT
)
)
}
}
return CreateAudioContentResponse(contentId = audioContent.id!!)
@@ -481,8 +499,9 @@ class AudioContentService(
@Transactional
fun uploadComplete(contentId: Long, content: String, duration: String) {
val keyFileName = content.split("/").last()
if (!keyFileName.startsWith(contentId.toString())) throw SodaException(messageKey = "common.error.invalid_request")
val registeredOutputMatches = subtitleJobService.matchesOutput(contentId, content)
val validOutput = registeredOutputMatches ?: content.substringAfterLast("/").startsWith(contentId.toString())
if (!validOutput) throw SodaException(messageKey = "common.error.invalid_request")
val audioContent = repository.findByIdOrNull(contentId)
?: throw SodaException(messageKey = "common.error.invalid_request")
@@ -781,6 +800,24 @@ class AudioContentService(
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 isLike = audioContentLikeRepository.findByMemberIdAndContentId(
memberId = member.id!!,
@@ -854,44 +891,14 @@ class AudioContentService(
listOf()
}
var translated: TranslatedContent? = null
/**
* audioContent.languageCode != languageCode
*
* 번역 콘텐츠를 조회한다. - contentId, locale
* 번역 콘텐츠가 있으면
* TranslatedContent로 가공한다
*
* 번역 콘텐츠가 없으면
* 누락 번역 job을 예약하고 원문 응답을 유지한다.
*
* 번역 대상: title, detail, tags
*
* 파파고로 번역한 데이터를 TranslatedContent로 가공한다
*/
if (
audioContent.languageCode != null &&
audioContent.languageCode!!.isNotBlank() &&
audioContent.languageCode != 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
val translation = detailTranslationService.resolve(id, langContext.lang.code)
if (translation.detectionQuery != null) {
applicationEventPublisher.publishEvent(
LanguageDetectEvent(
id = id,
query = translation.detectionQuery
)
} else {
resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = audioContent.id!!,
targetLanguage = langContext.lang.code
)
}
)
}
/**
@@ -933,7 +940,7 @@ class AudioContentService(
contentId = audioContent.id!!,
title = audioContent.title,
detail = contentDetail,
languageCode = audioContent.languageCode,
languageCode = translation.languageCode,
coverImageUrl = "$coverImageHost/${audioContent.coverImage!!}",
contentUrl = audioContentUrl,
themeStr = themeStrTranslated,
@@ -953,8 +960,8 @@ class AudioContentService(
purchaseOption = purchaseOption,
orderType = orderType,
remainingTime = remainingTime,
creatorOtherContentList = creatorOtherContentList,
sameThemeOtherContentList = sameThemeOtherContentList,
creatorOtherContentList = creatorOtherContentList.map(::translateRelatedContent),
sameThemeOtherContentList = sameThemeOtherContentList.map(::translateRelatedContent),
isCommentAvailable = audioContent.isCommentAvailable,
isLike = isLike,
likeCount = likeCount,
@@ -974,11 +981,23 @@ class AudioContentService(
isFollow = creatorFollowing?.isFollow ?: false,
isNotify = creatorFollowing?.isNotify ?: false
),
previousContent = previousContent,
nextContent = nextContent,
previousContent = previousContent?.let(::translateRelatedContent),
nextContent = nextContent?.let(::translateRelatedContent),
buyerList = buyerList,
isAvailableUsePoint = audioContent.isPointAvailable && audioContent.price > 0,
translated = translated
translated = translation.translated,
subtitle = if (
(isExistsAudioContent || creatorId == member.id || audioContent.price <= 0) &&
(audioContent.releaseDate == null || audioContent.releaseDate!! <= LocalDateTime.now() || creatorId == member.id)
) {
subtitleJobService.subtitle(
audioContent,
langContext.lang,
1000 * 60 * 60 * ((audioContent.duration ?: "00:00:00").split(":")[0].toLong() + 2)
)
} else {
null
}
)
}
@@ -1302,16 +1321,25 @@ class AudioContentService(
contentId = audioContent.id!!
)
val contentUrl = if (isExistsAudioContent) {
audioContentCloudFront.generateSignedURL(
resourcePath = audioContent.content!!,
expirationTime = 1000 * 60 * 60 * (audioContent.duration!!.split(":")[0].toLong() + 2)
return if (isExistsAudioContent) {
val expirationTime = 1000 * 60 * 60 * (audioContent.duration!!.split(":")[0].toLong() + 2)
GenerateUrlResponse(
contentUrl = audioContentCloudFront.generateSignedURL(
resourcePath = audioContent.content!!,
expirationTime = expirationTime
),
subtitle = if (
audioContent.releaseDate == null || audioContent.releaseDate!! <= LocalDateTime.now() ||
audioContent.member!!.id == member.id
) {
subtitleJobService.subtitle(audioContent, langContext.lang, expirationTime)
} else {
null
}
)
} else {
""
GenerateUrlResponse("")
}
return GenerateUrlResponse(contentUrl)
}
@Transactional(readOnly = true)
@@ -1,5 +1,8 @@
package kr.co.vividnext.sodalive.content
import kr.co.vividnext.sodalive.v2.subtitle.dto.ContentSubtitleResponse
data class GenerateUrlResponse(
val contentUrl: String
val contentUrl: String,
val subtitle: ContentSubtitleResponse? = null
)
@@ -4,6 +4,7 @@ import com.querydsl.core.annotations.QueryProjection
import kr.co.vividnext.sodalive.content.comment.GetAudioContentCommentListItem
import kr.co.vividnext.sodalive.content.order.OrderType
import kr.co.vividnext.sodalive.content.translation.TranslatedContent
import kr.co.vividnext.sodalive.v2.subtitle.dto.ContentSubtitleResponse
data class GetAudioContentDetailResponse(
val contentId: Long,
@@ -42,7 +43,8 @@ data class GetAudioContentDetailResponse(
val nextContent: OtherContentResponse?,
val buyerList: List<ContentBuyer>,
val isAvailableUsePoint: Boolean,
val translated: TranslatedContent?
val translated: TranslatedContent?,
val subtitle: ContentSubtitleResponse? = null
)
data class OtherContentResponse @QueryProjection constructor(
@@ -8,12 +8,11 @@ import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository
import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository
import kr.co.vividnext.sodalive.explorer.profile.CreatorCheersRepository
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunityRepository
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.slf4j.LoggerFactory
import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.repository.findByIdOrNull
import org.springframework.scheduling.annotation.Async
import org.springframework.stereotype.Component
@@ -64,8 +63,7 @@ class LanguageDetectListener(
private val languageDetectionCacheService: LanguageDetectionCacheService,
private val creatorCommunityTranslationService: CreatorCommunityTranslationService,
private val entityManager: EntityManager,
private val applicationEventPublisher: ApplicationEventPublisher
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler
) {
private val log = LoggerFactory.getLogger(LanguageDetectListener::class.java)
@@ -116,11 +114,9 @@ class LanguageDetectListener(
character.languageCode = langCode
chatCharacterRepository.save(character)
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = characterId,
targetType = LanguageTranslationTargetType.CHARACTER
)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CHARACTER,
resourceId = characterId
)
log.info(
@@ -156,11 +152,9 @@ class LanguageDetectListener(
// REQUIRES_NEW 트랜잭션 내에서 변경 내용을 저장한다.
audioContentRepository.save(audioContent)
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = contentId,
targetType = LanguageTranslationTargetType.CONTENT
)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = contentId
)
log.info(
@@ -288,11 +282,9 @@ class LanguageDetectListener(
series.languageCode = langCode
seriesRepository.save(series)
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = seriesId,
targetType = LanguageTranslationTargetType.SERIES
)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.SERIES,
resourceId = seriesId
)
log.info(
@@ -326,12 +318,9 @@ class LanguageDetectListener(
originalWork.languageCode = langCode
originalWorkRepository.save(originalWork)
// 언어 감지가 완료된 후 언어 번역 이벤트 호출
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = originalWorkId,
targetType = LanguageTranslationTargetType.ORIGINAL_WORK
)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.ORIGINAL_WORK,
resourceId = originalWorkId
)
log.info(
@@ -352,11 +341,9 @@ class LanguageDetectListener(
category.languageCode = langCode
categoryRepository.save(category)
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = categoryId,
targetType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY
)
resourceTranslationJobScheduler.scheduleResourceTranslations(
resourceType = LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY,
resourceId = categoryId
)
}
@@ -141,6 +141,11 @@ class CategoryService(
val categoryIds = baseList.map { it.categoryId }
val entities = repository.findAllById(categoryIds)
val entityMap = entities.associateBy { it.id!! }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY,
categoryIds,
locale
)
// 요청 로케일로 이미 저장된 번역 일괄 조회
val translations = categoryTranslationRepository
@@ -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.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.OrderType
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.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.creator.admin.content.series.SeriesPublishedDaysOfWeek
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.contentpreference.MemberContentPreferenceService
import org.springframework.beans.factory.annotation.Value
import org.springframework.context.ApplicationEventPublisher
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.ZoneId
@@ -36,7 +37,8 @@ class ContentSeriesService(
private val langContext: LangContext,
private val seriesTranslationRepository: SeriesTranslationRepository,
private val detailTranslationService: ContentSeriesDetailTranslationService,
private val applicationEventPublisher: ApplicationEventPublisher,
private val seriesGenreTranslationRepository: SeriesGenreTranslationRepository,
private val contentTranslationRepository: ContentTranslationRepository,
private val resourceTranslationJobScheduler: ResourceTranslationJobScheduler,
@@ -98,6 +100,11 @@ class ContentSeriesService(
if (currentLang == Lang.EN || currentLang == Lang.JA) {
val targetLocale = currentLang.code
val ids = genres.map { it.id }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.SERIES_GENRE,
ids,
targetLocale
)
// 기존 번역 일괄 조회
val existing = if (ids.isNotEmpty()) {
@@ -254,47 +261,16 @@ class ContentSeriesService(
limit = 5
)
/**
* series.languageCode != null && series.languageCode != languageCode
*
* 번역 시리즈를 조회한다. - series, locale
* 번역 콘텐츠가 있으면
* TranslatedSeries로 가공한다
*
* 번역 콘텐츠가 없으면
* 누락 번역 job을 예약하고 원문 응답을 유지한다.
*
* 번역 대상: title, introduction, keywordList
*
* 파파고로 번역한 데이터를 TranslatedSeries 가공한다
*/
val dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy.MM.dd")
// 요청된 언어(locale)에 대한 시리즈 번역을 조회하거나, 없으면 동기 번역 후 저장한다.
var translated: TranslatedSeries? = null
run {
val locale = langContext.lang.code
val languageCode = series.languageCode
// 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리
if (!languageCode.isNullOrBlank() && languageCode != 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 translation = detailTranslationService.resolve(seriesId, langContext.lang.code)
if (translation.detectionQuery != null) {
applicationEventPublisher.publishEvent(
LanguageDetectEvent(seriesId, translation.detectionQuery, LanguageDetectTargetType.SERIES)
)
}
val translated = translation.translated?.let {
it.copy(keywords = it.keywords.ifEmpty { keywordList })
}
// 장르 번역 조회 (있으면 반환)
@@ -58,6 +58,11 @@ class AudioContentThemeService(
val targetLocale = currentLang.code
// 1) 기존 번역을 한 번에 조회
val ids = themesWithIds.map { it.id }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CONTENT_THEME,
ids,
targetLocale
)
val existingTranslations = if (ids.isNotEmpty()) {
contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale)
} else {
@@ -1,9 +1,20 @@
package kr.co.vividnext.sodalive.content.translation
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> {
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>
}
@@ -199,7 +199,9 @@ class CreatorAdminContentService(
}
audioContent.audioContentHashTags.addAll(newAudioContentHashTagList)
}
if (request.title != null || request.detail != null || !request.tags.isNullOrBlank()) {
applicationEventPublisher.publishEvent(
LanguageTranslationEvent(
id = request.id,
@@ -1,6 +1,6 @@
package kr.co.vividnext.sodalive.i18n.translation
object LanguageProviderOrder {
val detectionOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val translationOrder = listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS)
val detectionOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
val translationOrder = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
}
@@ -2,12 +2,15 @@ package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
@Service
class ResourceTranslationJobScheduler(
private val sourceExtractor: TranslationSourceExtractor,
private val translationJobScheduler: TranslationJobScheduler
private val translationJobScheduler: TranslationJobScheduler,
private val translationJobRepository: TranslationJobRepository
) {
@Transactional
fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) {
@@ -27,6 +30,61 @@ class ResourceTranslationJobScheduler(
scheduleSource(source, targetLanguage)
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
fun restartFailedResourceTranslations(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String
) {
restartFailedResourceTranslationsInCurrentTransaction(resourceType, resourceIds, targetLanguage)
}
@Transactional
fun restartFailedResourceTranslationsInCurrentTransaction(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String
) {
if (resourceIds.isEmpty()) return
val target = targetLanguage.lowercase()
val candidates = translationJobRepository.findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus(
resourceType,
resourceIds,
target,
TranslationJobStatus.FAILED
) + if (resourceType == LanguageTranslationTargetType.CONTENT) {
translationJobRepository.findCompletedContentTagJobs(resourceIds, target)
} else {
emptyList()
}
val now = LocalDateTime.now()
candidates.groupBy { it.resourceId }.forEach { (resourceId, resourceJobs) ->
val source = sourceExtractor.extract(resourceType, resourceId) ?: return@forEach
val sourceLanguage = source.sourceLanguage.lowercase()
if (!TranslationLanguages.isSupported(sourceLanguage) || sourceLanguage == target) return@forEach
val sourceFields = source.fields.associateBy { it.fieldKey }
resourceJobs.filter { job ->
job.sourceLanguage == sourceLanguage &&
job.sourceHash == sourceFields[job.fieldKey]?.let { SourceTextNormalizer.hash(it.sourceText) }
}.forEach { job ->
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
}
}
}
}
private fun scheduleSource(source: TranslationSource, targetLanguage: String) {
source.fields.forEach { field ->
translationJobScheduler.scheduleMissingTranslation(
@@ -20,4 +20,8 @@ object SourceTextNormalizer {
.digest(normalized.toByteArray(Charsets.UTF_8))
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(
val texts: List<String>,
val sourceLanguage: String,
val targetLanguage: String
val targetLanguage: String,
val rejectUnchangedAwsResult: Boolean = false
)
data class TranslateResult(
@@ -10,7 +10,12 @@ class TranslationCoordinator(
) {
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 ->
val memory = translationMemoryRepository
.findBySourceHashAndSourceLanguageAndTargetLanguageAndProviderAndNormalizationVersion(
@@ -20,7 +25,14 @@ class TranslationCoordinator(
provider.providerId.code,
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
}
@@ -42,6 +54,14 @@ class TranslationCoordinator(
result != null && result.translatedText.size == request.texts.size &&
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)
}
}
@@ -1,6 +1,7 @@
package kr.co.vividnext.sodalive.i18n.translation
import org.springframework.data.jpa.repository.JpaRepository
import org.springframework.data.jpa.repository.Modifying
import org.springframework.data.jpa.repository.Query
import org.springframework.data.repository.query.Param
import java.time.LocalDateTime
@@ -14,6 +15,58 @@ interface TranslationJobRepository : JpaRepository<TranslationJob, Long> {
sourceHash: String
): TranslationJob?
fun findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String,
status: TranslationJobStatus
): 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
@Query(
"""
update TranslationJob j
set j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.PENDING,
j.retryCount = 0,
j.lastErrorMessage = null,
j.nextRetryAt = :now
where j.id = :jobId
and j.status = kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus.FAILED
"""
)
fun restartFailedJob(@Param("jobId") jobId: Long, @Param("now") now: LocalDateTime): Int
@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(
"""
select j from TranslationJob j
@@ -1,12 +1,15 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
@Service
class TranslationJobScheduler(
private val translationJobRepository: TranslationJobRepository
private val translationJobRepository: TranslationJobRepository,
private val translationCoordinator: TranslationCoordinator,
private val contentTranslationRepository: ContentTranslationRepository
) {
@Transactional
fun scheduleMissingTranslation(
@@ -34,7 +37,38 @@ class TranslationJobScheduler(
targetLanguage = normalizedTargetLanguage,
sourceHash = sourceHash
)
if (existingJob != null) return
if (existingJob != null) {
if (existingJob.sourceLanguage != normalizedSourceLanguage) return
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
}
translationJobRepository.save(
TranslationJob(
@@ -10,15 +10,14 @@ import java.time.LocalDateTime
@Component
class TranslationJobWorker(
private val translationJobRepository: TranslationJobRepository,
private val translationMemoryRepository: TranslationMemoryRepository,
private val translationCoordinator: TranslationCoordinator,
private val translationMemoryService: TranslationMemoryService,
private val materializer: TranslationReadModelMaterializer,
transactionManager: PlatformTransactionManager
) {
private val log = LoggerFactory.getLogger(javaClass)
private val transactionTemplate = TransactionTemplate(transactionManager)
@Scheduled(fixedDelayString = "\${sodalive.translation-job.fixed-delay-ms:600000}")
@Scheduled(fixedDelayString = "\${sodalive.translation-job.fixed-delay-ms:1000}")
fun runPendingJobs() {
repeat(MAX_GROUPS_PER_TICK) {
if (!processNextGroup()) return
@@ -34,7 +33,13 @@ class TranslationJobWorker(
val failedJobs = mutableListOf<Pair<TranslationJob, Exception>>()
jobs.forEach { job ->
try {
ensureMemory(job)
translationMemoryService.ensureMemory(
job.resourceType,
job.fieldKey,
job.sourceText,
job.sourceLanguage,
job.targetLanguage
)
succeededJobs.add(job)
} catch (ex: Exception) {
failedJobs.add(job to ex)
@@ -68,44 +73,6 @@ class TranslationJobWorker(
}.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) {
transactionTemplate.executeWithoutResult {
val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult
@@ -121,7 +88,7 @@ class TranslationJobWorker(
val job = translationJobRepository.findById(jobId).orElse(null) ?: return@executeWithoutResult
job.retryCount += 1
job.lastErrorMessage = ex.message?.take(MAX_ERROR_LENGTH)
if (job.retryCount >= MAX_RETRY_COUNT) {
if (job.retryCount >= MAX_ATTEMPTS) {
job.status = TranslationJobStatus.FAILED
} else {
job.status = TranslationJobStatus.PENDING
@@ -142,6 +109,6 @@ class TranslationJobWorker(
companion object {
private const val MAX_GROUPS_PER_TICK = 5
private const val MAX_ERROR_LENGTH = 1000
private const val MAX_RETRY_COUNT = 3
private const val MAX_ATTEMPTS = 6
}
}
@@ -30,7 +30,7 @@ class TranslationMemory(
val targetLanguage: String,
@Column(name = "translated_text", nullable = false, columnDefinition = "text")
val translatedText: String,
var translatedText: String,
@Column(name = "provider", nullable = false, length = 50)
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.OriginalWorkTranslationPayload
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.CategoryTranslationRepository
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.ContentTranslationPayload
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.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslation
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslationRepository
@@ -74,7 +76,9 @@ class TranslationReadModelMaterializer(
val memory = translationCoordinator.findCached(
sourceHash = SourceTextNormalizer.hash(normalizedText),
sourceLanguage = source.sourceLanguage.lowercase(),
targetLanguage = targetLanguage
targetLanguage = targetLanguage,
rejectUnchangedAwsResult = source.resourceType == LanguageTranslationTargetType.CONTENT &&
field.fieldKey == "tags"
) ?: return null
result[field.fieldKey] = memory.translatedText
@@ -88,7 +92,8 @@ class TranslationReadModelMaterializer(
detail = translations["detail"].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) {
contentTranslationRepository.save(ContentTranslation(resourceId, targetLanguage, payload))
} else {
@@ -137,6 +142,7 @@ class TranslationReadModelMaterializer(
.map { it.trim() }
.filter { it.isNotBlank() }
)
entityManager.find(Series::class.java, resourceId, LockModeType.PESSIMISTIC_WRITE)
val existing = seriesTranslationRepository.findBySeriesIdAndLocale(resourceId, targetLanguage)
if (existing == null) {
seriesTranslationRepository.save(SeriesTranslation(resourceId, targetLanguage, payload))
@@ -52,6 +52,7 @@ class TranslationSourceExtractor(
val content = audioContentRepository.findByIdOrNull(resourceId) ?: return null
val sourceLanguage = content.languageCode?.takeIf { it.isNotBlank() } ?: return null
val tags = content.audioContentHashTags
.filter { it.isActive }
.mapNotNull { it.hashTag?.tag }
.joinToString(",")
return TranslationSource(
@@ -19,6 +19,7 @@ import kr.co.vividnext.sodalive.v2.api.admin.aicharacter.error.AiCharacterAdminA
import org.springframework.data.domain.PageRequest
import org.springframework.http.HttpStatus
import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.web.multipart.MultipartFile
import java.time.DateTimeException
@@ -158,7 +159,7 @@ class AiCharacterAdminAudioContentFacade(
)
}
@Transactional
@Transactional(propagation = Propagation.NOT_SUPPORTED)
fun create(
characterId: Long,
coverImage: MultipartFile,
@@ -35,6 +35,17 @@ class CreatorCommunityTranslationService(
val normalizedLocale = locale.lowercase()
val posts = creatorCommunityRepository.findAllById(postIds).filter { it.isActive }
val translationPostIds = posts.filter { post ->
val sourceLanguage = post.languageCode?.lowercase()
!sourceLanguage.isNullOrBlank() && sourceLanguage != normalizedLocale
}.mapNotNull { it.id }
if (translationPostIds.isNotEmpty()) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
translationPostIds,
normalizedLocale
)
}
val translations = creatorCommunityTranslationRepository
.findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale)
.associateBy { it.creatorCommunityId }
@@ -62,6 +73,11 @@ class CreatorCommunityTranslationService(
targetLanguages
.filter { it != sourceLanguage }
.forEach { language ->
resourceTranslationJobScheduler.restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(postId),
language
)
if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) {
resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY,
@@ -0,0 +1,28 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.GeneratedValue
import javax.persistence.GenerationType
import javax.persistence.Id
import javax.persistence.Table
import javax.persistence.UniqueConstraint
@Entity
@Table(name = "subtitle", uniqueConstraints = [UniqueConstraint(columnNames = ["job_id", "language"])])
class Subtitle(
@Column(name = "job_id", nullable = false, length = 36)
val jobId: String,
@Column(nullable = false, length = 35)
val language: String,
@Column(nullable = false, length = 16)
val format: String,
@Column(name = "s3_bucket", nullable = false, length = 255)
val s3Bucket: String,
@Column(name = "s3_key", nullable = false, length = 255)
val s3Key: String
) {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
var id: Long? = null
}
@@ -0,0 +1,31 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence
import org.springframework.data.domain.Persistable
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.Id
import javax.persistence.Table
import javax.persistence.Transient
@Entity
@Table(name = "subtitle_callback_receipt")
class SubtitleCallbackReceipt(
@Id
@Column(length = 255)
val eventId: String,
@Column(nullable = false, length = 36)
val jobId: String,
@Column(nullable = false, length = 64)
val bodyHash: String
) : Persistable<String> {
@Column(nullable = false, columnDefinition = "TIMESTAMP")
val createdAt: LocalDateTime = LocalDateTime.now(ZoneOffset.UTC).truncatedTo(ChronoUnit.SECONDS)
override fun getId(): String = eventId
@Transient
override fun isNew(): Boolean = true
}
@@ -0,0 +1,5 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence
import org.springframework.data.jpa.repository.JpaRepository
interface SubtitleCallbackReceiptRepository : JpaRepository<SubtitleCallbackReceipt, String>
@@ -0,0 +1,47 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence
import kr.co.vividnext.sodalive.v2.subtitle.domain.SubtitleJobStatus
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
import javax.persistence.Column
import javax.persistence.Entity
import javax.persistence.EnumType
import javax.persistence.Enumerated
import javax.persistence.Id
import javax.persistence.Table
import javax.persistence.UniqueConstraint
@Entity
@Table(name = "subtitle_job", uniqueConstraints = [UniqueConstraint(columnNames = ["source_bucket", "source_key"])])
class SubtitleJob(
@Id
@Column(length = 36)
val jobId: String,
@Column(nullable = false)
val contentId: Long,
@Column(name = "source_bucket", nullable = false)
val sourceBucket: String,
@Column(name = "source_key", nullable = false)
val sourceKey: String,
@Column(nullable = false)
val outputKey: String,
@Enumerated(EnumType.STRING)
@Column(nullable = false, length = 32)
var status: SubtitleJobStatus = SubtitleJobStatus.PENDING
) {
var errorCode: String? = null
@Column(columnDefinition = "TEXT")
var errorMessage: String? = null
var sourceUploadErrorCode: String? = null
@Column(columnDefinition = "TIMESTAMP")
var sourceUploadErrorAt: LocalDateTime? = null
@Column(nullable = false, columnDefinition = "TIMESTAMP")
val createdAt: LocalDateTime = LocalDateTime.now(ZoneOffset.UTC).truncatedTo(ChronoUnit.SECONDS)
@Column(nullable = false, columnDefinition = "TIMESTAMP")
var updatedAt: LocalDateTime = createdAt
}
@@ -0,0 +1,16 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence
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 SubtitleJobRepository : JpaRepository<SubtitleJob, String> {
fun findBySourceBucketAndSourceKey(sourceBucket: String, sourceKey: String): SubtitleJob?
fun findFirstByContentIdOrderByCreatedAtAsc(contentId: Long): SubtitleJob?
@Lock(LockModeType.PESSIMISTIC_WRITE)
@Query("select j from SubtitleJob j where j.jobId = :jobId")
fun findForUpdate(@Param("jobId") jobId: String): SubtitleJob?
}
@@ -0,0 +1,8 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence
import org.springframework.data.jpa.repository.JpaRepository
interface SubtitleRepository : JpaRepository<Subtitle, Long> {
fun findAllByJobId(jobId: String): List<Subtitle>
fun findByJobIdAndLanguage(jobId: String, language: String): Subtitle?
}
@@ -0,0 +1,25 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.web
import org.springframework.core.Ordered
import org.springframework.core.annotation.Order
import org.springframework.http.ResponseEntity
import org.springframework.http.converter.HttpMessageNotReadableException
import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.RestControllerAdvice
import org.springframework.web.server.ResponseStatusException
@Order(Ordered.HIGHEST_PRECEDENCE)
@RestControllerAdvice(assignableTypes = [SubtitleJobController::class])
class SubtitleExceptionHandler {
@ExceptionHandler(ResponseStatusException::class)
fun handle(exception: ResponseStatusException): ResponseEntity<Map<String, String>> =
ResponseEntity.status(exception.status).body(mapOf("error" to "Subtitle request rejected"))
@ExceptionHandler(HttpMessageNotReadableException::class)
fun handleUnreadableBody(): ResponseEntity<Map<String, String>> =
ResponseEntity.unprocessableEntity().body(mapOf("error" to "Subtitle request rejected"))
@ExceptionHandler(Exception::class)
fun handleUnexpectedException(): ResponseEntity<Map<String, String>> =
ResponseEntity.internalServerError().body(mapOf("error" to "Subtitle request failed"))
}
@@ -0,0 +1,32 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.web
import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PathVariable
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.web.bind.annotation.RestController
@RestController
@RequestMapping("/internal/api/subtitle-jobs")
class SubtitleJobController(private val service: SubtitleJobService, private val parser: SubtitleRequestParser) {
@GetMapping("/resolve")
fun resolve(@RequestParam bucket: String, @RequestParam key: String) = service.resolve(bucket, key)
@GetMapping("/{jobId}")
fun get(@PathVariable jobId: String) = service.get(jobId)
@PostMapping("/{jobId}/started", consumes = ["application/json"])
fun started(@PathVariable jobId: String, @RequestBody body: ByteArray): Map<String, String> {
service.started(jobId, parser.started(body))
return emptyMap()
}
@PostMapping("/callback", consumes = ["application/json"])
fun callback(@RequestBody body: ByteArray): Map<String, String> {
service.callback(parser.callback(body), body)
return emptyMap()
}
}
@@ -0,0 +1,72 @@
package kr.co.vividnext.sodalive.v2.subtitle.adapter.web
import com.fasterxml.jackson.core.JsonParser
import com.fasterxml.jackson.core.JsonProcessingException
import com.fasterxml.jackson.databind.DeserializationFeature
import com.fasterxml.jackson.databind.JsonNode
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleCallbackRequest
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleResultRequest
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleStartedRequest
import org.springframework.http.HttpStatus
import org.springframework.stereotype.Component
import org.springframework.web.server.ResponseStatusException
@Component
class SubtitleRequestParser(objectMapper: ObjectMapper) {
private val mapper = objectMapper.copy()
.enable(JsonParser.Feature.STRICT_DUPLICATE_DETECTION)
.enable(DeserializationFeature.FAIL_ON_TRAILING_TOKENS)
fun started(body: ByteArray): SubtitleStartedRequest {
val node = parse(body)
fields(node, setOf("transcribeJobName", "status"))
return SubtitleStartedRequest(text(node, "transcribeJobName"), text(node, "status"))
}
fun callback(body: ByteArray): SubtitleCallbackRequest {
val node = parse(body)
fields(
node,
setOf("eventId", "jobId", "contentId", "transcribeJobName", "status", "subtitles", "errorCode", "errorMessage")
)
val contentId = node.path("contentId")
if (!contentId.isIntegralNumber || !contentId.canConvertToLong() || contentId.longValue() <= 0) throw invalid()
val subtitles = node.path("subtitles")
if (!subtitles.isArray || subtitles.size() > 2) throw invalid()
return SubtitleCallbackRequest(
eventId = text(node, "eventId"),
jobId = text(node, "jobId"),
contentId = contentId.longValue(),
transcribeJobName = text(node, "transcribeJobName"),
status = text(node, "status"),
subtitles = subtitles.map {
fields(it, setOf("language", "format", "s3Bucket", "s3Key"))
SubtitleResultRequest(text(it, "language"), text(it, "format"), text(it, "s3Bucket"), text(it, "s3Key"))
},
errorCode = nullableText(node, "errorCode"),
errorMessage = nullableText(node, "errorMessage")
)
}
private fun parse(body: ByteArray): JsonNode = try {
mapper.readTree(body) ?: throw invalid()
} catch (_: JsonProcessingException) {
throw invalid()
}
private fun fields(node: JsonNode, expected: Set<String>) {
if (!node.isObject || node.fieldNames().asSequence().toSet() != expected) throw invalid()
}
private fun text(node: JsonNode, field: String): String {
val value = node.path(field)
if (!value.isTextual || value.textValue().isBlank()) throw invalid()
return value.textValue()
}
private fun nullableText(node: JsonNode, field: String): String? =
if (node.path(field).isNull) null else text(node, field)
private fun invalid() = ResponseStatusException(HttpStatus.UNPROCESSABLE_ENTITY, "Invalid subtitle request")
}
@@ -0,0 +1,219 @@
package kr.co.vividnext.sodalive.v2.subtitle.application
import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.Subtitle
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleCallbackReceipt
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleCallbackReceiptRepository
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleJob
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleJobRepository
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleRepository
import kr.co.vividnext.sodalive.v2.subtitle.domain.SubtitleJobStatus
import kr.co.vividnext.sodalive.v2.subtitle.dto.ContentSubtitleResponse
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleCallbackRequest
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleJobResponse
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleResultRequest
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleSourceResponse
import kr.co.vividnext.sodalive.v2.subtitle.dto.SubtitleStartedRequest
import org.springframework.beans.factory.annotation.Value
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.data.repository.findByIdOrNull
import org.springframework.http.HttpStatus
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 org.springframework.web.server.ResponseStatusException
import java.security.MessageDigest
import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.temporal.ChronoUnit
import java.util.Locale
import java.util.UUID
@Service
class SubtitleJobService(
private val jobs: SubtitleJobRepository,
private val receipts: SubtitleCallbackReceiptRepository,
private val subtitles: SubtitleRepository,
private val cloudFront: AudioContentCloudFront,
transactionManager: PlatformTransactionManager,
@Value("\${cloud.aws.s3.content-bucket}") private val bucket: String
) {
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
isolationLevel = TransactionDefinition.ISOLATION_READ_COMMITTED
}
@Transactional(propagation = Propagation.MANDATORY)
fun register(content: AudioContent, originalFilename: String?): SubtitleJob {
val contentId = requireNotNull(content.id)
val sourceName = UUID.randomUUID().toString()
val extension = originalFilename?.replace('\\', '/')?.substringAfterLast('/')
?.substringAfterLast('.', "")?.takeIf { it.matches(Regex("[A-Za-z0-9]{1,16}")) }
?.lowercase(Locale.ROOT)
val sourceFileName = if (extension == null) sourceName else "$sourceName.$extension"
val job = jobs.save(
SubtitleJob(
jobId = UUID.randomUUID().toString(),
contentId = contentId,
sourceBucket = bucket,
sourceKey = "input/$contentId/$sourceFileName",
outputKey = "output/$contentId/$sourceName"
)
)
content.latestSubtitleJobId = job.jobId
content.content = job.sourceKey
return job
}
@Transactional(readOnly = true)
fun resolve(bucket: String, key: String): SubtitleJobResponse =
response(jobs.findBySourceBucketAndSourceKey(bucket, key) ?: throw missing())
@Transactional(readOnly = true)
fun get(jobId: String): SubtitleJobResponse = response(jobs.findByIdOrNull(jobId) ?: throw missing())
fun started(jobId: String, request: SubtitleStartedRequest) {
if (request.transcribeJobName != "subtitle-$jobId" || request.status != "PROCESSING") throw invalid()
transaction.executeWithoutResult {
val job = jobs.findForUpdate(jobId) ?: throw missing()
if (job.status == SubtitleJobStatus.PENDING) {
job.status = SubtitleJobStatus.PROCESSING
job.updatedAt = now()
}
}
}
fun callback(request: SubtitleCallbackRequest, rawBody: ByteArray) {
if (request.eventId.isBlank() || request.eventId.length > 255) throw invalid()
val hash = MessageDigest.getInstance("SHA-256").digest(rawBody).joinToString("") { "%02x".format(it) }
try {
transaction.executeWithoutResult {
val existing = receipts.findByIdOrNull(request.eventId)
if (existing != null) {
replay(existing, hash)
return@executeWithoutResult
}
val job = jobs.findForUpdate(request.jobId) ?: throw missing()
val afterLock = receipts.findByIdOrNull(request.eventId)
if (afterLock != null) {
replay(afterLock, hash)
return@executeWithoutResult
}
val status = validate(job, request)
val existingResults = subtitles.findAllByJobId(job.jobId).map {
SubtitleResultRequest(it.language, it.format, it.s3Bucket, it.s3Key)
}.sortedBy { it.language }
if (job.status.terminal && (
job.status != status || existingResults != request.subtitles.sortedBy { it.language } ||
job.errorCode != request.errorCode || job.errorMessage != request.errorMessage
)
) {
throw ResponseStatusException(HttpStatus.CONFLICT, "Subtitle job already finished")
}
if (!job.status.terminal) {
subtitles.saveAll(
request.subtitles.map {
Subtitle(job.jobId, it.language, it.format, it.s3Bucket, it.s3Key)
}
)
job.status = status
job.errorCode = request.errorCode
job.errorMessage = request.errorMessage
job.updatedAt = now()
}
receipts.saveAndFlush(SubtitleCallbackReceipt(request.eventId, job.jobId, hash))
}
} catch (exception: DataIntegrityViolationException) {
transaction.executeWithoutResult {
val receipt = receipts.findByIdOrNull(request.eventId) ?: throw exception
replay(receipt, hash)
}
}
}
fun recordUploadError(jobId: String) {
transaction.executeWithoutResult {
val job = jobs.findForUpdate(jobId) ?: throw missing()
val recordedAt = now()
job.sourceUploadErrorCode = "SOURCE_UPLOAD_UNCERTAIN"
job.sourceUploadErrorAt = recordedAt
job.updatedAt = recordedAt
}
}
@Transactional(readOnly = true)
fun matchesOutput(contentId: Long, outputKey: String): Boolean? =
jobs.findFirstByContentIdOrderByCreatedAtAsc(contentId)?.let { job ->
outputKey.substringBeforeLast('.', "") == job.outputKey &&
outputKey.substringAfterLast('.', "") in setOf("aac", "m4a", "mp3")
}
@Transactional(readOnly = true)
fun subtitle(content: AudioContent, lang: Lang, expirationTime: Long): ContentSubtitleResponse? {
val jobId = content.latestSubtitleJobId ?: return null
val job = jobs.findByIdOrNull(jobId) ?: return null
if (job.contentId != content.id || !job.status.terminal || job.status == SubtitleJobStatus.FAILED) return null
val language = when (lang) {
Lang.KO -> "ko-KR"
Lang.JA -> "ja-JP"
else -> return null
}
val subtitle = subtitles.findByJobIdAndLanguage(jobId, language) ?: return null
return ContentSubtitleResponse(
subtitle.language,
subtitle.format,
cloudFront.generateSignedURL(subtitle.s3Key, expirationTime)
)
}
private fun validate(job: SubtitleJob, request: SubtitleCallbackRequest): SubtitleJobStatus {
if (request.contentId != job.contentId || request.transcribeJobName != "subtitle-${job.jobId}") throw invalid()
if (request.subtitles.map { it.language }.distinct().size != request.subtitles.size) throw invalid()
request.subtitles.forEach {
val language = when (it.language) {
"ko-KR" -> "ko"
"ja-JP" -> "ja"
else -> throw invalid()
}
if (it.format != "SRT" || it.s3Bucket != bucket ||
it.s3Key != "subtitles/${job.contentId}/${job.jobId}/$language.srt"
) {
throw invalid()
}
}
val status = when (request.subtitles.size) {
2 -> SubtitleJobStatus.COMPLETED
1 -> SubtitleJobStatus.PARTIAL_COMPLETED
0 -> SubtitleJobStatus.FAILED
else -> throw invalid()
}
if (request.status != status.name) throw invalid()
if (status == SubtitleJobStatus.COMPLETED) {
if (request.errorCode != null || request.errorMessage != null) throw invalid()
} else if (request.errorCode.isNullOrBlank() || request.errorMessage.isNullOrBlank() || request.errorCode.length > 255) {
throw invalid()
}
return status
}
private fun replay(receipt: SubtitleCallbackReceipt, hash: String) {
if (receipt.bodyHash != hash) throw invalid()
}
private fun response(job: SubtitleJob) = SubtitleJobResponse(
job.jobId,
job.contentId,
job.status,
SubtitleSourceResponse(job.sourceBucket, job.sourceKey)
)
private fun now() = LocalDateTime.now(ZoneOffset.UTC).truncatedTo(ChronoUnit.SECONDS)
private fun missing() = ResponseStatusException(HttpStatus.NOT_FOUND, "Subtitle job not found")
private fun invalid() = ResponseStatusException(HttpStatus.UNPROCESSABLE_ENTITY, "Invalid subtitle request")
}
@@ -0,0 +1,8 @@
package kr.co.vividnext.sodalive.v2.subtitle.domain
enum class SubtitleJobStatus {
PENDING, PROCESSING, COMPLETED, PARTIAL_COMPLETED, FAILED;
val terminal: Boolean
get() = this == COMPLETED || this == PARTIAL_COMPLETED || this == FAILED
}
@@ -0,0 +1,29 @@
package kr.co.vividnext.sodalive.v2.subtitle.dto
import kr.co.vividnext.sodalive.v2.subtitle.domain.SubtitleJobStatus
data class SubtitleSourceResponse(val bucket: String, val key: String, val versionId: String? = null)
data class SubtitleJobResponse(
val jobId: String,
val contentId: Long,
val status: SubtitleJobStatus,
val source: SubtitleSourceResponse
)
data class SubtitleStartedRequest(val transcribeJobName: String, val status: String)
data class SubtitleResultRequest(val language: String, val format: String, val s3Bucket: String, val s3Key: String)
data class SubtitleCallbackRequest(
val eventId: String,
val jobId: String,
val contentId: Long,
val transcribeJobName: String,
val status: String,
val subtitles: List<SubtitleResultRequest>,
val errorCode: String?,
val errorMessage: String?
)
data class ContentSubtitleResponse(val language: String, val format: String, val url: String)
@@ -15,6 +15,7 @@ import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.context.ApplicationEventPublisher
import java.util.Optional
class AdminContentServiceTest {
@@ -43,6 +44,7 @@ class AdminContentServiceTest {
contentMainTabRepository = contentMainTabRepository,
objectMapper = jacksonObjectMapper(),
s3Uploader = s3Uploader,
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
bucket = "test-bucket"
)
}
@@ -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.i18n.LangContext
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.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
@@ -27,6 +26,7 @@ import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreference
import kr.co.vividnext.sodalive.support.originalLocalizedNameService
import kr.co.vividnext.sodalive.v2.home.following.application.HomeFollowingNewsPublishService
import kr.co.vividnext.sodalive.v2.recommendation.application.CreatorContentViewHistoryService
import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertNull
@@ -40,6 +40,7 @@ import org.mockito.Mockito
import org.springframework.boot.test.system.CapturedOutput
import org.springframework.boot.test.system.OutputCaptureExtension
import org.springframework.context.ApplicationEventPublisher
import org.springframework.transaction.PlatformTransactionManager
import java.time.LocalDateTime
import java.util.Optional
@@ -58,7 +59,6 @@ class AudioContentServiceTest {
private lateinit var audioContentLikeRepository: AudioContentLikeRepository
private lateinit var pinContentRepository: PinContentRepository
private lateinit var memberRepository: MemberRepository
private lateinit var resourceTranslationJobScheduler: ResourceTranslationJobScheduler
private lateinit var contentTranslationRepository: ContentTranslationRepository
private lateinit var s3Uploader: S3Uploader
private lateinit var audioContentCloudFront: AudioContentCloudFront
@@ -66,6 +66,7 @@ class AudioContentServiceTest {
private lateinit var contentThemeTranslationRepository: ContentThemeTranslationRepository
private lateinit var homeFollowingNewsPublishService: HomeFollowingNewsPublishService
private lateinit var memberContentPreferenceService: MemberContentPreferenceService
private lateinit var subtitleJobService: SubtitleJobService
private lateinit var service: AudioContentService
@@ -84,7 +85,6 @@ class AudioContentServiceTest {
audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java)
pinContentRepository = Mockito.mock(PinContentRepository::class.java)
memberRepository = Mockito.mock(MemberRepository::class.java)
resourceTranslationJobScheduler = Mockito.mock(ResourceTranslationJobScheduler::class.java)
contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java)
s3Uploader = Mockito.mock(S3Uploader::class.java)
audioContentCloudFront = Mockito.mock(AudioContentCloudFront::class.java)
@@ -92,6 +92,8 @@ class AudioContentServiceTest {
contentThemeTranslationRepository = Mockito.mock(ContentThemeTranslationRepository::class.java)
homeFollowingNewsPublishService = Mockito.mock(HomeFollowingNewsPublishService::class.java)
memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java)
subtitleJobService = Mockito.mock(SubtitleJobService::class.java)
Mockito.`when`(subtitleJobService.matchesOutput(Mockito.anyLong(), Mockito.anyString())).thenReturn(null)
service = AudioContentService(
repository = repository,
@@ -107,8 +109,11 @@ class AudioContentServiceTest {
audioContentLikeRepository = audioContentLikeRepository,
pinContentRepository = pinContentRepository,
memberRepository = memberRepository,
resourceTranslationJobScheduler = resourceTranslationJobScheduler,
contentTranslationRepository = contentTranslationRepository,
detailTranslationService = Mockito.mock(AudioContentDetailTranslationService::class.java).also {
Mockito.`when`(it.resolve(Mockito.anyLong(), Mockito.anyString()))
.thenReturn(AudioContentDetailTranslationResult("ko"))
},
s3Uploader = s3Uploader,
objectMapper = ObjectMapper(),
audioContentCloudFront = audioContentCloudFront,
@@ -119,6 +124,8 @@ class AudioContentServiceTest {
contentThemeTranslationRepository = contentThemeTranslationRepository,
homeFollowingNewsPublishService = homeFollowingNewsPublishService,
memberContentPreferenceService = memberContentPreferenceService,
subtitleJobService = subtitleJobService,
transactionManager = Mockito.mock(PlatformTransactionManager::class.java),
audioContentBucket = "audio-bucket",
coverImageBucket = "cover-bucket",
coverImageHost = "https://cdn.test"
@@ -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
}
}
@@ -0,0 +1,201 @@
package kr.co.vividnext.sodalive.content
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.chat.character.ChatCharacter
import kr.co.vividnext.sodalive.chat.original.OriginalWork
import kr.co.vividnext.sodalive.common.BaseEntity
import kr.co.vividnext.sodalive.configs.QueryDslConfig
import kr.co.vividnext.sodalive.content.category.Category
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.i18n.translation.DetectedLanguage
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.ResourceTranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJob
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobSchedulerTestConfiguration
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceExtractor
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Import
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.test.util.AopTestUtils
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import javax.persistence.EntityManager
@DataJpaTest(
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:metadata-language-detect;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(
QueryDslConfig::class,
AudioContentThemeQueryRepository::class,
LanguageDetectListener::class,
TranslationSourceExtractor::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class
)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MetadataLanguageDetectTransactionTest @Autowired constructor(
private val languageDetectListener: LanguageDetectListener,
private val jobRepository: TranslationJobRepository,
private val entityManager: EntityManager,
private val jdbcTemplate: JdbcTemplate,
transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager)
private val fixtures = mutableListOf<BaseEntity>()
@MockBean
private lateinit var detectionCache: LanguageDetectionCacheService
@MockBean
private lateinit var communityTranslationService: CreatorCommunityTranslationService
@AfterEach
fun cleanUp() {
transaction.executeWithoutResult {
jobRepository.deleteAll()
fixtures.asReversed().forEach { entity ->
entityManager.remove(entityManager.find(entity.javaClass, entity.id))
}
}
}
@ParameterizedTest
@EnumSource(MetadataTarget::class)
@DisplayName("메타데이터 감지는 언어와 전체 번역 작업을 커밋 전 같은 트랜잭션에 저장한다")
fun shouldPersistDetectedLanguageAndJobsInSameTransaction(target: MetadataTarget) {
val event = prepareDetection(target)
// 비동기 어댑터를 제외한 실제 리스너와 Spring scheduler를 하나의 DB 트랜잭션에서 실행한다.
val listener: LanguageDetectListener = AopTestUtils.getTargetObject(languageDetectListener)
val beforeCommit = transaction.execute {
listener.detectLanguage(event)
readState(target, event.id)
}!!
val afterCommit = transaction.execute { readState(target, event.id) }!!
val expectedJobs = target.fields.flatMap { (field, text) ->
listOf(Triple(field, "en", text), Triple(field, "ja", text))
}.toSet()
listOf(beforeCommit, afterCommit).forEach { (languageCode, jobs) ->
assertEquals("ko", languageCode)
assertEquals(expectedJobs.size, jobs.size)
assertEquals(expectedJobs, jobs.map { Triple(it.fieldKey, it.targetLanguage, it.sourceText) }.toSet())
assertEquals(setOf("ko"), jobs.map { it.sourceLanguage }.toSet())
assertEquals(setOf(TranslationJobStatus.PENDING), jobs.map { it.status }.toSet())
}
}
@ParameterizedTest
@EnumSource(MetadataTarget::class)
@DisplayName("번역 작업 INSERT 실패는 감지 언어와 먼저 저장한 작업을 모두 롤백한다")
fun shouldRollBackDetectedLanguageAndJobsWhenJobInsertFails(target: MetadataTarget) {
val event = prepareDetection(target)
val listener: LanguageDetectListener = AopTestUtils.getTargetObject(languageDetectListener)
// H2 전용 일시 제약으로 en INSERT 이후 ja INSERT를 실제 DB에서 실패시킨다.
jdbcTemplate.execute(
"ALTER TABLE translation_job ADD CONSTRAINT metadata_reject_ja CHECK (target_language <> 'ja')"
)
try {
assertThrows(DataIntegrityViolationException::class.java) {
transaction.executeWithoutResult { listener.detectLanguage(event) }
}
val (languageCode, jobs) = transaction.execute { readState(target, event.id) }!!
assertNull(languageCode)
assertEquals(emptyList<TranslationJob>(), jobs)
} finally {
jdbcTemplate.execute("ALTER TABLE translation_job DROP CONSTRAINT metadata_reject_ja")
}
}
private fun prepareDetection(target: MetadataTarget): LanguageDetectEvent {
Mockito.`when`(detectionCache.detectWithCache("원문 제목"))
.thenReturn(DetectedLanguage("ko", LanguageProviderId.PAPAGO))
val id = transaction.execute {
val owner = persist(Member(password = "password", nickname = "metadata-owner", role = MemberRole.CREATOR))
val metadata = when (target) {
MetadataTarget.CONTENT -> AudioContent("원문 제목", "원문 설명", null).apply {
member = owner
theme = persist(AudioContentTheme("theme", "theme.png"))
}
MetadataTarget.CHARACTER -> ChatCharacter(
characterUUID = "metadata-character",
name = "원문 제목",
description = "원문 설명",
systemPrompt = "system prompt"
).apply { creatorMember = owner }
MetadataTarget.SERIES -> Series("원문 제목", "원문 설명").apply {
member = owner
genre = persist(SeriesGenre("genre"))
}
MetadataTarget.ORIGINAL_WORK -> OriginalWork(
title = "원문 제목",
contentType = "소설",
category = "판타지",
description = "원문 설명"
)
MetadataTarget.CREATOR_CONTENT_CATEGORY -> Category("원문 제목").apply { member = owner }
}
requireNotNull(persist(metadata).id)
}!!
return LanguageDetectEvent(id, "원문 제목", LanguageDetectTargetType.valueOf(target.name))
}
private fun <T : BaseEntity> persist(entity: T): T {
entityManager.persist(entity)
fixtures.add(entity)
return entity
}
private fun readState(target: MetadataTarget, id: Long): Pair<String?, List<TranslationJob>> {
entityManager.flush()
entityManager.clear()
val languageCode = entityManager.createQuery(
"select metadata.languageCode from ${target.entityClass.simpleName} metadata where metadata.id = :id",
String::class.java
).setParameter("id", id).singleResult
val jobs = jobRepository.findAll().filter {
it.resourceType == LanguageTranslationTargetType.valueOf(target.name) && it.resourceId == id
}
return languageCode to jobs
}
enum class MetadataTarget(val entityClass: Class<out BaseEntity>, val fields: Map<String, String>) {
CONTENT(AudioContent::class.java, mapOf("title" to "원문 제목", "detail" to "원문 설명")),
CHARACTER(ChatCharacter::class.java, mapOf("name" to "원문 제목", "description" to "원문 설명")),
SERIES(Series::class.java, mapOf("title" to "원문 제목", "introduction" to "원문 설명")),
ORIGINAL_WORK(
OriginalWork::class.java,
mapOf("title" to "원문 제목", "contentType" to "소설", "category" to "판타지", "description" to "원문 설명")
),
CREATOR_CONTENT_CATEGORY(Category::class.java, mapOf("category" to "원문 제목"))
}
}
@@ -0,0 +1,125 @@
package kr.co.vividnext.sodalive.i18n.translation
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentDetailTranslationService
import kr.co.vividnext.sodalive.content.AudioContentRepository
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.comment.AudioContentCommentRepository
import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository
import kr.co.vividnext.sodalive.content.like.AudioContentLikeRepository
import kr.co.vividnext.sodalive.content.order.LimitedEditionOrderRepository
import kr.co.vividnext.sodalive.content.order.OrderRepository
import kr.co.vividnext.sodalive.content.pin.PinContentRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.support.originalLocalizedNameService
import kr.co.vividnext.sodalive.v2.home.following.application.HomeFollowingNewsPublishService
import kr.co.vividnext.sodalive.v2.recommendation.application.CreatorContentViewHistoryService
import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher
import java.util.Optional
import javax.persistence.EntityManager
class AudioContentReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var translations: ContentTranslationRepository
@Test
@DisplayName("오디오 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedContentWhilePreservingRenderedDetail() {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "title", "현재 제목")
val job = failedJob(source)
persistRendered(
ContentTranslation(10L, "en", ContentTranslationPayload("Old title", "Old detail", "old tags")),
"content_translation",
"""{"title":"Old title","detail":"Old detail","tags":"old tags"}"""
)
val member = Member(password = "password", nickname = "creator").apply { id = 100L }
val content = AudioContent("현재 제목", "현재 설명", "ko", isCommentAvailable = false).apply {
id = 10L
this.member = member
theme = AudioContentTheme("테마", "theme.png").apply { id = 20L }
this.content = "output/audio.mp3"
coverImage = "cover.png"
duration = "00:01:00"
isActive = true
}
val repository = Mockito.mock(AudioContentRepository::class.java)
val explorer = Mockito.mock(ExplorerQueryRepository::class.java)
val orders = Mockito.mock(OrderRepository::class.java)
val cloudFront = Mockito.mock(AudioContentCloudFront::class.java)
Mockito.`when`(repository.findById(10L)).thenReturn(Optional.of(content))
Mockito.`when`(explorer.getMember(100L)).thenReturn(member)
Mockito.`when`(orders.isExistOrderedAndOrderType(100L, 10L)).thenReturn(false to null)
Mockito.`when`(cloudFront.generateSignedURL("output/audio.mp3", 7_200_000L)).thenReturn("https://signed.test/audio")
val service = AudioContentService(
repository = repository,
explorerQueryRepository = explorer,
blockMemberRepository = Mockito.mock(BlockMemberRepository::class.java),
hashTagRepository = Mockito.mock(HashTagRepository::class.java),
orderRepository = orders,
limitedEditionOrderRepository = Mockito.mock(LimitedEditionOrderRepository::class.java),
themeQueryRepository = Mockito.mock(AudioContentThemeQueryRepository::class.java),
playbackTrackingRepository = Mockito.mock(PlaybackTrackingRepository::class.java),
creatorContentViewHistoryService = Mockito.mock(CreatorContentViewHistoryService::class.java),
commentRepository = Mockito.mock(AudioContentCommentRepository::class.java),
audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java),
pinContentRepository = Mockito.mock(PinContentRepository::class.java),
memberRepository = Mockito.mock(MemberRepository::class.java),
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),
objectMapper = ObjectMapper(),
audioContentCloudFront = cloudFront,
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
messageSource = SodaMessageSource(),
langContext = langContext,
localizedNameService = originalLocalizedNameService(),
contentThemeTranslationRepository = Mockito.mock(ContentThemeTranslationRepository::class.java),
homeFollowingNewsPublishService = Mockito.mock(HomeFollowingNewsPublishService::class.java),
memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java),
subtitleJobService = Mockito.mock(SubtitleJobService::class.java),
transactionManager = transactionManager,
audioContentBucket = "audio-bucket",
coverImageBucket = "cover-bucket",
coverImageHost = "https://cdn.test"
)
val response = service.getDetail(10L, member, false, "Asia/Seoul")
assertEquals("현재 제목", response.title)
assertEquals("Old title", response.translated?.title)
assertEquals("Old detail", response.translated?.detail)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
}
@@ -0,0 +1,78 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.chat.character.ChatCharacter
import kr.co.vividnext.sodalive.chat.character.comment.CharacterCommentService
import kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterController
import kr.co.vividnext.sodalive.chat.character.curation.CharacterCurationQueryService
import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterBannerService
import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService
import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslation
import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationRenderedPayload
import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationRepository
import kr.co.vividnext.sodalive.chat.room.service.ChatRoomService
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.member.contentpreference.ViewerContentPreference
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
class CharacterReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var translations: AiCharacterTranslationRepository
@Test
@DisplayName("캐릭터 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedCharacterWhilePreservingRenderedDetail() {
val source = givenSource(LanguageTranslationTargetType.CHARACTER, "name", "현재 이름")
val job = failedJob(source)
persistRendered(
AiCharacterTranslation(
10L,
"en",
AiCharacterTranslationRenderedPayload("Old name", "Old description", "", "", "", "", "", "")
),
"ai_character_translation",
"""
{"name":"Old name","description":"Old description","gender":"","personalityTrait":"",
"personalityDescription":"","backgroundTopic":"","backgroundDescription":"","tags":""}
""".trimIndent()
)
val member = Member(password = "password", nickname = "viewer").apply { id = 100L }
val character = ChatCharacter(
characterUUID = "character-10",
name = "현재 이름",
description = "현재 설명",
systemPrompt = "prompt",
languageCode = "ko"
).apply { id = 10L }
val characterService = Mockito.mock(ChatCharacterService::class.java)
val preferenceService = Mockito.mock(MemberContentPreferenceService::class.java)
Mockito.`when`(characterService.getCharacterDetail(10L)).thenReturn(character)
Mockito.`when`(preferenceService.getStoredPreference(member))
.thenReturn(ViewerContentPreference("KR", true, ContentType.ALL, true))
val controller = ChatCharacterController(
service = characterService,
bannerService = Mockito.mock(ChatCharacterBannerService::class.java),
chatRoomService = Mockito.mock(ChatRoomService::class.java),
characterCommentService = Mockito.mock(CharacterCommentService::class.java),
curationQueryService = Mockito.mock(CharacterCurationQueryService::class.java),
resourceTranslationJobScheduler = scheduler,
aiCharacterTranslationRepository = translations,
langContext = langContext,
memberContentPreferenceService = preferenceService,
imageHost = "https://cdn.test"
)
val response = controller.getCharacterDetail(10L, member)
assertEquals("현재 이름", response.data?.name)
assertEquals("Old name", response.data?.translated?.name)
assertEquals("Old description", response.data?.translated?.description)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
}
@@ -0,0 +1,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)
}
}
@@ -0,0 +1,116 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
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.ContentSeriesService
import kr.co.vividnext.sodalive.content.series.GetSeriesGenreListResponse
import kr.co.vividnext.sodalive.content.series.content.ContentSeriesContentRepository
import kr.co.vividnext.sodalive.content.series.content.GetSeriesContentMinMaxPriceResponse
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslation
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslation
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationPayload
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationRepository
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesSortType
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher
import java.time.LocalDateTime
import java.util.Optional
class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var seriesTranslations: SeriesTranslationRepository
@Autowired
private lateinit var genreTranslations: SeriesGenreTranslationRepository
private val repository = Mockito.mock(ContentSeriesRepository::class.java)
private val contents = Mockito.mock(ContentSeriesContentRepository::class.java)
@Test
@DisplayName("시리즈 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedSeriesWhilePreservingRenderedDetail() {
val source = givenSource(LanguageTranslationTargetType.SERIES, "title", "현재 제목")
val job = failedJob(source)
persistRendered(
SeriesTranslation(10L, "en", SeriesTranslationPayload("Old title", "Old introduction", listOf("old"))),
"series_translation",
"""{"title":"Old title","introduction":"Old introduction","keywords":["old"]}"""
)
val member = Member(password = "password", nickname = "viewer").apply { id = 100L }
val series = Series("현재 제목", "현재 소개", "ko").apply {
id = 10L
this.member = member
genre = SeriesGenre("현재 장르").apply { id = 20L }
createdAt = LocalDateTime.of(2026, 1, 1, 0, 0)
}
Mockito.`when`(repository.getSeriesDetail(10L, false, ContentType.ALL)).thenReturn(series)
Mockito.`when`(repository.findById(10L)).thenReturn(Optional.of(series))
Mockito.`when`(repository.getSeriesContentMinMaxPrice(10L)).thenReturn(GetSeriesContentMinMaxPriceResponse(0, 0))
Mockito.`when`(contents.getContentList(10L, false, ContentType.ALL, "https://cdn.test", SeriesSortType.NEWEST, 0, 5))
.thenReturn(emptyList())
val response = service().getSeriesDetail(10L, false, ContentType.ALL, member)
assertEquals("현재 제목", response.title)
assertEquals("Old title", response.translated?.title)
assertEquals("Old introduction", response.translated?.introduction)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
@Test
@DisplayName("장르 목록은 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedGenreWhilePreservingRenderedList() {
val source = givenSource(LanguageTranslationTargetType.SERIES_GENRE, "genre", "현재 장르")
val job = failedJob(source)
persist(SeriesGenreTranslation(10L, "en", "Old genre"))
Mockito.`when`(repository.getGenreList(false, 100L, ContentType.ALL))
.thenReturn(listOf(GetSeriesGenreListResponse(10L, "현재 장르")))
val response = service().getGenreList(100L, false, ContentType.ALL)
assertEquals(listOf(GetSeriesGenreListResponse(10L, "Old genre")), response)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
private fun service() = ContentSeriesService(
repository = repository,
orderRepository = Mockito.mock(OrderRepository::class.java),
blockMemberRepository = Mockito.mock(BlockMemberRepository::class.java),
explorerQueryRepository = Mockito.mock(ExplorerQueryRepository::class.java),
seriesContentRepository = contents,
langContext = langContext,
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,
contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java),
resourceTranslationJobScheduler = scheduler,
memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java),
coverImageHost = "https://cdn.test"
)
}
@@ -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
}
}
@@ -0,0 +1,114 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunity
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslation
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslationRepository
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Import
@Import(CreatorCommunityTranslationService::class)
class CreatorCommunityReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var service: CreatorCommunityTranslationService
@MockBean
private lateinit var materializer: TranslationReadModelMaterializer
@Autowired
private lateinit var translations: CreatorCommunityTranslationRepository
private lateinit var post: CreatorCommunity
private lateinit var job: TranslationJob
@BeforeEach
fun givenCurrentFailedPost() {
val creator = persist(Member(password = "password", nickname = "retry-creator"))
post = persist(
CreatorCommunity("현재 본문", 0, true, false, languageCode = "ko", contentRevision = 2).apply {
member = creator
}
)
val source = TranslationSource(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
requireNotNull(post.id),
"ko",
listOf(TranslationSourceField("content", "현재 본문")),
sourceRevision = 2
)
Mockito.`when`(sourceExtractor.extract(source.resourceType, source.resourceId)).thenReturn(source)
job = failedJob(source)
}
@ParameterizedTest
@ValueSource(booleans = [true, false])
@DisplayName("커뮤니티 표시 조회는 현재 FAILED를 재개하고 개정에 따른 번역과 원문 fallback을 보존한다")
fun shouldRestartFailedDisplayReadWhilePreservingRevisionFallback(currentRevision: Boolean) {
val postId = requireNotNull(post.id)
persist(
CreatorCommunityTranslation(
creatorCommunityId = postId,
locale = "en",
content = "Rendered content",
sourceRevision = if (currentRevision) 2 else 1,
sourceHash = SourceTextNormalizer.hash("현재 본문"),
sourceLanguage = "ko"
)
)
val response = service.findDisplayContents(listOf(postId), "EN")
assertEquals(if (currentRevision) "Rendered content" else "현재 본문", response[postId]?.content)
assertEquals(currentRevision, response[postId]?.hasValidTranslation)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
@Test
@DisplayName("커뮤니티 표시 조회는 재개할 작업이 없으면 원문을 반환하고 누락 작업을 새로 만들지 않는다")
fun shouldPreserveOriginalWithoutCreatingMissingJobsFromDisplayRead() {
jobs.deleteById(requireNotNull(job.id))
val postId = requireNotNull(post.id)
val response = service.findDisplayContents(listOf(postId), "en")
assertEquals("현재 본문", response[postId]?.content)
assertEquals(false, response[postId]?.hasValidTranslation)
assertEquals(emptyList<TranslationJob>(), jobs.findAll())
}
@Test
@DisplayName("커뮤니티 잠금 요청은 메모리 재료화에 성공해도 같은 트랜잭션에서 FAILED 작업을 재개한다")
fun shouldRestartFailedRequestEvenWhenMemoryMaterializesUnderPostLock() {
val postId = requireNotNull(post.id)
val rendered = persist(
CreatorCommunityTranslation(
creatorCommunityId = postId,
locale = "en",
content = "Rendered content",
sourceRevision = 2,
sourceHash = SourceTextNormalizer.hash("현재 본문"),
sourceLanguage = "ko"
)
)
Mockito.`when`(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en"))
.thenReturn(true)
service.requestTranslations(postId, "EN")
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
val preserved = translations.findByCreatorCommunityIdAndLocale(postId, "en")
assertEquals(rendered.id, preserved?.id)
assertEquals("Rendered content", preserved?.content)
}
}
@@ -18,6 +18,35 @@ class LanguageDetectionProviderTest {
private val query = "original source"
private val hash = SourceTextNormalizer.hash(query)
@Test
@DisplayName("기본 감지 순서에서 AWS 예외와 빈 결과는 Papago로 전환한다")
fun shouldFallbackToPapagoWithDefaultDetectionOrder() {
val failures: List<() -> String?> = listOf({ throw IllegalStateException("unavailable") }, { null }, { " " })
failures.forEach { failure ->
val aws = RecordingDetectionProvider(AWS, failure)
val papago = RecordingDetectionProvider(PAPAGO) { "ko" }
Mockito.`when`(repository.findDetectedLanguageForUpdate(hash, "papago", "v1")).thenReturn("ko")
val detector = LanguageDetectionCacheService(repository, listOf(papago, aws), LanguageProviderProperties())
assertEquals(DetectedLanguage("ko", PAPAGO), detector.detectWithCache(query))
assertEquals(listOf(query), aws.queries)
assertEquals(listOf(query), papago.queries)
}
}
@Test
@DisplayName("AWS 우선 기본 설정도 기존 Papago 감지 캐시는 외부 호출 없이 재사용한다")
fun shouldReusePapagoCacheWithDefaultDetectionOrder() {
val aws = RecordingDetectionProvider(AWS) { "en" }
val papago = RecordingDetectionProvider(PAPAGO) { "ko" }
Mockito.`when`(repository.findBySourceHashAndProviderAndNormalizationVersion(hash, "papago", "v1"))
.thenReturn(LanguageDetectionResult(hash, "sample", "ja", "papago", null, "v1"))
val detector = LanguageDetectionCacheService(repository, listOf(papago, aws), LanguageProviderProperties())
assertEquals(DetectedLanguage("ja", PAPAGO), detector.detectWithCache(query))
assertEquals(emptyList<String>(), aws.queries + papago.queries)
}
@Test
@DisplayName("감지 예외와 빈 결과는 다음 공급자로 넘기고 실제 공급자의 저장 승자를 반환한다")
fun shouldFallbackAndReturnCanonicalWinnerWithActualProvider() {
@@ -64,6 +64,7 @@ import java.util.UUID
LanguageDetectionCacheService::class,
TranslationCoordinator::class,
TranslationJobWorker::class,
TranslationMemoryService::class,
TranslationReadModelMaterializer::class,
TranslationSourceExtractor::class,
TranslationJobScheduler::class,
@@ -138,7 +139,7 @@ class LanguageProviderCacheEndToEndTest @Autowired constructor(
assertEquals("v1", it.normalizationVersion)
assertNotEquals(SourceTextNormalizer.hash(prefix), it.sourceHash)
}
assertEquals(sources, papagoDetection.queries)
assertEquals(emptyList<String>(), papagoDetection.queries)
assertDetectionRequests(prefix, prefix)
}
@@ -203,8 +204,7 @@ class LanguageProviderCacheEndToEndTest @Autowired constructor(
assertTrue(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en"))
schedule(postId, source)
assertTrue(worker.processNextGroup())
assertEquals(1, papagoTranslation.requests.size)
assertEquals(listOf(source), papagoTranslation.requests.single().texts)
assertEquals(emptyList<TranslateRequest>(), papagoTranslation.requests)
assertTranslationRequests(first, tail)
assertEquals(1L, transaction.execute { memoryRepository.count() })
assertEquals(
@@ -42,20 +42,20 @@ class LanguageProviderIdTest {
}
@Test
@DisplayName("production 기본 순서는 PAPAGO 다음 AWS이며 실제 Papago adapter 식별자는 유지한다")
fun shouldUsePapagoEnumForProductionDefaultsAndAdapters() {
@DisplayName("production 감지와 번역은 AWS 다음 PAPAGO이며 Papago adapter 식별자는 유지한다")
fun shouldUseCapabilityDefaultsAndPreservePapagoAdapterIdentity() {
assertAll(
{ assertEquals(listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), LanguageProviderOrder.detectionOrder) },
{ assertEquals(listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS), LanguageProviderOrder.translationOrder) },
{ assertEquals(listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderOrder.detectionOrder) },
{ assertEquals(listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO), LanguageProviderOrder.translationOrder) },
{
assertEquals(
listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS),
listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO),
LanguageProviderProperties().detectionOrder
)
},
{
assertEquals(
listOf(LanguageProviderId.PAPAGO, LanguageProviderId.AWS),
listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO),
LanguageProviderProperties().translationOrder
)
}
@@ -41,17 +41,17 @@ class LanguageProviderSpringConfigurationTest {
assertNull(context.startupFailure)
val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) }
{ assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) }
)
assertEquals(PAPAGO, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId)
assertEquals(AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId)
assertEquals(
PAPAGO,
AWS,
context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en")).providerId
)
assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(1, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
}
}
@@ -77,17 +77,17 @@ class LanguageProviderSpringConfigurationTest {
assertEquals("secondary,papago", context.environment.getProperty("sodalive.language-providers.translation-order"))
val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) }
{ assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) }
)
assertEquals(PAPAGO, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId)
assertEquals(AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId)
assertEquals(
PAPAGO,
AWS,
context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en")).providerId
)
assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(1, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
}
}
@@ -133,36 +133,47 @@ class LanguageProviderSpringConfigurationTest {
}
@Test
@DisplayName("Spring 기본 생성자는 두 기능 모두 PAPAGO 다음 AWS를 등록하고 첫 PAPAGO 성공 뒤 멈춘다")
fun shouldDefaultToPapago() {
@DisplayName("Spring 기본 설정은 감지와 번역에 AWS를 먼저 사용하고 첫 성공 뒤 멈춘다")
fun shouldDefaultToAwsForDetectionAndTranslation() {
defaultRunner.run { context ->
assertNull(context.startupFailure)
val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) }
)
assertEquals(
PAPAGO,
AWS,
context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId
)
assertEquals(
PAPAGO,
context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en")).providerId
val result = context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en"))
assertEquals(AWS, result.providerId)
assertEquals("AWS-v1", result.providerVersion)
assertEquals(listOf("AWS:0"), result.result.translatedText)
val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll(
{ assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) }
)
assertEquals(listOf("source"), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries)
assertEquals(1, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(0, context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries.size)
assertEquals(0, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(emptyList<String>(), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries)
assertEquals(0, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(listOf("source"), context.getBean("secondaryDetection", RecordingDetectionProvider::class.java).queries)
assertEquals(1, context.getBean("secondaryTranslation", RecordingTranslationProvider::class.java).requests.size)
}
}
@Test
@DisplayName("실제 AWS adapter와 SDK client만 등록한 context도 기본 순서에서 PAPAGO 첫 성공 뒤 SDK를 호출하지 않는다")
@DisplayName("실제 AWS adapter를 등록한 기본 context는 감지와 번역에 AWS SDK를 사용한다")
fun shouldWireActualAwsAdaptersWithoutDuplicateIds() {
actualRunner.withUserConfiguration(LanguageProviderProperties::class.java).run { context ->
assertNull(context.startupFailure)
val translationRequest = TranslateTextRequest.builder()
.text("source").sourceLanguageCode("ko").targetLanguageCode("en").build()
val client = context.getBean(TranslateClient::class.java)
val detectionRequest = DetectDominantLanguageRequest.builder().text("source").build()
val detector = context.getBean(ComprehendClient::class.java)
Mockito.`when`(detector.detectDominantLanguage(detectionRequest)).thenReturn(
DetectDominantLanguageResponse.builder()
.languages(DominantLanguage.builder().languageCode("ko").build()).build()
)
Mockito.`when`(client.translateText(translationRequest))
.thenReturn(TranslateTextResponse.builder().translatedText("translated").build())
assertEquals(2, context.getBeansOfType(LanguageDetectionProvider::class.java).size)
assertEquals(2, context.getBeansOfType(TranslationProvider::class.java).size)
assertEquals(AWS, context.getBean(AwsLanguageDetectionProvider::class.java).providerId)
@@ -171,19 +182,19 @@ class LanguageProviderSpringConfigurationTest {
assertEquals("translate-2017-07-01", translator.providerVersion)
val properties = context.getBean(LanguageProviderProperties::class.java)
assertAll(
{ assertEquals(listOf(PAPAGO, AWS), properties.detectionOrder) },
{ assertEquals(listOf(PAPAGO, AWS), properties.translationOrder) }
)
assertEquals(PAPAGO, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId)
assertEquals(
PAPAGO,
context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en")).providerId
)
Mockito.verifyNoInteractions(
context.getBean(ComprehendClient::class.java),
context.getBean(TranslateClient::class.java)
{ assertEquals(listOf(AWS, PAPAGO), properties.detectionOrder) },
{ assertEquals(listOf(AWS, PAPAGO), properties.translationOrder) }
)
assertEquals(AWS, context.getBean(LanguageDetectionCacheService::class.java).detectWithCache("source")?.providerId)
val result = context.getBean(TranslationCoordinator::class.java)
.translate(TranslateRequest(listOf("source"), "ko", "en"))
assertEquals(AWS, result.providerId)
assertEquals("translate-2017-07-01", result.providerVersion)
assertEquals(listOf("translated"), result.result.translatedText)
assertEquals(0, context.getBean("papagoTranslation", RecordingTranslationProvider::class.java).requests.size)
assertEquals(emptyList<String>(), context.getBean("papagoDetection", RecordingDetectionProvider::class.java).queries)
Mockito.verify(detector).detectDominantLanguage(detectionRequest)
Mockito.verify(client).translateText(translationRequest)
}
}
@@ -0,0 +1,92 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.content.AudioContentRepository
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.category.Category
import kr.co.vividnext.sodalive.content.category.CategoryContentRepository
import kr.co.vividnext.sodalive.content.category.CategoryRepository
import kr.co.vividnext.sodalive.content.category.CategoryService
import kr.co.vividnext.sodalive.content.category.CategoryTranslation
import kr.co.vividnext.sodalive.content.category.CategoryTranslationRepository
import kr.co.vividnext.sodalive.content.category.GetCategoryListResponse
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeService
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslation
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher
class MetadataListReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var themeTranslations: ContentThemeTranslationRepository
@Autowired
private lateinit var categoryTranslations: CategoryTranslationRepository
@Test
@DisplayName("활성 테마 목록은 이전 번역을 반환하면서 제외되지 않은 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedThemeWhilePreservingRenderedListAndExclusions() {
val source = givenSource(LanguageTranslationTargetType.CONTENT_THEME, "theme", "현재 테마")
val job = failedJob(source)
val excludedSource = source.copy(resourceId = 20L, fields = listOf(TranslationSourceField("theme", "제외 테마")))
val excluded = failedJob(excludedSource)
Mockito.`when`(sourceExtractor.extract(excludedSource.resourceType, excludedSource.resourceId)).thenReturn(excludedSource)
persist(ContentThemeTranslation(10L, "en", "Old theme"))
val query = Mockito.mock(AudioContentThemeQueryRepository::class.java)
Mockito.`when`(query.getActiveThemeWithIdsOfContent(false, false, false, ContentType.ALL)).thenReturn(
listOf(
AudioContentThemeQueryRepository.ThemeIdAndName(10L, "현재 테마"),
AudioContentThemeQueryRepository.ThemeIdAndName(20L, "제외 테마")
)
)
val service = AudioContentThemeService(
query,
Mockito.mock(AudioContentRepository::class.java),
themeTranslations,
scheduler,
langContext,
Mockito.mock(MemberContentPreferenceService::class.java)
)
val response = service.getActiveThemeOfContent(contentType = ContentType.ALL, excludeThemes = listOf("제외 테마"))
assertEquals(listOf("Old theme"), response)
assertRestarted(job)
assertEquals(TranslationJobStatus.FAILED, jobs.findById(requireNotNull(excluded.id)).orElseThrow().status)
assertEquals(setOf(job.id, excluded.id), jobs.findAll().map { it.id }.toSet())
}
@Test
@DisplayName("카테고리 목록은 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedCategoryWhilePreservingRenderedList() {
val source = givenSource(LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY, "category", "현재 분류")
val job = failedJob(source)
persist(CategoryTranslation(10L, "en", "Old category"))
val repository = Mockito.mock(CategoryRepository::class.java)
val category = Category("현재 분류", languageCode = "ko").apply { id = 10L }
Mockito.`when`(repository.findByCreatorId(100L)).thenReturn(listOf(GetCategoryListResponse(10L, "현재 분류")))
Mockito.`when`(repository.findAllById(listOf(10L))).thenReturn(listOf(category))
val service = CategoryService(
repository,
Mockito.mock(AudioContentRepository::class.java),
Mockito.mock(BlockMemberRepository::class.java),
Mockito.mock(CategoryContentRepository::class.java),
categoryTranslations,
langContext,
Mockito.mock(ApplicationEventPublisher::class.java),
scheduler
)
val response = service.getCategoryList(100L, 200L)
assertEquals(listOf(GetCategoryListResponse(10L, "Old category")), response)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
}
@@ -0,0 +1,116 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.common.BaseEntity
import kr.co.vividnext.sodalive.configs.QueryDslConfig
import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.i18n.LangContext
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Import
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import javax.persistence.EntityManager
@DataJpaTest(
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:metadata-read-retry;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(
QueryDslConfig::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class
)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
abstract class MetadataReadRetryTestSupport {
@Autowired
protected lateinit var scheduler: ResourceTranslationJobScheduler
@Autowired
protected lateinit var jobs: TranslationJobRepository
@Autowired
protected lateinit var transactionManager: PlatformTransactionManager
@Autowired
protected lateinit var entityManager: EntityManager
@MockBean
protected lateinit var sourceExtractor: TranslationSourceExtractor
protected val langContext = LangContext().apply { setLang(Lang.EN) }
protected val previousRetryAt = LocalDateTime.of(2040, 1, 1, 0, 0)
private val fixtures = mutableListOf<BaseEntity>()
protected fun givenSource(type: LanguageTranslationTargetType, fieldKey: String, text: String): TranslationSource {
val source = TranslationSource(type, 10L, "ko", listOf(TranslationSourceField(fieldKey, text)))
Mockito.`when`(sourceExtractor.extract(type, source.resourceId)).thenReturn(source)
return source
}
protected fun failedJob(source: TranslationSource, targetLanguage: String = "en"): TranslationJob {
val field = source.fields.first()
return persist(
TranslationJob(
resourceType = source.resourceType,
resourceId = source.resourceId,
fieldKey = field.fieldKey,
sourceHash = SourceTextNormalizer.hash(field.sourceText),
sourceText = field.sourceText,
sourceLanguage = source.sourceLanguage,
targetLanguage = targetLanguage,
status = TranslationJobStatus.FAILED,
retryCount = 6,
lastErrorMessage = "exhausted",
nextRetryAt = previousRetryAt
)
)
}
protected fun <T : BaseEntity> persist(entity: T): T {
TransactionTemplate(transactionManager).executeWithoutResult { entityManager.persist(entity) }
fixtures.add(entity)
return entity
}
protected fun <T : BaseEntity> persistRendered(entity: T, table: String, payload: String): T {
persist(entity)
TransactionTemplate(transactionManager).executeWithoutResult {
// H2 JSON 컬럼에는 문자열 대신 JSON 객체를 적재한다.
entityManager.createNativeQuery("update $table set rendered_payload = :payload format json where id = :id")
.setParameter("payload", payload)
.setParameter("id", entity.id)
.executeUpdate()
}
return entity
}
protected fun assertRestarted(job: TranslationJob) {
val restarted = jobs.findById(requireNotNull(job.id)).orElseThrow()
assertEquals(TranslationJobStatus.PENDING, restarted.status)
assertEquals(0, restarted.retryCount)
assertNull(restarted.lastErrorMessage)
}
@AfterEach
fun removeFixtures() {
TransactionTemplate(transactionManager).executeWithoutResult {
jobs.deleteAllInBatch()
fixtures.asReversed().filterNot { it is TranslationJob }.forEach { fixture ->
entityManager.remove(entityManager.find(fixture.javaClass, fixture.id))
}
}
}
}
@@ -0,0 +1,302 @@
package kr.co.vividnext.sodalive.i18n.translation
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import kr.co.vividnext.sodalive.admin.content.AdminContentController
import kr.co.vividnext.sodalive.admin.content.AdminContentService
import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.configs.QueryDslConfig
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.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.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.MemberAdapter
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.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.NullAndEmptySource
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.context.TestConfiguration
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Import
import org.springframework.core.task.SyncTaskExecutor
import org.springframework.jdbc.core.JdbcTemplate
import org.springframework.mock.web.MockMultipartFile
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.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import org.springframework.test.web.servlet.setup.MockMvcBuilders
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import java.util.concurrent.Executor
import javax.persistence.EntityManager
@DataJpaTest(
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:metadata-translation-http;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(
QueryDslConfig::class,
AdminContentService::class,
AudioContentService::class,
AudioContentDetailTranslationService::class,
TranslationMemoryService::class,
TranslationReadModelMaterializer::class,
ExplorerQueryRepository::class,
SodaMessageSource::class,
AudioContentThemeQueryRepository::class,
TranslationSourceExtractor::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class,
LanguageTranslationListener::class,
LanguageDetectListener::class,
MetadataTranslationHttpIntegrationTest.Configuration::class
)
@MockBean(
classes = [
CreatorCommunityTranslationService::class,
CreatorContentViewHistoryService::class,
CreatorLocalizedNameService::class,
HomeFollowingNewsPublishService::class,
SubtitleJobService::class
]
)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class MetadataTranslationHttpIntegrationTest @Autowired constructor(
private val service: AdminContentService,
private val contentService: AudioContentService,
private val localizedNames: CreatorLocalizedNameService,
private val langContext: LangContext,
private val jobs: TranslationJobRepository,
private val memories: TranslationMemoryRepository,
private val jdbc: JdbcTemplate,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager).apply {
isolationLevel = TransactionDefinition.ISOLATION_REPEATABLE_READ
}
@MockBean
private lateinit var uploader: S3Uploader
@MockBean
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
@DisplayName("관리자 multipart 수정 HTTP 요청은 커밋 후 같은 FAILED 행을 재개하고 번역 작업을 저장한다")
fun shouldRestartFailedTranslationAfterAdminHttpUpdateCommits() {
val (contentId, failedId) = transaction.execute {
val member = Member(password = "test", nickname = "http-translation", role = MemberRole.CREATOR)
val theme = AudioContentTheme("테마", "theme.png")
entityManager.persist(member)
entityManager.persist(theme)
val content = AudioContent("원문 제목", "원문 설명", "ko").apply {
this.member = member
this.theme = theme
}
entityManager.persist(content)
val failed = jobs.saveAndFlush(
TranslationJob(
LanguageTranslationTargetType.CONTENT, content.id!!, "title", SourceTextNormalizer.hash("원문 제목"),
"원문 제목", "ko", "en", TranslationJobStatus.FAILED, 6, "exhausted", LocalDateTime.of(2040, 1, 1, 0, 0)
)
)
content.id!! to failed.id!!
}!!
val response = MockMvcBuilders.standaloneSetup(AdminContentController(service)).build()
.perform(
multipart("/admin/audio-content")
.file(
MockMultipartFile(
"request",
"",
"application/json",
"""{"id":$contentId,"title":"원문 제목","isDefaultCoverImage":false}""".toByteArray()
)
)
.with { request -> request.apply { method = "PUT" } }
)
.andExpect(status().isOk)
.andReturn().response
transaction.executeWithoutResult {
val restarted = jobs.findById(failedId).orElseThrow()
assertEquals(TranslationJobStatus.PENDING, restarted.status)
assertEquals(0, restarted.retryCount)
assertNull(restarted.lastErrorMessage)
val stored = jobs.findAll().filter { it.resourceId == contentId }
assertEquals(
setOf("title" to "en", "title" to "ja", "detail" to "en", "detail" to "ja"),
stored.map { it.fieldKey to it.targetLanguage }.toSet()
)
assertEquals(4, stored.size)
}
println(
"HTTP QA: status=${response.status}, body=${response.contentAsString}, " +
"contentId=$contentId, restartedJobId=$failedId"
)
}
@TestConfiguration
@EnableAsync
class Configuration {
@Bean
fun objectMapper(): ObjectMapper = jacksonObjectMapper()
@Bean
fun langContext(): LangContext = LangContext().apply { setLang(Lang.EN) }
@Bean
fun taskExecutor(): Executor = SyncTaskExecutor()
}
}
@@ -0,0 +1,124 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.chat.original.OriginalWork
import kr.co.vividnext.sodalive.chat.original.service.OriginalWorkTranslationService
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslation
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationPayload
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationRepository
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.transaction.support.TransactionTemplate
class OriginalWorkReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var translations: OriginalWorkTranslationRepository
@Test
@DisplayName("이전 원작 번역을 반환해도 읽기 전용 트랜잭션과 별도로 현재 FAILED 작업만 재개한다")
fun shouldRestartOnlyCurrentFailedJobDespiteRenderedTranslationAndReadOnlyRollback() {
val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
val current = failedJob(source)
val stale = failedJob(source.copy(fields = listOf(TranslationSourceField("title", "이전 제목"))))
val otherTarget = failedJob(source, targetLanguage = "ja")
val otherLanguage = failedJob(
source.copy(sourceLanguage = "ja", fields = listOf(TranslationSourceField("category", "장르")))
)
val currentSource = source.copy(
fields = source.fields + listOf(
TranslationSourceField("category", "장르"),
TranslationSourceField("description", "현재 설명")
)
)
Mockito.`when`(sourceExtractor.extract(source.resourceType, source.resourceId)).thenReturn(currentSource)
val rendered = givenRenderedTranslation()
val original = OriginalWork("현재 제목", "소설", "장르", description = "현재 설명", languageCode = "ko").apply { id = 10L }
val service = OriginalWorkTranslationService(translations, scheduler)
val response = TransactionTemplate(transactionManager).apply { isReadOnly = true }.execute { transaction ->
service.ensureTranslated(original, "EN").also { transaction.setRollbackOnly() }
}
assertEquals("Old title", response?.title)
assertEquals("Old description", response?.description)
assertRestarted(current)
assertNotEquals(previousRetryAt, jobs.findById(requireNotNull(current.id)).orElseThrow().nextRetryAt)
val preserved = jobs.findAll().filter { it.id != current.id }
assertEquals(setOf(stale.id, otherTarget.id, otherLanguage.id), preserved.map { it.id }.toSet())
preserved.forEach {
assertEquals(TranslationJobStatus.FAILED, it.status)
assertEquals(6, it.retryCount)
assertEquals("exhausted", it.lastErrorMessage)
assertEquals(previousRetryAt, it.nextRetryAt)
}
assertEquals(rendered.id, translations.findByOriginalWorkIdAndLocale(10L, "en")?.id)
}
@ParameterizedTest
@EnumSource(TranslationJobStatus::class, names = ["PENDING", "RUNNING", "COMPLETED"])
@DisplayName("이전 원작 번역 조회는 진행 중이거나 완료된 작업의 재시도 예산을 보존한다")
fun shouldPreserveActiveOrCompletedJobWhenRenderedTranslationExists(status: TranslationJobStatus) {
val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
val job = failedJob(source)
TransactionTemplate(transactionManager).executeWithoutResult {
jobs.findById(requireNotNull(job.id)).orElseThrow().status = status
}
givenRenderedTranslation()
val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L }
OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en")
val preserved = jobs.findAll().single()
assertEquals(job.id, preserved.id)
assertEquals(status, preserved.status)
assertEquals(6, preserved.retryCount)
assertEquals("exhausted", preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
@Test
@DisplayName("번역이 없는 원작 조회도 다른 원문 언어의 FAILED 작업을 재개하지 않는다")
fun shouldPreserveOtherSourceLanguageWithoutRenderedTranslation() {
val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
val job = failedJob(source.copy(sourceLanguage = "ja"))
val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L }
val response = OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en")
assertEquals(null, response)
val preserved = jobs.findAll().single()
assertEquals(job.id, preserved.id)
assertEquals(TranslationJobStatus.FAILED, preserved.status)
assertEquals(6, preserved.retryCount)
assertEquals("exhausted", preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
@Test
@DisplayName("번역이 있는 원작 조회는 존재하지 않는 다른 필드 작업을 새로 만들지 않는다")
fun shouldNotCreateMissingJobsWhenRenderedTranslationExists() {
givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
givenRenderedTranslation()
val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L }
val response = OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en")
assertEquals("Old title", response?.title)
assertEquals(emptyList<TranslationJob>(), jobs.findAll())
}
private fun givenRenderedTranslation() = persistRendered(
OriginalWorkTranslation(
10L,
"en",
OriginalWorkTranslationPayload("Old title", "Novel", "Drama", "Old description", emptyList())
),
"original_work_translation",
"""{"title":"Old title","contentType":"Novel","category":"Drama","description":"Old description","tags":[]}"""
)
}
@@ -30,6 +30,22 @@ class TranslationCoordinatorTest {
assertEquals(emptyList<TranslateRequest>(), first.requests)
}
@Test
@DisplayName("기본 순서에서 AWS 번역 실패 뒤 전체 요청을 PAPAGO로 넘겨 성공 결과를 반환한다")
fun shouldFallbackToPapagoAfterAwsFailureWithDefaultOrder() {
val papago = RecordingTranslationProvider(PAPAGO)
val aws = RecordingTranslationProvider(AWS) { throw IllegalStateException("provider unavailable") }
val coordinator = TranslationCoordinator(listOf(papago, aws), LanguageProviderProperties(), repository)
val result = coordinator.translate(request)
assertEquals(PAPAGO, result.providerId)
assertEquals("PAPAGO-v1", result.providerVersion)
assertEquals(listOf("PAPAGO:0", "PAPAGO:1"), result.result.translatedText)
assertEquals(listOf(request), aws.requests)
assertEquals(listOf(request), papago.requests)
}
@Test
@DisplayName("예외와 부분 결과와 공백 결과 뒤에는 전체 요청을 다음 공급자로 넘긴다")
fun shouldFallbackWholeRequestAfterExceptionsOrInvalidResults() {
@@ -102,6 +118,24 @@ class TranslationCoordinatorTest {
assertEquals(emptyList<TranslateRequest>(), first.requests + second.requests)
}
@Test
@DisplayName("기본 순서는 기존 PAPAGO 캐시를 재사용하고 두 캐시가 유효하면 AWS 캐시를 먼저 선택한다")
fun shouldReusePapagoCacheAndPreferValidAwsCacheWithDefaultOrder() {
val papago = RecordingTranslationProvider(PAPAGO)
val aws = RecordingTranslationProvider(AWS)
val coordinator = TranslationCoordinator(listOf(papago, aws), LanguageProviderProperties(), repository)
val papagoMemory = memory("papago", "cached papago")
givenMemory("papago", papagoMemory)
assertSame(papagoMemory, coordinator.findCached("hash", "ko", "en"))
givenMemory("aws", memory("aws", " "))
assertSame(papagoMemory, coordinator.findCached("hash", "ko", "en"))
val awsMemory = memory("aws", "cached aws")
givenMemory("aws", awsMemory)
assertSame(awsMemory, coordinator.findCached("hash", "ko", "en"))
assertEquals(emptyList<TranslateRequest>(), papago.requests + aws.requests)
}
@Test
@DisplayName("캐시 저장소 오류는 공급자 실패로 숨기지 않는다")
fun shouldPropagateCacheRepositoryFailure() {
@@ -0,0 +1,300 @@
package kr.co.vividnext.sodalive.i18n.translation
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.assertFalse
import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.AdditionalAnswers
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.context.annotation.Import
import org.springframework.data.jpa.repository.Query
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.persistence.EntityManager
@DataJpaTest(
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:translation-job-retry;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(QueryDslConfig::class, TranslationJobScheduler::class, TranslationJobSchedulerTestConfiguration::class)
class TranslationJobRetryIntegrationTest @Autowired constructor(
private val repository: TranslationJobRepository,
private val scheduler: TranslationJobScheduler,
private val coordinator: TranslationCoordinator,
private val contentTranslations: ContentTranslationRepository,
private val entityManager: EntityManager,
private val transactionManager: PlatformTransactionManager
) {
private val transaction = TransactionTemplate(transactionManager)
private val requiresNewTransaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = Propagation.REQUIRES_NEW.value()
}
private val previousRetryAt = LocalDateTime.of(2040, 1, 1, 0, 0)
@ParameterizedTest
@ValueSource(ints = [3, 6])
@DisplayName("기존 실패 횟수가 3회 또는 6회인 FAILED 행을 같은 원문 요청으로 즉시 재개한다")
fun shouldResetSameFailedRowForCurrentNormalizedSource(previousFailures: Int) {
val original = persistJob(retryCount = previousFailures)
val requestStartedAt = LocalDateTime.now().withNano(0)
schedule()
val requestFinishedAt = LocalDateTime.now().plusSeconds(1).withNano(0)
entityManager.flush()
entityManager.clear()
val resumed = repository.findAll().single()
assertEquals(original.id, resumed.id)
assertEquals("제목", resumed.sourceText)
assertEquals(SourceTextNormalizer.hash("제목"), resumed.sourceHash)
assertEquals(TranslationJobStatus.PENDING, resumed.status)
assertEquals(0, resumed.retryCount)
assertNull(resumed.lastErrorMessage)
assertTrue(!resumed.nextRetryAt.isBefore(requestStartedAt))
assertTrue(resumed.nextRetryAt.isBefore(requestFinishedAt))
}
@ParameterizedTest
@EnumSource(TranslationJobStatus::class, names = ["PENDING", "RUNNING", "COMPLETED"])
@DisplayName("반복 요청은 진행 중이거나 완료된 행의 상태와 재시도 예산을 바꾸지 않는다")
fun shouldPreserveExistingRowOutsideFailedStatus(status: TranslationJobStatus) {
val original = persistJob(status = status, retryCount = 4)
repeat(2) { schedule() }
entityManager.flush()
entityManager.clear()
val preserved = repository.findAll().single()
assertEquals(original.id, preserved.id)
assertEquals(status, preserved.status)
assertEquals(4, preserved.retryCount)
assertEquals("previous failure", preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
@Test
@DisplayName("같은 원문 해시라도 원문 언어가 다른 FAILED 행은 재개하지 않는다")
fun shouldNotRestartFailedJobForDifferentSourceLanguage() {
val original = persistJob(sourceLanguage = "ja")
schedule()
entityManager.flush()
entityManager.clear()
val preserved = repository.findAll().single()
assertEquals(original.id, preserved.id)
assertEquals("ja", preserved.sourceLanguage)
assertEquals(TranslationJobStatus.FAILED, preserved.status)
assertEquals(6, preserved.retryCount)
assertEquals("previous failure", preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
@Test
@DisplayName("현재 원문 요청은 이전 원문의 FAILED 행을 재개하지 않고 현재 해시의 작업을 생성한다")
fun shouldLeaveFailedRowForPreviousSourceUntouched() {
val previous = persistJob(sourceText = "이전 제목")
schedule()
entityManager.flush()
entityManager.clear()
val jobs = repository.findAll()
assertEquals(2, jobs.size)
val unchanged = jobs.single { it.id == previous.id }
assertEquals(TranslationJobStatus.FAILED, unchanged.status)
assertEquals(6, unchanged.retryCount)
assertEquals("previous failure", unchanged.lastErrorMessage)
assertEquals(previousRetryAt, unchanged.nextRetryAt)
val current = jobs.single { it.sourceHash == SourceTextNormalizer.hash("제목") }
assertEquals(TranslationJobStatus.PENDING, current.status)
assertEquals(0, current.retryCount)
assertNull(current.lastErrorMessage)
}
@Test
@DisplayName("재시도 시각이 지난 FAILED 행도 요청 없이 워커가 자동 선점하지 않는다")
fun shouldNotPollFailedRowWithoutNewRequest() {
val original = persistJob().apply { nextRetryAt = LocalDateTime.of(2000, 1, 1, 0, 0) }
entityManager.flush()
val claimSql = TranslationJobRepository::class.java
.getMethod("findNextPendingGroupJobIdsForUpdate", LocalDateTime::class.java)
.getAnnotation(Query::class.java).value
.replace("skip locked", "") // H2에서는 잠금 옵션만 제외하고 실제 운영 쿼리의 선점 조건을 실행한다.
val claimRepository = Mockito.mock(
TranslationJobRepository::class.java,
AdditionalAnswers.delegatesTo<TranslationJobRepository>(repository)
)
Mockito.doAnswer { call ->
entityManager.createNativeQuery(claimSql)
.setParameter("now", call.getArgument<LocalDateTime>(0))
.resultList.map { (it as Number).toLong() }
}.`when`(claimRepository).findNextPendingGroupJobIdsForUpdate(
Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now()
)
val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java)
val provider = object : TranslationProvider {
override val providerId = LanguageProviderId.PAPAGO
override val providerVersion = "test"
override fun translate(request: TranslateRequest): TranslateResult =
throw IllegalStateException("unexpected translation")
}
val worker = TranslationJobWorker(
claimRepository,
TranslationMemoryService(
memoryRepository,
TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)),
memoryRepository
),
transactionManager
),
Mockito.mock(TranslationReadModelMaterializer::class.java),
transactionManager
)
assertFalse(worker.processNextGroup())
entityManager.flush()
entityManager.clear()
val untouched = repository.findAll().single()
assertEquals(original.id, untouched.id)
assertEquals(TranslationJobStatus.FAILED, untouched.status)
assertEquals(6, untouched.retryCount)
assertEquals("previous failure", untouched.lastErrorMessage)
assertEquals(LocalDateTime.of(2000, 1, 1, 0, 0), untouched.nextRetryAt)
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("같은 FAILED 행의 동시 재개 요청은 중복 행 없이 하나의 새 주기만 연다")
fun shouldResumeSameFailedRowFromConcurrentRequests() {
val original = persistJob()
val originalId = requireNotNull(original.id)
val executor = Executors.newFixedThreadPool(2)
val ready = CountDownLatch(2)
val start = CountDownLatch(1)
try {
val requests = (1..2).map {
executor.submit {
ready.countDown()
check(start.await(5, TimeUnit.SECONDS)) { "concurrent request start timed out" }
schedule()
}
}
assertTrue(ready.await(5, TimeUnit.SECONDS))
start.countDown()
requests.forEach { it.get(5, TimeUnit.SECONDS) }
val resumed = repository.findAll().single()
assertEquals(originalId, resumed.id)
assertEquals(TranslationJobStatus.PENDING, resumed.status)
assertEquals(0, resumed.retryCount)
assertNull(resumed.lastErrorMessage)
} finally {
start.countDown()
executor.shutdownNow()
check(executor.awaitTermination(5, TimeUnit.SECONDS)) { "concurrent requests did not stop" }
repository.deleteById(originalId)
}
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("FAILED 조회 뒤 다른 트랜잭션이 RUNNING으로 선점하면 오래된 재개 요청은 예산을 초기화하지 않는다")
fun shouldPreserveClaimCommittedAfterFailedSnapshotWasRead() {
val originalId = requireNotNull(persistJob().id)
val interleavingRepository = Mockito.mock(
TranslationJobRepository::class.java,
AdditionalAnswers.delegatesTo<TranslationJobRepository>(repository)
)
Mockito.doAnswer {
val snapshot = repository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
LanguageTranslationTargetType.CONTENT,
10L,
"title",
"en",
SourceTextNormalizer.hash("제목")
)
requiresNewTransaction.executeWithoutResult {
val claimed = repository.findById(originalId).orElseThrow()
claimed.status = TranslationJobStatus.RUNNING
claimed.retryCount = 4
repository.saveAndFlush(claimed)
}
snapshot
}.`when`(interleavingRepository).findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
LanguageTranslationTargetType.CONTENT,
10L,
"title",
"en",
SourceTextNormalizer.hash("제목")
)
try {
transaction.executeWithoutResult {
schedule(TranslationJobScheduler(interleavingRepository, coordinator, contentTranslations))
}
val claimed = repository.findAll().single()
assertEquals(originalId, claimed.id)
assertEquals(TranslationJobStatus.RUNNING, claimed.status)
assertEquals(4, claimed.retryCount)
assertEquals("previous failure", claimed.lastErrorMessage)
assertEquals(previousRetryAt, claimed.nextRetryAt)
} finally {
repository.deleteById(originalId)
}
}
private fun schedule(scheduler: TranslationJobScheduler = this.scheduler) {
scheduler.scheduleMissingTranslation(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = 10L,
fieldKey = "title",
sourceText = " 제목\n",
sourceLanguage = "ko",
targetLanguage = "EN"
)
}
private fun persistJob(
status: TranslationJobStatus = TranslationJobStatus.FAILED,
sourceText: String = "제목",
retryCount: Int = 6,
sourceLanguage: String = "ko"
): TranslationJob = repository.saveAndFlush(
TranslationJob(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = 10L,
fieldKey = "title",
sourceHash = SourceTextNormalizer.hash(sourceText),
sourceText = sourceText,
sourceLanguage = sourceLanguage,
targetLanguage = "en",
status = status,
retryCount = retryCount,
lastErrorMessage = "previous failure",
nextRetryAt = previousRetryAt
)
)
}
@@ -1,5 +1,6 @@
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.assertNotNull
import org.junit.jupiter.api.Test
@@ -7,10 +8,13 @@ import org.mockito.ArgumentCaptor
import org.mockito.Mockito
class TranslationJobSchedulerTest {
private val coordinator = Mockito.mock(TranslationCoordinator::class.java)
private val contentTranslations = Mockito.mock(ContentTranslationRepository::class.java)
@Test
fun shouldCreateOnePendingJobForMissingNormalizedText() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
Mockito.`when`(
jobRepository.findActiveJob(
@@ -49,7 +53,7 @@ class TranslationJobSchedulerTest {
@Test
fun shouldNotCreateDuplicateJobWhenSameCompletedJobAlreadyExists() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
val sourceHash = SourceTextNormalizer.hash("제목")
Mockito.`when`(
@@ -88,7 +92,7 @@ class TranslationJobSchedulerTest {
@Test
fun shouldNotCreateJobWhenSourceLanguageIsUnsupported() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
scheduler.scheduleMissingTranslation(
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
)
}
@@ -2,8 +2,12 @@ package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId.PAPAGO
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
import org.mockito.ArgumentCaptor
import org.mockito.Mockito
import org.springframework.scheduling.annotation.Scheduled
@@ -14,12 +18,13 @@ import java.util.Optional
class TranslationJobWorkerTest {
@Test
fun shouldRunEveryTenMinutesByDefault() {
@DisplayName("번역 워커의 기본 실행 간격은 1초다")
fun shouldRunEverySecondByDefault() {
val scheduled = TranslationJobWorker::class.java
.getDeclaredMethod("runPendingJobs")
.getAnnotation(Scheduled::class.java)
assertEquals("\${sodalive.translation-job.fixed-delay-ms:600000}", scheduled.fixedDelayString)
assertEquals("\${sodalive.translation-job.fixed-delay-ms:1000}", scheduled.fixedDelayString)
}
@Test
@@ -30,12 +35,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository,
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
translationMemoryService = memoryService(memoryRepository, provider),
materializer = materializer,
transactionManager = TestTransactionManager()
)
@@ -58,12 +58,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository,
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
translationMemoryService = memoryService(memoryRepository, provider),
materializer = materializer,
transactionManager = TestTransactionManager()
)
@@ -92,12 +87,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository,
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
translationMemoryService = memoryService(memoryRepository, provider),
materializer = materializer,
transactionManager = TestTransactionManager()
)
@@ -141,12 +131,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository,
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
translationMemoryService = memoryService(memoryRepository, provider),
materializer = materializer,
transactionManager = TestTransactionManager()
)
@@ -181,12 +166,7 @@ class TranslationJobWorkerTest {
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository,
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
translationMemoryService = memoryService(memoryRepository, provider),
materializer = materializer,
transactionManager = TestTransactionManager()
)
@@ -210,36 +190,69 @@ class TranslationJobWorkerTest {
assertEquals(setOf(1L, 2L, 3L, 4L, 5L), completedResourceIds)
}
@Test
fun shouldRetryFailedJobWithBackoff() {
@ParameterizedTest(name = "기존 실패 {0}회 뒤 실패하면 {1}, 대기 {2}분")
@CsvSource("0, PENDING, 1", "1, PENDING, 5", "2, PENDING, 15", "3, PENDING, 15", "4, PENDING, 15", "5, FAILED, 0")
@DisplayName("최초 시도와 재시도 5회의 실패 횟수를 누적하고 여섯 번째 실패에 종료한다")
fun shouldScheduleFiveRetriesBeforeFailingOnSixthAttempt(
failuresBeforeAttempt: Int,
expectedStatus: TranslationJobStatus,
delayMinutes: Long
) {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java)
val provider = failingProvider()
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryRepository = memoryRepository,
translationCoordinator = TranslationCoordinator(
listOf(provider),
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
translationMemoryService = memoryService(memoryRepository, provider),
materializer = materializer,
transactionManager = TestTransactionManager()
)
val job = translationJob()
job.id = 200L
val beforeRetryAt = job.nextRetryAt
job.retryCount = failuresBeforeAttempt
Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L))
Mockito.`when`(jobRepository.findById(200L)).thenReturn(Optional.of(job))
worker.processNextGroup()
val attemptStartedAt = LocalDateTime.now()
assertTrue(worker.processNextGroup())
val attemptFinishedAt = LocalDateTime.now()
assertEquals(TranslationJobStatus.PENDING, job.status)
assertEquals(1, job.retryCount)
assertEquals(expectedStatus, job.status, "failure #${failuresBeforeAttempt + 1}")
assertEquals(failuresBeforeAttempt + 1, job.retryCount)
assertEquals("all translation providers failed", job.lastErrorMessage)
assertTrue(job.nextRetryAt.isAfter(beforeRetryAt))
if (expectedStatus == TranslationJobStatus.PENDING) {
assertTrue(!job.nextRetryAt.isBefore(attemptStartedAt.plusMinutes(delayMinutes)))
assertTrue(!job.nextRetryAt.isAfter(attemptFinishedAt.plusMinutes(delayMinutes)))
}
}
@Test
@DisplayName("다섯 번 실패한 작업도 여섯 번째 시도가 성공하면 완료된다")
fun shouldCompleteSixthAttemptAfterFiveFailures() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val memoryRepository = Mockito.mock(TranslationMemoryRepository::class.java)
val materializer = Mockito.mock(TranslationReadModelMaterializer::class.java)
val worker = TranslationJobWorker(
translationJobRepository = jobRepository,
translationMemoryService = memoryService(memoryRepository, successfulProvider()),
materializer = materializer,
transactionManager = TestTransactionManager()
)
val job = translationJob().also {
it.id = 200L
it.retryCount = 5
it.lastErrorMessage = "previous failure"
}
Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L))
Mockito.`when`(jobRepository.findById(200L)).thenReturn(Optional.of(job))
assertTrue(worker.processNextGroup())
assertEquals(TranslationJobStatus.COMPLETED, job.status)
assertEquals(5, job.retryCount)
assertNull(job.lastErrorMessage)
}
private fun translationJob(
@@ -259,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 {
return object : TranslationProvider {
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.TranslationJobRepository
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.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
@@ -61,6 +62,7 @@ import javax.persistence.EntityManager
ResourceTranslationJobScheduler::class,
TranslationSourceExtractor::class,
TranslationJobScheduler::class,
TranslationJobSchedulerTestConfiguration::class,
AudioContentThemeQueryRepository::class
)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@@ -50,7 +50,10 @@ import org.springframework.test.web.servlet.result.MockMvcResultMatchers.content
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.header
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
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.net.URL
import java.time.Instant
import java.time.LocalDateTime
@@ -66,6 +69,7 @@ class AiCharacterAdminAudioContentControllerTest @Autowired constructor(
private val chatCharacterService: ChatCharacterService,
private val audioContentService: AudioContentService,
private val creatorAdminContentService: CreatorAdminContentService,
private val transactionTemplate: TransactionTemplate,
private val entityManager: EntityManager
) {
@MockBean
@@ -79,6 +83,7 @@ class AiCharacterAdminAudioContentControllerTest @Autowired constructor(
private lateinit var originalAudioContentServicePublisher: ApplicationEventPublisher
private lateinit var originalCreatorAdminContentServicePublisher: ApplicationEventPublisher
private var originalContentIds: Set<Long> = emptySet()
@BeforeEach
fun replaceActualServicePublishers() {
@@ -88,15 +93,46 @@ class AiCharacterAdminAudioContentControllerTest @Autowired constructor(
creatorAdminContentService,
applicationEventPublisher
)
originalContentIds = entityManager.createQuery("select c.id from AudioContent c", java.lang.Long::class.java)
.resultList.map { it.toLong() }.toSet()
}
@AfterEach
fun restoreActualServicePublishers() {
replacePublisher(audioContentService, originalAudioContentServicePublisher)
replacePublisher(creatorAdminContentService, originalCreatorAdminContentServicePublisher)
deleteCommittedAudioContents()
}
private fun deleteCommittedAudioContents() {
TransactionTemplate(transactionTemplate.transactionManager!!).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}.executeWithoutResult {
val created = entityManager.createQuery("select c from AudioContent c", AudioContent::class.java)
.resultList.filter { it.id !in originalContentIds }
created.forEach { content ->
content.latestSubtitleJobId = null
entityManager.flush()
val jobIds = entityManager.createQuery(
"select j.jobId from SubtitleJob j where j.contentId = :id",
String::class.java
)
.setParameter("id", content.id).resultList
if (jobIds.isNotEmpty()) {
entityManager.createQuery("delete from Subtitle where jobId in :ids")
.setParameter("ids", jobIds).executeUpdate()
entityManager.createQuery("delete from SubtitleCallbackReceipt where jobId in :ids")
.setParameter("ids", jobIds).executeUpdate()
entityManager.createQuery("delete from SubtitleJob where jobId in :ids")
.setParameter("ids", jobIds).executeUpdate()
}
entityManager.remove(content)
}
}
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("생성은 레거시 multipart request로 target 소유 콘텐츠 ID를 반환한다")
fun shouldCreateOwnedContentWithUtcMultipartRequest() {
val character = chatCharacterService.createChatCharacterWithDetails(
@@ -105,9 +141,12 @@ class AiCharacterAdminAudioContentControllerTest @Autowired constructor(
description = "description",
systemPrompt = "prompt"
)
val theme = AudioContentTheme(theme = "create-theme", image = "theme.png")
entityManager.persist(theme)
entityManager.flush()
val theme = transactionTemplate.execute {
val newTheme = AudioContentTheme(theme = "create-theme", image = "theme.png")
entityManager.persist(newTheme)
entityManager.flush()
newTheme
}!!
Mockito.`when`(amazonS3Client.getUrl(Mockito.anyString(), Mockito.anyString()))
.thenReturn(URL("https://s3.example.com/test"))
@@ -1006,12 +1045,14 @@ class AiCharacterAdminAudioContentControllerTest @Autowired constructor(
}
private fun registerMysqlDateFunctions() {
entityManager.createNativeQuery(
"CREATE ALIAS IF NOT EXISTS DATE_FORMAT FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.dateFormat'"
).executeUpdate()
entityManager.createNativeQuery(
"CREATE ALIAS IF NOT EXISTS CONVERT_TZ FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.convertTz'"
).executeUpdate()
transactionTemplate.executeWithoutResult {
entityManager.createNativeQuery(
"CREATE ALIAS IF NOT EXISTS DATE_FORMAT FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.dateFormat'"
).executeUpdate()
entityManager.createNativeQuery(
"CREATE ALIAS IF NOT EXISTS CONVERT_TZ FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.convertTz'"
).executeUpdate()
}
}
private fun adminAuthentication() = authentication(
@@ -14,6 +14,7 @@ import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotNull
import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Assertions.assertSame
import org.junit.jupiter.api.Assertions.assertTrue
@@ -46,6 +47,7 @@ import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multi
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.header
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
@@ -72,15 +74,42 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
private lateinit var applicationEventPublisher: ApplicationEventPublisher
private lateinit var originalAudioContentServicePublisher: ApplicationEventPublisher
private var originalContentIds: Set<Long> = emptySet()
@BeforeEach
fun replaceActualServicePublisher() {
originalAudioContentServicePublisher = replaceAudioContentServicePublisher(applicationEventPublisher)
originalContentIds = entityManager.createQuery("select c.id from AudioContent c", java.lang.Long::class.java)
.resultList.map { it.toLong() }.toSet()
}
@AfterEach
fun restoreActualServicePublisher() {
replaceAudioContentServicePublisher(originalAudioContentServicePublisher)
TransactionTemplate(transactionTemplate.transactionManager!!).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}.executeWithoutResult {
val created = entityManager.createQuery("select c from AudioContent c", AudioContent::class.java)
.resultList.filter { it.id !in originalContentIds }
created.forEach { content ->
content.latestSubtitleJobId = null
entityManager.flush()
val jobIds = entityManager.createQuery(
"select j.jobId from SubtitleJob j where j.contentId = :id",
String::class.java
)
.setParameter("id", content.id).resultList
if (jobIds.isNotEmpty()) {
entityManager.createQuery("delete from Subtitle where jobId in :ids")
.setParameter("ids", jobIds).executeUpdate()
entityManager.createQuery("delete from SubtitleCallbackReceipt where jobId in :ids")
.setParameter("ids", jobIds).executeUpdate()
entityManager.createQuery("delete from SubtitleJob where jobId in :ids")
.setParameter("ids", jobIds).executeUpdate()
}
entityManager.remove(content)
}
}
}
@ParameterizedTest
@@ -319,6 +348,7 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("생성은 존재하지 않는 themeId를 업로드 전 invalid request로 거부한다")
fun shouldRejectMissingThemeBeforeUpload() {
val character = chatCharacterService.createChatCharacterWithDetails(
@@ -360,6 +390,7 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
],
delimiter = '|'
)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("생성은 잘못된 preview 시간을 업로드 전 기존 오류로 거부한다")
fun shouldRejectInvalidPreviewTimeBeforeUpload(previewCase: String, language: String, message: String) {
val character = chatCharacterService.createChatCharacterWithDetails(
@@ -539,8 +570,8 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("생성은 audio 업로드 실패 시 DB와 이벤트를 남기지 않고 cover 업로드 호출만 남긴다")
fun shouldRollBackDatabaseAndEventWhenAudioUploadFails() {
@DisplayName("audio 업로드 실패는 이미 commit된 등록을 보존하고 업로드 오류를 기록하며 이벤트는 발행하지 않는다")
fun shouldKeepCommittedRegistrationAndRecordErrorWhenAudioUploadFails() {
val character = chatCharacterService.createChatCharacterWithDetails(
characterUUID = "v2-audio-create-audio-failure-character",
name = "v2-audio-create-audio-failure-character",
@@ -568,13 +599,21 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
Mockito.verify(amazonS3Client, Mockito.times(2)).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verifyNoInteractions(applicationEventPublisher)
assertNull(findAudioContentByTitle("audio"))
val content = findAudioContentByTitle("audio")!!
assertNotNull(content.latestSubtitleJobId)
assertEquals(
"SOURCE_UPLOAD_UNCERTAIN",
entityManager.createQuery(
"select j.sourceUploadErrorCode from SubtitleJob j where j.jobId = :id",
String::class.java
).setParameter("id", content.latestSubtitleJobId).singleResult
)
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("생성은 이벤트 발행 실패 시 DB를 롤백하고 두 S3 업로드 호출만 남긴다")
fun shouldRollBackDatabaseWhenCreateEventPublishFails() {
@DisplayName("생성 후 이벤트 실패는 이미 commit된 원본/job binding을 롤백하지 않는다")
fun shouldKeepCommittedRegistrationWhenCreateEventPublishFails() {
val character = chatCharacterService.createChatCharacterWithDetails(
characterUUID = "v2-audio-create-event-failure-character",
name = "v2-audio-create-event-failure-character",
@@ -607,10 +646,11 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
Mockito.verify(amazonS3Client, Mockito.times(2)).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verify(applicationEventPublisher).publishEvent(Mockito.any(Any::class.java))
assertNull(findAudioContentByTitle("audio"))
assertNotNull(findAudioContentByTitle("audio")!!.latestSubtitleJobId)
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("생성은 timezone 없이 UTC releaseDate를 저장하고 data.contentId만 반환한다")
fun shouldCreateWithUtcReleaseDateAndReturnContentId() {
val character = chatCharacterService.createChatCharacterWithDetails(
@@ -660,6 +700,7 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
}
@ParameterizedTest
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@ValueSource(strings = ["", ",\"releaseDate\":null"])
@DisplayName("생성은 생략 또는 null releaseDate를 허용한다")
fun shouldAllowOmittedOrNullReleaseDate(releaseDateField: String) {
@@ -693,12 +734,12 @@ class AiCharacterAdminAudioContentCreateTest @Autowired constructor(
.andExpect(jsonPath("$.data.contentId").isNumber)
}
private fun saveTheme(): AudioContentTheme {
private fun saveTheme(): AudioContentTheme = transactionTemplate.execute {
val theme = AudioContentTheme(theme = "create-test-theme", image = "theme.png")
entityManager.persist(theme)
entityManager.flush()
return theme
}
theme
}!!
private fun requestPart(
themeId: Long,
@@ -182,7 +182,8 @@ class AiCharacterAdminAudioContentQueryTest @Autowired constructor(
"nextContent",
"buyerList",
"isAvailableUsePoint",
"translated"
"translated",
"subtitle"
),
data.fieldNames().asSequence().toSet()
)
@@ -2,6 +2,7 @@ package kr.co.vividnext.sodalive.v2.api.admin.aicharacter.content
import com.amazonaws.services.s3.AmazonS3Client
import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
import kr.co.vividnext.sodalive.admin.content.AdminContentService
import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.common.SodaException
@@ -26,6 +27,8 @@ import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
import org.mockito.ArgumentCaptor
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
@@ -35,7 +38,11 @@ import org.springframework.context.ApplicationEventPublisher
import org.springframework.data.domain.PageRequest
import org.springframework.mock.web.MockMultipartFile
import org.springframework.test.context.ContextConfiguration
import org.springframework.test.context.event.ApplicationEvents
import org.springframework.test.context.event.RecordApplicationEvents
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.net.URL
import java.time.LocalDateTime
import javax.persistence.EntityManager
@@ -43,13 +50,24 @@ import javax.persistence.EntityManager
@SpringBootTest
@Transactional
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@RecordApplicationEvents
class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
private val audioContentService: AudioContentService,
private val repository: CreatorAdminContentRepository,
private val hashTagRepository: HashTagRepository,
private val contentPriceChangeLogRepository: ContentPriceChangeLogRepository,
private val entityManager: EntityManager
private val entityManager: EntityManager,
private val transactionTemplate: TransactionTemplate
) {
@Autowired
private lateinit var adminContentService: AdminContentService
@Autowired
private lateinit var creatorAdminContentService: CreatorAdminContentService
@Autowired
private lateinit var applicationEvents: ApplicationEvents
private lateinit var audioContentCloudFront: AudioContentCloudFront
@MockBean
@@ -81,12 +99,16 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
}
@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
@DisplayName("기존 콘텐츠 생성은 표지와 오디오를 업로드하고 처리 대기 콘텐츠를 저장한다")
fun shouldCreateContentThroughLegacyUploadPipeline() {
val owner = saveMember("legacy-create-owner")
val theme = AudioContentTheme(theme = "legacy-create-theme", image = "theme.png")
entityManager.persist(theme)
entityManager.flush()
val (owner, theme) = transactionTemplate.execute {
val owner = saveMember("legacy-create-owner")
val theme = AudioContentTheme(theme = "legacy-create-theme", image = "theme.png")
entityManager.persist(theme)
entityManager.flush()
owner to theme
}!!
val response = audioContentService.createAudioContent(
contentFile = MockMultipartFile("contentFile", "audio.mp3", "audio/mpeg", byteArrayOf(1, 2, 3)),
@@ -96,9 +118,7 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
""".trimIndent(),
member = owner
)
entityManager.flush()
val content = entityManager.find(AudioContent::class.java, response.contentId)
val content = transactionTemplate.execute { entityManager.find(AudioContent::class.java, response.contentId) }!!
assertEquals("legacy created audio", content.title)
assertEquals(owner.id, content.member!!.id)
assertEquals(theme.id, content.theme!!.id)
@@ -219,6 +239,42 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
return member
}
@ParameterizedTest
@CsvSource(
"true,title,",
"true,detail,",
"false,title,",
"false,detail,",
"false,title,''",
"false,detail,''",
"false,title,' '",
"false,detail,' '"
)
@DisplayName("관리자와 크리에이터 관리자의 제목 또는 상세 수정은 태그 없이도 커밋 후 번역을 요청한다")
fun shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags(asAdmin: Boolean, field: String, tags: String?) {
val owner = saveMember("metadata-update-owner")
val content = saveAudioContent(owner, "before title", "00:10:00")
entityManager.flush()
val tagsField = tags?.let { ",\"tags\":\"$it\"" }.orEmpty()
val coverField = if (asAdmin) ",\"isDefaultCoverImage\":false" else ""
val request = """{"id":${content.id},"$field":"updated text"$tagsField$coverField}"""
if (asAdmin) {
adminContentService.updateAudioContent(null, request)
} else {
creatorAdminContentService.updateAudioContent(null, request, owner)
}
entityManager.flush()
entityManager.clear()
val updated = entityManager.find(AudioContent::class.java, content.id)
assertEquals("updated text", if (field == "title") updated.title else updated.detail)
val events = applicationEvents.stream(LanguageTranslationEvent::class.java).filter { it.id == content.id }.toList()
assertEquals(1, events.size)
assertEquals(LanguageTranslationTargetType.CONTENT, events.single().targetType)
assertTrue(events.single().waitTransactionCommit)
}
private fun saveAudioContent(owner: Member, title: String, duration: String): AudioContent {
val theme = AudioContentTheme(theme = "theme-$title", image = "theme.png")
entityManager.persist(theme)
@@ -240,7 +296,7 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
}
}
private fun registerMysqlDateFunctions() {
private fun registerMysqlDateFunctions() = transactionTemplate.executeWithoutResult {
entityManager.createNativeQuery(
"CREATE ALIAS IF NOT EXISTS DATE_FORMAT FOR 'kr.co.vividnext.sodalive.support.H2MysqlDateFunctions.dateFormat'"
).executeUpdate()
@@ -146,7 +146,13 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
assertEquals("original", contents[3L]?.content)
assertTrue(contents[3L]?.hasValidTranslation == false)
assertTrue(4L !in contents)
Mockito.verifyNoInteractions(sourceExtractor, materializer, scheduler)
Mockito.verifyNoInteractions(sourceExtractor, materializer)
Mockito.verify(scheduler).restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(1L, 2L),
"en"
)
Mockito.verifyNoMoreInteractions(scheduler)
}
@Test
@@ -231,7 +237,12 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
service.requestTranslations(1L, "EN")
Mockito.verify(materializer).materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, 1L, "en")
Mockito.verifyNoInteractions(scheduler)
Mockito.verify(scheduler).restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(1L),
"en"
)
Mockito.verifyNoMoreInteractions(scheduler)
}
@Test
@@ -718,7 +729,12 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
materializer = persistentMaterializer(sourceExtractor),
resourceTranslationJobScheduler = ResourceTranslationJobScheduler(
sourceExtractor,
TranslationJobScheduler(translationJobRepository)
TranslationJobScheduler(
translationJobRepository,
Mockito.mock(TranslationCoordinator::class.java),
Mockito.mock(ContentTranslationRepository::class.java)
),
translationJobRepository
),
applicationEventPublisher = applicationEventPublisher,
entityManager = entityManager
@@ -0,0 +1,905 @@
package kr.co.vividnext.sodalive.v2.subtitle
import com.amazonaws.services.s3.AmazonS3Client
import com.amazonaws.services.s3.model.PutObjectRequest
import com.amazonaws.services.s3.model.PutObjectResult
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentService
import kr.co.vividnext.sodalive.content.CreateAudioContentRequest
import kr.co.vividnext.sodalive.content.order.Order
import kr.co.vividnext.sodalive.content.order.OrderType
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleCallbackReceipt
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleCallbackReceiptRepository
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleJob
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleJobRepository
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.SubtitleRepository
import kr.co.vividnext.sodalive.v2.subtitle.adapter.web.SubtitleRequestParser
import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService
import kr.co.vividnext.sodalive.v2.subtitle.domain.SubtitleJobStatus
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.assertNotNull
import org.junit.jupiter.api.Assertions.assertNull
import org.junit.jupiter.api.Assertions.assertThrows
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.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.boot.test.mock.mockito.SpyBean
import org.springframework.boot.test.web.client.TestRestTemplate
import org.springframework.context.ApplicationEventPublisher
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.data.repository.findByIdOrNull
import org.springframework.http.HttpEntity
import org.springframework.http.HttpHeaders
import org.springframework.http.HttpMethod
import org.springframework.http.MediaType
import org.springframework.mock.web.MockMultipartFile
import org.springframework.security.crypto.password.PasswordEncoder
import org.springframework.test.context.ContextConfiguration
import org.springframework.test.context.DynamicPropertyRegistry
import org.springframework.test.context.DynamicPropertySource
import org.springframework.test.util.AopTestUtils
import org.springframework.test.util.ReflectionTestUtils
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.support.TransactionSynchronizationManager
import org.springframework.transaction.support.TransactionTemplate
import java.net.URL
import java.security.MessageDigest
import java.time.LocalDateTime
import java.util.Base64
import java.util.UUID
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)
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
class SubtitleHttpIntegrationTest @Autowired constructor(
private val http: TestRestTemplate,
private val mapper: ObjectMapper,
private val members: MemberRepository,
private val passwordEncoder: PasswordEncoder,
private val jobs: SubtitleJobRepository,
private val receipts: SubtitleCallbackReceiptRepository,
private val subtitles: SubtitleRepository,
private val service: SubtitleJobService,
private val contentService: AudioContentService,
private val parser: SubtitleRequestParser,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
companion object {
@JvmStatic
@DynamicPropertySource
fun properties(registry: DynamicPropertyRegistry) {
registry.add("jwt.secret") { Base64.getEncoder().encodeToString(ByteArray(64) { 7 }) }
registry.add("cloud.aws.s3.content-bucket") { "subtitle-audio" }
registry.add("cloud.aws.s3.bucket") { "subtitle-cover" }
registry.add("spring.jpa.properties.hibernate.show_sql") { "false" }
}
}
@MockBean
private lateinit var s3: AmazonS3Client
@MockBean
private lateinit var cloudFront: AudioContentCloudFront
@SpyBean
private lateinit var receiptWriter: SubtitleCallbackReceiptRepository
private val transaction = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
private lateinit var originalPublisher: ApplicationEventPublisher
private lateinit var publisher: ApplicationEventPublisher
@BeforeEach
fun setupExternalBoundaries() {
val target = AopTestUtils.getTargetObject<AudioContentService>(contentService)
originalPublisher = ReflectionTestUtils.getField(target, "applicationEventPublisher") as ApplicationEventPublisher
publisher = Mockito.mock(ApplicationEventPublisher::class.java)
ReflectionTestUtils.setField(target, "applicationEventPublisher", publisher)
Mockito.`when`(s3.getUrl(Mockito.anyString(), Mockito.anyString())).thenReturn(URL("https://example.test/object"))
Mockito.`when`(s3.putObject(Mockito.any(PutObjectRequest::class.java))).thenReturn(PutObjectResult())
Mockito.`when`(cloudFront.generateSignedURL(Mockito.anyString(), Mockito.anyLong()))
.thenAnswer { "https://signed.example.test/${it.arguments[0]}" }
}
@AfterEach
fun restorePublisher() {
ReflectionTestUtils.setField(
AopTestUtils.getTargetObject<AudioContentService>(contentService),
"applicationEventPublisher",
originalPublisher
)
}
@Test
@DisplayName("실제 EMAIL 로그인 JWT라도 BOT 외 역할은 내부 자막 경로에 접근할 수 없다")
fun shouldRejectActualNonBotLoginJwt() {
listOf(MemberRole.ADMIN, MemberRole.USER, MemberRole.CREATOR).forEach { role ->
val token = login(role)
assertEquals(403, get("/resolve?bucket=audio&key=unknown", token).statusCodeValue)
assertEquals(403, post("/callback", token, "{}").statusCodeValue)
assertEquals(403, get("/${UUID.randomUUID()}", token).statusCodeValue)
assertEquals(403, post("/${UUID.randomUUID()}/started", token, "{}").statusCodeValue)
}
assertEquals(
401,
http.getForEntity("/internal/api/subtitle-jobs/resolve?bucket=a&key=b", String::class.java).statusCodeValue
)
}
@Test
@DisplayName("활성 EMAIL BOT의 실제 JWT는 네 API를 허용하며 조회 응답은 envelope 없는 정확한 계약이다")
fun shouldUseRealBotJwtAndStoreCallbackBeforeStartedWithExactByteReplay() {
val token = login(MemberRole.BOT)
val job = fixture()
val lookup = get("/resolve?bucket=${job.sourceBucket}&key=${job.sourceKey}", token)
assertEquals(200, lookup.statusCodeValue)
val body = mapper.readTree(lookup.body)
assertEquals(setOf("jobId", "contentId", "status", "source"), body.fieldNames().asSequence().toSet())
assertTrue(body.path("contentId").isIntegralNumber)
assertEquals(job.contentId, body.path("contentId").longValue())
assertEquals(setOf("bucket", "key", "versionId"), body.path("source").fieldNames().asSequence().toSet())
assertTrue(body.path("source").path("versionId").isNull)
assertEquals("PENDING", body.path("status").textValue())
assertEquals(lookup.body, get("/${job.jobId}", token).body)
val raw = callback(job, eventId = "non-UUID/event-1")
assertEquals(200, post("/callback", token, raw).statusCodeValue)
assertEquals(200, post("/${job.jobId}/started", token, started(job)).statusCodeValue)
assertEquals(200, post("/callback", token, raw).statusCodeValue)
assertEquals(422, post("/callback", token, "$raw ").statusCodeValue)
assertEquals(422, post("/callback", token, raw.replace(job.jobId, UUID.randomUUID().toString())).statusCodeValue)
val resultIds = subtitles.findAllByJobId(job.jobId).map { it.id }.sortedBy { it }
assertEquals(200, post("/callback", token, raw.replace("non-UUID/event-1", "same-result-new-event")).statusCodeValue)
assertEquals(resultIds, subtitles.findAllByJobId(job.jobId).map { it.id }.sortedBy { it })
assertEquals(409, post("/callback", token, callback(job, "new-result", emptyList())).statusCodeValue)
val stored = jobs.findByIdOrNull(job.jobId)!!
assertEquals(SubtitleJobStatus.COMPLETED, stored.status)
assertEquals(
"subtitles/${job.contentId}/${job.jobId}/ko.srt",
subtitles.findByJobIdAndLanguage(job.jobId, "ko-KR")!!.s3Key
)
assertEquals(
"subtitles/${job.contentId}/${job.jobId}/ja.srt",
subtitles.findByJobIdAndLanguage(job.jobId, "ja-JP")!!.s3Key
)
assertEquals(0, stored.updatedAt.nano)
val receipt = receipts.findByIdOrNull("non-UUID/event-1")!!
assertEquals(
MessageDigest.getInstance("SHA-256").digest(raw.toByteArray()).joinToString("") { "%02x".format(it) },
receipt.bodyHash
)
assertEquals(0, receipt.createdAt.nano)
assertEquals(
job.jobId,
transaction.execute { entityManager.find(AudioContent::class.java, job.contentId).latestSubtitleJobId }
)
}
@Test
@DisplayName("started는 PENDING만 전이하며 partial/failed는 정확한 언어 결과만 저장한다")
fun shouldStartMonotonicallyAndAcceptPartialAndFailedResults() {
val token = login(MemberRole.BOT)
val partial = fixture()
assertEquals(200, post("/${partial.jobId}/started", token, started(partial)).statusCodeValue)
val processing = jobs.findByIdOrNull(partial.jobId)!!
assertEquals(SubtitleJobStatus.PROCESSING, processing.status)
assertEquals(200, post("/${partial.jobId}/started", token, started(partial)).statusCodeValue)
assertEquals(processing.updatedAt, jobs.findByIdOrNull(partial.jobId)!!.updatedAt)
assertEquals(200, post("/callback", token, callback(partial, languages = listOf("ja-JP"))).statusCodeValue)
val storedPartial = jobs.findByIdOrNull(partial.jobId)!!
assertEquals(SubtitleJobStatus.PARTIAL_COMPLETED, storedPartial.status)
assertNull(subtitles.findByJobIdAndLanguage(partial.jobId, "ko-KR"))
assertNotNull(subtitles.findByJobIdAndLanguage(partial.jobId, "ja-JP"))
val failed = fixture()
assertEquals(200, post("/callback", token, callback(failed, languages = emptyList())).statusCodeValue)
assertEquals(SubtitleJobStatus.FAILED, jobs.findByIdOrNull(failed.jobId)!!.status)
assertEquals(200, post("/${failed.jobId}/started", token, started(failed)).statusCodeValue)
assertEquals(SubtitleJobStatus.FAILED, jobs.findByIdOrNull(failed.jobId)!!.status)
}
@Test
@DisplayName("unknown source/job은 생성 없이 404이며 DB role 변경 및 비활성화는 기존 JWT도 차단한다")
fun shouldReturn404WithoutDiscoveryAndCheckCurrentDatabaseRole() {
val token = login(MemberRole.BOT)
val count = jobs.count()
val unknown = UUID.randomUUID().toString()
assertEquals(404, get("/resolve?bucket=wrong&key=unknown", token).statusCodeValue)
assertEquals(404, get("/$unknown", token).statusCodeValue)
val unknownStarted = """{"transcribeJobName":"subtitle-$unknown","status":"PROCESSING"}"""
assertEquals(
404,
post("/$unknown/started", token, unknownStarted).statusCodeValue
)
val job = fixture()
assertEquals(404, post("/callback", token, callback(job).replace(job.jobId, unknown)).statusCodeValue)
assertEquals(count + 1, jobs.count())
val member = members.findAll().single { it.email == lastLoginEmail }
member.role = MemberRole.ADMIN
members.saveAndFlush(member)
assertEquals(403, get("/${job.jobId}", token).statusCodeValue)
member.role = MemberRole.BOT
member.isActive = false
members.saveAndFlush(member)
assertEquals(403, post("/callback", token, callback(job)).statusCodeValue)
}
@Test
@DisplayName("callback JSON은 숫자 coercion, 누락 null, 추가/중복 필드와 잘못된 binding을 원자적으로 거부한다")
fun shouldRejectMalformedContractsWithoutPersistingAnything() {
val token = login(MemberRole.BOT)
val job = fixture()
val valid = callback(job, "strict-event")
val invalidBodies = listOf(
valid.replace("\"contentId\":${job.contentId}", "\"contentId\":\"${job.contentId}\""),
valid.replace("\"contentId\":${job.contentId}", "\"contentId\":${job.contentId}.0"),
valid.replace("\"contentId\":${job.contentId}", "\"contentId\":9223372036854775808"),
valid.replace(",\"errorMessage\":null", ""),
valid.dropLast(1) + ",\"unknown\":null}",
valid.dropLast(1) + ",\"status\":\"COMPLETED\"}",
valid.replace("\"language\":\"ko-KR\"", "\"language\":\"ko-KR\",\"language\":\"ko-KR\""),
valid.replace("\"format\":\"SRT\"", "\"format\":\"SRT\",\"extra\":true"),
valid.replace("subtitle-${job.jobId}", "wrong-name"),
valid.replace("\"contentId\":${job.contentId}", "\"contentId\":${job.contentId + 1}"),
valid.replace(job.sourceBucket, "other-bucket"),
valid.replace("/${job.jobId}/ko.srt", "/${job.jobId}/../ko.srt"),
valid.replace("ja-JP", "ko-KR"),
valid.replace("\"SRT\"", "\"VTT\""),
valid.replace("ko-KR", "en-US"),
valid.replace("\"COMPLETED\"", "\"PARTIAL_COMPLETED\""),
valid.replace("\"errorCode\":null", "\"errorCode\":\"unexpected\""),
valid.replace("strict-event", ""),
"$valid {}",
callback(job, languages = emptyList()).replace("\"errorMessage\":\"pipeline failed\"", "\"errorMessage\":null")
)
invalidBodies.forEachIndexed { index, raw ->
assertEquals(422, post("/callback", token, raw).statusCodeValue, "invalid case $index")
}
listOf(
started(job).replace("PROCESSING", "COMPLETED"),
started(job).replace("subtitle-${job.jobId}", "wrong"),
started(job).dropLast(1) + ",\"extra\":true}",
started(job).dropLast(1) + ",\"status\":\"PROCESSING\"}"
).forEach { assertEquals(422, post("/${job.jobId}/started", token, it).statusCodeValue) }
val stored = jobs.findByIdOrNull(job.jobId)!!
assertEquals(SubtitleJobStatus.PENDING, stored.status)
assertTrue(subtitles.findAllByJobId(job.jobId).isEmpty())
assertNull(receipts.findByIdOrNull("strict-event"))
}
@Test
@DisplayName("빈 callback과 started body는 422이며 job, receipt, 결과를 변경하지 않는다")
fun shouldRejectEmptyCallbackAndStartedBodiesWithoutPersistingAnything() {
val token = login(MemberRole.BOT)
val job = fixture()
val counts = listOf(jobs.count(), receipts.count(), subtitles.count())
val responses = listOf("/callback", "/${job.jobId}/started").map { post(it, token, "") }
assertEquals(listOf(422, 422), responses.map { it.statusCodeValue })
assertEquals(counts, listOf(jobs.count(), receipts.count(), subtitles.count()))
val stored = jobs.findByIdOrNull(job.jobId)!!
assertEquals(SubtitleJobStatus.PENDING, stored.status)
assertEquals(job.updatedAt, stored.updatedAt)
assertNull(stored.errorCode)
assertNull(stored.errorMessage)
assertTrue(subtitles.findAllByJobId(job.jobId).isEmpty())
}
@Test
@DisplayName("HTTP callback의 receipt 쓰기 실패는 일반화된 500이며 상태, 오류, 결과와 receipt를 rollback한다")
fun shouldReturn500AndRollbackWhenReceiptInsertFailsOverHttp() {
val token = login(MemberRole.BOT)
val job = fixture()
Mockito.doThrow(DataIntegrityViolationException("receipt write failed"))
.`when`(receiptWriter).saveAndFlush(
Mockito.any(SubtitleCallbackReceipt::class.java) ?: SubtitleCallbackReceipt("unused", "unused", "unused")
)
val response = post("/callback", token, callback(job, "http-receipt-write-failure", listOf("ko-KR")))
assertEquals(500, response.statusCodeValue)
assertEquals(mapper.readTree("""{"error":"Subtitle request failed"}"""), mapper.readTree(response.body))
val stored = jobs.findByIdOrNull(job.jobId)!!
assertEquals(SubtitleJobStatus.PENDING, stored.status)
assertEquals(job.updatedAt, stored.updatedAt)
assertNull(stored.errorCode)
assertNull(stored.errorMessage)
assertTrue(subtitles.findAllByJobId(job.jobId).isEmpty())
assertNull(receipts.findByIdOrNull("http-receipt-write-failure"))
}
@Test
@DisplayName("동시 callback은 같은 event를 중복 반영하지 않으며 다른 job 간 unique 경합은 rollback 후 판정한다")
fun shouldSerializeConcurrentCallbacksAndRollbackLosingJob() {
val token = login(MemberRole.BOT)
val first = fixture()
val sameBody = callback(first, "concurrent-same")
assertEquals(
listOf(200, 200),
race({ post("/callback", token, sameBody).statusCodeValue }, { post("/callback", token, sameBody).statusCodeValue })
)
val left = fixture()
val right = fixture()
val statuses = race(
{ post("/callback", token, callback(left, "concurrent-cross-job")).statusCodeValue },
{ post("/callback", token, callback(right, "concurrent-cross-job")).statusCodeValue }
)
assertEquals(listOf(200, 422), statuses)
val winner = receipts.findByIdOrNull("concurrent-cross-job")!!.jobId
val loser = if (left.jobId == winner) right else left
assertEquals(SubtitleJobStatus.PENDING, jobs.findByIdOrNull(loser.jobId)!!.status)
assertTrue(subtitles.findAllByJobId(loser.jobId).isEmpty())
}
@Test
@DisplayName("receipt 쓰기 실패 시 이미 flush된 결과 행도 상태와 함께 rollback된다")
fun shouldRollbackResultsAndStatusWhenReceiptInsertFails() {
val job = fixture()
val raw = callback(job, "receipt-write-failure").toByteArray()
Mockito.doThrow(DataIntegrityViolationException("receipt write failed"))
.`when`(receiptWriter).saveAndFlush(
Mockito.any(SubtitleCallbackReceipt::class.java) ?: SubtitleCallbackReceipt("unused", "unused", "unused")
)
assertThrows(DataIntegrityViolationException::class.java) {
service.callback(parser.callback(raw), raw)
}
assertEquals(SubtitleJobStatus.PENDING, jobs.findByIdOrNull(job.jobId)!!.status)
assertTrue(subtitles.findAllByJobId(job.jobId).isEmpty())
assertNull(receipts.findByIdOrNull("receipt-write-failure"))
}
@Test
@DisplayName("이전 job의 결과는 저장하지만 content의 최신 job 선택값을 변경하지 않는다")
fun shouldKeepLatestPointerWhenOlderJobCompletes() {
val token = login(MemberRole.BOT)
val older = fixture()
val latest = transaction.execute {
service.register(entityManager.find(AudioContent::class.java, older.contentId), "later.mp3")
}!!
assertEquals(200, post("/callback", token, callback(older)).statusCodeValue)
assertEquals(
latest.jobId,
transaction.execute { entityManager.find(AudioContent::class.java, older.contentId).latestSubtitleJobId }
)
assertEquals(SubtitleJobStatus.PENDING, jobs.findByIdOrNull(latest.jobId)!!.status)
assertEquals(SubtitleJobStatus.COMPLETED, jobs.findByIdOrNull(older.jobId)!!.status)
}
@Test
@DisplayName("외부 transaction이 있어도 S3 원본 업로드 전에 content/source/PENDING이 별도 HTTP에서 보인다")
fun shouldCommitRegistrationBeforeUploadAndNeverRevertEarlyMediaConvertOutput() {
val token = login(MemberRole.BOT)
val owner = members.saveAndFlush(Member(password = "unused", nickname = "upload-owner-${UUID.randomUUID()}"))
val themeId = transaction.execute {
AudioContentTheme(theme = "upload theme", image = "theme.png").also { entityManager.persist(it) }.id!!
}!!
var uploadedJob: SubtitleJob? = null
Mockito.`when`(s3.putObject(Mockito.any(PutObjectRequest::class.java))).thenAnswer { invocation ->
val request = invocation.arguments[0] as PutObjectRequest
if (request.key.startsWith("input/")) {
assertFalse(TransactionSynchronizationManager.isActualTransactionActive())
val response = get("/resolve?bucket=${request.bucketName}&key=${request.key}", token)
assertEquals(200, response.statusCodeValue)
assertEquals("PENDING", mapper.readTree(response.body).path("status").textValue())
val jobId = mapper.readTree(response.body).path("jobId").textValue()
uploadedJob = jobs.findByIdOrNull(jobId)!!
val sourceFileName = request.key.substringAfterLast('/')
assertTrue(sourceFileName.endsWith(".mp3"))
assertEquals(
UUID.fromString(sourceFileName.substringBeforeLast('.')).toString(),
sourceFileName.substringBeforeLast('.')
)
val content = transaction.execute { entityManager.find(AudioContent::class.java, uploadedJob!!.contentId) }!!
assertEquals(request.key, content.content)
assertNotNull(content.coverImage)
assertEquals(jobId, content.latestSubtitleJobId)
assertEquals(
1,
transaction.execute { entityManager.find(AudioContent::class.java, content.id).audioContentHashTags.size }
)
contentService.uploadComplete(content.id!!, "${uploadedJob!!.outputKey}.aac", "00:03:00")
}
PutObjectResult()
}
val request = CreateAudioContentRequest(
title = "new uploaded",
detail = "detail",
tags = "#tag",
price = 100,
themeId = themeId,
languageCode = "ko"
)
transaction.executeWithoutResult {
contentService.createAudioContent(
MockMultipartFile("contentFile", "C:\\unsafe\\nested/audio.MP3", "audio/mpeg", byteArrayOf(1)),
MockMultipartFile("coverImage", "cover.png", "image/png", byteArrayOf(2)),
request,
LocalDateTime.now().minusMinutes(1),
owner
)
}
val job = uploadedJob!!
val stored = transaction.execute { entityManager.find(AudioContent::class.java, job.contentId) }!!
assertEquals("${job.outputKey}.aac", stored.content)
assertEquals("00:03:00", stored.duration)
assertTrue(stored.isActive)
assertTrue(service.matchesOutput(job.contentId, "${job.outputKey}.aac")!!)
assertTrue(service.matchesOutput(job.contentId, "${job.outputKey}.m4a")!!)
assertTrue(service.matchesOutput(job.contentId, "${job.outputKey}.mp3")!!)
listOf(
"${job.outputKey}-other.aac",
"${job.outputKey}.txt",
"output/999/${job.outputKey.substringAfterLast('/')}.aac",
"${job.outputKey}.aac/extra"
).forEach {
assertFalse(service.matchesOutput(job.contentId, it)!!)
}
}
@Test
@DisplayName("putObject 수락 후 getUrl 실패도 원본 오류만 기록하고 조기 완료 callback을 terminal에서 회귀시키지 않는다")
fun shouldKeepAcceptedSourceAndTerminalResultWhenUploadReturnFails() {
val token = login(MemberRole.BOT)
val owner = members.saveAndFlush(Member(password = "unused", nickname = "uncertain-${UUID.randomUUID()}"))
val themeId = transaction.execute {
AudioContentTheme(theme = "uncertain theme", image = "theme.png").also { entityManager.persist(it) }.id!!
}!!
var uploadedJob: SubtitleJob? = null
Mockito.`when`(s3.putObject(Mockito.any(PutObjectRequest::class.java))).thenAnswer { invocation ->
val request = invocation.arguments[0] as PutObjectRequest
if (request.key.startsWith("input/")) {
uploadedJob = jobs.findBySourceBucketAndSourceKey(request.bucketName, request.key)!!
assertEquals(200, post("/callback", token, callback(uploadedJob!!)).statusCodeValue)
}
PutObjectResult()
}
Mockito.`when`(s3.getUrl(Mockito.anyString(), Mockito.anyString())).thenAnswer { invocation ->
if ((invocation.arguments[1] as String).startsWith("input/")) throw IllegalStateException("upload return failed")
URL("https://example.test/cover")
}
assertThrows(IllegalStateException::class.java) {
contentService.createAudioContent(
MockMultipartFile("contentFile", byteArrayOf(1)),
MockMultipartFile("coverImage", byteArrayOf(2)),
CreateAudioContentRequest(title = "uncertain", detail = "detail", tags = "", price = 0, themeId = themeId),
LocalDateTime.now(),
owner
)
}
val job = jobs.findByIdOrNull(uploadedJob!!.jobId)!!
assertEquals(SubtitleJobStatus.COMPLETED, job.status)
assertEquals("SOURCE_UPLOAD_UNCERTAIN", job.sourceUploadErrorCode)
assertEquals(0, job.sourceUploadErrorAt!!.nano)
assertEquals(2, subtitles.findAllByJobId(job.jobId).size)
assertNotNull(transaction.execute { entityManager.find(AudioContent::class.java, job.contentId) })
}
@Test
@DisplayName("원본 filename의 안전한 확장자만 소문자로 보존하고 canonical UUID 이외 경로는 source로 전달하지 않는다")
fun shouldPreserveOnlySafeActualSourceExtensionsWithoutClaimingConversion() {
val filenames = listOf(
"C:\\client\\dir/file.MP3" to "mp3",
"../../voice.WAV" to "wav",
"voice.FLAC" to "flac",
"voice.aac" to "aac",
"voice.opus" to "opus",
"voice" to null,
"voice.bad-extension" to null,
null to null
)
filenames.forEach { (filename, extension) ->
val job = fixture(filename)
val sourceFile = job.sourceKey.substringAfterLast('/')
val uuid = if (extension == null) sourceFile else sourceFile.removeSuffix(".$extension")
assertEquals(UUID.fromString(uuid).toString(), uuid)
if (extension != null) assertTrue(sourceFile.endsWith(".$extension"))
assertEquals("input/${job.contentId}/$sourceFile", job.sourceKey)
assertEquals("output/${job.contentId}/$uuid", job.outputKey)
}
}
@Test
@DisplayName("콘텐츠 상세는 preview에 자막을 숨기고 소유자/구매자/무료 원본 권한과 공개 시점 및 ko/ja를 적용한다")
fun shouldExposeLanguageSubtitleOnlyWithReleasedOriginalAccessInExistingDetail() {
val bot = login(MemberRole.BOT)
val ownerToken = login(MemberRole.CREATOR)
val owner = members.findByEmail(lastLoginEmail)!!
val viewerToken = login(MemberRole.USER)
val viewer = members.findByEmail(lastLoginEmail)!!
val job = fixture(owner = owner)
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).apply {
price = 100
content = "${job.outputKey}.aac"
duration = "00:03:00"
coverImage = "cover/test.png"
isActive = true
isCommentAvailable = false
releaseDate = LocalDateTime.now().minusMinutes(1)
}
}
assertEquals(200, post("/callback", bot, callback(job)).statusCodeValue)
fun detail(token: String, language: String) = http.exchange(
"/audio-content/${job.contentId}?timezone=UTC",
HttpMethod.GET,
HttpEntity<Void>(headers(token).apply { set(HttpHeaders.ACCEPT_LANGUAGE, language) }),
String::class.java
).let {
assertEquals(200, it.statusCodeValue)
val response = mapper.readTree(it.body)
assertTrue(response.path("success").booleanValue(), response.path("message").asText())
response.path("data")
}
assertTrue(detail(viewerToken, "ko").path("subtitle").isNull)
val ownerKo = detail(ownerToken, "ko").path("subtitle")
assertEquals(setOf("language", "format", "url"), ownerKo.fieldNames().asSequence().toSet())
assertEquals("ko-KR", ownerKo.path("language").textValue())
assertEquals("SRT", ownerKo.path("format").textValue())
assertEquals(
"https://signed.example.test/subtitles/${job.contentId}/${job.jobId}/ko.srt",
ownerKo.path("url").textValue()
)
assertEquals("ja-JP", detail(ownerToken, "ja").path("subtitle").path("language").textValue())
assertTrue(detail(ownerToken, "en").path("subtitle").isNull)
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, job.contentId)
entityManager.persist(
Order(type = OrderType.KEEP).apply {
member = viewer
creator = owner
audioContent = content
}
)
}
assertEquals("ko-KR", detail(viewerToken, "ko").path("subtitle").path("language").textValue())
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).releaseDate = LocalDateTime.now().plusDays(1)
}
assertTrue(detail(viewerToken, "ko").path("subtitle").isNull)
assertEquals("ko-KR", detail(ownerToken, "ko").path("subtitle").path("language").textValue())
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).apply {
price = 0
releaseDate = LocalDateTime.now().minusDays(1)
}
}
val freeViewer = login(MemberRole.USER)
assertEquals("ja-JP", detail(freeViewer, "ja").path("subtitle").path("language").textValue())
}
@Test
@DisplayName("자막 조회는 최신 job의 실제 언어 행만 선택하고 미완료/없는 언어/content 불일치는 null이다")
fun shouldReadOnlyPersistedLanguageOfMatchingLatestCompletedJob() {
val token = login(MemberRole.BOT)
val job = fixture()
val content = transaction.execute { entityManager.find(AudioContent::class.java, job.contentId) }!!
assertNull(service.subtitle(content, kr.co.vividnext.sodalive.i18n.Lang.KO, 1000))
assertEquals(200, post("/callback", token, callback(job, languages = listOf("ja-JP"))).statusCodeValue)
assertNull(service.subtitle(content, kr.co.vividnext.sodalive.i18n.Lang.KO, 1000))
assertEquals("ja-JP", service.subtitle(content, kr.co.vividnext.sodalive.i18n.Lang.JA, 1000)!!.language)
val different = fixture()
content.latestSubtitleJobId = different.jobId
assertNull(service.subtitle(content, kr.co.vividnext.sodalive.i18n.Lang.JA, 1000))
content.latestSubtitleJobId = null
assertNull(service.subtitle(content, kr.co.vividnext.sodalive.i18n.Lang.JA, 1000))
}
@Test
@DisplayName("구매자의 generate-url은 ko/ja 자막과 기존 음원 URL 및 상세와 같은 자막 스키마를 반환한다")
fun shouldIncludeRequestedSubtitleInGenerateUrl() {
val bot = login(MemberRole.BOT)
val owner = members.saveAndFlush(Member(password = "unused", nickname = "generate-owner-${UUID.randomUUID()}"))
val token = login(MemberRole.USER)
val buyer = members.findByEmail(lastLoginEmail)!!
val job = fixture(owner = owner)
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, job.contentId).apply {
price = 100
this.content = "${job.outputKey}.aac"
duration = "02:03:00"
coverImage = "cover/test.png"
isActive = true
isCommentAvailable = false
releaseDate = LocalDateTime.now().minusDays(1)
}
entityManager.persist(
Order(type = OrderType.KEEP).apply {
member = buyer
creator = owner
audioContent = content
}
)
}
assertEquals(200, post("/callback", bot, callback(job)).statusCodeValue)
Mockito.`when`(cloudFront.generateSignedURL(Mockito.anyString(), Mockito.anyLong()))
.thenAnswer { "https://signed.example.test/${it.arguments[0]}?expiresIn=${it.arguments[1]}" }
listOf("ko" to "ko-KR", "ja" to "ja-JP").forEach { (language, expectedLanguage) ->
val data = generateUrl(job.contentId, token, language)
assertTrue(data.has("subtitle"))
assertEquals(setOf("contentUrl", "subtitle"), data.fieldNames().asSequence().toSet())
assertEquals(
"https://signed.example.test/${job.outputKey}.aac?expiresIn=14400000",
data.path("contentUrl").textValue()
)
val subtitle = data.path("subtitle")
assertEquals(setOf("language", "format", "url"), subtitle.fieldNames().asSequence().toSet())
assertEquals(expectedLanguage, subtitle.path("language").textValue())
assertEquals("SRT", subtitle.path("format").textValue())
assertEquals(
"https://signed.example.test/subtitles/${job.contentId}/${job.jobId}/$language.srt?expiresIn=14400000",
subtitle.path("url").textValue()
)
val detail = http.exchange(
"/audio-content/${job.contentId}?timezone=UTC",
HttpMethod.GET,
HttpEntity<Void>(headers(token).apply { set(HttpHeaders.ACCEPT_LANGUAGE, language) }),
String::class.java
)
assertEquals(200, detail.statusCodeValue)
val detailBody = mapper.readTree(detail.body)
assertTrue(detailBody.path("success").booleanValue())
assertEquals(detailBody.path("data").path("subtitle"), subtitle)
}
}
@Test
@DisplayName("generate-url은 pending/미등록/없는 언어/미지원 언어의 자막을 명시적 null로 반환하고 음원 URL은 유지한다")
fun shouldReturnNullSubtitleInGenerateUrlWhenUnavailable() {
val bot = login(MemberRole.BOT)
val owner = members.saveAndFlush(Member(password = "unused", nickname = "unavailable-owner-${UUID.randomUUID()}"))
val token = login(MemberRole.USER)
val buyer = members.findByEmail(lastLoginEmail)!!
val job = fixture(owner = owner)
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, job.contentId).apply {
this.content = "${job.outputKey}.aac"
duration = "00:03:00"
releaseDate = LocalDateTime.now().minusDays(1)
}
entityManager.persist(
Order(type = OrderType.KEEP).apply {
member = buyer
creator = owner
audioContent = content
}
)
}
val pending = generateUrl(job.contentId, token, "ko")
assertTrue(pending.has("subtitle"))
assertTrue(pending.path("subtitle").isNull)
assertEquals("https://signed.example.test/${job.outputKey}.aac", pending.path("contentUrl").textValue())
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).latestSubtitleJobId = null
}
val missing = generateUrl(job.contentId, token, "ko")
assertTrue(missing.has("subtitle"))
assertTrue(missing.path("subtitle").isNull)
assertEquals(pending.path("contentUrl"), missing.path("contentUrl"))
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).latestSubtitleJobId = job.jobId
}
assertEquals(200, post("/callback", bot, callback(job, languages = listOf("ja-JP"))).statusCodeValue)
listOf("ko", "en").forEach { language ->
val unavailable = generateUrl(job.contentId, token, language)
assertTrue(unavailable.has("subtitle"))
assertTrue(unavailable.path("subtitle").isNull)
assertEquals(pending.path("contentUrl"), unavailable.path("contentUrl"))
}
val available = generateUrl(job.contentId, token, "ja")
assertEquals("ja-JP", available.path("subtitle").path("language").textValue())
assertEquals("SRT", available.path("subtitle").path("format").textValue())
assertEquals(
"https://signed.example.test/subtitles/${job.contentId}/${job.jobId}/ja.srt",
available.path("subtitle").path("url").textValue()
)
assertEquals(pending.path("contentUrl"), available.path("contentUrl"))
}
@Test
@DisplayName("generate-url은 소유자/무료도 활성 구매가 필요하며 예약 공개는 자막에만 상세의 공개 제한을 적용한다")
fun shouldPreserveGenerateUrlPurchaseAndReleaseRestrictions() {
val bot = login(MemberRole.BOT)
val ownerToken = login(MemberRole.CREATOR)
val owner = members.findByEmail(lastLoginEmail)!!
val viewerToken = login(MemberRole.USER)
val viewer = members.findByEmail(lastLoginEmail)!!
val job = fixture(owner = owner)
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).apply {
price = 100
content = "${job.outputKey}.aac"
duration = "00:03:00"
releaseDate = LocalDateTime.now().minusDays(1)
}
}
assertEquals(200, post("/callback", bot, callback(job)).statusCodeValue)
listOf(viewerToken, ownerToken).forEach { token ->
val denied = generateUrl(job.contentId, token, "ko")
assertTrue(denied.has("subtitle"))
assertTrue(denied.path("subtitle").isNull)
assertEquals("", denied.path("contentUrl").textValue())
}
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, job.contentId).price = 0 }
listOf(viewerToken, ownerToken).forEach { token ->
val free = generateUrl(job.contentId, token, "ko")
assertTrue(free.has("subtitle"))
assertTrue(free.path("subtitle").isNull)
assertEquals("", free.path("contentUrl").textValue())
}
val expiredOrderId = transaction.execute {
val content = entityManager.find(AudioContent::class.java, job.contentId)
content.price = 100
entityManager.persist(
Order(type = OrderType.KEEP, isActive = false).apply {
member = viewer
creator = owner
audioContent = content
}
)
Order(type = OrderType.RENTAL).apply {
member = viewer
creator = owner
audioContent = content
entityManager.persist(this)
entityManager.flush()
endDate = LocalDateTime.now().minusDays(1)
}.id!!
}!!
val expired = generateUrl(job.contentId, viewerToken, "ko")
assertTrue(expired.has("subtitle"))
assertTrue(expired.path("subtitle").isNull)
assertEquals("", expired.path("contentUrl").textValue())
transaction.executeWithoutResult {
entityManager.find(Order::class.java, expiredOrderId).endDate = LocalDateTime.now().plusDays(1)
val content = entityManager.find(AudioContent::class.java, job.contentId)
content.releaseDate = LocalDateTime.now().plusDays(1)
entityManager.persist(
Order(type = OrderType.KEEP).apply {
member = owner
creator = owner
audioContent = content
}
)
}
val scheduled = generateUrl(job.contentId, viewerToken, "ko")
assertTrue(scheduled.has("subtitle"))
assertTrue(scheduled.path("subtitle").isNull)
assertEquals("https://signed.example.test/${job.outputKey}.aac", scheduled.path("contentUrl").textValue())
val purchasedOwner = generateUrl(job.contentId, ownerToken, "ko")
assertEquals(scheduled.path("contentUrl"), purchasedOwner.path("contentUrl"))
assertEquals("ko-KR", purchasedOwner.path("subtitle").path("language").textValue())
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, job.contentId).releaseDate = null }
assertEquals("ko-KR", generateUrl(job.contentId, viewerToken, "ko").path("subtitle").path("language").textValue())
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, job.contentId).releaseDate = LocalDateTime.now().minusDays(1)
}
val released = generateUrl(job.contentId, viewerToken, "ko")
assertEquals(scheduled.path("contentUrl"), released.path("contentUrl"))
assertEquals("ko-KR", released.path("subtitle").path("language").textValue())
assertEquals(
401,
http.getForEntity("/audio-content/${job.contentId}/generate-url", String::class.java).statusCodeValue
)
}
private fun generateUrl(contentId: Long, token: String, language: String) = http.exchange(
"/audio-content/$contentId/generate-url",
HttpMethod.GET,
HttpEntity<Void>(headers(token).apply { set(HttpHeaders.ACCEPT_LANGUAGE, language) }),
String::class.java
).let {
assertEquals(200, it.statusCodeValue)
val body = mapper.readTree(it.body)
assertTrue(body.path("success").booleanValue())
body.path("data")
}
private var lastLoginEmail: String? = null
private fun login(role: MemberRole): String {
val email = "subtitle-${UUID.randomUUID()}@example.test"
lastLoginEmail = email
members.saveAndFlush(
Member(email = email, password = passwordEncoder.encode("test-password"), nickname = email, role = role)
)
val response = http.postForEntity(
"/member/login",
HttpEntity(
"""{"email":"$email","password":"test-password","isAdmin":false,"isCreator":false}""",
HttpHeaders().apply { contentType = MediaType.APPLICATION_JSON }
),
String::class.java
)
assertEquals(200, response.statusCodeValue)
val body = mapper.readTree(response.body)
assertTrue(body.path("success").booleanValue())
assertFalse(body.path("data").path("isNew").booleanValue())
return body.path("data").path("token").textValue().also { assertTrue(it.isNotBlank()) }
}
private fun headers(token: String) = HttpHeaders().apply {
setBearerAuth(token)
contentType = MediaType.APPLICATION_JSON
}
private fun get(path: String, token: String) = http.exchange(
"/internal/api/subtitle-jobs$path",
HttpMethod.GET,
HttpEntity<Void>(headers(token)),
String::class.java
)
private fun post(path: String, token: String, raw: String) = http.exchange(
"/internal/api/subtitle-jobs$path",
HttpMethod.POST,
HttpEntity(raw.toByteArray(), headers(token)),
String::class.java
)
private fun started(job: SubtitleJob) = """{"transcribeJobName":"subtitle-${job.jobId}","status":"PROCESSING"}"""
private fun callback(
job: SubtitleJob,
eventId: String = UUID.randomUUID().toString(),
languages: List<String> = listOf(
"ko-KR",
"ja-JP"
)
): String {
val subtitles = languages.joinToString(",") {
val short = if (it == "ko-KR") "ko" else "ja"
"""{"language":"$it","format":"SRT","s3Bucket":"${job.sourceBucket}",""" +
""""s3Key":"subtitles/${job.contentId}/${job.jobId}/$short.srt"}"""
}
val status = when (languages.size) { 2 -> "COMPLETED"; 1 -> "PARTIAL_COMPLETED"; else -> "FAILED" }
val error = if (languages.size == 2) "null" else "\"PIPELINE_FAILED\""
val message = if (languages.size == 2) "null" else "\"pipeline failed\""
return """{"eventId":"$eventId","jobId":"${job.jobId}","contentId":${job.contentId},""" +
""""transcribeJobName":"subtitle-${job.jobId}","status":"$status","subtitles":[$subtitles],""" +
""""errorCode":$error,"errorMessage":$message}"""
}
private fun fixture(originalFilename: String? = "fixture.mp3", owner: Member? = null): SubtitleJob = transaction.execute {
val creator = owner ?: Member(password = "unused", nickname = "fixture-${UUID.randomUUID()}").also {
entityManager.persist(
it
)
}
val theme = AudioContentTheme(theme = "subtitle theme", image = "theme.png")
entityManager.persist(theme)
val content = AudioContent(title = "subtitle content", detail = "detail", languageCode = "ko").apply {
member = creator
this.theme = theme
}
entityManager.persist(content)
service.register(content, originalFilename)
}!!
private fun race(first: () -> Int, second: () -> Int): List<Int> {
val pool = Executors.newFixedThreadPool(2)
val gate = CountDownLatch(1)
return try {
val futures = listOf(first, second).map { action -> pool.submit(Callable { gate.await(); action() }) }
gate.countDown()
futures.map { it.get(30, TimeUnit.SECONDS) }.sorted()
} finally {
pool.shutdownNow()
}
}
}
@@ -0,0 +1,85 @@
package kr.co.vividnext.sodalive.v2.subtitle
import kr.co.vividnext.sodalive.v2.subtitle.adapter.persistence.Subtitle
import org.hibernate.boot.MetadataSources
import org.hibernate.boot.registry.StandardServiceRegistryBuilder
import org.hibernate.cfg.AvailableSettings
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.boot.autoconfigure.orm.jpa.HibernateProperties
import org.springframework.boot.autoconfigure.orm.jpa.HibernateSettings
import java.sql.DriverManager
import java.util.UUID
class SubtitleSchemaValidationTest {
@Test
@DisplayName("기존 DDL의 s3_bucket과 s3_key를 실제 Hibernate validate 및 저장 조회에 사용한다")
fun shouldValidateAndUseExistingS3Columns() {
val url = "jdbc:h2:mem:subtitle-schema-${UUID.randomUUID()};MODE=MySQL"
DriverManager.getConnection(url, "sa", "").use { connection ->
connection.createStatement().use {
it.execute(
"""
CREATE TABLE subtitle (
id BIGINT GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
job_id VARCHAR(36) NOT NULL,
language VARCHAR(35) NOT NULL,
format VARCHAR(16) NOT NULL,
s3_bucket VARCHAR(255) NOT NULL,
s3_key VARCHAR(255) NOT NULL,
UNIQUE (job_id, language)
)
""".trimIndent()
)
}
val bootProperties = HibernateProperties().determineHibernateProperties(emptyMap(), HibernateSettings())
val registry = StandardServiceRegistryBuilder()
.applySettings(bootProperties)
.applySetting(AvailableSettings.DRIVER, "org.h2.Driver")
.applySetting(AvailableSettings.URL, url)
.applySetting(AvailableSettings.USER, "sa")
.applySetting(AvailableSettings.PASS, "")
.applySetting(AvailableSettings.DIALECT, "org.hibernate.dialect.H2Dialect")
.applySetting(AvailableSettings.HBM2DDL_AUTO, "validate")
.build()
try {
MetadataSources(registry).addAnnotatedClass(Subtitle::class.java)
.buildMetadata().buildSessionFactory().use { factory ->
val id = factory.openSession().use { session ->
val transaction = session.beginTransaction()
val subtitle = Subtitle(
jobId = "550e8400-e29b-41d4-a716-446655440000",
language = "ko-KR",
format = "SRT",
s3Bucket = "subtitle-media",
s3Key = "subtitles/100/550e8400-e29b-41d4-a716-446655440000/ko.srt"
)
session.persist(subtitle)
transaction.commit()
requireNotNull(subtitle.id)
}
factory.openSession().use { session ->
val stored = session.find(Subtitle::class.java, id)
assertEquals("subtitle-media", stored.s3Bucket)
assertEquals("subtitles/100/550e8400-e29b-41d4-a716-446655440000/ko.srt", stored.s3Key)
}
connection.prepareStatement("SELECT s3_bucket, s3_key FROM subtitle WHERE id = ?").use {
it.setLong(1, id)
it.executeQuery().use { result ->
assertTrue(result.next())
assertEquals("subtitle-media", result.getString("s3_bucket"))
assertEquals(
"subtitles/100/550e8400-e29b-41d4-a716-446655440000/ko.srt",
result.getString("s3_key")
)
}
}
}
} finally {
StandardServiceRegistryBuilder.destroy(registry)
}
}
}
}