feat(content): 관리자 번역 후보 선택과 필드별 승인 보호를 구현한다

This commit is contained in:
2026-11-18 12:29:41 +09:00
parent a3c76a1bbe
commit 9d8bc9149b
104 changed files with 7696 additions and 383 deletions
@@ -15,7 +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 org.springframework.transaction.PlatformTransactionManager
import java.util.Optional
class AdminContentServiceTest {
@@ -44,7 +44,10 @@ class AdminContentServiceTest {
contentMainTabRepository = contentMainTabRepository,
objectMapper = jacksonObjectMapper(),
s3Uploader = s3Uploader,
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
sourceInvalidation = Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class.java
),
transactionManager = Mockito.mock(PlatformTransactionManager::class.java),
bucket = "test-bucket"
)
}
@@ -20,6 +20,8 @@ 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.i18n.translation.TranslationSourceExtractor
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import org.junit.jupiter.api.Assertions.assertEquals
@@ -69,6 +71,7 @@ class AudioContentDetailTranslationHttpIntegrationTest @Autowired constructor(
private val jdbc: JdbcTemplate,
private val worker: TranslationJobWorker,
private val scheduler: ResourceTranslationJobScheduler,
private val sourceExtractor: TranslationSourceExtractor,
private val entityManager: EntityManager,
transactionManager: PlatformTransactionManager
) {
@@ -133,7 +136,45 @@ class AudioContentDetailTranslationHttpIntegrationTest @Autowired constructor(
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())
assertEquals(6L, jobs.count())
assertEquals(setOf("en", "ja"), jobs.findAll().map { it.targetLanguage }.toSet())
}
@Test
@DisplayName("상세와 추출기는 연관 ID 순서의 활성 태그와 같은 원문을 사용하고 메모리 정규화를 유지한다")
fun shouldShareOrderedActiveSourceAcrossExtractorAndDetail() {
val fixture = fixture(null, detail = "\t원문 설명 \n")
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, fixture.first)
content.title = " 원문 제목 \t"
val tag = HashTag(" #차분")
entityManager.persist(tag)
entityManager.persist(
AudioContentHashTag().apply {
audioContent = content
hashTag = tag
}
)
}
val response = detail(fixture)
val extracted = transaction.execute {
entityManager.find(AudioContent::class.java, fixture.first).audioContentHashTags.reverse()
sourceExtractor.extract(LanguageTranslationTargetType.CONTENT, fixture.first)
}
assertTranslation(response, "English title", "English detail", "#Healing, #Calm")
assertEquals(listOf("원문 제목 원문 설명 #힐링 #차분"), provider.detectionQueries)
assertEquals(
listOf(
TranslationSourceField("title", " 원문 제목 \t"),
TranslationSourceField("detail", "\t원문 설명 \n"),
TranslationSourceField("tags", "#힐링, #차분")
),
extracted?.fields
)
assertEquals(setOf("원문 제목", "원문 설명", "#힐링, #차분"), memories.findAll().map { it.sourceText }.toSet())
memories.findAll().forEach { assertEquals(SourceTextNormalizer.hash(it.sourceText), it.sourceHash) }
}
@Test
@@ -125,6 +125,9 @@ class AudioContentServiceTest {
homeFollowingNewsPublishService = homeFollowingNewsPublishService,
memberContentPreferenceService = memberContentPreferenceService,
subtitleJobService = subtitleJobService,
sourceInvalidation = Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class.java
),
transactionManager = Mockito.mock(PlatformTransactionManager::class.java),
audioContentBucket = "audio-bucket",
coverImageBucket = "cover-bucket",
@@ -29,6 +29,8 @@ 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.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService
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
@@ -70,7 +72,11 @@ import javax.servlet.http.HttpServletResponse
TranslationReadModelMaterializer::class, LanguageDetectionCacheService::class,
AudioContentDetailTranslationService::class, TranslationMemoryService::class, TranslationJobWorker::class,
LanguageDetectListener::class, ContentSeriesController::class, ContentSeriesService::class,
ContentSeriesDetailTranslationService::class
ContentSeriesDetailTranslationService::class,
ContentTranslationWriteService::class,
JpaContentTranslationOverrideStore::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class
)
@MockBean(
classes = [
@@ -86,9 +86,13 @@ import javax.persistence.EntityManager
QueryDslConfig::class,
AudioContentThemeQueryRepository::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
CreatorCommunityTranslationService::class,
TranslationSourceExtractor::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
TranslationCoordinator::class,
PapagoTranslationService::class,
ResourceTranslationJobScheduler::class,
@@ -691,9 +695,10 @@ class CreatorCommunityLanguageDetectTest @Autowired constructor(
@Bean
@Primary
fun languageDetectionCacheService(
languageDetectionResultRepository: LanguageDetectionResultRepository
languageDetectionResultRepository: LanguageDetectionResultRepository,
transactionManager: PlatformTransactionManager
): ControlledLanguageDetectionCacheService {
return ControlledLanguageDetectionCacheService(languageDetectionResultRepository)
return ControlledLanguageDetectionCacheService(languageDetectionResultRepository, transactionManager)
}
@Bean
@@ -732,14 +737,16 @@ class CreatorCommunityLanguageDetectTest @Autowired constructor(
}
class ControlledLanguageDetectionCacheService(
languageDetectionResultRepository: LanguageDetectionResultRepository
languageDetectionResultRepository: LanguageDetectionResultRepository,
transactionManager: PlatformTransactionManager
) : LanguageDetectionCacheService(
languageDetectionResultRepository,
listOf(object : LanguageDetectionProvider {
override val providerId = LanguageProviderId.PAPAGO
override fun detect(query: String): String? = null
}),
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO))
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)),
transactionManager
) {
val detections = ConcurrentHashMap<String, String>()
val queries = ConcurrentLinkedQueue<String>()
@@ -79,9 +79,13 @@ import java.util.concurrent.atomic.AtomicInteger
PapagoTranslationService::class,
TranslationCoordinator::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
CreatorCommunityTranslationService::class,
TranslationSourceExtractor::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class
)
@@ -9,6 +9,9 @@ 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.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.support.SimpleTransactionStatus
class LanguageDetectionCacheServiceTest {
@Test
@@ -111,7 +114,11 @@ class LanguageDetectionCacheServiceTest {
return LanguageDetectionCacheService(
repository,
listOf(provider),
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO))
LanguageProviderProperties(listOf(LanguageProviderId.PAPAGO), listOf(LanguageProviderId.PAPAGO)),
Mockito.mock(PlatformTransactionManager::class.java).also {
Mockito.`when`(it.getTransaction(Mockito.any(TransactionDefinition::class.java)))
.thenReturn(SimpleTransactionStatus())
}
)
}
}
@@ -55,6 +55,10 @@ import javax.persistence.EntityManager
QueryDslConfig::class,
AudioContentThemeQueryRepository::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
TranslationSourceExtractor::class,
ResourceTranslationJobScheduler::class,
TranslationJobScheduler::class,
@@ -137,7 +141,8 @@ class MetadataLanguageDetectTransactionTest @Autowired constructor(
}
private fun prepareDetection(target: MetadataTarget): LanguageDetectEvent {
Mockito.`when`(detectionCache.detectWithCache("원문 제목"))
val query = if (target == MetadataTarget.CONTENT) "원문 제목 원문 설명" else "원문 제목"
Mockito.`when`(detectionCache.detectWithCache(query))
.thenReturn(DetectedLanguage("ko", LanguageProviderId.PAPAGO))
val id = transaction.execute {
val owner = persist(Member(password = "password", nickname = "metadata-owner", role = MemberRole.CREATOR))
@@ -166,7 +171,7 @@ class MetadataLanguageDetectTransactionTest @Autowired constructor(
}
requireNotNull(persist(metadata).id)
}!!
return LanguageDetectEvent(id, "원문 제목", LanguageDetectTargetType.valueOf(target.name))
return LanguageDetectEvent(id, query, LanguageDetectTargetType.valueOf(target.name))
}
private fun <T : BaseEntity> persist(entity: T): T {
@@ -7,7 +7,6 @@ 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
@@ -28,6 +27,7 @@ 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.contenttranslation.application.ContentTranslationSourceInvalidationService
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
@@ -90,7 +90,17 @@ class AudioContentReadRetryTest : MetadataReadRetryTestSupport() {
detailTranslationService = AudioContentDetailTranslationService(
repository,
translations,
Mockito.mock(LanguageDetectionCacheService::class.java),
Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class.java
),
Mockito.mock(
ContentTranslationSourceInvalidationService::class.java
),
Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class.java
).also {
Mockito.`when`(it.lockContent(10L)).thenReturn(content)
},
Mockito.mock(TranslationMemoryService::class.java),
Mockito.mock(TranslationReadModelMaterializer::class.java),
scheduler,
@@ -108,6 +118,9 @@ class AudioContentReadRetryTest : MetadataReadRetryTestSupport() {
homeFollowingNewsPublishService = Mockito.mock(HomeFollowingNewsPublishService::class.java),
memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java),
subtitleJobService = Mockito.mock(SubtitleJobService::class.java),
sourceInvalidation = Mockito.mock(
ContentTranslationSourceInvalidationService::class.java
),
transactionManager = transactionManager,
audioContentBucket = "audio-bucket",
coverImageBucket = "cover-bucket",
@@ -142,7 +142,7 @@ class CompletedContentTagRepairTest : MetadataReadRetryTestSupport() {
@ParameterizedTest
@CsvSource("false,language", "false,hash", "true,language", "true,hash")
@DisplayName("현재 원문 언어 또는 해시가 다른 완료 태그는 수정과 조회에서 재개하지 않는다")
@DisplayName("다른 원문 언어·해시의 완료 태그는 보존하고 수정 요청만 현재 identity 작업을 만든다")
fun shouldPreserveCompletedTagsForDifferentCurrentSource(readRequest: Boolean, mismatch: String) {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
val previousSource = if (mismatch == "language") {
@@ -160,7 +160,13 @@ class CompletedContentTagRepairTest : MetadataReadRetryTestSupport() {
}
assertPreserved(job)
assertEquals(if (!readRequest && mismatch == "hash") 2L else 1L, jobs.count())
assertEquals(if (readRequest) 1L else 2L, jobs.count())
if (!readRequest) {
val current = jobs.findAll().single { it.id != job.id }
assertEquals("ko", current.sourceLanguage)
assertEquals(SourceTextNormalizer.hash(sourceText), current.sourceHash)
assertEquals(TranslationJobStatus.PENDING, current.status)
}
}
@ParameterizedTest
@@ -200,16 +206,17 @@ class CompletedContentTagRepairTest : MetadataReadRetryTestSupport() {
jobs.saveAndFlush(claimed)
}
snapshot
}.`when`(repository).findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
}.`when`(repository).findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
source.resourceType,
source.resourceId,
"tags",
"en",
SourceTextNormalizer.hash(sourceText)
SourceTextNormalizer.hash(sourceText),
source.sourceLanguage
)
TransactionTemplate(transactionManager).executeWithoutResult {
schedule(source, TranslationJobScheduler(repository, coordinator, translations))
schedule(source, TranslationJobScheduler(repository, coordinator, translations, entityManager))
}
val claimed = jobs.findById(requireNotNull(job.id)).orElseThrow()
@@ -2,9 +2,14 @@ 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.AudioContent
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.member.Member
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
@@ -21,11 +26,14 @@ 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 org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
@Import(
TranslationCoordinator::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
ContentTagTranslationIntegrationTest.Providers::class
)
class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
@@ -51,6 +59,8 @@ class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
private lateinit var papago: PapagoTagProvider
private val sourceText = "#힐링,#수면"
private var contentId = 0L
private lateinit var sourceTag: HashTag
@BeforeEach
fun prepareProviders() {
@@ -59,12 +69,22 @@ class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
papago.result = "#Healing, #Sleep"
papago.calls = 0
papago.fail = false
val creator = persist(Member(password = "test", nickname = "tag-creator"))
val theme = persist(AudioContentTheme("tag-theme", "tag.png"))
sourceTag = HashTag(sourceText)
TransactionTemplate(transactionManager).executeWithoutResult { entityManager.persist(sourceTag) }
contentId = requireNotNull(persist(AudioContent("", "", "ko").apply { member = creator; this.theme = theme }).id)
}
@AfterEach
fun removeWorkerResults() {
translations.deleteAllInBatch()
memories.deleteAllInBatch()
TransactionTemplate(transactionManager).executeWithoutResult {
entityManager.createQuery("delete from AudioContentHashTag t where t.audioContent.id = :id")
.setParameter("id", contentId).executeUpdate()
entityManager.remove(entityManager.find(HashTag::class.java, sourceTag.id))
}
}
@ParameterizedTest
@@ -121,12 +141,12 @@ class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
@Test
@DisplayName("AWS 미번역 태그 캐시만 있을 때는 정상 번역 응답으로 조립하지 않는다")
fun shouldNotMaterializeUnchangedAwsTagCache() {
givenSource(LanguageTranslationTargetType.CONTENT, "tags", sourceText)
givenContentSource("tags")
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", aws.result, "aws", "test")
)
assertFalse(materializer.materialize(LanguageTranslationTargetType.CONTENT, 10L, "en"))
assertFalse(materializer.materialize(LanguageTranslationTargetType.CONTENT, contentId, "en"))
assertEquals(0L, translations.count())
}
@@ -168,16 +188,16 @@ class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(sourceText), sourceText, "ko", "en", aws.result, "aws", "test")
)
translations.saveAndFlush(ContentTranslation(10L, "en", ContentTranslationPayload("", "", aws.result)))
translations.saveAndFlush(ContentTranslation(contentId, "en", ContentTranslationPayload("", "", aws.result)))
storeRenderedPayloadAsJsonObject()
papago.result = sourceText
scheduler.restartFailedResourceTranslations(LanguageTranslationTargetType.CONTENT, listOf(10L), "en")
scheduler.restartFailedResourceTranslations(LanguageTranslationTargetType.CONTENT, listOf(contentId), "en")
assertEquals(TranslationJobStatus.PENDING, jobs.findAll().single().status)
assertTrue(worker().processNextGroup())
assertEquals(sourceText, renderedTags())
storeRenderedPayloadAsJsonObject()
scheduler.restartFailedResourceTranslations(LanguageTranslationTargetType.CONTENT, listOf(10L), "en")
scheduler.restartFailedResourceTranslations(LanguageTranslationTargetType.CONTENT, listOf(contentId), "en")
val completed = jobs.findAll().single()
assertEquals(job.id, completed.id)
@@ -217,8 +237,32 @@ class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
}
private fun prepareJob(fieldKey: String = "tags") {
givenSource(LanguageTranslationTargetType.CONTENT, fieldKey, sourceText)
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.CONTENT, 10L, "en")
givenContentSource(fieldKey)
scheduler.scheduleResourceTranslation(LanguageTranslationTargetType.CONTENT, contentId, "en")
}
private fun givenContentSource(fieldKey: String) {
val source = TranslationSource(
LanguageTranslationTargetType.CONTENT,
contentId,
"ko",
listOf(TranslationSourceField(fieldKey, sourceText))
)
Mockito.`when`(sourceExtractor.extract(LanguageTranslationTargetType.CONTENT, contentId)).thenReturn(source)
if (fieldKey == "title") {
TransactionTemplate(transactionManager).executeWithoutResult {
entityManager.find(AudioContent::class.java, contentId).title = sourceText
}
} else {
TransactionTemplate(transactionManager).executeWithoutResult {
entityManager.persist(
AudioContentHashTag().apply {
audioContent = entityManager.getReference(AudioContent::class.java, contentId)
hashTag = sourceTag
}
)
}
}
}
private fun worker(): TranslationJobWorker {
@@ -243,16 +287,18 @@ class ContentTagTranslationIntegrationTest : MetadataReadRetryTestSupport() {
private fun storeRenderedPayloadAsJsonObject() {
jdbc.update(
"update content_translation set rendered_payload = ? format json where content_id = 10",
renderedPayload().toString()
"update content_translation set rendered_payload = ? format json where content_id = ?",
renderedPayload().toString(),
contentId
)
}
private fun renderedPayload(): JsonNode {
val raw = jdbc.queryForObject(
"select rendered_payload from content_translation where content_id = 10",
String::class.java
)!!
"select rendered_payload from content_translation where content_id = ?",
String::class.java,
contentId
)
val mapper = jacksonObjectMapper()
val value = mapper.readTree(raw)
// H2 JSON은 converter가 저장한 JSON 문자열을 한 겹 감싸 반환한다.
@@ -12,11 +12,17 @@ import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.TransactionDefinition
import org.springframework.transaction.support.SimpleTransactionStatus
class LanguageDetectionProviderTest {
private val repository = Mockito.mock(LanguageDetectionResultRepository::class.java)
private val query = "original source"
private val hash = SourceTextNormalizer.hash(query)
private val transactionManager = Mockito.mock(PlatformTransactionManager::class.java).also {
Mockito.`when`(it.getTransaction(Mockito.any(TransactionDefinition::class.java))).thenReturn(SimpleTransactionStatus())
}
@Test
@DisplayName("기본 감지 순서에서 AWS 예외와 빈 결과는 Papago로 전환한다")
@@ -26,7 +32,12 @@ class LanguageDetectionProviderTest {
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())
val detector = LanguageDetectionCacheService(
repository,
listOf(papago, aws),
LanguageProviderProperties(),
transactionManager
)
assertEquals(DetectedLanguage("ko", PAPAGO), detector.detectWithCache(query))
assertEquals(listOf(query), aws.queries)
@@ -41,7 +52,12 @@ class LanguageDetectionProviderTest {
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())
val detector = LanguageDetectionCacheService(
repository,
listOf(papago, aws),
LanguageProviderProperties(),
transactionManager
)
assertEquals(DetectedLanguage("ja", PAPAGO), detector.detectWithCache(query))
assertEquals(emptyList<String>(), aws.queries + papago.queries)
@@ -125,7 +141,12 @@ class LanguageDetectionProviderTest {
private fun service(
providers: List<LanguageDetectionProvider>,
order: List<LanguageProviderId> = providers.map { it.providerId }
) = LanguageDetectionCacheService(repository, providers, LanguageProviderProperties(order, listOf(PAPAGO)))
) = LanguageDetectionCacheService(
repository,
providers,
LanguageProviderProperties(order, listOf(PAPAGO)),
transactionManager
)
}
class RecordingDetectionProvider(
@@ -66,6 +66,8 @@ import java.util.UUID
TranslationJobWorker::class,
TranslationMemoryService::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
TranslationSourceExtractor::class,
TranslationJobScheduler::class,
ResourceTranslationJobScheduler::class,
@@ -82,6 +82,8 @@ import javax.persistence.EntityManager
AudioContentDetailTranslationService::class,
TranslationMemoryService::class,
TranslationReadModelMaterializer::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore::class,
ExplorerQueryRepository::class,
SodaMessageSource::class,
AudioContentThemeQueryRepository::class,
@@ -91,6 +93,8 @@ import javax.persistence.EntityManager
TranslationJobSchedulerTestConfiguration::class,
LanguageTranslationListener::class,
LanguageDetectListener::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService::class,
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationLanguageService::class,
MetadataTranslationHttpIntegrationTest.Configuration::class
)
@MockBean(
@@ -215,7 +219,7 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
.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 })
assertEquals(6, jobs.findAll().count { it.resourceId == contentId })
Mockito.verify(detectionCache).detectWithCache(query)
}
transaction.executeWithoutResult {
@@ -224,7 +228,9 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
val stored = jobs.findAll().filter {
it.resourceType == LanguageTranslationTargetType.CONTENT && it.resourceId == contentId
}
assertEquals(0, stored.size)
assertEquals(6, stored.size)
assertEquals(setOf("title", "detail", "tags"), stored.map { it.fieldKey }.toSet())
assertEquals(setOf("en", "ja"), stored.map { it.targetLanguage }.toSet())
}
} finally {
SecurityContextHolder.clearContext()
@@ -246,8 +252,8 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
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)
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!!
@@ -261,7 +267,7 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
"request",
"",
"application/json",
"""{"id":$contentId,"title":"원문 제목","isDefaultCoverImage":false}""".toByteArray()
"""{"id":$contentId,"title":"수정 제목","isDefaultCoverImage":false}""".toByteArray()
)
)
.with { request -> request.apply { method = "PUT" } }
@@ -276,10 +282,10 @@ class MetadataTranslationHttpIntegrationTest @Autowired constructor(
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"),
setOf("title" to "en", "title" to "ja"),
stored.map { it.fieldKey to it.targetLanguage }.toSet()
)
assertEquals(4, stored.size)
assertEquals(2, stored.size)
}
println(
"HTTP QA: status=${response.status}, body=${response.contentAsString}, " +
@@ -92,7 +92,7 @@ class TranslationJobRetryIntegrationTest @Autowired constructor(
}
@Test
@DisplayName("같은 원문 해시라도 원문 언어가 다른 FAILED 행은 재개하지 않는다")
@DisplayName("다른 원문 언어의 FAILED 행은 보존하고 같은 hash의 현재 언어 작업을 새로 만든다")
fun shouldNotRestartFailedJobForDifferentSourceLanguage() {
val original = persistJob(sourceLanguage = "ja")
@@ -100,13 +100,20 @@ class TranslationJobRetryIntegrationTest @Autowired constructor(
entityManager.flush()
entityManager.clear()
val preserved = repository.findAll().single()
val jobs = repository.findAll()
assertEquals(2, jobs.size)
val preserved = jobs.single { it.id == original.id }
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)
val current = jobs.single { it.sourceLanguage == "ko" }
assertEquals(original.sourceHash, current.sourceHash)
assertEquals(TranslationJobStatus.PENDING, current.status)
assertEquals(0, current.retryCount)
assertNull(current.lastErrorMessage)
}
@Test
@@ -229,12 +236,13 @@ class TranslationJobRetryIntegrationTest @Autowired constructor(
AdditionalAnswers.delegatesTo<TranslationJobRepository>(repository)
)
Mockito.doAnswer {
val snapshot = repository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
val snapshot = repository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
LanguageTranslationTargetType.CONTENT,
10L,
"title",
"en",
SourceTextNormalizer.hash("제목")
SourceTextNormalizer.hash("제목"),
"ko"
)
requiresNewTransaction.executeWithoutResult {
val claimed = repository.findById(originalId).orElseThrow()
@@ -243,16 +251,18 @@ class TranslationJobRetryIntegrationTest @Autowired constructor(
repository.saveAndFlush(claimed)
}
snapshot
}.`when`(interleavingRepository).findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
LanguageTranslationTargetType.CONTENT,
10L,
"title",
"en",
SourceTextNormalizer.hash("제목")
)
}.`when`(interleavingRepository)
.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
LanguageTranslationTargetType.CONTENT,
10L,
"title",
"en",
SourceTextNormalizer.hash("제목"),
"ko"
)
try {
transaction.executeWithoutResult {
schedule(TranslationJobScheduler(interleavingRepository, coordinator, contentTranslations))
schedule(TranslationJobScheduler(interleavingRepository, coordinator, contentTranslations, entityManager))
}
val claimed = repository.findAll().single()
@@ -6,15 +6,17 @@ import org.junit.jupiter.api.Assertions.assertNotNull
import org.junit.jupiter.api.Test
import org.mockito.ArgumentCaptor
import org.mockito.Mockito
import javax.persistence.EntityManager
class TranslationJobSchedulerTest {
private val coordinator = Mockito.mock(TranslationCoordinator::class.java)
private val contentTranslations = Mockito.mock(ContentTranslationRepository::class.java)
private val entityManager = Mockito.mock(EntityManager::class.java)
@Test
fun shouldCreateOnePendingJobForMissingNormalizedText() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations, entityManager)
Mockito.`when`(
jobRepository.findActiveJob(
@@ -22,7 +24,8 @@ class TranslationJobSchedulerTest {
resourceId = 10L,
fieldKey = "title",
targetLanguage = "en",
sourceHash = SourceTextNormalizer.hash("제목")
sourceHash = SourceTextNormalizer.hash("제목"),
sourceLanguage = "ko"
)
).thenReturn(null)
@@ -53,16 +56,17 @@ class TranslationJobSchedulerTest {
@Test
fun shouldNotCreateDuplicateJobWhenSameCompletedJobAlreadyExists() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations, entityManager)
val sourceHash = SourceTextNormalizer.hash("제목")
Mockito.`when`(
jobRepository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
jobRepository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
resourceType = LanguageTranslationTargetType.CONTENT,
resourceId = 10L,
fieldKey = "title",
targetLanguage = "en",
sourceHash = sourceHash
sourceHash = sourceHash,
sourceLanguage = "ko"
)
).thenReturn(
TranslationJob(
@@ -92,7 +96,7 @@ class TranslationJobSchedulerTest {
@Test
fun shouldNotCreateJobWhenSourceLanguageIsUnsupported() {
val jobRepository = Mockito.mock(TranslationJobRepository::class.java)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations)
val scheduler = TranslationJobScheduler(jobRepository, coordinator, contentTranslations, entityManager)
scheduler.scheduleMissingTranslation(
resourceType = LanguageTranslationTargetType.CONTENT,
@@ -71,12 +71,13 @@ class TranslationJobWorkerTest {
.thenReturn(listOf(100L, 101L))
Mockito.`when`(jobRepository.findById(100L)).thenReturn(Optional.of(titleJob))
Mockito.`when`(jobRepository.findById(101L)).thenReturn(Optional.of(detailJob))
Mockito.`when`(materializer.materializeContentFields(10L, "en", setOf("title", "detail"))).thenReturn(true)
worker.processNextGroup()
assertEquals(TranslationJobStatus.COMPLETED, titleJob.status)
assertEquals(TranslationJobStatus.COMPLETED, detailJob.status)
Mockito.verify(materializer, Mockito.times(1)).materialize(LanguageTranslationTargetType.CONTENT, 10L, "en")
Mockito.verify(materializer, Mockito.times(1)).materializeContentFields(10L, "en", setOf("title", "detail"))
}
@Test
@@ -145,7 +146,7 @@ class TranslationJobWorkerTest {
.thenReturn(listOf(100L, 101L))
Mockito.`when`(jobRepository.findById(100L)).thenReturn(Optional.of(titleJob))
Mockito.`when`(jobRepository.findById(101L)).thenReturn(Optional.of(detailJob))
Mockito.`when`(materializer.materialize(LanguageTranslationTargetType.CONTENT, 10L, "en"))
Mockito.`when`(materializer.materializeContentFields(10L, "en", setOf("title", "detail")))
.thenThrow(IllegalStateException("materialize down"))
worker.processNextGroup()
@@ -177,6 +178,7 @@ class TranslationJobWorkerTest {
.thenReturn(listOf(1L), listOf(2L), listOf(3L), listOf(4L), listOf(5L), listOf(6L))
jobs.forEach { job ->
Mockito.`when`(jobRepository.findById(job.id!!)).thenReturn(Optional.of(job))
Mockito.`when`(materializer.materializeContentFields(job.resourceId, "en", setOf("title"))).thenReturn(true)
}
worker.runPendingJobs()
@@ -248,6 +250,7 @@ class TranslationJobWorkerTest {
Mockito.`when`(jobRepository.findNextPendingGroupJobIdsForUpdate(anyLocalDateTime())).thenReturn(listOf(200L))
Mockito.`when`(jobRepository.findById(200L)).thenReturn(Optional.of(job))
Mockito.`when`(materializer.materializeContentFields(10L, "en", setOf("title"))).thenReturn(true)
assertTrue(worker.processNextGroup())
assertEquals(TranslationJobStatus.COMPLETED, job.status)
@@ -7,7 +7,6 @@ import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.creator.admin.content.CreatorAdminContentService
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.member.Member
@@ -15,11 +14,8 @@ import kr.co.vividnext.sodalive.member.MemberAdapter
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
import org.hamcrest.Matchers.nullValue
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertSame
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
@@ -40,8 +36,6 @@ import org.springframework.security.authentication.UsernamePasswordAuthenticatio
import org.springframework.security.core.authority.SimpleGrantedAuthority
import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.authentication
import org.springframework.test.context.ContextConfiguration
import org.springframework.test.util.AopTestUtils
import org.springframework.test.util.ReflectionTestUtils
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.header
@@ -60,7 +54,6 @@ import javax.persistence.EntityManager
class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
private val mockMvc: MockMvc,
private val chatCharacterService: ChatCharacterService,
private val creatorAdminContentService: CreatorAdminContentService,
private val entityManager: EntityManager
) {
@MockBean
@@ -72,18 +65,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
@MockBean
private lateinit var applicationEventPublisher: ApplicationEventPublisher
private lateinit var originalCreatorAdminContentServicePublisher: ApplicationEventPublisher
@BeforeEach
fun replaceActualServicePublisher() {
originalCreatorAdminContentServicePublisher = replaceCreatorAdminContentServicePublisher(applicationEventPublisher)
}
@AfterEach
fun restoreActualServicePublisher() {
replaceCreatorAdminContentServicePublisher(originalCreatorAdminContentServicePublisher)
}
@ParameterizedTest
@CsvSource(
value = [
@@ -131,7 +112,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
entityManager.clear()
assertEquals("before update", entityManager.find(AudioContent::class.java, content.id).title)
assertActualCreatorAdminContentServicePublisher(applicationEventPublisher)
Mockito.verify(amazonS3Client, Mockito.never()).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verifyNoInteractions(applicationEventPublisher)
}
@@ -175,7 +155,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
entityManager.clear()
assertEquals("undefined-part-before", entityManager.find(AudioContent::class.java, content.id).title)
assertActualCreatorAdminContentServicePublisher(applicationEventPublisher)
Mockito.verify(amazonS3Client, Mockito.never()).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verifyNoInteractions(applicationEventPublisher)
}
@@ -219,7 +198,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
entityManager.clear()
assertEquals("filename-less-part-before", entityManager.find(AudioContent::class.java, content.id).title)
assertActualCreatorAdminContentServicePublisher(applicationEventPublisher)
Mockito.verify(amazonS3Client, Mockito.never()).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verifyNoInteractions(applicationEventPublisher)
}
@@ -397,7 +375,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
.andExpect(status().isOk)
assertEquals(oldCover, entityManager.find(AudioContent::class.java, content.id).coverImage)
assertActualCreatorAdminContentServicePublisher(applicationEventPublisher)
Mockito.verify(amazonS3Client, Mockito.never()).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verifyNoInteractions(applicationEventPublisher)
}
@@ -433,7 +410,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
.andExpect(jsonPath("$.success").value(false))
assertEquals(oldTitle, entityManager.find(AudioContent::class.java, content.id).title)
assertActualCreatorAdminContentServicePublisher(applicationEventPublisher)
Mockito.verify(amazonS3Client, Mockito.never()).putObject(Mockito.any(PutObjectRequest::class.java))
Mockito.verifyNoInteractions(applicationEventPublisher)
}
@@ -523,20 +499,6 @@ class AiCharacterAdminAudioContentUpdateTest @Autowired constructor(
).setParameter("contentId", contentId).resultList
}
private fun replaceCreatorAdminContentServicePublisher(
publisher: ApplicationEventPublisher
): ApplicationEventPublisher {
val target = AopTestUtils.getTargetObject<CreatorAdminContentService>(creatorAdminContentService)
val original = ReflectionTestUtils.getField(target, "applicationEventPublisher") as ApplicationEventPublisher
ReflectionTestUtils.setField(target, "applicationEventPublisher", publisher)
return original
}
private fun assertActualCreatorAdminContentServicePublisher(publisher: ApplicationEventPublisher) {
val target = AopTestUtils.getTargetObject<CreatorAdminContentService>(creatorAdminContentService)
assertSame(publisher, ReflectionTestUtils.getField(target, "applicationEventPublisher"))
}
private fun adminAuthentication() = authentication(
UsernamePasswordAuthenticationToken(
MemberAdapter(
@@ -13,11 +13,13 @@ import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.creator.admin.content.CreatorAdminContentRepository
import kr.co.vividnext.sodalive.creator.admin.content.CreatorAdminContentService
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationEvent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorker
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.support.EmbeddedRedisInitializer
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceInvalidationService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertFalse
import org.junit.jupiter.api.Assertions.assertNotEquals
@@ -29,17 +31,13 @@ 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
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.MockBean
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
@@ -50,7 +48,6 @@ import javax.persistence.EntityManager
@SpringBootTest
@Transactional
@ContextConfiguration(initializers = [EmbeddedRedisInitializer::class])
@RecordApplicationEvents
class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
private val audioContentService: AudioContentService,
private val repository: CreatorAdminContentRepository,
@@ -66,7 +63,13 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
private lateinit var creatorAdminContentService: CreatorAdminContentService
@Autowired
private lateinit var applicationEvents: ApplicationEvents
private lateinit var jobs: TranslationJobRepository
@Autowired
private lateinit var sourceInvalidation: ContentTranslationSourceInvalidationService
@MockBean
private lateinit var worker: TranslationJobWorker
private lateinit var audioContentCloudFront: AudioContentCloudFront
@@ -74,7 +77,6 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
private lateinit var amazonS3Client: AmazonS3Client
private lateinit var s3Uploader: S3Uploader
private lateinit var applicationEventPublisher: ApplicationEventPublisher
private lateinit var service: CreatorAdminContentService
@BeforeEach
@@ -84,7 +86,6 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
Mockito.`when`(amazonS3Client.getUrl(Mockito.anyString(), Mockito.anyString()))
.thenReturn(URL("https://s3.example.com/test"))
s3Uploader = S3Uploader(amazonS3Client)
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java)
service = CreatorAdminContentService(
repository = repository,
hashTagRepository = hashTagRepository,
@@ -92,7 +93,8 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
audioContentCloudFront = audioContentCloudFront,
objectMapper = jacksonObjectMapper(),
s3Uploader = s3Uploader,
applicationEventPublisher = applicationEventPublisher,
sourceInvalidation = sourceInvalidation,
transactionManager = requireNotNull(transactionTemplate.transactionManager),
bucket = "test-bucket",
coverImageHost = "https://cover.example.com"
)
@@ -175,7 +177,7 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
}
@Test
@DisplayName("기존 크리에이터 콘텐츠 수정은 가격과 플래그를 저장하고 비활성화 시 예약을 해제하며 번역 이벤트를 발행한다")
@DisplayName("기존 크리에이터 콘텐츠 수정은 가격과 플래그를 저장하고 비활성화 시 예약 해제와 변경 필드 번역을 저장한다")
fun shouldUpdatePriceFlagsSoftDeleteAndTranslationEvent() {
val owner = saveMember("legacy-update-owner")
val content = saveAudioContent(owner, "before title", "00:10:00").apply {
@@ -204,12 +206,12 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
assertEquals(100, contentPriceChangeLogRepository.findAll().single().prevPrice)
assertEquals(listOf("#updated"), content.audioContentHashTags.map { it.hashTag!!.tag })
val eventCaptor = ArgumentCaptor.forClass(Any::class.java)
Mockito.verify(applicationEventPublisher).publishEvent(eventCaptor.capture())
val event = eventCaptor.value as LanguageTranslationEvent
assertEquals(content.id, event.id)
assertEquals(LanguageTranslationTargetType.CONTENT, event.targetType)
assertTrue(event.waitTransactionCommit)
val scheduled = jobs.findAll().filter {
it.resourceId == content.id && it.resourceType == LanguageTranslationTargetType.CONTENT
}
assertEquals(6, scheduled.size)
assertEquals(setOf("title", "detail", "tags"), scheduled.map { it.fieldKey }.toSet())
assertEquals(setOf("en", "ja"), scheduled.map { it.targetLanguage }.toSet())
}
@Test
@@ -250,7 +252,7 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
"false,title,' '",
"false,detail,' '"
)
@DisplayName("관리자와 크리에이터 관리자의 제목 또는 상세 수정은 태그 없이도 커밋 후 번역을 요청한다")
@DisplayName("관리자와 크리에이터 관리자의 제목 또는 상세 수정은 태그 없이도 변경 필드 번역을 저장한다")
fun shouldRequestTranslationAfterCommitWhenMetadataIsUpdatedWithoutTags(asAdmin: Boolean, field: String, tags: String?) {
val owner = saveMember("metadata-update-owner")
val content = saveAudioContent(owner, "before title", "00:10:00")
@@ -269,10 +271,12 @@ class LegacyCreatorAdminAudioContentCharacterizationTest @Autowired constructor(
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)
val scheduled = jobs.findAll().filter {
it.resourceId == content.id && it.resourceType == LanguageTranslationTargetType.CONTENT
}
assertEquals(2, scheduled.size)
assertEquals(setOf(field), scheduled.map { it.fieldKey }.toSet())
assertEquals(setOf("en", "ja"), scheduled.map { it.targetLanguage }.toSet())
}
private fun saveAudioContent(owner: Member, title: String, duration: String): AudioContent {
@@ -77,6 +77,7 @@ class LegacyCreatorAdminSeriesCharacterizationTest @Autowired constructor(
genreRepository = genreRepository,
hashTagRepository = hashTagRepository,
audioContentRepository = audioContentRepository,
entityManager = entityManager,
s3Uploader = S3Uploader(amazonS3Client),
objectMapper = jacksonObjectMapper(),
applicationEventPublisher = eventPublisher,
@@ -0,0 +1,138 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import kr.co.vividnext.sodalive.content.AudioContent
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.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.http.HttpMethod
import java.util.UUID
class AdminTranslationSelectionApplyHttpIntegrationTest : TranslationSelectionApplyHttpTestSupport() {
@Test
@DisplayName("시리즈의 여러 그룹과 개별 제목을 HTTP에서 검토 생성 부분 적용하며 선택 출처와 폐기를 반환한다")
fun shouldCompleteSeriesFlowWithMultipleGroupsAndIndividualTitle() {
val titles = listOf("공통 원문 제목 끝 1", "공통 원문 제목 끝 2", "다른 제목 3", "다른 제목 4", "원문 제목")
val ids = titles.map { title ->
val id = fixture()
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = title }
id
}
val requestId = call(
HttpMethod.POST,
"",
"""{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"SERIES","seriesId":${series(ids)}}}"""
)
.path("data").path("requestId").asLong()
preparation.prepareNext()
val analyzed = call(HttpMethod.GET, "/$requestId/grouping").path("data")
assertFalse(analyzed.path("reviewed").asBoolean())
val review = """{"expectedRevision":1,"groups":[
{"groupId":"g1","memberContentIds":[${ids[0]},${ids[1]}],"sharedParts":[
{"partId":"end","occurrences":[{"contentId":${ids[0]},"startCodePoint":9,"endCodePoint":10},
{"contentId":${ids[1]},"startCodePoint":9,"endCodePoint":10}]},
{"partId":"start","occurrences":[{"contentId":${ids[0]},"startCodePoint":0,"endCodePoint":2},
{"contentId":${ids[1]},"startCodePoint":0,"endCodePoint":2}]}]},
{"groupId":"g2","memberContentIds":[${ids[2]},${ids[3]}],"sharedParts":[
{"partId":"other","occurrences":[{"contentId":${ids[2]},"startCodePoint":0,"endCodePoint":5},
{"contentId":${ids[3]},"startCodePoint":0,"endCodePoint":5}]}]}
],"individualContentIds":[${ids[4]}]}"""
assertTrue(call(HttpMethod.PUT, "/$requestId/grouping", review).path("success").asBoolean())
assertTrue(call(HttpMethod.POST, "/$requestId/generate", """{"expectedRevision":2}""").path("success").asBoolean())
repeat(requests.get(requestId).progress.total + 1) { selectionWorker.runNext() }
val candidates = candidatePage(requestId)
fun candidate(kind: String, owner: String, locale: String): Long = candidates.single {
val unit = it.path("unit")
unit.path("kind").asText() == kind &&
(unit.path("groupId").asText() == owner || unit.path("contentId").asText() == owner) &&
it.path("targetLanguage").asText() == locale && it.path("provider").path("id").asText() == "papago" &&
(kind != "FIELD" || unit.path("field").asText() == "title")
}.path("candidateId").asLong()
val firstResidual = candidates.single {
it.path("unit").path("kind").asText() == "TITLE_RESIDUAL" && it.path("unit").path("contentId").asLong() == ids[0] &&
it.path("targetLanguage").asText() == "en" && it.path("provider").path("id").asText() == "aws"
}.path("candidateId").asLong()
val otherResidual = candidates.single {
it.path("unit").path("kind").asText() == "TITLE_RESIDUAL" && it.path("unit").path("contentId").asLong() == ids[1] &&
it.path("targetLanguage").asText() == "en" && it.path("provider").path("id").asText() == "papago"
}.path("candidateId").asLong()
val body = """{"operationId":"${UUID.randomUUID()}","expectedRevision":3,"selections":[
{"kind":"TITLE_GROUP","groupId":"g1","targetLanguage":"en","commonCandidateId":${candidate("GROUP_COMMON", "g1", "en")},
"residualChoices":[{"contentId":${ids[0]},"candidateId":$firstResidual},{"contentId":${ids[1]},"candidateId":$otherResidual}]},
{"kind":"TITLE_GROUP","groupId":"g2","targetLanguage":"ja","commonCandidateId":${candidate("GROUP_COMMON", "g2", "ja")},
"residualChoices":[{"contentId":${ids[2]},"candidateId":null},{"contentId":${ids[3]},"candidateId":null}]},
{"kind":"FIELD","contentId":${ids[4]},"field":"title","targetLanguage":"en",
"candidateId":${candidate("FIELD", ids[4].toString(), "en")}}
]}"""
val incomplete = body.replace(
""",{"contentId":${ids[3]},"candidateId":null}""",
""
)
assertEquals(
"INCOMPLETE_TITLE_GROUP",
call(HttpMethod.POST, "/$requestId/apply", incomplete).path("errorProperty").asText()
)
assertEquals(0L, overrideRepository.count())
val applied = call(HttpMethod.POST, "/$requestId/apply", body)
assertTrue(applied.path("success").asBoolean(), applied.toString())
val receipt = applied.path("data")
assertEquals(5, receipt.path("appliedFields").size())
assertEquals(
listOf("result:공통 English title result:끝 1", "result:공통 English title result:끝 2"),
ids.take(2).map { payload(it)?.title }
)
assertEquals("English title", payload(ids[4])?.title)
assertEquals(
"result:다른 제목 3",
transaction.execute { translations.findByContentIdAndLocale(ids[2], "ja")?.renderedPayload?.title }
)
assertEquals(null, payload(ids[2]))
val field = receipt.path("appliedFields").single { it.path("contentId").asLong() == ids[0] }
assertEquals(setOf("aws", "papago"), field.path("providers").map { it.path("id").asText() }.toSet())
assertEquals(receipt, call(HttpMethod.GET, "/$requestId").path("data").path("applyReceipt"))
assertEquals(5L, overrideRepository.count())
assertEquals(0L, memories.count())
val summary = call(HttpMethod.GET, "/$requestId").path("data")
assertEquals(candidates.size, summary.path("progress").path("terminal").asInt())
assertEquals(
receipt.path("discardedCandidateCount").asInt(),
candidatePage(requestId).count { it.path("status").asText() == "DISCARDED" }
)
}
@ParameterizedTest
@ValueSource(strings = ["uuid", "kind", "field", "empty", "candidate", "source", "closed", "language", "negative"])
@DisplayName("apply 입력과 선택 불가 후보 오류는 실제 HTTP에서 안정 코드와 번역 메시지를 반환한다")
fun shouldReturnTypedApplyErrors(kind: String) {
val id = fixture()
val requestId = readyContent(id)
val valid = candidatePage(requestId).first { it.path("status").asText() == "SUCCEEDED" }.path("candidateId").asLong()
if (kind == "source") transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title += " " }
if (kind == "closed") call(HttpMethod.POST, "/$requestId/cancel")
val selection = """{"kind":"${if (kind == "kind") "ARBITRARY" else "FIELD"}","contentId":$id,
"field":"${if (kind == "field") "other" else "title"}","targetLanguage":"${if (kind == "language") "fr" else "en"}",
"candidateId":${when (kind) { "candidate" -> Long.MAX_VALUE; "negative" -> -1; else -> valid }}}"""
val body = """{"operationId":"${if (kind == "uuid") "bad" else UUID.randomUUID()}","expectedRevision":2,
"selections":[${if (kind == "empty") "" else selection}]}"""
val error = call(HttpMethod.POST, "/$requestId/apply", body)
assertFalse(error.path("success").asBoolean())
val expected = when (kind) {
"candidate" ->
"CANDIDATE_NOT_SELECTABLE" to
"This translation candidate cannot be selected. Check its request, field and language."
"source" -> "SOURCE_CHANGED" to "The selected source field changed. Create a new translation request."
"closed" -> "REQUEST_CLOSED" to "The translation request is already closed."
else -> "INVALID_REQUEST" to "Invalid request."
}
assertEquals(expected.first, error.path("errorProperty").asText())
assertEquals(expected.second, error.path("message").asText())
assertEquals(0L, overrideRepository.count())
}
}
@@ -0,0 +1,111 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
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.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.http.HttpMethod
import java.util.UUID
class AdminTranslationSelectionContentsHttpIntegrationTest : TranslationSelectionHttpTestSupport() {
@Test
@DisplayName("콘텐츠는 ID cursor 기본 50개 최대 100개와 마지막 null cursor로 조회한다")
fun shouldPageFrozenContents() {
val ids = (1..101).map { fixture() }
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(ids)))
preparation.prepareNext()
val first = call(HttpMethod.GET, "/${created.requestId}/contents").path("data")
assertEquals(ids.take(50), first.path("items").map { it.path("contentId").asLong() })
assertEquals(ids[49], first.path("nextAfterContentId").asLong())
val next = call(HttpMethod.GET, "/${created.requestId}/contents?afterContentId=${ids[49]}&size=100").path("data")
assertEquals(ids.drop(50), next.path("items").map { it.path("contentId").asLong() })
assertTrue(next.path("nextAfterContentId").isNull)
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("동결 원문과 현재 필드 fingerprint 활성 연결 자격을 구분하고 출처 불명을 추정하지 않는다")
fun shouldReturnSnapshotAndCurrentEligibilityWithApprovalProvenance() {
val first = fixture()
val second = fixture()
val third = fixture()
val seriesId = series(listOf(first, second, third))
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(seriesId))
preparation.prepareNext()
translations.saveAndFlush(
ContentTranslation(first, "en", ContentTranslationPayload("Legacy", "Legacy detail", "Legacy tags"))
)
writer.approve(first, "en", listOf(approval(snapshot(first), ContentSourceFieldKey.TITLE, "Chosen title")))
transaction.executeWithoutResult {
writer.lockContent(first)!!.detail = "현재 설명"
writer.lockContent(second)!!.isActive = false
entityManager.createQuery("delete from SeriesContent s where s.series.id = :series and s.content.id = :content")
.setParameter("series", seriesId).setParameter("content", third).executeUpdate()
}
val items = call(HttpMethod.GET, "/${created.requestId}/contents").path("data").path("items")
val item = items[0]
assertEquals("원문 설명", item.path("sourceFields").path("detail").asText())
assertTrue(item.path("eligible").asBoolean())
assertFalse(item.path("sourceFingerprints").path("detail") == item.path("currentSourceFingerprints").path("detail"))
val english = item.path("currentTranslations").first { it.path("targetLanguage").asText() == "en" }
assertEquals("Chosen title", english.path("fields").path("title").asText())
assertEquals("ADMIN", english.path("approvalOrigins").path("title").asText())
assertEquals("UNKNOWN", english.path("approvalOrigins").path("detail").asText())
assertEquals(71, english.path("approvalProvenance").path("title").path("requestId").asLong())
assertEquals(listOf(81L, 82L), english.path("approvalProvenance").path("title").path("candidateIds").map { it.asLong() })
assertFalse(english.path("approvalProvenance").has("detail"))
val japanese = item.path("currentTranslations").first { it.path("targetLanguage").asText() == "ja" }
assertEquals("현재 설명", japanese.path("fields").path("detail").asText())
assertFalse(items[1].path("active").asBoolean())
assertFalse(items[1].path("eligible").asBoolean())
assertTrue(items[2].path("active").asBoolean())
assertFalse(items[2].path("eligible").asBoolean())
assertEquals("원문 제목", items[2].path("currentTranslations")[0].path("fields").path("title").asText())
}
@ParameterizedTest
@ValueSource(strings = ["size=0", "size=101", "size=x", "afterContentId=0"])
@DisplayName("페이지 경계와 형식 오류는 안정 INVALID_REQUEST envelope로 반환한다")
fun shouldRejectInvalidPage(query: String) {
val created = request(fixture())
val result = call(HttpMethod.GET, "/${created.requestId}/contents?$query")
assertFalse(result.path("success").asBoolean())
assertEquals("INVALID_REQUEST", result.path("errorProperty").asText())
}
@Test
@DisplayName("누락 요청과 잘못된 UUID scope ID를 typed business 오류로 반환한다")
fun shouldMapInvalidBoundaryAndMissingResource() {
assertEquals("RESOURCE_NOT_FOUND", call(HttpMethod.GET, "/9223372036854775807").path("errorProperty").asText())
val malformed = """{"clientRequestId":"bad","scope":{"type":"CONTENT","contentId":1}}"""
assertEquals("INVALID_REQUEST", call(HttpMethod.POST, "", malformed).path("errorProperty").asText())
val invalidId = """{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"CONTENT","contentId":-1}}"""
assertEquals("INVALID_REQUEST", call(HttpMethod.POST, "", invalidId).path("errorProperty").asText())
}
@Test
@DisplayName("삭제된 콘텐츠도 빈 필드와 동결 원문은 남고 현재 fingerprint와 자격은 사라진다")
fun shouldPreserveDeletedContentSnapshot() {
val id = fixture()
transaction.executeWithoutResult { writer.lockContent(id)!!.detail = "" }
val created = request(id)
preparation.prepareNext()
transaction.executeWithoutResult { entityManager.remove(writer.lockContent(id)) }
val item = call(HttpMethod.GET, "/${created.requestId}/contents").path("data").path("items")[0]
assertEquals(id, item.path("contentId").asLong())
assertEquals("원문 제목", item.path("sourceFields").path("title").asText())
assertEquals(listOf("detail"), item.path("emptyFields").map { it.asText() })
assertTrue(item.path("currentSourceFingerprints").isNull)
assertFalse(item.path("eligible").asBoolean())
assertFalse(item.path("active").asBoolean())
}
}
@@ -0,0 +1,243 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import com.fasterxml.jackson.databind.JsonNode
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionWorkerService
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
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.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.http.HttpEntity
import org.springframework.http.HttpMethod
import java.util.UUID
class AdminTranslationSelectionHttpIntegrationTest : TranslationSelectionHttpTestSupport() {
@Autowired private lateinit var worker: TranslationSelectionWorkerService
@Test
@DisplayName("실제 HTTP 생성부터 일부 적용까지 진행하고 영수증과 필드 출처를 재조회한다")
fun shouldApplyContentSubsetAndReplayReceiptOverHttp() {
val id = fixture()
val created = call(
HttpMethod.POST,
"",
"""{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"CONTENT","contentId":$id}}"""
).path("data")
val requestId = created.path("requestId").asLong()
preparation.prepareNext()
val generated = call(HttpMethod.POST, "/$requestId/generate", """{"expectedRevision":1}""")
assertTrue(generated.path("success").asBoolean())
repeat(7) { worker.runNext() }
val candidates = call(HttpMethod.GET, "/$requestId/candidates").path("data").path("items")
val title = candidates.single {
it.path("unit").path("field").asText() == "title" && it.path("targetLanguage").asText() == "en"
}
val detail = candidates.single {
it.path("unit").path("field").asText() == "detail" && it.path("targetLanguage").asText() == "en"
}
val body = """{"operationId":"${UUID.randomUUID()}","expectedRevision":2,"selections":[
{"kind":"FIELD","contentId":$id,"field":"title","targetLanguage":"en","candidateId":${title.path("candidateId")}},
{"kind":"FIELD","contentId":$id,"field":"detail","targetLanguage":"en","candidateId":${detail.path("candidateId")}}
]}"""
val applyingAdmin = actor()
val callsBeforeApply = provider.calls.get()
val applied = callAs(applyingAdmin, HttpMethod.POST, "/$requestId/apply", body)
assertTrue(applied.path("success").asBoolean(), applied.toString())
val receipt = applied.path("data")
assertEquals("APPLIED", receipt.path("status").asText())
assertEquals(2, receipt.path("appliedFields").size())
assertEquals(4, receipt.path("discardedCandidateCount").asInt())
assertEquals("English title", payload(id)?.title)
assertEquals("English detail", payload(id)?.detail)
assertEquals("#힐링", payload(id)?.tags)
assertEquals(receipt, call(HttpMethod.GET, "/$requestId").path("data").path("applyReceipt"))
assertEquals(applied, call(HttpMethod.POST, "/$requestId/apply", body))
val current = call(HttpMethod.GET, "/$requestId/contents").path("data").path("items")[0]
.path("currentTranslations").single { it.path("targetLanguage").asText() == "en" }
assertEquals("ADMIN", current.path("approvalOrigins").path("title").asText())
assertEquals(requestId, current.path("approvalProvenance").path("detail").path("requestId").asLong())
assertEquals(applyingAdmin, current.path("approvalProvenance").path("detail").path("approvedBy").asLong())
assertEquals("REQUEST_CLOSED", call(HttpMethod.POST, "/$requestId/cancel").path("errorProperty").asText())
assertEquals(callsBeforeApply, provider.calls.get())
}
@ParameterizedTest
@ValueSource(strings = ["CONTENT_MANAGER", "CREATOR", "USER"])
@DisplayName("생성 조회 콘텐츠 그룹 검토 취소 모두 ADMIN 이외 역할을 거부한다")
fun shouldRequireAdminRole(role: String) {
val created = request(fixture())
val actor = actor(MemberRole.valueOf(role))
val operations = listOf(
HttpMethod.POST to "",
HttpMethod.GET to "/${created.requestId}",
HttpMethod.GET to "/${created.requestId}/contents",
HttpMethod.GET to "/${created.requestId}/grouping",
HttpMethod.PUT to "/${created.requestId}/grouping",
HttpMethod.POST to "/${created.requestId}/cancel",
HttpMethod.POST to "/${created.requestId}/generate",
HttpMethod.GET to "/${created.requestId}/candidates",
HttpMethod.POST to "/${created.requestId}/apply"
)
operations.forEach { (method, path) ->
val body = when (path) {
"" -> """{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"CONTENT","contentId":1}}"""
"/${created.requestId}/grouping" -> """{"expectedRevision":1,"groups":[],"individualContentIds":[]}"""
"/${created.requestId}/generate" -> """{"expectedRevision":1}"""
"/${created.requestId}/apply" -> """{"operationId":"${UUID.randomUUID()}","expectedRevision":1,"selections":[]}"""
else -> null
}
assertFalse(callAs(actor, method, path, body).path("success").booleanValue())
}
assertEquals("PREPARING", requests.get(created.requestId).status.name)
assertEquals(1L, requestRepository.count())
}
@Test
@DisplayName("상태 조회는 준비를 실행하지 않으며 PREPARING 콘텐츠는 비어 있다")
fun shouldReadWithoutHiddenPreparation() {
val created = request(fixture(null))
assertEquals("PREPARING", call(HttpMethod.GET, "/${created.requestId}").path("data").path("status").asText())
assertEquals(0, call(HttpMethod.GET, "/${created.requestId}/contents").path("data").path("items").size())
assertEquals("REQUEST_NOT_READY", call(HttpMethod.GET, "/${created.requestId}/grouping").path("errorProperty").asText())
assertEquals(emptyList<String>(), provider.detectionQueries)
}
@Test
@DisplayName("분석 결과의 code point template와 valueIndex는 원문 구문 전체를 보존한다")
fun shouldReturnAnalyzedGroupingAndAcceptRevision() {
val first = fixture()
val second = fixture()
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, first).title = "공통 제목 - 비 오는 날"
entityManager.find(AudioContent::class.java, second).title = "공통 제목 - 새로운 밤"
}
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(listOf(first, second))))
preparation.prepareNext()
val proposed = call(HttpMethod.GET, "/${created.requestId}/grouping").path("data")
assertEquals("UNICODE_CODE_POINT", proposed.path("indexUnit").asText())
assertFalse(proposed.path("reviewed").asBoolean())
assertEquals(1, proposed.path("groups").size())
val segments = proposed.path("templates")[0].path("segments")
assertEquals("공통 제목 - 비 오는 날", segments.joinToString("") { it.path("sourceText").asText() })
assertEquals(
listOf("비 오는 날"),
segments.filter { it.path("kind").asText() == "RESIDUAL" }.map { it.path("sourceText").asText() }
)
assertEquals(0, segments.first { it.path("kind").asText() == "SHARED" }.path("valueIndex").asInt())
assertFalse(proposed.path("templates")[0].has("residualInputs"))
val review = """{
"expectedRevision":1,
"groups":[{"groupId":"g","memberContentIds":[$first,$second],"sharedParts":[{"partId":"p","occurrences":[
{"contentId":$first,"startCodePoint":0,"endCodePoint":5},
{"contentId":$second,"startCodePoint":0,"endCodePoint":5}
]}]}],"individualContentIds":[]
}"""
val accepted = call(HttpMethod.PUT, "/${created.requestId}/grouping", review).path("data")
assertEquals(2, accepted.path("revision").asLong())
assertTrue(accepted.path("reviewed").asBoolean())
assertEquals("공통 제목", accepted.path("groups")[0].path("sharedParts")[0].path("sourceText").asText())
assertEquals(
"REVISION_CONFLICT",
call(HttpMethod.PUT, "/${created.requestId}/grouping", review).path("errorProperty").asText()
)
assertEquals("READY_TO_GENERATE", requests.get(created.requestId).status.name)
}
@ParameterizedTest
@ValueSource(strings = ["missing", "duplicate", "different", "grapheme", "language"])
@DisplayName("누락 중복 다른 공유 원문 grapheme 분할 언어 혼합 검토는 거부한다")
fun shouldRejectInvalidCompleteGrouping(kind: String) {
val first = fixture()
val second = fixture(if (kind == "language") "en" else "ko")
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, first).title = "가\u0301 제목"
entityManager.find(AudioContent::class.java, second).title = "나\u0301 제목"
}
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(listOf(first, second))))
preparation.prepareNext()
val body = when (kind) {
"missing" -> """{"expectedRevision":1,"groups":[],"individualContentIds":[$first]}"""
"duplicate" -> """{"expectedRevision":1,"groups":[],"individualContentIds":[$first,$first,$second]}"""
else -> {
val start = if (kind == "language") 3 else 0
val end = if (kind == "language") 5 else if (kind == "grapheme") 1 else 2
"""{
"expectedRevision":1,
"groups":[{"groupId":"g","memberContentIds":[$first,$second],"sharedParts":[{"partId":"p","occurrences":[
{"contentId":$first,"startCodePoint":$start,"endCodePoint":$end},
{"contentId":$second,"startCodePoint":$start,"endCodePoint":$end}
]}]}],"individualContentIds":[]
}"""
}
}
assertEquals(
"INVALID_GROUPING",
call(HttpMethod.PUT, "/${created.requestId}/grouping", body).path("errorProperty").asText()
)
assertEquals(1, requests.get(created.requestId).revision)
assertEquals("REVIEW_REQUIRED", requests.get(created.requestId).status.name)
}
@Test
@DisplayName("모두 개별인 분석도 관리자 확정과 revision 증가가 필요하며 생성 뒤 편집은 거부한다")
fun shouldAcceptAllIndividualReview() {
val id = fixture()
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(listOf(id))))
preparation.prepareNext()
assertEquals("REVIEW_REQUIRED", requests.get(created.requestId).status.name)
val body = """{"expectedRevision":1,"groups":[],"individualContentIds":[$id]}"""
assertEquals(2, call(HttpMethod.PUT, "/${created.requestId}/grouping", body).path("data").path("revision").asLong())
val edited = body.replace("\"expectedRevision\":1", "\"expectedRevision\":2")
assertEquals(3, call(HttpMethod.PUT, "/${created.requestId}/grouping", edited).path("data").path("revision").asLong())
transaction.executeWithoutResult {
requestStore.save(requestStore.lock(created.requestId)!!.copy(status = TranslationSelectionStatus.GENERATING))
}
assertEquals(
"REQUEST_NOT_READY",
call(HttpMethod.PUT, "/${created.requestId}/grouping", edited).path("errorProperty").asText()
)
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("취소는 revision 없이 즉시 확정하고 같은 취소는 같은 terminal 결과를 반환한다")
fun shouldCancelAndReplayWithoutRevision() {
val created = request(fixture())
val first = call(HttpMethod.POST, "/${created.requestId}/cancel")
assertEquals("CANCELLED", first.path("data").path("status").asText())
assertEquals(first, call(HttpMethod.POST, "/${created.requestId}/cancel"))
val body = """{"expectedRevision":1,"groups":[],"individualContentIds":[]}"""
assertEquals(
"REQUEST_CLOSED",
call(HttpMethod.PUT, "/${created.requestId}/grouping", body).path("errorProperty").asText()
)
}
@Test
@DisplayName("generate endpoint는 검토 전 시리즈를 REVIEW_REQUIRED로 거부하고 후보를 호출하지 않는다")
fun shouldRequireReviewBeforeGeneration() {
val id = fixture()
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(listOf(id))))
preparation.prepareNext()
val response = http.exchange(
"$BASE/${created.requestId}/generate",
HttpMethod.POST,
HttpEntity("""{"expectedRevision":1}""", headers(actor())),
JsonNode::class.java
)
assertEquals(200, response.statusCodeValue)
assertFalse(response.body!!.path("success").asBoolean())
assertEquals("REVIEW_REQUIRED", response.body!!.path("errorProperty").asText())
assertEquals("REVIEW_REQUIRED", requests.get(created.requestId).status.name)
assertEquals(0, provider.calls.get())
}
}
@@ -0,0 +1,71 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationSourceService
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionApplyService
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ApplyTranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionChoice
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionField
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.http.HttpMethod
import java.time.Instant
import java.time.LocalDateTime
import java.util.UUID
class AdminTranslationSelectionReceiptHttpIntegrationTest : TranslationSelectionApplyHttpTestSupport() {
@Autowired private lateinit var candidates: TranslationCandidateStore
@Autowired private lateinit var sources: ContentTranslationSourceService
@ParameterizedTest
@ValueSource(ints = [0, 123456789, 999999999])
@DisplayName("단일 승인 시각은 나노초 날짜 경계에서 모든 override와 receipt DB 왕복 HTTP에 정확히 일치한다")
fun shouldPersistAndReplayExactSecondPrecisionReceipt(nano: Int) {
val id = fixture()
val requestId = readyContent(id)
val candidate = candidatePage(requestId).single {
it.path("unit").path("field").asText() == "title" && it.path("provider").path("id").asText() == "papago" &&
it.path("targetLanguage").asText() == "en"
}.path("candidateId").asLong()
val fixed = LocalDateTime.of(2026, 11, 17, 23, 59, 59, nano)
val service = TranslationSelectionApplyService(requestStore, candidates, sources, writer) { fixed }
val body = ApplyTranslationSelectionRequest(
UUID.randomUUID(),
2,
listOf(TranslationSelectionChoice.Field(id, TranslationSelectionField.TITLE, "en", candidate))
)
val receipt = transaction.execute {
val result = service.apply(requestId, 777, body)
entityManager.flush()
entityManager.clear()
assertEquals(result, requestStore.find(requestId)?.applyReceipt)
result
}!!
assertEquals(Instant.parse("2026-11-17T23:59:59Z"), receipt.appliedAt)
assertEquals(
LocalDateTime.of(2026, 11, 17, 23, 59, 59),
transaction.execute { overrides.findByContentId(id).single().approvedAt }
)
assertEquals(
LocalDateTime.of(2026, 11, 17, 23, 59, 59),
transaction.execute { requestRepository.findById(requestId).orElseThrow().appliedAt }
)
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = "원본은 이후 변경" }
val summary = call(HttpMethod.GET, "/$requestId").path("data").path("applyReceipt")
assertEquals("2026-11-17T23:59:59Z", summary.path("appliedAt").asText())
val replay = call(
HttpMethod.POST,
"/$requestId/apply",
"""{"operationId":"${body.operationId}","expectedRevision":2,
"selections":[{"kind":"FIELD","contentId":$id,"field":"title","targetLanguage":"en","candidateId":$candidate}]}"""
)
assertEquals(summary, replay.path("data"))
}
}
@@ -0,0 +1,50 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.scheduler.TranslationSelectionWorker
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.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationContext
import org.springframework.http.HttpMethod
import java.util.UUID
class TranslationSelectionActivationHttpIntegrationTest : TranslationSelectionHttpTestSupport() {
@Autowired private lateinit var context: ApplicationContext
@Test
@DisplayName("별도 활성화 설정 없이 ADMIN은 실제 HTTP로 생성·조회하고 일반 사용자는 거부한다")
fun shouldCreateAndReadAdminRequestWithoutActivationProperty() {
val id = fixture(null)
val body = """{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"CONTENT","contentId":$id}}"""
val created = call(HttpMethod.POST, "", body)
assertTrue(created.path("success").asBoolean())
val data = created.path("data")
assertEquals("PREPARING", data.path("status").asText())
val requestId = data.path("requestId").asLong()
assertEquals(data, call(HttpMethod.GET, "/$requestId").path("data"))
val user = actor(MemberRole.USER)
assertFalse(callAs(user, HttpMethod.POST, "", body).path("success").asBoolean())
assertFalse(callAs(user, HttpMethod.GET, "/$requestId", null).path("success").asBoolean())
assertEquals(1L, requestRepository.count())
assertEquals("PREPARING", requests.get(requestId).status.name)
assertEquals(emptyList<String>(), provider.detectionQueries)
assertEquals(0, provider.calls.get())
assertNull(context.environment.getProperty("sodalive.translation-selection.enabled"))
}
@Test
@DisplayName("별도 활성화 설정 없이 실제 후보 worker bean을 등록한다")
fun shouldRegisterWorkerWithoutActivationProperty() {
assertEquals(
1,
context.getBeansOfType(TranslationSelectionWorker::class.java).size
)
assertNull(context.environment.getProperty("sodalive.translation-selection.enabled"))
}
}
@@ -0,0 +1,37 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import com.fasterxml.jackson.databind.JsonNode
import kr.co.vividnext.sodalive.v2.contenttranslation.application.SelectionCandidateProviderConfiguration
import kr.co.vividnext.sodalive.v2.contenttranslation.application.SelectionPapagoProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionWorkerService
import org.junit.jupiter.api.BeforeEach
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Import
import org.springframework.http.HttpMethod
import java.util.UUID
@Import(SelectionCandidateProviderConfiguration::class)
abstract class TranslationSelectionApplyHttpTestSupport : TranslationSelectionHttpTestSupport() {
@Autowired protected lateinit var selectionWorker: TranslationSelectionWorkerService
@Autowired protected lateinit var papago: SelectionPapagoProvider
@BeforeEach
fun resetApplyHttpProvider() { papago.reset() }
protected fun readyContent(id: Long): Long {
val result = call(
HttpMethod.POST,
"",
"""{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"CONTENT","contentId":$id}}"""
)
val requestId = result.path("data").path("requestId").asLong()
preparation.prepareNext()
call(HttpMethod.POST, "/$requestId/generate", """{"expectedRevision":1}""")
repeat(requests.get(requestId).progress.total + 1) { selectionWorker.runNext() }
return requestId
}
protected fun candidatePage(requestId: Long): List<JsonNode> =
call(HttpMethod.GET, "/$requestId/candidates?size=100").path("data").path("items").toList()
}
@@ -0,0 +1,46 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web
import com.fasterxml.jackson.databind.JsonNode
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionTestConfiguration
import kr.co.vividnext.sodalive.v2.contenttranslation.application.TranslationSelectionTestSupport
import org.junit.jupiter.api.Assertions.assertEquals
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
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.http.MediaType
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
classes = [TranslationSelectionTestConfiguration::class],
properties = ["spring.cache.type=none"]
)
abstract class TranslationSelectionHttpTestSupport : TranslationSelectionTestSupport() {
@Autowired protected lateinit var http: TestRestTemplate
protected fun actor(role: MemberRole = MemberRole.ADMIN): Long = transaction.execute {
val member = Member(password = "test", nickname = "selection-http").apply { this.role = role }
entityManager.persist(member)
requireNotNull(member.id)
}!!
protected fun headers(actorId: Long) = HttpHeaders().apply {
contentType = MediaType.APPLICATION_JSON
set("X-Test-Member", actorId.toString())
}
protected fun call(method: HttpMethod, path: String, body: String? = null): JsonNode =
callAs(actor(), method, path, body)
protected fun callAs(actorId: Long, method: HttpMethod, path: String, body: String?): JsonNode {
val result = http.exchange(BASE + path, method, HttpEntity(body, headers(actorId)), JsonNode::class.java)
assertEquals(200, result.statusCodeValue)
return requireNotNull(result.body)
}
companion object { const val BASE = "/admin/audio-content/translation-requests" }
}
@@ -0,0 +1,133 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.admin.content.AdminContentService
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentService
import kr.co.vividnext.sodalive.creator.admin.content.CreatorAdminContentService
import kr.co.vividnext.sodalive.creator.admin.content.series.CreatorAdminContentSeriesService
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.creator.admin.content.series.content.AddingContentToTheSeriesRequest
import kr.co.vividnext.sodalive.creator.admin.content.series.content.RemoveContentToTheSeriesRequest
import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService
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.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.context.annotation.Import
import java.time.LocalDateTime
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.persistence.LockModeType
@Import(AdminContentService::class, CreatorAdminContentService::class, CreatorAdminContentSeriesService::class)
class ContentTranslationMembershipIntegrationTest : ContentTranslationTestSupport() {
@Autowired private lateinit var ownerService: AudioContentService
@Autowired private lateinit var adminService: AdminContentService
@Autowired private lateinit var creatorService: CreatorAdminContentService
@Autowired private lateinit var seriesService: CreatorAdminContentSeriesService
@Autowired private lateinit var subtitles: SubtitleJobService
@ParameterizedTest
@ValueSource(strings = ["delete", "admin", "creator", "upload", "publish"])
@DisplayName("활성 상태 변경 경로는 부모 잠금을 공유하면서 원문이 같은 승인 필드를 유지한다")
fun shouldKeepApprovalsAcrossActivityChanges(entry: String) {
val id = fixture()
approveAll(id)
val creator = transaction.execute {
val content = entityManager.find(AudioContent::class.java, id)
if (entry == "upload" || entry == "publish") content.isActive = false
content.releaseDate = LocalDateTime.of(2000, 1, 1, 0, 0)
content.member
}!!
Mockito.`when`(subtitles.matchesOutput(id, "$id.mp3")).thenReturn(true)
when (entry) {
"delete" -> ownerService.deleteAudioContent(id, creator)
"admin" -> adminService.updateAudioContent(null, """{"id":$id,"isActive":false,"isDefaultCoverImage":false}""")
"creator" -> creatorService.updateAudioContent(null, """{"id":$id,"isActive":false}""", creator)
"upload" -> ownerService.uploadComplete(id, "$id.mp3", "00:01:00")
"publish" -> ownerService.releaseContent()
}
assertEquals(
entry == "upload" || entry == "publish",
transaction.execute { entityManager.find(AudioContent::class.java, id).isActive }
)
assertEquals(3L, overrideRepository.count())
assertEquals("Approved title", payload(id)?.title)
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("시리즈 잠금 뒤 최신 연관 목록을 다시 읽어 추가와 제거를 직렬화한다")
fun shouldRefreshMembershipUnderSeriesParentLock() {
val id = fixture()
val seriesId = transaction.execute {
val content = entityManager.find(AudioContent::class.java, id)
val genre = SeriesGenre("approval-genre")
entityManager.persist(genre)
val series = Series("approval-series", "intro", "ko").apply {
member = content.member
this.genre = genre
}
entityManager.persist(series)
requireNotNull(series.id)
}!!
val ownerId = transaction.execute { requireNotNull(entityManager.find(AudioContent::class.java, id).member?.id) }!!
transaction.executeWithoutResult {
val stale = entityManager.find(Series::class.java, seriesId)
assertEquals(0, stale.contentList.size)
transaction.executeWithoutResult {
seriesService.addingContentToTheSeries(AddingContentToTheSeriesRequest(seriesId, listOf(id)), ownerId)
}
seriesService.removeContentInTheSeries(RemoveContentToTheSeriesRequest(seriesId, id), ownerId)
}
assertEquals(0, transaction.execute { entityManager.find(Series::class.java, seriesId).contentList.size })
}
@Test
@DisplayName("명시적으로 잡은 콘텐츠 부모 잠금과 활성 변경이 경쟁해도 변경은 잠금 해제 뒤 반영된다")
fun shouldSerializeActivityMutationWithContentParentLock() {
val id = fixture()
val creator = transaction.execute { entityManager.find(AudioContent::class.java, id).member }!!
val locked = CountDownLatch(1)
val started = CountDownLatch(1)
val release = CountDownLatch(1)
val executor = Executors.newFixedThreadPool(2)
try {
val holder = executor.submit {
transaction.executeWithoutResult {
val content = writer.lockContent(id)!!
assertEquals(LockModeType.PESSIMISTIC_WRITE, entityManager.getLockMode(content))
locked.countDown()
check(release.await(5, TimeUnit.SECONDS))
}
}
assertTrue(locked.await(5, TimeUnit.SECONDS))
val mutation = executor.submit {
started.countDown()
ownerService.deleteAudioContent(id, creator)
}
assertTrue(started.await(5, TimeUnit.SECONDS))
release.countDown()
holder.get(10, TimeUnit.SECONDS)
mutation.get(10, TimeUnit.SECONDS)
} finally {
release.countDown()
executor.shutdownNow()
}
assertEquals(false, transaction.execute { entityManager.find(AudioContent::class.java, id).isActive })
}
}
@@ -0,0 +1,183 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaContentTranslationOverrideStore
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
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.assertThrows
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.ValueSource
import org.mockito.Mockito
import org.springframework.boot.test.mock.mockito.SpyBean
import java.time.LocalDateTime
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.persistence.LockModeType
class ContentTranslationOverrideIntegrationTest : ContentTranslationTestSupport() {
@SpyBean private lateinit var overrideReads: JpaContentTranslationOverrideStore
@Test
@DisplayName("잠금 전 영속성 문맥에 남은 원문으로 자동 번역 결과를 쓰지 않는다")
fun shouldRejectAutomaticResultWithStaleSource() {
val id = fixture()
cache(snapshot(id))
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, id).toContentSourceSnapshot()
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = "현재 제목" }
assertFalse(materializer.materialize(LanguageTranslationTargetType.CONTENT, id, "en"))
}
assertNull(payload(id))
}
@Test
@DisplayName("현재 승인은 같은 원문의 자동 번역 재실행보다 우선한다")
fun shouldProtectCurrentApprovalFromAutomaticWrite() {
val id = fixture()
cache(snapshot(id))
writer.approve(id, "en", listOf(approval(snapshot(id), ContentSourceFieldKey.TITLE)))
assertTrue(materializer.materialize(LanguageTranslationTargetType.CONTENT, id, "en"))
assertEquals(ContentTranslationPayload("Approved title", "Automatic detail", "Automatic tags"), payload(id))
}
@Test
@DisplayName("전역 메모리가 전혀 없어도 승인된 세 필드를 재료화한다")
fun shouldMaterializeApprovedFieldsWithoutSharedMemory() {
val id = fixture()
approveAll(id)
translations.deleteAllInBatch()
assertTrue(materializer.materialize(LanguageTranslationTargetType.CONTENT, id, "en"))
assertEquals(ContentTranslationPayload("Approved title", "Approved detail", "Approved tags"), payload(id))
assertEquals(0L, memories.count())
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("일부 필드 승인 시 선택하지 않은 기존 문자열의 모든 바이트를 유지한다")
fun shouldKeepUnselectedFieldsByteForByte() {
val id = fixture()
translations.saveAndFlush(ContentTranslation(id, "en", ContentTranslationPayload("Old", " \tDetail\n", "#A, #B ")))
writer.approve(id, "en", listOf(approval(snapshot(id), ContentSourceFieldKey.TITLE)))
assertEquals(ContentTranslationPayload("Approved title", " \tDetail\n", "#A, #B "), payload(id))
assertEquals(1L, overrideRepository.count())
}
@ParameterizedTest
@ValueSource(ints = [0, 123456789, 999999999])
@DisplayName("승인 출처와 UTC 초 시각은 날짜 경계에서도 flush clear 왕복 후 정확히 같다")
fun shouldPersistApprovalProvenance(nano: Int) {
val id = fixture()
val fixed = LocalDateTime.of(2026, 11, 17, 23, 59, 59, nano)
val timedWriter = ContentTranslationWriteService(entityManager, translations, overrides, coordinator) { fixed }
val source = snapshot(id)
val result = transaction.execute {
val saved = timedWriter.approve(id, "en", listOf(approval(source, ContentSourceFieldKey.TITLE)))
entityManager.flush()
entityManager.clear()
saved
}!!
val persisted = transaction.execute { overrides.findByContentId(id).single() }!!
assertEquals(LocalDateTime.of(2026, 11, 17, 23, 59, 59), result.single().approvedAt)
assertEquals(result.single(), persisted)
assertEquals(provenance, persisted.approval.provenance)
}
@Test
@DisplayName("선택한 필드가 달라진 승인은 아무 값도 쓰지 않는다")
fun shouldRejectApprovalForChangedSelectedSource() {
val id = fixture()
val old = snapshot(id)
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = "현재 제목" }
val error = assertThrows(SodaException::class.java) {
writer.approve(id, "en", listOf(approval(old, ContentSourceFieldKey.TITLE)))
}
assertEquals("SOURCE_CHANGED", error.errorProperty)
assertNull(payload(id))
assertEquals(0L, overrideRepository.count())
}
@Test
@DisplayName("후속 그룹 적용용 외부 트랜잭션에서 한 승인이 실패하면 앞선 승인도 함께 롤백한다")
fun shouldParticipateInOuterTransactionAcrossContents() {
val first = fixture()
val second = fixture()
val source = snapshot(first)
assertThrows(SodaException::class.java) {
transaction.executeWithoutResult {
writer.approve(first, "en", listOf(approval(source, ContentSourceFieldKey.TITLE)))
writer.approve(
second,
"en",
listOf(approval(source, ContentSourceFieldKey.TITLE).copy(sourceFingerprint = "stale"))
)
}
}
assertNull(payload(first))
assertEquals(0L, overrideRepository.count())
}
@Test
@DisplayName("부모 잠금 안에서 승인 중인 값은 대기한 자동 writer에 의해 덮어써지지 않는다")
fun shouldSerializeApprovalAndAutomaticWriter() {
val id = fixture()
cache(snapshot(id))
Mockito.doAnswer {
assertEquals(
LockModeType.PESSIMISTIC_WRITE,
entityManager.getLockMode(entityManager.find(AudioContent::class.java, id))
)
it.callRealMethod()
}.`when`(overrideReads).findByContentId(id)
val locked = CountDownLatch(1)
val automaticStarted = CountDownLatch(1)
val releaseApproval = CountDownLatch(1)
val executor = Executors.newFixedThreadPool(2)
try {
val approval = executor.submit {
transaction.executeWithoutResult {
writer.lockContent(id)
writer.approve(id, "en", listOf(approval(snapshot(id), ContentSourceFieldKey.TITLE)))
locked.countDown()
check(releaseApproval.await(5, TimeUnit.SECONDS))
}
}
assertTrue(locked.await(5, TimeUnit.SECONDS))
val automatic = executor.submit<Boolean> {
automaticStarted.countDown()
materializer.materialize(LanguageTranslationTargetType.CONTENT, id, "en")
}
assertTrue(automaticStarted.await(5, TimeUnit.SECONDS))
releaseApproval.countDown()
approval.get(10, TimeUnit.SECONDS)
assertTrue(automatic.get(10, TimeUnit.SECONDS))
} finally {
releaseApproval.countDown()
executor.shutdownNow()
}
assertEquals("Approved title", payload(id)?.title)
}
}
@@ -0,0 +1,211 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobWorker
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemory
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryService
import kr.co.vividnext.sodalive.i18n.translation.TranslationReadModelMaterializer
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.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.AdditionalAnswers
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.SpyBean
import org.springframework.data.jpa.repository.Query
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.support.TransactionSynchronizationManager
import java.time.LocalDateTime
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
class ContentTranslationQueueIntegrationTest : ContentTranslationTestSupport() {
@Autowired private lateinit var worker: TranslationJobWorker
@SpyBean private lateinit var claims: TranslationJobRepository
@Autowired private lateinit var memoryService: TranslationMemoryService
@Autowired private lateinit var transactionManager: PlatformTransactionManager
@Autowired private lateinit var invalidation: ContentTranslationSourceInvalidationService
@BeforeEach
fun useH2ClaimSyntax() {
val sql = TranslationJobRepository::class.java.getMethod("findNextPendingGroupJobIdsForUpdate", LocalDateTime::class.java)
.getAnnotation(Query::class.java).value.replace("skip locked", "")
Mockito.doAnswer { call ->
entityManager.createNativeQuery(sql).setParameter("now", call.getArgument<LocalDateTime>(0))
.resultList.map { (it as Number).toLong() }
}.`when`(claims).findNextPendingGroupJobIdsForUpdate(Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now())
}
@Test
@DisplayName("설정 없이 같은 원문 hash와 필드도 원문 언어마다 별도 작업으로 저장한다")
fun shouldDistinguishJobsBySourceLanguage() {
enqueue(10L, "ko")
enqueue(10L, "ja")
assertEquals(setOf("ko", "ja"), jobs.findAll().map { it.sourceLanguage }.toSet())
assertEquals(2L, jobs.count())
transaction.executeWithoutResult {
val ids = claims.findNextPendingGroupJobIdsForUpdate(LocalDateTime.now())
assertEquals(1, ids.size)
}
}
@Test
@DisplayName("같은 원문 언어의 반복 요청은 기존 작업 하나를 유지한다")
fun shouldDeduplicateSameSourceLanguage() {
repeat(2) { enqueue(10L, "ko") }
assertEquals(listOf("ko"), jobs.findAll().map { it.sourceLanguage })
assertEquals(1L, jobs.count())
}
@Test
@DisplayName("같은 hash의 다른 언어 작업은 보존하고 exact 언어 작업만 재개한다")
fun shouldRestartOnlyExactLanguageJob() {
enqueue(10L, "ko")
enqueue(10L, "ja")
jobs.findAll().forEach { jobs.saveAndFlush(it.apply { status = TranslationJobStatus.FAILED }) }
enqueue(10L, "ja")
assertEquals(TranslationJobStatus.FAILED, jobs.findAll().single { it.sourceLanguage == "ko" }.status)
assertEquals(TranslationJobStatus.PENDING, jobs.findAll().single { it.sourceLanguage == "ja" }.status)
assertEquals(2L, jobs.count())
}
@Test
@DisplayName("materialize false는 완료가 아니라 기존 재시도 정책으로 돌아간다")
fun shouldNotCompleteJobWhenMaterializationReturnsFalse() {
val id = fixture()
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash("원문 제목"), "원문 제목", "ko", "en", "Cached title", "aws", "test")
)
enqueue(id, "ko")
assertTrue(worker.processNextGroup())
val job = jobs.findAll().single()
assertEquals(TranslationJobStatus.PENDING, job.status)
assertEquals(1, job.retryCount)
assertEquals("translation materialization is incomplete", job.lastErrorMessage)
assertNull(payload(id))
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("승인된 필드의 자동 작업이 재실행돼도 공급자나 전역 메모리가 필요하지 않다")
fun shouldSkipProviderForCurrentApprovedField() {
val id = fixture()
approveAll(id)
provider.fail = true
enqueue(id, "ko")
assertTrue(worker.processNextGroup())
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single().status)
assertEquals("Approved title", payload(id)?.title)
assertEquals(0L, memories.count())
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("재료화와 완료 사이 같은 정규화 hash의 원문이 바뀌어도 refresh 작업을 잃지 않는다")
fun shouldKeepRefreshWhenRawSourceChangesDuringWorkerCompletion() {
val id = fixture()
listOf("원문 설명" to "Cached detail", "#힐링" to "#Cached").forEach { (source, translated) ->
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash(source), source, "ko", "en", translated, "aws", "test")
)
}
enqueue(id, "ko")
val originalJobId = jobs.findAll().single().id
val materialized = CountDownLatch(1)
val mutationStarted = CountDownLatch(1)
val mutationCommitted = CountDownLatch(1)
val pausedMaterializer = Mockito.mock(
TranslationReadModelMaterializer::class.java,
AdditionalAnswers.delegatesTo<TranslationReadModelMaterializer>(materializer)
)
Mockito.doAnswer {
val result = materializer.materializeContentFields(id, "en", setOf("title"))
materialized.countDown()
if (TransactionSynchronizationManager.isActualTransactionActive()) {
check(mutationStarted.await(10, TimeUnit.SECONDS))
} else {
check(mutationCommitted.await(10, TimeUnit.SECONDS))
}
result
}.`when`(pausedMaterializer).materializeContentFields(id, "en", setOf("title"))
val completingWorker = TranslationJobWorker(jobs, memoryService, pausedMaterializer, transactionManager)
provider.beforeTranslate = { assertFalse(TransactionSynchronizationManager.isActualTransactionActive()) }
val executor = Executors.newFixedThreadPool(2)
try {
val completion = executor.submit<Boolean> { completingWorker.processNextGroup() }
assertTrue(materialized.await(10, TimeUnit.SECONDS))
val mutation = executor.submit {
mutationStarted.countDown()
transaction.executeWithoutResult {
val content = requireNotNull(writer.lockContent(id))
val before = content.toContentSourceSnapshot()
content.title = "원문 제목 "
invalidation.invalidateChanged(content, before)
}
mutationCommitted.countDown()
}
assertTrue(completion.get(15, TimeUnit.SECONDS))
mutation.get(15, TimeUnit.SECONDS)
} finally {
mutationStarted.countDown()
mutationCommitted.countDown()
executor.shutdownNow()
assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS))
}
val refreshed = jobs.findAll().single { it.targetLanguage == "en" }
assertEquals(originalJobId, refreshed.id)
assertEquals(SourceTextNormalizer.hash("원문 제목"), refreshed.sourceHash)
assertEquals(TranslationJobStatus.PENDING, refreshed.status)
assertEquals("원문 제목 ", payload(id)?.title)
assertTrue(worker.processNextGroup())
assertEquals("English title", payload(id)?.title)
assertEquals(TranslationJobStatus.COMPLETED, jobs.findById(requireNotNull(originalJobId)).orElseThrow().status)
assertEquals(1, provider.calls.get())
}
@Test
@DisplayName("비 CONTENT 리소스도 언어 identity만 바뀌고 완료 작업 정책은 유지한다")
fun shouldPreserveOtherResourceCompletedPolicy() {
enqueue(10L, "ko", LanguageTranslationTargetType.CHARACTER)
jobs.saveAndFlush(jobs.findAll().single().apply { status = TranslationJobStatus.COMPLETED })
enqueue(10L, "ko", LanguageTranslationTargetType.CHARACTER)
enqueue(10L, "ja", LanguageTranslationTargetType.CHARACTER)
assertEquals(2L, jobs.count())
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single { it.sourceLanguage == "ko" }.status)
}
private fun enqueue(
id: Long,
language: String,
type: LanguageTranslationTargetType = LanguageTranslationTargetType.CONTENT
) {
transaction.executeWithoutResult {
TranslationJobScheduler(jobs, coordinator, translations, entityManager)
.scheduleMissingTranslation(type, id, "title", "원문 제목", language, "en")
}
}
}
@@ -0,0 +1,156 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
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 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.EnumSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.SpyBean
import java.time.LocalDateTime
class ContentTranslationRefreshIntegrationTest : ContentTranslationTestSupport() {
@Autowired private lateinit var invalidation: ContentTranslationSourceInvalidationService
@SpyBean private lateinit var reads: TranslationJobRepository
private val hash = SourceTextNormalizer.hash("원문 제목")
private val previousRetryAt = LocalDateTime.of(2040, 1, 1, 0, 0)
@Test
@DisplayName("managed RUNNING 뒤 다른 트랜잭션이 완료한 작업도 현재 상태로 refresh한다")
fun shouldRefreshCompletedJobDespiteStaleManagedRunningState() {
val contentId = fixture()
val jobId = persistJob(contentId, TranslationJobStatus.RUNNING)
val otherLanguageJobId = persistJob(contentId, language = "ja")
val observed = transaction.execute {
entityManager.find(AudioContent::class.java, contentId).toContentSourceSnapshot()
val stale = jobs.findById(jobId).orElseThrow()
transaction.executeWithoutResult { jobs.findById(jobId).orElseThrow().status = TranslationJobStatus.COMPLETED }
assertEquals(TranslationJobStatus.RUNNING, stale.status)
invalidateTitle(contentId)
stale.status
}
assertEquals(TranslationJobStatus.PENDING, jobs.findById(jobId).orElseThrow().status)
assertEquals(TranslationJobStatus.PENDING, observed)
assertEquals(TranslationJobStatus.COMPLETED, jobs.findById(otherLanguageJobId).orElseThrow().status)
}
@Test
@DisplayName("기존 consistent read가 비어 있어도 이후 commit된 exact 언어 작업을 refresh한다")
fun shouldRefreshJobCommittedAfterEmptyConsistentRead() {
val contentId = fixture()
val jobId = transaction.execute {
entityManager.find(AudioContent::class.java, contentId).toContentSourceSnapshot()
assertNull(
reads.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
LanguageTranslationTargetType.CONTENT,
contentId,
"title",
"en",
hash,
"ko"
)
)
val inserted = persistJob(contentId)
Mockito.doReturn(null).`when`(reads)
.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
LanguageTranslationTargetType.CONTENT,
contentId,
"title",
"en",
hash,
"ko"
)
invalidateTitle(contentId)
inserted
}!!
assertEquals(TranslationJobStatus.PENDING, jobs.findById(jobId).orElseThrow().status)
assertEquals(1, jobs.findAll().count { it.resourceId == contentId && it.targetLanguage == "en" })
}
@Test
@DisplayName("기존 snapshot 뒤 다른 언어 작업이 commit돼도 현재 원문 언어의 독립 refresh를 생성한다")
fun shouldCreateIndependentLanguageRefreshAgainstCurrentRows() {
val contentId = fixture()
val otherLanguageId = transaction.execute {
entityManager.find(AudioContent::class.java, contentId).toContentSourceSnapshot()
val inserted = persistJob(contentId, language = "ja")
invalidateTitle(contentId)
inserted
}!!
val englishJobs = jobs.findAll().filter { it.resourceId == contentId && it.targetLanguage == "en" }
assertEquals(setOf("ko", "ja"), englishJobs.map { it.sourceLanguage }.toSet())
assertEquals(2, englishJobs.size)
val current = englishJobs.single { it.sourceLanguage == "ko" }
assertEquals(TranslationJobStatus.PENDING, current.status)
assertEquals(hash, current.sourceHash)
val other = englishJobs.single { it.id == otherLanguageId }
assertEquals("ja", other.sourceLanguage)
assertEquals(TranslationJobStatus.COMPLETED, other.status)
assertEquals(4, other.retryCount)
assertEquals(previousRetryAt, other.nextRetryAt)
}
@ParameterizedTest
@EnumSource(TranslationJobStatus::class)
@DisplayName("강제 refresh는 현재 종료 상태만 재개하고 진행 중 작업의 예산을 유지한다")
fun shouldRestartOnlyCurrentTerminalJob(status: TranslationJobStatus) {
val contentId = fixture()
val jobId = persistJob(contentId, status)
transaction.executeWithoutResult { invalidateTitle(contentId) }
val current = jobs.findById(jobId).orElseThrow()
val restart = status == TranslationJobStatus.COMPLETED || status == TranslationJobStatus.FAILED
assertEquals(if (restart) TranslationJobStatus.PENDING else status, current.status)
assertEquals(if (restart) 0 else 4, current.retryCount)
assertEquals(if (restart) null else "previous failure", current.lastErrorMessage)
if (!restart) assertEquals(previousRetryAt, current.nextRetryAt)
assertEquals("ko", current.sourceLanguage)
assertEquals(hash, current.sourceHash)
}
private fun invalidateTitle(contentId: Long) {
val content = requireNotNull(writer.lockContent(contentId))
val before = content.toContentSourceSnapshot()
content.title = "원문 제목 "
invalidation.invalidateChanged(content, before)
}
private fun persistJob(
contentId: Long,
status: TranslationJobStatus = TranslationJobStatus.COMPLETED,
language: String = "ko"
): Long = transaction.execute {
requireNotNull(
jobs.saveAndFlush(
TranslationJob(
LanguageTranslationTargetType.CONTENT,
contentId,
"title",
hash,
"원문 제목",
language,
"en",
status,
4,
"previous failure",
previousRetryAt
)
).id
)
}!!
}
@@ -0,0 +1,197 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import com.amazonaws.services.s3.model.ObjectMetadata
import kr.co.vividnext.sodalive.admin.content.AdminContentService
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.AudioContentService
import kr.co.vividnext.sodalive.content.LanguageDetectEvent
import kr.co.vividnext.sodalive.content.LanguageDetectListener
import kr.co.vividnext.sodalive.creator.admin.content.CreatorAdminContentService
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobScheduler
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
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.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.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Import
import org.springframework.mock.web.MockMultipartFile
import org.springframework.transaction.support.TransactionSynchronizationManager
import java.io.ByteArrayInputStream
import java.io.InputStream
@Import(AdminContentService::class, CreatorAdminContentService::class)
class ContentTranslationSourceInvalidationIntegrationTest : ContentTranslationTestSupport() {
@Autowired private lateinit var ownerService: AudioContentService
@Autowired private lateinit var adminService: AdminContentService
@Autowired private lateinit var creatorService: CreatorAdminContentService
@Autowired private lateinit var detailService: AudioContentDetailTranslationService
@Autowired private lateinit var languageService: ContentTranslationLanguageService
@Autowired private lateinit var detectorListener: LanguageDetectListener
@Autowired private lateinit var uploader: S3Uploader
@ParameterizedTest
@ValueSource(strings = ["owner", "admin", "creator"])
@DisplayName("각 원문 수정 진입점은 제목 승인만 해제하고 같은 트랜잭션에 fallback과 refresh를 저장한다")
fun shouldInvalidateOnlyChangedField(entry: String) {
val id = fixture()
approveAll(id)
val creator = transaction.execute { entityManager.find(AudioContent::class.java, id).member }!!
val image = MockMultipartFile("coverImage", "cover.png", "image/png", byteArrayOf(1))
Mockito.doAnswer {
assertFalse(TransactionSynchronizationManager.isActualTransactionActive())
"saved/cover.png"
}.`when`(uploader).upload(
Mockito.any(InputStream::class.java) ?: ByteArrayInputStream(byteArrayOf()),
Mockito.anyString(),
Mockito.anyString(),
Mockito.any(ObjectMetadata::class.java)
)
when (entry) {
"owner" -> ownerService.modifyAudioContent(
image,
"""{"contentId":$id,"title":"수정 제목","isAdult":false,"isCommentAvailable":true}""",
creator
)
"admin" -> adminService.updateAudioContent(image, """{"id":$id,"title":"수정 제목","isDefaultCoverImage":false}""")
"creator" -> creatorService.updateAudioContent(image, """{"id":$id,"title":"수정 제목"}""", creator)
}
assertEquals("수정 제목", payload(id)?.title)
assertEquals("Approved detail", payload(id)?.detail)
assertEquals("Approved tags", payload(id)?.tags)
val fields = transaction.execute { overrides.findByContentId(id).map { it.approval.field }.toSet() }
assertEquals(setOf(ContentSourceFieldKey.DETAIL, ContentSourceFieldKey.TAGS), fields)
assertEquals(setOf("title"), jobs.findAll().map { it.fieldKey }.toSet())
assertTrue(jobs.findAll().all { it.sourceText == "수정 제목" })
}
@ParameterizedTest
@CsvSource("owner,detail", "owner,tags", "admin,detail", "creator,detail", "creator,tags")
@DisplayName("상세와 태그도 해당 필드만 무효화하고 pending 태그의 영속화 전후 순서를 유지한다")
fun shouldInvalidateChangedDetailOrTags(entry: String, field: String) {
val id = fixture()
approveAll(id)
val creator = transaction.execute { entityManager.find(AudioContent::class.java, id).member }!!
val value = if (field == "tags") "#힐링 #새태그" else "수정 상세"
when (entry) {
"owner" -> ownerService.modifyAudioContent(
null,
"""{"contentId":$id,"$field":"$value","isAdult":false,"isCommentAvailable":true}""",
creator
)
"admin" -> adminService.updateAudioContent(null, """{"id":$id,"$field":"$value","isDefaultCoverImage":false}""")
"creator" -> creatorService.updateAudioContent(null, """{"id":$id,"$field":"$value"}""", creator)
}
val current = snapshot(id)
assertEquals("Approved title", payload(id)?.title)
assertEquals(if (field == "detail") "수정 상세" else "Approved detail", payload(id)?.detail)
assertEquals(if (field == "tags") "#힐링,#새태그" else "Approved tags", payload(id)?.tags)
assertEquals(setOf(field), jobs.findAll().map { it.fieldKey }.toSet())
assertEquals(
setOf(if (field == "tags") current.tags.joinToString(",") else current.detail),
jobs.findAll().map { it.sourceText }.toSet()
)
assertEquals(2L, overrideRepository.count())
}
@Test
@DisplayName("A에서 B로 변경한 뒤 A로 돌아와도 이전 승인은 복원하지 않고 완료 작업을 다시 연다")
fun shouldNotRestoreApprovalAfterSourceReturns() {
val id = fixture()
approveAll(id)
val old = snapshot(id)
val scheduler = TranslationJobScheduler(jobs, coordinator, translations, entityManager)
scheduler.scheduleMissingTranslation(LanguageTranslationTargetType.CONTENT, id, "title", old.title, "ko", "en")
jobs.saveAndFlush(jobs.findAll().single().apply { status = TranslationJobStatus.COMPLETED })
adminService.updateAudioContent(null, """{"id":$id,"title":"B","isDefaultCoverImage":false}""")
adminService.updateAudioContent(null, """{"id":$id,"title":"원문 제목","isDefaultCoverImage":false}""")
assertEquals("원문 제목", payload(id)?.title)
assertEquals("Approved detail", payload(id)?.detail)
assertEquals(2L, overrideRepository.count())
assertEquals(
TranslationJobStatus.PENDING,
jobs.findAll().single { it.sourceText == old.title && it.targetLanguage == "en" }.status
)
}
@Test
@DisplayName("누락된 언어 감지는 트랜잭션 밖에서 실행하고 언어 변경은 세 승인을 모두 해제한다")
fun shouldInvalidateEveryFieldOnLanguageChange() {
val id = fixture(null)
approveAll(id)
provider.beforeDetect = { assertFalse(TransactionSynchronizationManager.isActualTransactionActive()) }
languageService.detectMissing(id)
assertEquals("ko", snapshot(id).sourceLanguage)
assertEquals(0L, overrideRepository.count())
assertEquals("원문 제목", payload(id)?.title)
assertEquals("원문 설명", payload(id)?.detail)
assertEquals("#힐링", payload(id)?.tags)
assertEquals(6L, jobs.count())
}
@Test
@DisplayName("이전 원문 이벤트는 현재 원문의 언어를 감지하거나 저장하지 않는다")
fun shouldIgnoreStaleDetectionEvent() {
val id = fixture(null)
detectorListener.detectLanguage(LanguageDetectEvent(id, "이전 원문"))
assertEquals(null, snapshot(id).sourceLanguage)
assertEquals(emptyList<String>(), provider.detectionQueries)
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("감지 중 원문이 바뀌면 늦은 언어 결과를 저장하지 않는다")
fun shouldRejectDetectionAfterConcurrentSourceChange() {
val id = fixture(null)
provider.beforeDetect = {
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = "다른 제목" }
}
languageService.detectMissing(id)
assertEquals(null, snapshot(id).sourceLanguage)
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("기존 payload shortcut도 오래된 승인 필드를 현재 원문 fallback으로 바꿔 반환한다")
fun shouldNotReturnStaleValueFromExistingPayloadShortcut() {
val id = fixture()
approveAll(id)
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = "우회 변경" }
val result = detailService.resolve(id, "en")
assertEquals("우회 변경", result.translated?.title)
assertEquals("Approved detail", result.translated?.detail)
assertEquals("Approved tags", result.translated?.tags)
assertEquals(2L, overrideRepository.count())
assertEquals(setOf("title"), jobs.findAll().map { it.fieldKey }.toSet())
assertEquals(0, provider.calls.get())
}
}
@@ -0,0 +1,131 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.ContentDetailTranslationTestConfiguration
import kr.co.vividnext.sodalive.content.DetailTranslationProvider
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.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationCoordinator
import kr.co.vividnext.sodalive.i18n.translation.TranslationJobRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemory
import kr.co.vividnext.sodalive.i18n.translation.TranslationMemoryRepository
import kr.co.vividnext.sodalive.i18n.translation.TranslationReadModelMaterializer
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.ContentTranslationOverrideRepository
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvenance
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ApprovalProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentFieldApproval
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceSnapshot
import kr.co.vividnext.sodalive.v2.contenttranslation.port.ContentTranslationOverrideStore
import org.junit.jupiter.api.BeforeEach
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
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 javax.persistence.EntityManager
@SpringBootTest(
classes = [ContentDetailTranslationTestConfiguration::class],
properties = ["spring.cache.type=none", "spring.jpa.properties.hibernate.show_sql=false"]
)
@ActiveProfiles("content-detail-translation-test")
abstract class ContentTranslationTestSupport {
@Autowired protected lateinit var entityManager: EntityManager
@Autowired protected lateinit var materializer: TranslationReadModelMaterializer
@Autowired protected lateinit var writer: ContentTranslationWriteService
@Autowired protected lateinit var memories: TranslationMemoryRepository
@Autowired protected lateinit var translations: ContentTranslationRepository
@Autowired protected lateinit var overrides: ContentTranslationOverrideStore
@Autowired protected lateinit var overrideRepository: ContentTranslationOverrideRepository
@Autowired protected lateinit var coordinator: TranslationCoordinator
@Autowired protected lateinit var provider: DetailTranslationProvider
@Autowired protected lateinit var jobs: TranslationJobRepository
@Autowired protected lateinit var jdbc: JdbcTemplate
@Autowired private lateinit var transactionManager: PlatformTransactionManager
protected val transaction: TransactionTemplate
get() = TransactionTemplate(transactionManager).apply {
propagationBehavior = TransactionDefinition.PROPAGATION_REQUIRES_NEW
}
protected val provenance = ApprovalProvenance(71L, listOf(81L, 82L), listOf(ApprovalProvider("aws", "test")), 91L)
@BeforeEach
fun prepareTranslationStorage() {
jobs.deleteAllInBatch()
overrideRepository.deleteAllInBatch()
translations.deleteAllInBatch()
memories.deleteAllInBatch()
jdbc.update("delete from language_detection_result")
provider.reset()
jdbc.execute("alter table content_translation alter column rendered_payload varchar(1000000)")
}
protected fun fixture(language: String? = "ko"): Long = transaction.execute {
val creator = Member(password = "test", nickname = "approval-creator")
val theme = AudioContentTheme("approval-theme", "theme.png")
entityManager.persist(creator)
entityManager.persist(theme)
val content = AudioContent("원문 제목", "원문 설명", language).apply {
member = creator
this.theme = theme
isActive = true
duration = "00:01:00"
}
entityManager.persist(content)
val tag = HashTag("#힐링")
entityManager.persist(tag)
entityManager.persist(AudioContentHashTag().apply { audioContent = content; hashTag = tag })
requireNotNull(content.id)
}!!
protected fun snapshot(id: Long): ContentSourceSnapshot = transaction.execute {
entityManager.find(AudioContent::class.java, id).toContentSourceSnapshot()
}!!
protected fun approval(source: ContentSourceSnapshot, field: ContentSourceFieldKey, text: String = "Approved ${field.key}") =
ContentFieldApproval(field, source.fingerprint(field), text, provenance)
protected fun approveAll(id: Long) {
val source = snapshot(id)
writer.approve(id, "en", ContentSourceFieldKey.values().map { approval(source, it) })
}
protected fun cache(source: ContentSourceSnapshot) {
source.fields.filter { it.sourceText.isNotBlank() }.forEach {
memories.saveAndFlush(
TranslationMemory(
SourceTextNormalizer.hash(it.sourceText),
it.sourceText,
requireNotNull(source.sourceLanguage),
"en",
"Automatic ${it.fieldKey}",
"aws",
"test"
)
)
}
}
protected fun payload(id: Long): ContentTranslationPayload? = transaction.execute {
translations.findByContentIdAndLocale(id, "en")?.renderedPayload
}
}
@@ -0,0 +1,84 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId
import kr.co.vividnext.sodalive.i18n.translation.TranslateRequest
import kr.co.vividnext.sodalive.i18n.translation.TranslateResult
import kr.co.vividnext.sodalive.i18n.translation.TranslationProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
import org.junit.jupiter.api.BeforeEach
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Import
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.support.TransactionSynchronizationManager
import java.util.Collections
@Import(SelectionCandidateProviderConfiguration::class)
abstract class TranslationCandidateTestSupport : TranslationSelectionTestSupport() {
@Autowired protected lateinit var generation: TranslationSelectionGenerationService
@Autowired protected lateinit var candidateWorker: TranslationSelectionWorkerService
@Autowired protected lateinit var candidateStore: TranslationCandidateStore
@Autowired protected lateinit var papago: SelectionPapagoProvider
@Autowired protected lateinit var selectionTransactionManager: PlatformTransactionManager
@BeforeEach
fun resetCandidateProvider() { papago.reset() }
protected fun generated(): Long {
val created = request(fixture())
preparation.prepareNext()
generation.generate(created.requestId, 1)
return created.requestId
}
protected fun candidates(requestId: Long): List<TranslationCandidate> = transaction.execute {
candidateStore.page(requestId, 0, 1000)
}!!
protected fun drain(requestId: Long) {
repeat(requests.get(requestId).progress.total + 1) { candidateWorker.runNext() }
}
}
@Configuration
class SelectionCandidateProviderConfiguration {
@Bean fun selectionPapagoProvider() = SelectionPapagoProvider()
}
class SelectionPapagoProvider : TranslationProvider {
override val providerId = LanguageProviderId.PAPAGO
override var providerVersion = "nmt-test"
val requests: MutableList<TranslateRequest> = Collections.synchronizedList(mutableListOf())
var beforeTranslate: () -> Unit = {}
var result: (TranslateRequest) -> List<String> = ::outputs
fun reset() {
requests.clear()
providerVersion = "nmt-test"
beforeTranslate = {}
result = ::outputs
}
override fun translate(request: TranslateRequest): TranslateResult {
check(!TransactionSynchronizationManager.isActualTransactionActive()) { "network inside transaction" }
request.callControl?.beforeCall()
requests.add(request)
beforeTranslate()
return TranslateResult(result(request))
}
private fun outputs(request: TranslateRequest): List<String> = request.texts.map {
when (it) {
"원문 제목" -> "English title"
"원문 설명" -> "English detail"
"#힐링" -> "#Healing"
else -> "result:$it"
}
}
}
@@ -0,0 +1,203 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
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.ValueSource
import java.util.concurrent.Callable
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import javax.persistence.LockModeType
class TranslationSelectionApplyConcurrencyIntegrationTest : TranslationSelectionApplyTestSupport() {
@Test
@DisplayName("별도 요청의 후속 관리자 적용이 이기고 경합한 일반 materializer는 유효 승인을 덮어쓰지 않는다")
fun shouldSerializeExplicitApplicationsAndAutomaticWriter() {
val id = fixture()
val first = ready(id)
papago.result = { request -> request.texts.map { "Later:$it" } }
val second = ready(id)
val firstBody = body(first, listOf(field(first, ContentSourceFieldKey.TITLE)))
val secondBody = body(second, listOf(field(second, ContentSourceFieldKey.TITLE)))
cache(snapshot(id))
val locked = CountDownLatch(1)
val release = CountDownLatch(1)
val started = CountDownLatch(2)
val executor = Executors.newFixedThreadPool(3)
try {
val firstApply = executor.submit(
Callable {
transaction.execute {
val receipt = applyService.apply(first.requestId, 777, firstBody)
locked.countDown()
check(release.await(10, TimeUnit.SECONDS))
receipt
}
}
)
assertTrue(locked.await(10, TimeUnit.SECONDS))
val secondApply = executor.submit(
Callable {
started.countDown()
applyService.apply(second.requestId, 888, secondBody)
}
)
val automatic = executor.submit(
Callable {
started.countDown()
materializer.materialize(LanguageTranslationTargetType.CONTENT, id, "en")
}
)
assertTrue(started.await(10, TimeUnit.SECONDS))
release.countDown()
assertEquals("English title", firstApply.get(15, TimeUnit.SECONDS)!!.appliedFields.single().translatedValue)
assertEquals("Later:원문 제목", secondApply.get(15, TimeUnit.SECONDS).appliedFields.single().translatedValue)
assertTrue(automatic.get(15, TimeUnit.SECONDS))
} finally {
release.countDown()
executor.shutdownNow()
}
assertEquals("Later:원문 제목", payload(id)?.title)
assertEquals(888L, transaction.execute { overrides.findByContentId(id).single().approval.provenance.approvedBy })
}
@ParameterizedTest
@ValueSource(booleans = [true, false])
@DisplayName("apply와 cancel은 같은 request 잠금에서 먼저 commit한 terminal 상태만 보존한다")
fun shouldLinearizeCancelAndApply(applyFirst: Boolean) {
val id = fixture()
val request = ready(id)
val body = body(request, listOf(field(request, ContentSourceFieldKey.TITLE)))
val locked = CountDownLatch(1)
val release = CountDownLatch(1)
val started = CountDownLatch(1)
val executor = Executors.newFixedThreadPool(2)
try {
val winner = executor.submit {
transaction.executeWithoutResult {
if (applyFirst) applyService.apply(request.requestId, 777, body) else requests.cancel(request.requestId)
locked.countDown()
check(release.await(10, TimeUnit.SECONDS))
}
}
assertTrue(locked.await(10, TimeUnit.SECONDS))
val loser = executor.submit(
Callable {
started.countDown()
assertThrows(SodaException::class.java) {
if (applyFirst) requests.cancel(request.requestId) else applyService.apply(request.requestId, 777, body)
}.errorProperty
}
)
assertTrue(started.await(10, TimeUnit.SECONDS))
release.countDown()
winner.get(15, TimeUnit.SECONDS)
assertEquals("REQUEST_CLOSED", loser.get(15, TimeUnit.SECONDS))
} finally {
release.countDown()
executor.shutdownNow()
}
assertEquals(
if (applyFirst) TranslationSelectionStatus.APPLIED else TranslationSelectionStatus.CANCELLED,
requests.get(request.requestId).status
)
assertEquals(if (applyFirst) "English title" else null, payload(id)?.title)
assertEquals(if (applyFirst) 1L else 0L, overrideRepository.count())
}
@ParameterizedTest
@ValueSource(strings = ["title", "tags"])
@DisplayName("잠금 전에 로드된 원문과 태그 연관은 current refresh 뒤에만 선택을 판정한다")
fun shouldRefreshManagedSourceAssociationsBeforeValidation(kind: String) {
val id = fixture()
val request = ready(id)
val choice = field(request, if (kind == "tags") ContentSourceFieldKey.TAGS else ContentSourceFieldKey.TITLE)
val error = assertThrows(SodaException::class.java) {
transaction.executeWithoutResult {
val managed = entityManager.find(AudioContent::class.java, id)
managed.toContentSourceSnapshot()
transaction.executeWithoutResult {
val current = writer.lockContent(id)!!
if (kind == "title") {
current.title += " "
} else {
current.audioContentHashTags.single().isActive = false
}
}
applyService.apply(request.requestId, 777, body(request, listOf(choice)))
}
}
assertEquals("SOURCE_CHANGED", error.errorProperty)
assertEquals(0L, translations.count())
assertEquals(0L, overrideRepository.count())
assertEquals(TranslationSelectionStatus.READY, requests.get(request.requestId).status)
}
@Test
@DisplayName("원본 수정이 먼저 잠금을 보유하면 대기하던 적용은 commit된 최신 원문을 거부한다")
fun shouldReadSourceAfterWaitingForMutationCommit() {
val id = fixture()
val request = ready(id)
val body = body(request, listOf(field(request, ContentSourceFieldKey.TITLE)))
val locked = CountDownLatch(1)
val release = CountDownLatch(1)
val started = CountDownLatch(1)
val executor = Executors.newFixedThreadPool(2)
try {
val mutation = executor.submit {
transaction.executeWithoutResult {
writer.lockContent(id)!!.title += " "
locked.countDown()
check(release.await(10, TimeUnit.SECONDS))
}
}
assertTrue(locked.await(10, TimeUnit.SECONDS))
val applying = executor.submit(
Callable {
started.countDown()
assertThrows(SodaException::class.java) { applyService.apply(request.requestId, 777, body) }.errorProperty
}
)
assertTrue(started.await(10, TimeUnit.SECONDS))
release.countDown()
mutation.get(15, TimeUnit.SECONDS)
assertEquals("SOURCE_CHANGED", applying.get(15, TimeUnit.SECONDS))
} finally {
release.countDown()
executor.shutdownNow()
}
assertEquals(0L, overrideRepository.count())
}
@Test
@DisplayName("외부 transaction rollback은 payload override 영수증 discard 상태를 함께 되돌린다")
fun shouldCommitReceiptDiscardAndPayloadInOneTransaction() {
val id = fixture()
val request = ready(id)
assertThrows(IllegalStateException::class.java) {
transaction.executeWithoutResult {
applyService.apply(request.requestId, 777, body(request, listOf(field(request, ContentSourceFieldKey.TITLE))))
assertEquals(
LockModeType.PESSIMISTIC_WRITE,
entityManager.getLockMode(entityManager.find(AudioContent::class.java, id))
)
throw IllegalStateException("rollback after all application writes")
}
}
assertEquals(TranslationSelectionStatus.READY, requests.get(request.requestId).status)
assertEquals(null, requests.get(request.requestId).applyReceipt)
assertEquals(0L, translations.count())
assertEquals(0L, overrideRepository.count())
assertEquals(setOf(TranslationCandidateStatus.SUCCEEDED), candidates(request.requestId).map { it.status }.toSet())
}
}
@@ -0,0 +1,169 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
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.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionChoice
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionField
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotNull
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
class TranslationSelectionApplyGroupIntegrationTest : TranslationSelectionApplyTestSupport() {
@Test
@DisplayName("공통 bundle의 선언 순서와 template 순서가 달라도 전체 제목과 literal 출처를 정확히 적용한다")
fun shouldApplyCompleteGroupAndReplayResidualOrdering() {
val fixture = readyGroup()
val choice = groupChoice(fixture)
val body = body(fixture.request, listOf(choice))
val receipt = applyService.apply(fixture.request.requestId, 777, body)
assertEquals(
listOf("result:공통 result:잔여 구문 result:끝 1", "result:공통 result:잔여 구문 result:끝 2", "result:공통 result:끝 3"),
fixture.ids.take(3).map { payload(it)?.title }
)
assertEquals(null, payload(fixture.ids.last()))
assertEquals(3, receipt.appliedFields.size)
assertEquals(
listOf(choice.commonCandidateId),
receipt.appliedFields.single { it.contentId == fixture.ids[2] }.candidateIds
)
assertEquals(
listOf(choice.commonCandidateId, choice.residualChoices[1].candidateId),
receipt.appliedFields.single { it.contentId == fixture.ids[1] }.candidateIds
)
assertEquals(
receipt,
applyService.apply(
fixture.request.requestId,
777,
body.copy(selections = listOf(choice.copy(residualChoices = choice.residualChoices.reversed())))
)
)
assertEquals(3L, overrideRepository.count())
}
@ParameterizedTest
@ValueSource(
strings = ["missing", "duplicate", "nullResidual", "literalCandidate", "wrongMember", "wrongCommon", "fieldTitle"]
)
@DisplayName("누락 중복 literal 및 residual 소유권 불일치와 grouped title FIELD 우회를 원자 거부한다")
fun shouldRejectIncompleteOrConflictingGroupWithoutWrites(kind: String) {
val fixture = readyGroup()
val choice = groupChoice(fixture)
val invalid = when (kind) {
"missing" -> choice.copy(residualChoices = choice.residualChoices.dropLast(1))
"duplicate" -> choice.copy(residualChoices = choice.residualChoices + choice.residualChoices.first())
"nullResidual" -> choice.copy(residualChoices = choice.residualChoices.map { it.copy(candidateId = null) })
"literalCandidate" -> choice.copy(
residualChoices = choice.residualChoices.map {
if (it.contentId == fixture.ids[2]) it.copy(candidateId = choice.residualChoices.first().candidateId) else it
}
)
"wrongMember" -> choice.copy(
residualChoices = choice.residualChoices.map {
if (it.contentId == fixture.ids[1]) it.copy(candidateId = choice.residualChoices.first().candidateId) else it
}
)
"wrongCommon" -> choice.copy(commonCandidateId = requireNotNull(choice.residualChoices.first().candidateId))
else -> choice
}
val choices = if (kind == "fieldTitle") {
listOf(
choice,
TranslationSelectionChoice.Field(
fixture.ids.first(),
TranslationSelectionField.TITLE,
"en",
choice.commonCandidateId
)
)
} else {
listOf(invalid)
}
val code = when (kind) {
"wrongMember", "wrongCommon" -> "CANDIDATE_NOT_SELECTABLE"
"fieldTitle" -> "INVALID_REQUEST"
else -> "INCOMPLETE_TITLE_GROUP"
}
rejected(fixture.request, body(fixture.request, choices), code)
}
@ParameterizedTest
@ValueSource(strings = ["title", "language", "active", "removed", "added"])
@DisplayName("잠금 후 모든 그룹 제목과 언어 및 전체 활성 membership을 검증한다")
fun shouldRejectChangedSelectedGroupSourceOrMembership(kind: String) {
val fixture = readyGroup()
val additional = if (kind == "added") this.fixture() else null
transaction.executeWithoutResult {
when (kind) {
"title" -> entityManager.find(AudioContent::class.java, fixture.ids[1]).title += " "
"language" -> entityManager.find(AudioContent::class.java, fixture.ids[1]).languageCode = "en"
"active" -> entityManager.find(AudioContent::class.java, fixture.ids.last()).isActive = false
"removed" -> entityManager.createQuery(
"delete from SeriesContent s where s.series.id = :id and s.content.id = :content"
)
.setParameter("id", fixture.seriesId).setParameter("content", fixture.ids.last()).executeUpdate()
else -> entityManager.persist(
SeriesContent().apply {
series = entityManager.find(Series::class.java, fixture.seriesId)
content = entityManager.find(AudioContent::class.java, additional)
}
)
}
}
rejected(
fixture.request,
body(fixture.request, listOf(groupChoice(fixture))),
if (kind in listOf("title", "language")) "SOURCE_CHANGED" else "MEMBERSHIP_CHANGED"
)
}
@Test
@DisplayName("FIELD 선택은 무관한 member 추가와 다른 필드 변경을 허용하고 선택된 alias의 복사 결과를 유지한다")
fun shouldAllowUnrelatedMembershipAndKeepSelectedLinkedCandidate() {
val fixture = readyGroup()
val choice = field(fixture.request, ContentSourceFieldKey.DETAIL, fixture.ids[1])
val alias = candidates(fixture.request.requestId).single { it.candidateId == choice.candidateId }
assertNotNull(alias.linkedCandidateId)
val added = this.fixture()
transaction.executeWithoutResult {
entityManager.persist(
SeriesContent().apply {
series = entityManager.find(Series::class.java, fixture.seriesId)
content = entityManager.find(AudioContent::class.java, added)
}
)
entityManager.find(AudioContent::class.java, fixture.ids[1]).title += " "
}
val receipt = applyService.apply(fixture.request.requestId, 777, body(fixture.request, listOf(choice)))
assertEquals("English detail", payload(fixture.ids[1])?.detail)
assertEquals(listOf(choice.candidateId), receipt.appliedFields.single().candidateIds)
val persisted = candidates(fixture.request.requestId)
assertEquals(TranslationCandidateStatus.DISCARDED, persisted.single { it.candidateId == alias.linkedCandidateId }.status)
assertEquals(listOf("English detail"), persisted.single { it.candidateId == choice.candidateId }.translatedValues)
}
@Test
@DisplayName("SERIES FIELD의 선택 콘텐츠가 비활성이면 다른 source가 같아도 거부한다")
fun shouldRejectIneligibleSelectedSeriesField() {
val fixture = readyGroup()
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, fixture.ids.first()).isActive = false }
rejected(
fixture.request,
body(fixture.request, listOf(field(fixture.request, ContentSourceFieldKey.DETAIL))),
"SOURCE_CHANGED"
)
}
}
@@ -0,0 +1,194 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.TranslationGenerationUnitConverter
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
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 java.util.UUID
class TranslationSelectionApplyIntegrationTest : TranslationSelectionApplyTestSupport() {
@Test
@DisplayName("한 번의 subset은 같은 locale 필드를 함께 합치고 미선택 바이트와 provider manifest를 보존한다")
fun shouldApplySubsetOnceAndDiscardOnlyOmittedCandidates() {
val id = fixture()
val request = ready(id)
translations.saveAndFlush(ContentTranslation(id, "en", ContentTranslationPayload("Old", "Old detail", " \t#A, #B\n")))
val title = field(request, ContentSourceFieldKey.TITLE).copy(
candidateId = candidates(request.requestId).single {
it.unit.field == ContentSourceFieldKey.TITLE && it.provider.id == "aws" && it.targetLanguage == "en"
}.candidateId
)
val detail = field(request, ContentSourceFieldKey.DETAIL)
val body = body(request, listOf(detail, title))
papago.providerVersion = "changed-after-generation"
val receipt = applyService.apply(request.requestId, 777, body)
assertEquals(ContentTranslationPayload("English title", "English detail", " \t#A, #B\n"), payload(id))
val persisted = requests.get(request.requestId)
assertEquals(TranslationSelectionStatus.APPLIED, persisted.status)
assertEquals(request.snapshot, persisted.snapshot)
assertEquals(receipt, persisted.applyReceipt)
assertEquals(10, receipt.discardedCandidateCount)
assertEquals(
setOf(title.candidateId, detail.candidateId),
candidates(request.requestId).filter { it.status == TranslationCandidateStatus.SUCCEEDED }
.map { it.candidateId }.toSet()
)
val approved = transaction.execute { overrides.findByContentId(id) }!!
assertEquals(2, approved.size)
assertEquals(setOf(777L), approved.map { it.approval.provenance.approvedBy }.toSet())
assertEquals(
request.snapshot.providerManifest.toSet(),
approved.flatMap { it.approval.provenance.providers }.toSet()
)
assertEquals(0L, memories.count())
}
@ParameterizedTest
@ValueSource(strings = ["foreign", "failed", "pending", "provider", "unit", "target", "source", "values"])
@DisplayName("성공 여부 요청 unit 언어 frozen provider 원문 소유권이 다른 후보를 모두 거부한다")
fun shouldRejectUnselectableCandidateWithoutAnyWrites(kind: String) {
val id = fixture()
val request = ready(id)
val choice = field(request, ContentSourceFieldKey.TITLE)
val candidate = candidates(request.requestId).single { it.candidateId == choice.candidateId }
val bad = when (kind) {
"foreign" -> field(ready(fixture()), ContentSourceFieldKey.TITLE).candidateId
"failed" -> { replaceCandidate(candidate.copy(status = TranslationCandidateStatus.FAILED)); candidate.candidateId }
"pending" -> { replaceCandidate(candidate.copy(status = TranslationCandidateStatus.PENDING)); candidate.candidateId }
"values" -> { replaceCandidate(candidate.copy(translatedValues = listOf(" "))); candidate.candidateId }
"provider" -> {
jdbc.update("update translation_candidate set provider_version = ? where id = ?", "forged", candidate.candidateId)
candidate.candidateId
}
"target" -> candidates(request.requestId).single {
it.unit == candidate.unit && it.provider == candidate.provider && it.targetLanguage == "ja"
}.candidateId
else -> {
val unit = if (kind == "unit") {
candidate.unit.copy(contentId = id + 999)
} else {
candidate.unit.copy(inputValues = listOf("forged"))
}
jdbc.update(
"update translation_candidate set unit = ? where id = ?",
TranslationGenerationUnitConverter().convertToDatabaseColumn(unit),
candidate.candidateId
)
candidate.candidateId
}
}
rejected(request, body(request, listOf(choice.copy(candidateId = bad))), "CANDIDATE_NOT_SELECTABLE")
}
@ParameterizedTest
@ValueSource(strings = ["raw", "language", "deleted"])
@DisplayName("정규화하면 같아지는 raw 수정과 원본 언어 변경 및 삭제도 선택 필드의 이전 후보를 거부한다")
fun shouldRejectChangedSelectedSource(kind: String) {
val id = fixture()
val request = ready(id)
transaction.executeWithoutResult {
val content = entityManager.find(AudioContent::class.java, id)
when (kind) {
"raw" -> content.title += " "
"language" -> content.languageCode = "ja"
else -> {
entityManager.createQuery("delete from AudioContentHashTag t where t.audioContent.id = :id")
.setParameter("id", id).executeUpdate()
entityManager.remove(content)
}
}
}
rejected(request, body(request, listOf(field(request, ContentSourceFieldKey.TITLE))), "SOURCE_CHANGED")
}
@Test
@DisplayName("미선택 필드 원문 변경은 허용하고 없는 locale의 나머지 필드는 최신 원문으로 초기화한다")
fun shouldAllowUnselectedFieldSourceChange() {
val id = fixture()
val request = ready(id)
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).detail = "현재 상세 " }
applyService.apply(request.requestId, 777, body(request, listOf(field(request, ContentSourceFieldKey.TITLE))))
assertEquals(ContentTranslationPayload("English title", "현재 상세 ", "#힐링"), payload(id))
assertEquals(1L, overrideRepository.count())
}
@Test
@DisplayName("같은 operation의 순서만 다른 body는 원본 변경 후에도 저장된 영수증을 반환한다")
fun shouldReplayCanonicalBodyBeforeClosedAndRevisionValidation() {
val id = fixture()
val request = ready(id)
val body = body(request, listOf(field(request, ContentSourceFieldKey.TITLE), field(request, ContentSourceFieldKey.TAGS)))
val receipt = applyService.apply(request.requestId, 777, body)
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = "변경 이후" }
assertEquals(receipt, applyService.apply(request.requestId, 888, body.copy(selections = body.selections.reversed())))
val changed = assertThrows(SodaException::class.java) {
applyService.apply(request.requestId, 777, body.copy(selections = body.selections.take(1)))
}
assertEquals("IDEMPOTENCY_CONFLICT", changed.errorProperty)
val closed = assertThrows(SodaException::class.java) {
applyService.apply(request.requestId, 777, body.copy(operationId = UUID.randomUUID()))
}
assertEquals("REQUEST_CLOSED", closed.errorProperty)
}
@ParameterizedTest
@ValueSource(strings = ["empty", "duplicate", "revision", "generating", "cancelled"])
@DisplayName("빈 선택 중복 stale revision과 미완료 취소 요청은 적용할 수 없다")
fun shouldValidateNewApplicationStateAndChoices(kind: String) {
val request = ready(fixture())
val title = field(request, ContentSourceFieldKey.TITLE)
val choices = when (kind) {
"empty" -> emptyList()
"duplicate" -> listOf(title, title)
else -> listOf(title)
}
val body = body(request, choices)
if (kind == "cancelled") requests.cancel(request.requestId)
if (kind == "generating") {
transaction.executeWithoutResult { requestStore.save(request.copy(status = TranslationSelectionStatus.GENERATING)) }
}
val error = assertThrows(SodaException::class.java) {
applyService.apply(request.requestId, 777, if (kind == "revision") body.copy(expectedRevision = 1) else body)
}
assertEquals(
when (kind) {
"revision" -> "REVISION_CONFLICT"
"generating" -> "REQUEST_NOT_READY"
"cancelled" -> "REQUEST_CLOSED"
else -> "INVALID_REQUEST"
},
error.errorProperty
)
assertEquals(0L, overrideRepository.count())
assertEquals(0L, translations.count())
}
@Test
@DisplayName("여러 선택 중 하나가 stale이면 앞선 유효 선택과 영수증 폐기까지 전부 쓰지 않는다")
fun shouldRollbackWholeRequestWhenAnySelectionIsInvalid() {
val id = fixture()
val request = ready(id)
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).detail += " " }
val choices = listOf(field(request, ContentSourceFieldKey.TITLE), field(request, ContentSourceFieldKey.DETAIL))
rejected(request, body(request, choices), "SOURCE_CHANGED")
assertEquals(setOf(TranslationCandidateStatus.SUCCEEDED), candidates(request.requestId).map { it.status }.toSet())
}
}
@@ -0,0 +1,126 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ContentSourceFieldKey
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ReviewedSharedPart
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ReviewedTitleGroup
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TitleOccurrence
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidate
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationUnitKind
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ApplyTranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ReviewTranslationSelectionGroupingRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionChoice
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionField
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.TranslationSelectionResidualChoice
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
import org.springframework.beans.factory.annotation.Autowired
import java.util.UUID
abstract class TranslationSelectionApplyTestSupport : TranslationCandidateTestSupport() {
@Autowired protected lateinit var applyService: TranslationSelectionApplyService
@Autowired protected lateinit var grouping: TranslationSelectionGroupingService
protected fun ready(id: Long): TranslationSelectionRequest {
val created = request(id)
preparation.prepareNext()
generation.generate(created.requestId, 1)
drain(created.requestId)
return requests.get(created.requestId)
}
protected fun field(
request: TranslationSelectionRequest,
field: ContentSourceFieldKey,
contentId: Long = request.snapshot.contents.first().contentId
): TranslationSelectionChoice.Field {
val candidate = candidates(request.requestId).single {
it.unit.kind == TranslationUnitKind.FIELD && it.unit.field == field && it.unit.contentId == contentId &&
it.targetLanguage == "en" && it.provider.id == "papago"
}
return TranslationSelectionChoice.Field(
requireNotNull(candidate.unit.contentId),
TranslationSelectionField.values().single { it.key == field.key },
"en",
candidate.candidateId
)
}
protected fun body(request: TranslationSelectionRequest, choices: List<TranslationSelectionChoice>) =
ApplyTranslationSelectionRequest(UUID.randomUUID(), request.revision, choices)
protected fun rejected(request: TranslationSelectionRequest, body: ApplyTranslationSelectionRequest, code: String) {
val error = assertThrows(SodaException::class.java) { applyService.apply(request.requestId, 777, body) }
assertEquals(code, error.errorProperty)
assertEquals(TranslationSelectionStatus.READY, requests.get(request.requestId).status)
assertEquals(0L, overrideRepository.count())
assertEquals(0L, translations.count())
assertEquals(null, requests.get(request.requestId).applyReceipt)
}
protected data class GroupFixture(val request: TranslationSelectionRequest, val ids: List<Long>, val seriesId: Long)
protected fun readyGroup(): GroupFixture {
val titles = listOf("공통 잔여 구문 끝 1", "공통 잔여 구문 끝 2", "공통 끝 3", "개별 제목")
val ids = titles.map { title ->
val id = fixture()
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).title = title }
id
}
val seriesId = series(ids)
val request = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(seriesId))
preparation.prepareNext()
val members = ids.take(3)
grouping.review(
request.requestId,
ReviewTranslationSelectionGroupingRequest(
1,
listOf(
ReviewedTitleGroup(
"g",
members,
listOf(
ReviewedSharedPart(
"end",
members.mapIndexed { index, id ->
val start = titles[index].indexOf("끝")
TitleOccurrence(id, start, start + 1)
}
),
ReviewedSharedPart("start", members.map { TitleOccurrence(it, 0, 2) })
)
)
),
listOf(ids.last())
)
)
generation.generate(request.requestId, 2)
drain(request.requestId)
return GroupFixture(requests.get(request.requestId), ids, seriesId)
}
protected fun groupChoice(fixture: GroupFixture): TranslationSelectionChoice.TitleGroup {
val candidates = candidates(fixture.request.requestId).filter { it.targetLanguage == "en" && it.provider.id == "papago" }
return TranslationSelectionChoice.TitleGroup(
"g",
"en",
candidates.single { it.unit.kind == TranslationUnitKind.GROUP_COMMON }.candidateId,
fixture.ids.take(3).map { id ->
TranslationSelectionResidualChoice(
id,
candidates.singleOrNull { it.unit.kind == TranslationUnitKind.TITLE_RESIDUAL && it.unit.contentId == id }
?.candidateId
)
}
)
}
protected fun replaceCandidate(candidate: TranslationCandidate) {
transaction.executeWithoutResult { candidateStore.save(candidate) }
}
}
@@ -0,0 +1,106 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import com.sun.net.httpserver.HttpServer
import kr.co.vividnext.sodalive.i18n.translation.AwsTranslationCallInterceptor
import kr.co.vividnext.sodalive.i18n.translation.AwsTranslationService
import kr.co.vividnext.sodalive.i18n.translation.awsTestHttpResponse
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
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.DisplayName
import org.junit.jupiter.api.Test
import software.amazon.awssdk.auth.credentials.AwsBasicCredentials
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider
import software.amazon.awssdk.regions.Region
import software.amazon.awssdk.services.translate.TranslateClient
import java.net.InetSocketAddress
import java.net.URI
import java.util.concurrent.Callable
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicInteger
class TranslationSelectionCancelIntegrationTest : TranslationCandidateTestSupport() {
@Test
@DisplayName("취소 DB commit 뒤 실제 AWS SDK retry의 전송 gate와 늦은 게시를 거부한다")
fun shouldFenceActualSdkRetryAfterCancellationCommit() {
val created = request(fixture())
preparation.prepareNext()
val calls = AtomicInteger()
val server = HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
server.createContext("/") { exchange ->
calls.incrementAndGet()
requests.cancel(created.requestId)
val body = awsTestHttpResponse("__type" to "InternalServerException", "message" to "retry")
exchange.responseHeaders.set("Content-Type", "application/cbor")
exchange.sendResponseHeaders(500, body.size.toLong())
exchange.responseBody.use { it.write(body) }
}
server.start()
try {
TranslateClient.builder().endpointOverride(URI("http://127.0.0.1:${server.address.port}"))
.region(Region.AP_NORTHEAST_2)
.credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create("test", "test")))
.overrideConfiguration { it.addExecutionInterceptor(AwsTranslationCallInterceptor()) }
.build().use { client ->
val provider = AwsTranslationService(client)
val generation = TranslationSelectionGenerationService(requestStore, candidateStore, listOf(provider))
transaction.execute { generation.generate(created.requestId, 1) }
val worker = TranslationSelectionWorkerService(
requestStore,
candidateStore,
listOf(provider),
selectionTransactionManager
)
assertTrue(worker.runNext())
}
assertEquals(1, calls.get())
assertEquals("CANCELLED", requests.get(created.requestId).status.name)
assertTrue(candidates(created.requestId).all { it.status == TranslationCandidateStatus.DISCARDED })
} finally { server.stop(0) }
}
@Test
@DisplayName("취소는 모든 후보를 폐기하고 claim의 추가 전송과 게시를 거부한다")
fun shouldDiscardCandidatesAndRevokeClaimOnCancel() {
val requestId = generated()
val claim = requireNotNull(candidateWorker.claimNext())
assertTrue(candidateWorker.authorize(claim))
requests.cancel(requestId)
assertTrue(candidates(requestId).all { it.status == TranslationCandidateStatus.DISCARDED })
assertTrue(candidates(requestId).all { it.leaseUntil == null && it.translatedValues == null })
assertFalse(candidateWorker.authorize(claim))
assertFalse(candidateWorker.publish(claim, listOf("late"), null))
assertEquals(null, candidateWorker.claimNext())
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("이미 승인된 외부 호출을 기다리지 않고 취소하며 늦은 성공을 저장하지 않는다")
fun shouldRejectLateCompletionAfterCancel() {
val requestId = generated()
candidateWorker.runNext()
candidateWorker.runNext()
val entered = CountDownLatch(1)
val release = CountDownLatch(1)
papago.beforeTranslate = { entered.countDown(); check(release.await(10, TimeUnit.SECONDS)) }
val executor = Executors.newSingleThreadExecutor()
try {
val result = executor.submit(Callable { candidateWorker.runNext() })
assertTrue(entered.await(10, TimeUnit.SECONDS))
assertEquals("CANCELLED", requests.cancel(requestId).status.name)
release.countDown()
assertTrue(result.get(10, TimeUnit.SECONDS))
assertTrue(candidates(requestId).all { it.status == TranslationCandidateStatus.DISCARDED })
assertEquals(1, papago.requests.size)
assertEquals(null, payload(requests.get(requestId).snapshot.memberContentIds.single()))
} finally {
release.countDown()
executor.shutdownNow()
}
}
}
@@ -0,0 +1,92 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
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.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import java.time.LocalDateTime
import java.util.concurrent.Callable
import java.util.concurrent.CyclicBarrier
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
class TranslationSelectionCandidateLeaseIntegrationTest : TranslationCandidateTestSupport() {
@Test
@DisplayName("동시 generate replay는 같은 후보를 반환하고 worker claim은 서로 다른 후보를 소유한다")
fun shouldSerializeConcurrentGenerationAndClaims() {
val created = request(fixture())
preparation.prepareNext()
val executor = Executors.newFixedThreadPool(2)
try {
val barrier = CyclicBarrier(2)
val generated = (1..2).map {
executor.submit(Callable { barrier.await(5, TimeUnit.SECONDS); generation.generate(created.requestId, 1) })
}.map { it.get(10, TimeUnit.SECONDS) }
assertEquals(listOf(2L, 2L), generated.map { it.revision })
assertEquals(12, candidates(created.requestId).size)
val claims = (1..2).map { executor.submit(Callable { candidateWorker.claimNext() }) }
.map { requireNotNull(it.get(10, TimeUnit.SECONDS)) }
assertEquals(2, claims.map { it.candidate.candidateId }.distinct().size)
assertEquals(0, provider.calls.get())
} finally { executor.shutdownNow() }
}
@Test
@DisplayName("만료 claim은 갱신과 게시를 거부하며 두 번째 실행 만료는 실패 종결한다")
fun shouldRecoverLeaseAtMostOnceAndFenceExpiredExecutions() {
val id = generated()
var now = LocalDateTime.of(2026, 11, 17, 23, 59, 59)
val worker = TranslationSelectionWorkerService(
requestStore,
candidateStore,
listOf(provider, papago),
selectionTransactionManager
) { now }
val first = requireNotNull(worker.claimNext())
now = now.plusSeconds(60)
assertFalse(worker.authorize(first))
assertFalse(worker.publish(first, listOf("expired"), null))
val recovered = requireNotNull(worker.claimNext())
assertEquals(first.candidate.candidateId, recovered.candidate.candidateId)
assertEquals(2, recovered.candidate.attempt)
assertTrue(recovered.candidate.fence > first.candidate.fence)
assertFalse(worker.publish(first, listOf("stale"), null))
now = now.plusSeconds(60)
assertEquals(null, worker.claimNext())
val exhausted = candidates(id).first()
assertEquals(TranslationCandidateStatus.FAILED, exhausted.status)
assertEquals("EXECUTION_INTERRUPTED", exhausted.failureCode?.name)
assertEquals(2, exhausted.attempt)
assertTrue(worker.runNext())
assertEquals(1, provider.calls.get())
}
@ParameterizedTest
@ValueSource(ints = [0, 123456789, 999999999])
@DisplayName("후보 lease와 terminal 시각은 초 정밀도로 저장하고 DB 왕복에도 일치한다")
fun shouldPersistSecondPrecisionCandidateTimes(nanos: Int) {
val id = generated()
val now = LocalDateTime.of(2026, 11, 17, 23, 59, 59, nanos)
val worker = TranslationSelectionWorkerService(
requestStore,
candidateStore,
listOf(provider, papago),
selectionTransactionManager
) { now }
val claim = requireNotNull(worker.claimNext())
assertEquals(LocalDateTime.of(2026, 11, 18, 0, 0, 59), claim.candidate.leaseUntil)
assertTrue(worker.publish(claim, listOf("result"), null))
val row = transaction.execute {
entityManager.flush()
entityManager.clear()
candidateStore.find(claim.candidate.candidateId)
}!!
assertEquals(LocalDateTime.of(2026, 11, 17, 23, 59, 59), row.terminalAt)
assertEquals(row.terminalAt, row.updatedAt)
assertEquals(1, requests.get(id).progress.succeeded)
}
}
@@ -0,0 +1,167 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.i18n.translation.LanguageProviderId
import kr.co.vividnext.sodalive.i18n.translation.TranslateRequest
import kr.co.vividnext.sodalive.i18n.translation.TranslateResult
import kr.co.vividnext.sodalive.i18n.translation.TranslationProvider
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationCandidateStatus
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
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.ValueSource
import java.util.UUID
class TranslationSelectionCandidateLifecycleIntegrationTest : TranslationCandidateTestSupport() {
@ParameterizedTest
@ValueSource(strings = ["ko", "en", "ja"])
@DisplayName("세 원본 언어 각각에서 source 외 두 지원 언어와 세 필드를 모두 동결한다")
fun shouldFreezeEveryNonSourceLanguage(source: String) {
val created = request(fixture(source))
preparation.prepareNext()
generation.generate(created.requestId, 1)
val rows = candidates(created.requestId)
assertEquals(12, rows.size)
assertEquals(listOf("ko", "en", "ja").filter { it != source }.toSet(), rows.map { it.targetLanguage }.toSet())
assertEquals(setOf("title", "detail", "tags"), rows.map { it.unit.field?.key }.toSet())
assertTrue(rows.all { it.unit.sourceLanguage == source })
}
@Test
@DisplayName("AWS의 unchanged tags는 해당 후보만 실패하고 Papago는 독립적으로 성공한다")
fun shouldFailUnchangedAwsTagsWithoutBlockingPapago() {
val id = generated()
val unchangedAws = object : TranslationProvider {
override val providerId = LanguageProviderId.AWS
override val providerVersion = "test"
override fun translate(request: TranslateRequest) = TranslateResult(
if (request.rejectUnchangedAwsResult) request.texts else request.texts.map { "translated" }
)
}
val worker = TranslationSelectionWorkerService(
requestStore,
candidateStore,
listOf(unchangedAws, papago),
selectionTransactionManager
)
repeat(12) { worker.runNext() }
assertEquals(2, requests.get(id).progress.failed)
assertEquals(10, requests.get(id).progress.succeeded)
assertTrue(
candidates(id).filter { it.failureCode != null }.all { it.unit.field?.key == "tags" && it.provider.id == "aws" }
)
assertEquals(6, papago.requests.size)
}
@Test
@DisplayName("수락된 generate revision의 replay는 취소 및 최신 revision 검사보다 먼저 처리한다")
fun shouldReplayGenerateBeforeClosedOrRevisionChecks() {
val id = generated()
val original = candidates(id).map { it.candidateId }
requests.cancel(id)
assertEquals("CANCELLED", generation.generate(id, 1).status.name)
assertEquals(original, candidates(id).map { it.candidateId })
assertEquals("REQUEST_CLOSED", assertThrows(SodaException::class.java) { generation.generate(id, 2) }.errorProperty)
assertEquals(0, provider.calls.get())
assertEquals(0, papago.requests.size)
}
@Test
@DisplayName("모두 개별인 시리즈도 검토 전에는 generate를 시작할 수 없다")
fun shouldRequireReviewForAllIndividualSeries() {
val id = fixture()
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(listOf(id))))
preparation.prepareNext()
assertEquals(
"REVIEW_REQUIRED",
assertThrows(SodaException::class.java) { generation.generate(created.requestId, 1) }.errorProperty
)
assertEquals(emptyList<Long>(), candidates(created.requestId).map { it.candidateId })
}
@Test
@DisplayName("한 제공자의 실패는 다른 제공자 성공과 출처를 보존한다")
fun shouldIsolateProviderFailureAndKeepEqualResultOrigins() {
val id = generated()
provider.fail = true
drain(id)
val rows = candidates(id)
assertEquals("READY", requests.get(id).status.name)
assertEquals(6, rows.count { it.status == TranslationCandidateStatus.SUCCEEDED && it.provider.id == "papago" })
assertEquals(6, rows.count { it.failureCode?.name == "PROVIDER_FAILED" && it.provider.id == "aws" })
assertEquals(6, papago.requests.size)
assertEquals(0, memories.count())
}
@Test
@DisplayName("모든 제공자가 실패해도 후보가 종결되면 요청은 READY다")
fun shouldReachReadyAfterAllProviderFailures() {
val id = generated()
provider.fail = true
papago.result = { throw IllegalStateException("secret provider body") }
drain(id)
val result = requests.get(id)
assertEquals("READY", result.status.name)
assertEquals(12, result.progress.failed)
assertEquals(12, result.progress.terminal)
assertTrue(candidates(id).all { it.translatedValues == null && it.failureCode?.name == "PROVIDER_FAILED" })
}
@Test
@DisplayName("동일 번역 결과여도 후보 ID와 제공자 출처는 별개로 유지한다")
fun shouldKeepBothProvidersForEqualResults() {
val id = generated()
drain(id)
val title = candidates(id).filter { it.unit.field?.key == "title" && it.targetLanguage == "en" }
assertEquals(2, title.map { it.candidateId }.distinct().size)
assertEquals(setOf("aws", "papago"), title.map { it.provider.id }.toSet())
assertEquals(listOf(listOf("English title"), listOf("English title")), title.map { it.translatedValues })
}
@Test
@DisplayName("동결 이후 버전이 바뀌거나 사라진 제공자는 대체 없이 PROVIDER_CHANGED로 종결한다")
fun shouldFailChangedProviderWithoutSubstitution() {
val id = generated()
papago.providerVersion = "changed"
drain(id)
assertEquals(6, candidates(id).count { it.failureCode?.name == "PROVIDER_CHANGED" })
assertEquals(0, papago.requests.size)
assertEquals(6, provider.calls.get())
assertEquals("nmt-test", requests.get(id).snapshot.providerManifest.single { it.id == "papago" }.version)
}
@ParameterizedTest
@ValueSource(strings = ["blank", "count"])
@DisplayName("개수 불일치와 공백 결과는 INVALID_PROVIDER_RESULT다")
fun shouldRejectInvalidProviderResults(kind: String) {
val id = generated()
papago.result = { if (kind == "count") emptyList() else listOf(" \t") }
drain(id)
assertEquals(6, candidates(id).count { it.failureCode?.name == "INVALID_PROVIDER_RESULT" })
assertEquals("READY", requests.get(id).status.name)
}
@Test
@DisplayName("빈 필드는 후보나 외부 호출을 만들지 않고 즉시 READY가 된다")
fun shouldReachReadyWithZeroWork() {
val contentId = fixture()
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, contentId).apply { title = " "; detail = "" }
entityManager.createQuery("delete from AudioContentHashTag t where t.audioContent.id = :id")
.setParameter("id", contentId).executeUpdate()
}
val created = request(contentId)
preparation.prepareNext()
val result = generation.generate(created.requestId, 1)
assertEquals("READY", result.status.name)
assertEquals(0, result.progress.total)
assertEquals(0, provider.calls.get())
assertEquals(0, papago.requests.size)
}
}
@@ -0,0 +1,51 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.content.LanguageDetectionResultRepository
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 org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.transaction.PlatformTransactionManager
import java.util.concurrent.atomic.AtomicInteger
class TranslationSelectionDetectionDispatchIntegrationTest : TranslationSelectionTestSupport() {
@Autowired private lateinit var results: LanguageDetectionResultRepository
@Autowired private lateinit var sources: ContentTranslationSourceService
@Autowired private lateinit var manager: PlatformTransactionManager
@Test
@DisplayName("첫 감지 제공자 실행 중 취소하면 cache detector의 다음 제공자 dispatch도 거부한다")
fun shouldStopFallbackDetectionAfterCancellation() {
val created = request(fixture(null))
val fallbackCalls = AtomicInteger()
val fallback = object : LanguageDetectionProvider {
override val providerId = LanguageProviderId.PAPAGO
override fun detect(query: String): String {
fallbackCalls.incrementAndGet()
return "ko"
}
}
val order = listOf(LanguageProviderId.AWS, LanguageProviderId.PAPAGO)
val detector = LanguageDetectionCacheService(
results,
listOf(provider, fallback),
LanguageProviderProperties(order, order),
manager
)
val worker = TranslationSelectionPreparationService(requestStore, sources, detector, listOf(provider), manager)
provider.detection = null
provider.beforeDetect = { requests.cancel(created.requestId) }
worker.prepareNext()
assertEquals("CANCELLED", requests.get(created.requestId).status.name)
assertEquals(0, fallbackCalls.get())
assertEquals(0, requests.get(created.requestId).snapshot.contents.size)
}
}
@@ -0,0 +1,73 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ReviewedSharedPart
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.ReviewedTitleGroup
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TitleOccurrence
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationUnitKind
import kr.co.vividnext.sodalive.v2.contenttranslation.dto.ReviewTranslationSelectionGroupingRequest
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.beans.factory.annotation.Autowired
import java.util.UUID
class TranslationSelectionGroupingGenerationIntegrationTest : TranslationCandidateTestSupport() {
@Autowired private lateinit var grouping: TranslationSelectionGroupingService
@Test
@DisplayName("공통 배열 순서와 member 소유권을 보존하며 동일 residual 입력은 요청 안에서만 공유한다")
fun shouldTranslateCommonOnceAndDeduplicateResidualWithoutLosingMembers() {
val titles = listOf("공통 잔여 구문 끝 1", "공통 잔여 구문 끝 2", "공통 끝 3", "개별 제목")
val ids = titles.map { title ->
val id = fixture()
transaction.executeWithoutResult {
entityManager.find(AudioContent::class.java, id).apply { this.title = title; detail = "" }
entityManager.createQuery("delete from AudioContentHashTag t where t.audioContent.id = :id")
.setParameter("id", id).executeUpdate()
}
id
}
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(series(ids)))
preparation.prepareNext()
val members = ids.take(3)
val end = ReviewedSharedPart(
"end",
members.mapIndexed { i, id ->
val start = titles[i].indexOf("끝")
TitleOccurrence(id, start, start + 1)
}
)
val start = ReviewedSharedPart("start", members.map { TitleOccurrence(it, 0, 2) })
grouping.review(
created.requestId,
ReviewTranslationSelectionGroupingRequest(
1,
listOf(ReviewedTitleGroup("g", members, listOf(end, start))),
listOf(ids.last())
)
)
generation.generate(created.requestId, 2)
val frozen = requests.get(created.requestId).snapshot
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, ids.first()).title = "changed" }
drain(created.requestId)
assertEquals(frozen, requests.get(created.requestId).snapshot)
assertEquals(16, candidates(created.requestId).size)
assertEquals(6, papago.requests.size)
assertEquals(
listOf(listOf("끝", "공통"), listOf("잔여 구문"), listOf("개별 제목")).toSet(),
papago.requests.map { it.texts }.toSet()
)
val residuals = candidates(created.requestId).filter { it.unit.kind == TranslationUnitKind.TITLE_RESIDUAL }
assertEquals(members.take(2).toSet(), residuals.map { it.unit.contentId }.toSet())
assertTrue(
candidates(created.requestId).none { it.unit.kind == TranslationUnitKind.FIELD && it.unit.contentId in members }
)
assertEquals(emptyList<String>(), papago.requests.flatMap { it.texts }.filter { it.isBlank() })
assertEquals(0, memories.count())
}
}
@@ -0,0 +1,32 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.scheduler.TranslationSelectionWorker
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.redisson.api.RLock
import org.redisson.api.RedissonClient
import org.springframework.beans.factory.annotation.Autowired
import java.util.concurrent.TimeUnit
class TranslationSelectionPollingIntegrationTest : TranslationSelectionTestSupport() {
@Autowired private lateinit var worker: TranslationSelectionWorker
@Autowired private lateinit var redisson: RedissonClient
@ParameterizedTest
@ValueSource(booleans = [false, true])
@DisplayName("feature poller는 기존 Redisson lock 소유권이 있을 때만 durable 준비를 처리한다")
fun shouldPrepareOnlyWhenSchedulerLockIsHeld(held: Boolean) {
val created = request(fixture())
val lock = Mockito.mock(RLock::class.java)
Mockito.`when`(redisson.getLock("lock:translation-selection")).thenReturn(lock)
Mockito.`when`(lock.tryLock(0, 180, TimeUnit.SECONDS)).thenReturn(held)
Mockito.`when`(lock.isHeldByCurrentThread).thenReturn(held)
worker.runPendingRequests()
assertEquals(if (held) "READY_TO_GENERATE" else "PREPARING", requests.get(created.requestId).status.name)
assertEquals(0, provider.calls.get())
}
}
@@ -0,0 +1,198 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.LanguageDetectionCacheService
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
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.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.NullSource
import org.junit.jupiter.params.provider.ValueSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.support.TransactionSynchronizationManager
import java.time.LocalDateTime
import java.util.UUID
import java.util.concurrent.CountDownLatch
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
class TranslationSelectionPreparationIntegrationTest : TranslationSelectionTestSupport() {
@Autowired private lateinit var sources: ContentTranslationSourceService
@Autowired private lateinit var detector: LanguageDetectionCacheService
@Autowired private lateinit var manager: PlatformTransactionManager
@Test
@DisplayName("유효한 기존 언어는 재감지 없이 snapshot과 모든 등록 제공자 버전을 준비한다")
fun shouldUseValidSourceLanguageWithoutRedetection() {
val created = request(fixture("en"))
assertTrue(preparation.prepareNext())
val result = requests.get(created.requestId)
assertEquals("READY_TO_GENERATE", result.status.name)
assertEquals(listOf("ko", "ja"), result.snapshot.targetLanguages)
assertEquals(listOf("aws" to "test"), result.snapshot.providerManifest.map { it.id to it.version })
assertEquals(emptyList<String>(), provider.detectionQueries)
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("누락 언어 감지는 DB 잠금 밖에서 실행하고 기존 payload와 일반 번역 작업을 변경하지 않는다")
fun shouldDetectMissingLanguageWithoutPublishingOrEnqueuing() {
val id = fixture(null)
val old = ContentTranslationPayload("Published", " Previous detail ", "#old")
translations.saveAndFlush(ContentTranslation(id, "en", old))
val created = request(id)
provider.beforeDetect = { assertFalse(TransactionSynchronizationManager.isActualTransactionActive()) }
assertTrue(preparation.prepareNext())
val result = requests.get(created.requestId)
assertEquals("READY_TO_GENERATE", result.status.name)
assertEquals("ko", result.snapshot.contents.single().sourceLanguage)
assertEquals("ko", snapshot(id).sourceLanguage)
assertEquals(listOf("원문 제목 원문 설명 #힐링"), provider.detectionQueries)
assertEquals(old, payload(id))
assertEquals(0L, jobs.count())
assertEquals(0L, memories.count())
assertEquals(0, provider.calls.get())
}
@ParameterizedTest
@NullSource
@ValueSource(strings = ["fr"])
@DisplayName("실패하거나 미지원인 감지는 부분 snapshot을 게시하지 않고 명시적으로 실패한다")
fun shouldFailUnsupportedOrUndetectedLanguage(detected: String?) {
val id = fixture(null)
val created = request(id)
provider.detection = detected
preparation.prepareNext()
val result = requests.get(created.requestId)
assertEquals("FAILED", result.status.name)
assertEquals(if (detected == null) "LANGUAGE_DETECTION_FAILED" else "UNSUPPORTED_SOURCE_LANGUAGE", result.errorCode?.name)
assertEquals(emptyList<Long>(), result.snapshot.contents.map { it.contentId })
assertEquals(null, snapshot(id).sourceLanguage)
}
@Test
@DisplayName("저장된 미지원 원본 언어는 재감지로 대체하지 않는다")
fun shouldFailExistingUnsupportedLanguage() {
val created = request(fixture("fr"))
preparation.prepareNext()
assertEquals("UNSUPPORTED_SOURCE_LANGUAGE", requests.get(created.requestId).errorCode?.name)
assertEquals(emptyList<String>(), provider.detectionQueries)
}
@Test
@DisplayName("감지 전에 취소된 요청은 새 감지를 시작하지 않는다")
fun shouldCancelBeforeDetection() {
val created = request(fixture(null))
requests.cancel(created.requestId)
assertFalse(preparation.prepareNext())
assertEquals("CANCELLED", requests.get(created.requestId).status.name)
assertEquals(emptyList<String>(), provider.detectionQueries)
}
@ParameterizedTest
@ValueSource(strings = ["cancel", "source", "membership"])
@DisplayName("감지 중 취소 또는 원문 구성원 변경은 늦은 snapshot과 후속 감지를 막는다")
fun shouldNotPublishPreparedSnapshotAfterCancelOrSourceChange(change: String) {
val id = fixture(null)
val second = fixture(null)
val seriesId = series(listOf(id, second))
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(seriesId))
provider.beforeDetect = {
when (change) {
"cancel" -> requests.cancel(created.requestId)
"source" -> transaction.executeWithoutResult { writer.lockContent(id)!!.title = "변경" }
"membership" -> transaction.executeWithoutResult { writer.lockContent(second)!!.isActive = false }
}
}
preparation.prepareNext()
val result = requests.get(created.requestId)
assertEquals(if (change == "cancel") "CANCELLED" else "FAILED", result.status.name)
assertEquals(
when (change) { "source" -> "SOURCE_CHANGED"; "membership" -> "MEMBERSHIP_CHANGED"; else -> null },
result.errorCode?.name
)
assertEquals(emptyList<Long>(), result.snapshot.contents.map { it.contentId })
assertEquals(null, snapshot(id).sourceLanguage)
assertEquals(1, provider.detectionQueries.size)
assertEquals(0L, jobs.count())
}
@Test
@DisplayName("진행 중 감지의 종료를 기다리지 않고 취소를 커밋하며 늦은 결과를 폐기한다")
fun shouldCancelWhileDetectionIsInFlight() {
val id = fixture(null)
val created = request(id)
val entered = CountDownLatch(1)
val release = CountDownLatch(1)
val executor = Executors.newSingleThreadExecutor()
provider.beforeDetect = { entered.countDown(); check(release.await(10, TimeUnit.SECONDS)) }
try {
val running = executor.submit<Boolean> { preparation.prepareNext() }
assertTrue(entered.await(5, TimeUnit.SECONDS))
val cancelled = requests.cancel(created.requestId)
assertEquals("CANCELLED", cancelled.status.name)
assertEquals("CANCELLED", requests.get(created.requestId).status.name)
release.countDown()
assertTrue(running.get(10, TimeUnit.SECONDS))
assertEquals(emptyList<Long>(), requests.get(created.requestId).snapshot.contents.map { it.contentId })
assertEquals(null, snapshot(id).sourceLanguage)
} finally {
release.countDown()
executor.shutdownNow()
}
}
@Test
@DisplayName("60초 lease 만료는 한 번만 복구하며 두 번째 만료는 준비 중단으로 실패한다")
fun shouldRecoverPreparationOnceThenFail() {
var now = LocalDateTime.of(2026, 11, 17, 23, 59, 59, 999999999)
val worker = TranslationSelectionPreparationService(requestStore, sources, detector, listOf(provider), manager) { now }
val created = request(fixture(null))
val first = requireNotNull(worker.claimNext())
assertEquals(1, requests.get(created.requestId).preparationAttempt)
assertEquals(LocalDateTime.of(2026, 11, 18, 0, 0, 59), requests.get(created.requestId).preparationLeaseUntil)
now = now.plusSeconds(60)
val recovered = requireNotNull(worker.claimNext())
assertTrue(recovered.fence > first.fence)
assertEquals(2, requests.get(created.requestId).preparationAttempt)
worker.processPrepare(first)
assertEquals(emptyList<String>(), provider.detectionQueries)
now = now.plusSeconds(60)
assertEquals(null, worker.claimNext())
val failed = requests.get(created.requestId)
assertEquals("FAILED", failed.status.name)
assertEquals("PREPARATION_INTERRUPTED", failed.errorCode?.name)
worker.processPrepare(recovered)
assertEquals(emptyList<Long>(), requests.get(created.requestId).snapshot.contents.map { it.contentId })
}
@Test
@DisplayName("만료된 실행은 스스로 lease를 갱신하거나 복구 실행의 snapshot을 덮지 못한다")
fun shouldRejectExpiredFenceAndPublishRecovery() {
var now = LocalDateTime.of(2026, 11, 17, 0, 0)
val worker = TranslationSelectionPreparationService(requestStore, sources, detector, listOf(provider), manager) { now }
val created = request(fixture(null))
val first = requireNotNull(worker.claimNext())
now = now.plusSeconds(60)
worker.processPrepare(first)
assertEquals(emptyList<String>(), provider.detectionQueries)
val recovered = requireNotNull(worker.claimNext())
worker.processPrepare(recovered)
val result = requests.get(created.requestId)
worker.processPrepare(first)
assertEquals("READY_TO_GENERATE", result.status.name)
assertEquals(result, requests.get(created.requestId))
assertEquals(1, provider.detectionQueries.size)
}
}
@@ -0,0 +1,143 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentDetailTranslationService
import kr.co.vividnext.sodalive.content.AudioContentService
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.i18n.translation.LanguageTranslationTargetType
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.v2.contenttranslation.domain.ContentSourceFieldKey
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.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.SpyBean
import org.springframework.data.jpa.repository.Query
import org.springframework.transaction.support.TransactionSynchronizationManager
import java.time.LocalDateTime
class TranslationSelectionRefreshIntegrationTest : TranslationSelectionApplyTestSupport() {
@Autowired private lateinit var ownerService: AudioContentService
@Autowired private lateinit var ordinaryWorker: TranslationJobWorker
@Autowired private lateinit var detailService: AudioContentDetailTranslationService
@SpyBean private lateinit var claims: TranslationJobRepository
@BeforeEach
fun useH2ClaimSyntax() {
val sql = TranslationJobRepository::class.java.getMethod("findNextPendingGroupJobIdsForUpdate", LocalDateTime::class.java)
.getAnnotation(Query::class.java).value.replace("skip locked", "")
Mockito.doAnswer { call ->
entityManager.createNativeQuery(sql).setParameter("now", call.getArgument<LocalDateTime>(0))
.resultList.map { (it as Number).toLong() }
}.`when`(claims).findNextPendingGroupJobIdsForUpdate(Mockito.any(LocalDateTime::class.java) ?: LocalDateTime.now())
}
@Test
@DisplayName("후보 제목 상세만 적용한 뒤 일반 제목 수정과 worker는 태그 메모리 없이 제목을 게시하고 완료한다")
fun shouldRefreshChangedTitleAfterPartialApplyWithoutUnselectedMemories() {
val id = fixture()
applyTitleAndDetail(id)
assertEquals(ContentTranslationPayload("English title", "English detail", "#힐링"), payload(id))
assertEquals(0L, memories.count())
assertEquals(0L, jobs.count())
assertFalse(materializer.materialize(LanguageTranslationTargetType.CONTENT, id, "en"))
modify(id, "")
val detailApproval = transaction.execute { overrides.findByContentId(id).single() }!!
assertEquals(ContentSourceFieldKey.DETAIL, detailApproval.approval.field)
assertEquals(setOf("title"), jobs.findAll().map { it.fieldKey }.toSet())
provider.beforeTranslate = { assertFalse(TransactionSynchronizationManager.isActualTransactionActive()) }
assertTrue(ordinaryWorker.processNextGroup())
assertEquals(ContentTranslationPayload("Edited title", "English detail", "#힐링"), payload(id))
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single { it.targetLanguage == "en" }.status)
assertEquals(detailApproval, transaction.execute { overrides.findByContentId(id).single() })
assertEquals(listOf("수정 제목"), memories.findAll().map { it.sourceText })
assertEquals(0, memories.findAll().count { it.sourceHash == SourceTextNormalizer.hash("#힐링") })
assertEquals("Edited title", detailService.resolve(id, "en").translated?.title)
assertEquals(setOf("title"), jobs.findAll().map { it.fieldKey }.toSet())
}
@Test
@DisplayName("변경되지 않은 태그의 메모리가 있어도 worker는 기존 payload의 태그 바이트를 그대로 보존한다")
fun shouldPreserveUnselectedPayloadEvenWhenItsMemoryExists() {
val id = fixture()
applyTitleAndDetail(id)
val tags = " \t#Legacy, #Tags\n"
transaction.executeWithoutResult {
translations.findByContentIdAndLocale(id, "en")!!.renderedPayload =
ContentTranslationPayload("English title", "English detail", tags)
}
memories.saveAndFlush(
TranslationMemory(SourceTextNormalizer.hash("#힐링"), "#힐링", "ko", "en", "#Automatic tags", "aws", "test")
)
modify(id, "")
assertTrue(ordinaryWorker.processNextGroup())
assertEquals(ContentTranslationPayload("Edited title", "English detail", tags), payload(id))
assertEquals(TranslationJobStatus.COMPLETED, jobs.findAll().single { it.targetLanguage == "en" }.status)
}
@ParameterizedTest
@ValueSource(booleans = [true, false])
@DisplayName("같은 변경 묶음의 태그 번역 실패 시 기존 payload의 성공 제목만 게시하며 새 payload는 완성 전 생성하지 않는다")
fun shouldCompleteSuccessfulFieldsOnlyAfterPublishingThem(existingPayload: Boolean) {
val id = fixture()
if (existingPayload) applyTitleAndDetail(id)
modify(id, ",\"tags\":\"#새태그\"")
assertEquals(setOf("title", "tags"), jobs.findAll().map { it.fieldKey }.toSet())
provider.beforeTranslate = { assertFalse(TransactionSynchronizationManager.isActualTransactionActive()) }
assertTrue(ordinaryWorker.processNextGroup())
val englishJobs = jobs.findAll().filter { it.targetLanguage == "en" }.associateBy { it.fieldKey }
assertEquals(TranslationJobStatus.PENDING, englishJobs.getValue("tags").status)
assertEquals(1, englishJobs.getValue("tags").retryCount)
assertEquals(listOf("수정 제목"), memories.findAll().map { it.sourceText })
if (existingPayload) {
assertEquals(ContentTranslationPayload("Edited title", "English detail", "#새태그"), payload(id))
assertEquals(TranslationJobStatus.COMPLETED, englishJobs.getValue("title").status)
assertEquals(
setOf(ContentSourceFieldKey.DETAIL),
transaction.execute { overrides.findByContentId(id).map { it.approval.field }.toSet() }
)
} else {
assertNull(payload(id))
assertEquals(TranslationJobStatus.PENDING, englishJobs.getValue("title").status)
assertEquals(1, englishJobs.getValue("title").retryCount)
}
}
private fun applyTitleAndDetail(id: Long) {
val request = ready(id)
applyService.apply(
request.requestId,
777,
body(request, listOf(field(request, ContentSourceFieldKey.TITLE), field(request, ContentSourceFieldKey.DETAIL)))
)
}
private fun modify(id: Long, extra: String) {
val creator = transaction.execute { entityManager.find(AudioContent::class.java, id).member }!!
ownerService.modifyAudioContent(
null,
"""{"contentId":$id,"title":"수정 제목","isAdult":false,"isCommentAvailable":true$extra}""",
creator
)
}
}
@@ -0,0 +1,175 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import com.fasterxml.jackson.databind.JsonNode
import kr.co.vividnext.sodalive.common.SodaException
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionStatus
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
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.ValueSource
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
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.http.MediaType
import java.time.LocalDateTime
import java.util.UUID
import java.util.concurrent.Callable
import java.util.concurrent.CyclicBarrier
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
classes = [TranslationSelectionTestConfiguration::class],
properties = ["spring.cache.type=none"]
)
class TranslationSelectionRequestIntegrationTest : TranslationSelectionTestSupport() {
@Autowired private lateinit var http: TestRestTemplate
@Test
@DisplayName("생성은 외부 호출 전에 PREPARING 요청을 저장하고 같은 본문은 원래 요청을 반환한다")
fun shouldReplaySameCreationBody() {
val contentId = fixture(null)
val adminId = transaction.execute {
val admin = Member(password = "test", nickname = "selection-admin").apply { role = MemberRole.ADMIN }
entityManager.persist(admin)
requireNotNull(admin.id)
}!!
val headers = HttpHeaders().apply {
contentType = MediaType.APPLICATION_JSON
set("X-Test-Member", adminId.toString())
}
val body = """{"clientRequestId":"${UUID.randomUUID()}","scope":{"type":"CONTENT","contentId":$contentId}}"""
val first = http.postForEntity(BASE, HttpEntity(body, headers), JsonNode::class.java)
assertEquals(200, first.statusCodeValue)
assertTrue(first.body!!.path("success").booleanValue())
val data = first.body!!.path("data")
assertEquals("PREPARING", data.path("status").textValue())
assertEquals(1, jdbc.queryForObject("select count(*) from translation_selection_request", Int::class.java))
val replay = http.postForEntity(BASE, HttpEntity(body, headers), JsonNode::class.java)
assertEquals(data, replay.body!!.path("data"))
assertEquals(emptyList<String>(), provider.detectionQueries)
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("같은 관리자 UUID에 다른 범위를 보내면 원래 요청을 유지하고 충돌한다")
fun shouldRejectReusedClientIdWithDifferentBody() {
val key = UUID.randomUUID()
val first = requests.create(91, key, TranslationSelectionScope.Content(fixture()))
val error = assertThrows(SodaException::class.java) {
requests.create(91, key, TranslationSelectionScope.Content(fixture()))
}
assertEquals("IDEMPOTENCY_CONFLICT", error.errorProperty)
assertEquals(first, requests.get(first.requestId))
}
@Test
@DisplayName("동시 생성 unique 충돌은 롤백된 삽입과 분리하여 같은 요청으로 반환한다")
fun shouldSerializeConcurrentUniqueCreation() {
val scope = TranslationSelectionScope.Content(fixture())
val key = UUID.randomUUID()
val barrier = CyclicBarrier(2)
val executor = Executors.newFixedThreadPool(2)
try {
val results = (1..2).map {
executor.submit(Callable { barrier.await(5, TimeUnit.SECONDS); requests.create(91, key, scope) })
}.map { it.get(10, TimeUnit.SECONDS) }
assertEquals(results[0].requestId, results[1].requestId)
assertEquals(1L, requestRepository.count())
} finally {
executor.shutdownNow()
}
}
@Test
@DisplayName("현재 연결된 활성 콘텐츠만 고정하고 시리즈 자체 언어는 감지하지 않는다")
fun shouldSnapshotOnlyActiveLinkedMembers() {
val active = fixture()
val inactive = fixture()
fixture()
val seriesId = series(listOf(active, inactive))
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, inactive).isActive = false }
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(seriesId))
assertEquals(listOf(active), created.snapshot.memberContentIds)
assertTrue(preparation.prepareNext())
val prepared = requests.get(created.requestId)
assertEquals(TranslationSelectionStatus.REVIEW_REQUIRED, prepared.status)
assertEquals(listOf(active), prepared.snapshot.contents.map { it.contentId })
assertEquals(listOf(active), prepared.snapshot.grouping!!.individualContentIds)
assertEquals(null, transaction.execute { entityManager.find(Series::class.java, seriesId).languageCode })
assertEquals(emptyList<String>(), provider.detectionQueries)
}
@Test
@DisplayName("활성 콘텐츠가 없는 시리즈는 EMPTY_SCOPE 실패 요청을 저장한다")
fun shouldStoreEmptyScopeFailure() {
val id = fixture()
val seriesId = series(listOf(id))
transaction.executeWithoutResult { entityManager.find(AudioContent::class.java, id).isActive = false }
val created = requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Series(seriesId))
assertEquals(TranslationSelectionStatus.FAILED, requests.get(created.requestId).status)
assertEquals("EMPTY_SCOPE", created.errorCode?.name)
assertEquals(1L, requestRepository.count())
}
@ParameterizedTest
@ValueSource(ints = [0, 123456789, 999999999])
@DisplayName("생성 UTC 시각은 날짜 경계에서 초 단위로 한 번 정규화하고 DB 왕복에도 동일하다")
fun shouldPersistSecondPrecisionCreationTime(nano: Int) {
val fixed = LocalDateTime.of(2026, 11, 17, 23, 59, 59, nano)
val service = TranslationSelectionRequestService(
requestStore,
sourceService,
transactionManagerForSelection,
candidateStore
) { fixed }
val result = service.create(91, UUID.randomUUID(), TranslationSelectionScope.Content(fixture()))
val stored = transaction.execute {
entityManager.flush()
entityManager.clear()
requestStore.find(result.requestId)
}!!
assertEquals(LocalDateTime.of(2026, 11, 17, 23, 59, 59), result.createdAt)
assertEquals(result.createdAt, stored.createdAt)
assertEquals(result.updatedAt, stored.updatedAt)
val adminId = transaction.execute {
val admin = Member(password = "test", nickname = "timestamp-admin").apply { role = MemberRole.ADMIN }
entityManager.persist(admin)
requireNotNull(admin.id)
}!!
val headers = HttpHeaders().apply { set("X-Test-Member", adminId.toString()) }
val response = http.exchange(
"$BASE/${result.requestId}",
HttpMethod.GET,
HttpEntity<String>(headers),
JsonNode::class.java
)
assertEquals("2026-11-17T23:59:59Z", response.body!!.path("data").path("createdAt").asText())
}
@Autowired private lateinit var sourceService: ContentTranslationSourceService
@Autowired private lateinit var candidateStore: kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationCandidateStore
@Autowired private lateinit var transactionManagerForSelection: org.springframework.transaction.PlatformTransactionManager
companion object {
const val BASE = "/admin/audio-content/translation-requests"
}
}
@@ -0,0 +1,28 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.common.SodaExceptionHandler
import kr.co.vividnext.sodalive.content.ContentDetailTranslationTestConfiguration
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web.AdminTranslationSelectionController
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.`in`.web.TranslationSelectionInputExceptionHandler
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaTranslationCandidateStore
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.out.persistence.JpaTranslationSelectionStore
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.scheduler.TranslationSelectionWorker
import org.redisson.api.RedissonClient
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Import
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity
@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true)
@Import(
ContentDetailTranslationTestConfiguration::class, SodaExceptionHandler::class,
JpaTranslationSelectionStore::class, JpaTranslationCandidateStore::class, ContentTranslationSourceService::class,
TranslationSelectionGenerationService::class, TranslationSelectionCandidateQueryService::class,
TranslationSelectionWorkerService::class, TranslationSelectionApplyService::class,
TranslationSelectionRequestService::class, TranslationSelectionPreparationService::class,
AdminTranslationSelectionController::class, TranslationSelectionInputExceptionHandler::class,
TranslationSelectionGroupingService::class, TranslationSelectionContentsService::class, TranslationSelectionWorker::class
)
@MockBean(RedissonClient::class)
class TranslationSelectionTestConfiguration
@@ -0,0 +1,54 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.AudioContent
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.v2.contenttranslation.adapter.out.persistence.TranslationSelectionRequestRepository
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionRequest
import kr.co.vividnext.sodalive.v2.contenttranslation.domain.TranslationSelectionScope
import kr.co.vividnext.sodalive.v2.contenttranslation.port.TranslationSelectionStore
import org.junit.jupiter.api.BeforeEach
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import java.util.UUID
@SpringBootTest(
classes = [TranslationSelectionTestConfiguration::class],
properties = ["spring.cache.type=none", "spring.jpa.show-sql=false"]
)
abstract class TranslationSelectionTestSupport : ContentTranslationTestSupport() {
@Autowired protected lateinit var requests: TranslationSelectionRequestService
@Autowired protected lateinit var preparation: TranslationSelectionPreparationService
@Autowired protected lateinit var requestStore: TranslationSelectionStore
@Autowired protected lateinit var requestRepository: TranslationSelectionRequestRepository
@BeforeEach
fun prepareSelectionStorage() {
jdbc.update("delete from translation_candidate")
requestRepository.deleteAllInBatch()
}
protected fun request(id: Long): TranslationSelectionRequest =
requests.create(91, UUID.randomUUID(), TranslationSelectionScope.Content(id))
protected fun series(ids: List<Long>): Long = transaction.execute {
val creator = entityManager.find(AudioContent::class.java, ids.first()).member
val genre = SeriesGenre("selection-genre")
entityManager.persist(genre)
val series = Series("시리즈 메타데이터", "소개", null).apply { member = creator; this.genre = genre }
entityManager.persist(series)
ids.forEach { id ->
entityManager.persist(
SeriesContent().apply {
this.series = series
content = entityManager.find(AudioContent::class.java, id)
}
)
}
requireNotNull(series.id)
}!!
}
@@ -0,0 +1,146 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.application
import com.fasterxml.jackson.databind.JsonNode
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRole
import kr.co.vividnext.sodalive.v2.contenttranslation.adapter.scheduler.TranslationSelectionWorker
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.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.redisson.api.RLock
import org.redisson.api.RedissonClient
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
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.http.MediaType
import java.util.concurrent.TimeUnit
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
classes = [TranslationSelectionTestConfiguration::class],
properties = ["spring.cache.type=none"]
)
class TranslationSelectionWorkerIntegrationTest : TranslationCandidateTestSupport() {
@Autowired private lateinit var http: TestRestTemplate
@Autowired private lateinit var worker: TranslationSelectionWorker
@Autowired private lateinit var redisson: RedissonClient
@Test
@DisplayName("생성 API는 저장된 원문에서 모든 필드와 source 외 언어의 durable 후보를 만든다")
fun shouldGenerateAllFieldsAndNonSourceSupportedLanguages() {
val created = request(fixture())
preparation.prepareNext()
val result = http.postForEntity(
"/admin/audio-content/translation-requests/${created.requestId}/generate",
HttpEntity("""{"expectedRevision":1}""", adminHeaders()),
JsonNode::class.java
)
assertEquals(200, result.statusCodeValue)
assertTrue(result.body!!.path("success").asBoolean())
assertEquals("GENERATING", result.body!!.path("data").path("status").asText())
assertEquals(12, result.body!!.path("data").path("progress").path("total").asInt())
}
@Test
@DisplayName("후보 HTTP는 모든 상태를 cursor로 반환하고 provider 예외 원문을 숨긴다")
fun shouldPageAllCandidateStatesAndReturnActualProgress() {
val id = generated()
val headers = adminHeaders()
val base = "/admin/audio-content/translation-requests/$id"
fun get(path: String) = requireNotNull(
http.exchange(base + path, HttpMethod.GET, HttpEntity<String>(headers), JsonNode::class.java).body
)
val first = get("/candidates?size=5").path("data")
val cursor = first.path("nextAfterCandidateId").asLong()
val second = get("/candidates?afterCandidateId=$cursor&size=100").path("data")
assertEquals(5, first.path("items").size())
assertEquals(7, second.path("items").size())
assertTrue(second.path("nextAfterCandidateId").isNull)
val rows = first.path("items").toList() + second.path("items").toList()
assertEquals(12, rows.map { it.path("candidateId").asLong() }.distinct().size)
assertTrue(first.path("items").all { it.path("status").asText() == "PENDING" && it.path("inputValues").size() == 1 })
assertEquals("INVALID_REQUEST", get("/candidates?size=101").path("errorProperty").asText())
assertEquals(0, provider.calls.get())
papago.result = { throw IllegalStateException("secret-raw-provider-body") }
drain(id)
val terminal = get("/candidates").path("data").path("items")
assertEquals(
6,
terminal.count { it.path("status").asText() == "FAILED" && it.path("failureCode").asText() == "PROVIDER_FAILED" }
)
assertFalse(terminal.toString().contains("secret-raw-provider-body"))
val summary = get("").path("data")
assertEquals("READY", summary.path("status").asText())
assertEquals(12, summary.path("progress").path("terminal").asInt())
assertEquals(6, summary.path("progress").path("succeeded").asInt())
requests.cancel(id)
assertTrue(get("/candidates").path("data").path("items").all { it.path("status").asText() == "DISCARDED" })
}
@Test
@DisplayName("복구를 소진한 후보를 종결한 poll에서도 다른 요청의 준비를 처리한다")
fun shouldPrepareOtherRequestsAfterExhaustedCandidate() {
val id = generated()
val candidateId = candidates(id).first().candidateId
jdbc.update(
"update translation_candidate set status='RUNNING', attempt=2, lease_until=? where id=?",
java.sql.Timestamp.valueOf("2026-01-01 00:00:00"),
candidateId
)
val waiting = request(fixture())
val lock = Mockito.mock(RLock::class.java)
Mockito.`when`(redisson.getLock("lock:translation-selection")).thenReturn(lock)
Mockito.`when`(lock.tryLock(0, 180, TimeUnit.SECONDS)).thenReturn(true)
Mockito.`when`(lock.isHeldByCurrentThread).thenReturn(true)
worker.runPendingRequests()
assertEquals("EXECUTION_INTERRUPTED", candidates(id).first().failureCode?.name)
assertEquals("READY_TO_GENERATE", requests.get(waiting.requestId).status.name)
assertEquals(0, provider.calls.get())
}
@Test
@DisplayName("메모리가 있어도 worker는 제공자를 새로 호출하고 게시 값과 메모리는 바꾸지 않는다")
fun shouldAttemptEveryRegisteredProviderDespiteMemory() {
val id = fixture()
cache(snapshot(id))
approveAll(id)
val original = payload(id)
val created = request(id)
preparation.prepareNext()
generation.generate(created.requestId, 1)
val lock = Mockito.mock(RLock::class.java)
Mockito.`when`(redisson.getLock("lock:translation-selection")).thenReturn(lock)
Mockito.`when`(lock.tryLock(0, 180, TimeUnit.SECONDS)).thenReturn(true)
Mockito.`when`(lock.isHeldByCurrentThread).thenReturn(true)
repeat(12) { worker.runPendingRequests() }
assertEquals("READY", requests.get(created.requestId).status.name)
assertEquals(6, provider.calls.get())
assertEquals(6, papago.requests.size)
assertEquals(12, requests.get(created.requestId).progress.succeeded)
assertEquals(3, memories.count())
assertEquals(original, payload(id))
}
private fun adminHeaders(): HttpHeaders {
val id = transaction.execute {
val member = Member(password = "test", nickname = "candidate-admin").apply { role = MemberRole.ADMIN }
entityManager.persist(member)
requireNotNull(member.id)
}!!
return HttpHeaders().apply { contentType = MediaType.APPLICATION_JSON; set("X-Test-Member", id.toString()) }
}
}
@@ -0,0 +1,188 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.hashtag.AudioContentHashTag
import kr.co.vividnext.sodalive.content.hashtag.HashTag
import kr.co.vividnext.sodalive.i18n.translation.SourceTextNormalizer
import kr.co.vividnext.sodalive.i18n.translation.TranslationSourceField
import kr.co.vividnext.sodalive.v2.contenttranslation.application.toContentSourceSnapshot
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.ValueSource
class ContentSourceSnapshotTest {
@Test
@DisplayName("원문 필드와 쉼표 태그 입력을 보존하고 감지 쿼리의 기존 공백 형식을 유지한다")
fun shouldPreserveRawProviderFieldsAndDetectionFormatting() {
val snapshot = ContentSourceSnapshot("ko", " 제목 \t", "\n상세 내용 ", listOf(" #힐링", "#수면 "))
assertEquals(
listOf(
TranslationSourceField("title", " 제목 \t"),
TranslationSourceField("detail", "\n상세 내용 "),
TranslationSourceField("tags", " #힐링,#수면 ")
),
snapshot.fields
)
assertEquals("제목 상세 내용 #힐링 #수면", snapshot.detectionQuery)
}
@Test
@DisplayName("감지 쿼리는 빈 원문 부분을 제외하고 빈 태그 번역 필드는 보존한다")
fun shouldExcludeBlankPartsOnlyFromDetectionQuery() {
val snapshot = ContentSourceSnapshot(null, " \t", " 상세 ", emptyList())
assertEquals("상세", snapshot.detectionQuery)
assertEquals(listOf(" \t", " 상세 ", ""), snapshot.fields.map { it.sourceText })
assertEquals("", ContentSourceSnapshot(null, " ", "\n", listOf("\t")).detectionQuery)
}
@Test
@DisplayName("활성 태그는 로딩 순서와 무관하게 연관 ID 순서를 따르고 중복과 원문을 보존한다")
fun shouldOrderActiveTagsByAssociationIdWithoutMutatingContent() {
val content = AudioContent("title", "detail", "ko")
content.audioContentHashTags.addAll(
listOf(
association(5L, " z "),
association(2L, "inactive", active = false),
association(3L, "a"),
association(4L, null),
association(1L, " z ")
)
)
val snapshot = content.toContentSourceSnapshot()
content.audioContentHashTags.reverse()
val reloaded = content.toContentSourceSnapshot()
assertEquals(listOf(" z ", "a", " z "), snapshot.tags)
assertEquals(" z ,a, z ", snapshot.fields.last().sourceText)
assertEquals(snapshot, reloaded)
assertEquals(snapshot.hashCode(), reloaded.hashCode())
assertEquals(listOf(1L, 4L, 3L, 2L, 5L), content.audioContentHashTags.map { it.id })
}
@Test
@DisplayName("미저장 태그는 저장된 태그 뒤의 입력 순서를 유지하고 ID 부여 후에도 스냅샷이 같다")
fun shouldAppendPendingTagsAndKeepSnapshotStableAfterIdAssignment() {
val pendingFirst = association(null, "pending-b")
val pendingSecond = association(null, "pending-a")
val content = AudioContent("title", "detail", "en").apply {
audioContentHashTags.addAll(
listOf(association(20L, "saved-b"), pendingFirst, association(10L, "saved-a"), pendingSecond)
)
}
val before = content.toContentSourceSnapshot()
pendingFirst.id = 21L
pendingSecond.id = 22L
val after = content.toContentSourceSnapshot()
assertEquals(listOf("saved-a", "saved-b", "pending-b", "pending-a"), before.tags)
assertEquals(before.tags, after.tags)
assertEquals("saved-a,saved-b,pending-b,pending-a", before.fields.last().sourceText)
assertEquals(before.fields, after.fields)
assertEquals(before.fingerprint(ContentSourceFieldKey.TAGS), after.fingerprint(ContentSourceFieldKey.TAGS))
assertEquals(before, after)
}
@ParameterizedTest
@ValueSource(strings = [" 제목", "제목 ", "제목\n", "제목\r\n"])
@DisplayName("메모리에서 정규화되는 공백 변경도 raw 필드 fingerprint에서는 구분한다")
fun shouldFingerprintRawWhitespaceWithoutChangingMemoryIdentity(changed: String) {
val original = ContentSourceSnapshot("ko", "제목", "제목", listOf("제목"))
val updated = ContentSourceSnapshot("ko", changed, changed, listOf(changed))
assertEquals(SourceTextNormalizer.hash("제목"), SourceTextNormalizer.hash(changed))
ContentSourceFieldKey.values().forEach { field ->
assertNotEquals(original.fingerprint(field), updated.fingerprint(field), field.key)
}
}
@Test
@DisplayName("정규화된 유니코드가 같아도 정확한 원문 코드 포인트를 fingerprint에 반영한다")
fun shouldDistinguishCanonicallyEquivalentRawUnicode() {
val composed = ContentSourceSnapshot("ko", "가", "가", listOf("가"))
val decomposed = ContentSourceSnapshot("ko", "\u1100\u1161", "\u1100\u1161", listOf("\u1100\u1161"))
assertEquals(SourceTextNormalizer.hash(composed.title), SourceTextNormalizer.hash(decomposed.title))
ContentSourceFieldKey.values().forEach { field ->
assertNotEquals(composed.fingerprint(field), decomposed.fingerprint(field), field.key)
}
}
@Test
@DisplayName("원본 언어와 필드 키는 같은 원문 값의 fingerprint를 각각 구분한다")
fun shouldIncludeExactLanguageAndFieldKeyInFingerprint() {
val languages = listOf(null, "", "ko", "KO", "en")
val fingerprints = languages.flatMap { language ->
val snapshot = ContentSourceSnapshot(language, "same", "same", listOf("same"))
ContentSourceFieldKey.values().map(snapshot::fingerprint)
}
assertEquals(15, fingerprints.toSet().size)
assertEquals(true, fingerprints.all { it.matches(Regex("v1:[0-9a-f]{64}")) })
assertEquals(
"v1:1d0cd3ff0611757678c2ae9031792c8514497c1408ab81f7d5795b7d23ab3cb0",
ContentSourceSnapshot("en", "A", "", emptyList()).fingerprint(ContentSourceFieldKey.TITLE)
)
}
@Test
@DisplayName("쉼표 문자열이 같은 태그 벡터도 길이 프레이밍으로 서로 다른 fingerprint를 만든다")
fun shouldDistinguishTagBoundariesDespiteIdenticalProviderText() {
val snapshots = listOf(listOf("a,b", "c"), listOf("a", "b,c"), listOf("a", "b", "c"), listOf("a,b,c"))
.map { ContentSourceSnapshot("en", "title", "detail", it) }
assertEquals(listOf("a,b,c", "a,b,c", "a,b,c", "a,b,c"), snapshots.map { it.fields.last().sourceText })
assertEquals(4, snapshots.map { it.fingerprint(ContentSourceFieldKey.TAGS) }.toSet().size)
assertNotEquals(snapshots[0], snapshots[1])
}
@Test
@DisplayName("태그 벡터는 요소 경계와 순서 및 빈 요소를 fingerprint에서 구분한다")
fun shouldFingerprintTagLengthsOrderAndEmptyElements() {
val vectors = listOf(listOf("a", "bc"), listOf("ab", "c"), listOf("bc", "a"), emptyList(), listOf(""))
val fingerprints = vectors.map {
ContentSourceSnapshot("en", "title", "detail", it).fingerprint(ContentSourceFieldKey.TAGS)
}
assertEquals(5, fingerprints.toSet().size)
}
@Test
@DisplayName("제목 변경은 다른 필드 fingerprint에 영향을 주지 않는다")
fun shouldKeepUnchangedFieldFingerprintsStable() {
val original = ContentSourceSnapshot("ko", "title", "detail", listOf("tag"))
val changed = ContentSourceSnapshot("ko", "edited", "detail", listOf("tag"))
assertNotEquals(original.fingerprint(ContentSourceFieldKey.TITLE), changed.fingerprint(ContentSourceFieldKey.TITLE))
assertEquals(original.fingerprint(ContentSourceFieldKey.DETAIL), changed.fingerprint(ContentSourceFieldKey.DETAIL))
assertEquals(original.fingerprint(ContentSourceFieldKey.TAGS), changed.fingerprint(ContentSourceFieldKey.TAGS))
}
@Test
@DisplayName("스냅샷을 만든 뒤 입력 태그 목록을 수정해도 원문과 fingerprint는 유지된다")
fun shouldDetachSnapshotFromMutableTagInput() {
val tags = mutableListOf("first", "second")
val snapshot = ContentSourceSnapshot("en", "title", "detail", tags)
val fingerprint = snapshot.fingerprint(ContentSourceFieldKey.TAGS)
tags[0] = "edited"
tags.add("third")
assertEquals(listOf("first", "second"), snapshot.tags)
assertEquals("first,second", snapshot.fields.last().sourceText)
assertEquals(fingerprint, snapshot.fingerprint(ContentSourceFieldKey.TAGS))
}
private fun association(id: Long?, tag: String?, active: Boolean = true) = AudioContentHashTag().apply {
this.id = id
hashTag = tag?.let(::HashTag)
isActive = active
}
}
@@ -0,0 +1,271 @@
package kr.co.vividnext.sodalive.v2.contenttranslation.domain
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
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
class TitleGroupingAnalyzerTest {
private val analyzer = TitleGroupingAnalyzer()
@Test
@DisplayName("실제 반복 제목을 묶고 회차 숫자는 원문 literal로 보존한다")
fun shouldGroupSampleTitlesWithoutAnEpisodeParser() {
val inputs = pair("섹드립 하는 여사친 EP.05", "섹드립 하는 여사친 EP.06", "ko")
val result = analyzer.analyze(inputs)
assertEquals(listOf("섹드립 하는 여사친 EP."), result.groups.single().sharedParts.map { it.sourceText })
assertEquals(listOf("05", "06"), result.templates.map { it.segments.last().sourceText })
assertEquals(listOf(emptyList<String>(), emptyList()), result.templates.map { it.residualInputs })
assertEquals(listOf("친구 EP.05", "친구 EP.06"), result.templates.map { it.render(listOf("친구 EP."), emptyList()) })
}
@Test
@DisplayName("접두사나 EP 형식이 아닌 제목 내부의 반복 구간도 찾는다")
fun shouldFindRepeatedInternalSpanWithoutEpisodeRule() {
val result = analyzer.analyze(pair("빨강<공통 이야기>시작", "파랑[공통 이야기]끝", "ko"))
assertEquals(listOf("공통 이야기"), result.groups.single().sharedParts.map { it.sourceText })
assertEquals(listOf("빨강", "시작"), result.templates.first().residualInputs)
assertEquals("red<shared>start", result.templates.first().render(listOf("shared"), listOf("red", "start")))
}
@Test
@DisplayName("한 제목에서 공통 문구가 여러 번 나오면 그 제목은 개별 처리한다")
fun shouldKeepAmbiguousTitlesIndividual() {
val result = analyzer.analyze(pair("이야기 / 이야기", "이야기", "ko"))
assertEquals(emptyList<TitleGroup>(), result.groups)
assertEquals(listOf(1L, 2L), result.individualContentIds)
}
@Test
@DisplayName("같은 문자열이어도 원본 언어가 다른 제목을 함께 묶지 않는다")
fun shouldPartitionBySourceLanguage() {
val inputs = pair("shared 01", "shared 02", "ko") +
listOf(TitleGroupingInput(3, "en", "shared 03"), TitleGroupingInput(4, "en", "shared 04"))
val result = analyzer.analyze(inputs)
assertEquals(listOf(listOf(1L, 2L), listOf(3L, 4L)), result.groups.map { it.memberContentIds })
assertEquals(listOf("ko", "en"), result.groups.map { it.sourceLanguage })
}
@Test
@DisplayName("단어 내부 조각과 숫자 구두점 및 한 글자 반복은 자동 그룹에서 제외한다")
fun shouldRequireLexicalBoundariesAndTwoUnicodeLetters() {
val inputs = pair("cathedral", "catnip") + listOf(
TitleGroupingInput(3, "ko", "123 ! 가"),
TitleGroupingInput(4, "ko", "123 ! 나")
)
val result = analyzer.analyze(inputs)
assertEquals(emptyList<TitleGroup>(), result.groups)
assertEquals(listOf(1L, 2L, 3L, 4L), result.individualContentIds)
}
@Test
@DisplayName("이모지 결합문자 공백 구두점을 보존하고 code point offset을 반환한다")
fun shouldPreserveEmojiCombiningAndPunctuationExactly() {
val inputs = pair("👩‍💻 cafe\u0301! 05\t", "👩‍💻 cafe\u0301! 06\n")
val result = analyzer.analyze(inputs)
assertEquals(
listOf(TitleOccurrence(1, 0, 11), TitleOccurrence(2, 0, 11)),
result.groups.single().sharedParts.single().occurrences
)
assertEquals(
inputs.map { it.title },
result.templates.map { it.segments.joinToString("") { segment -> segment.sourceText } }
)
assertEquals(
listOf("👩‍💻 cafe\u0301! 05\t", "👩‍💻 cafe\u0301! 06\n"),
result.templates.map { it.render(listOf("👩‍💻 cafe\u0301! "), emptyList()) }
)
}
@Test
@DisplayName("절약량이 큰 후보에 먼저 배정하고 입력 순서와 무관하게 같은 그룹을 만든다")
fun shouldAssignBySavingsBeforeLengthDeterministically() {
val inputs = listOf(
TitleGroupingInput(1, "en", "Long phrase | Common"),
TitleGroupingInput(2, "en", "Long phrase / Common"),
TitleGroupingInput(3, "en", "Common"),
TitleGroupingInput(4, "en", "Common!")
)
val result = analyzer.analyze(inputs.reversed())
assertEquals(listOf(1L, 2L, 3L, 4L), result.groups.single().memberContentIds)
assertEquals(listOf("Common"), result.groups.single().sharedParts.map { it.sourceText })
assertEquals(result, analyzer.analyze(inputs))
}
@Test
@DisplayName("절약량 동률은 길이와 code point 사전순 및 구성원 ID로 결정한다")
fun shouldBreakTiesByLengthThenCodePointTextThenMemberId() {
val inputs = listOf(
TitleGroupingInput(1, "en", "aaaa | bb"),
TitleGroupingInput(2, "en", "aaaa"),
TitleGroupingInput(3, "en", "bb"),
TitleGroupingInput(4, "en", "bb!")
)
val unicode = listOf(
TitleGroupingInput(1, "ko", "\uE000ab | 𐐀cd"),
TitleGroupingInput(2, "ko", "\uE000ab"),
TitleGroupingInput(3, "ko", "𐐀cd")
)
assertEquals(listOf(1L, 2L), analyzer.analyze(inputs).groups.first().memberContentIds)
assertEquals("\uE000ab", analyzer.analyze(unicode).groups.first().sharedParts.first().sourceText)
}
@Test
@DisplayName("한 그룹에 겹치지 않는 공유 구간을 추가하고 서로 다른 공유 순서를 정확히 매핑한다")
fun shouldAllowNonoverlappingSharedPartsWithStableValueIndexes() {
val inputs = pair("Alpha<red>Omega", "Omega[blue]Alpha")
val result = analyzer.analyze(inputs)
assertEquals(listOf("Alpha", "Omega"), result.groups.single().sharedParts.map { it.sourceText })
assertEquals(
listOf("A<r>O", "O[b]A"),
result.templates.mapIndexed { index, template ->
template.render(listOf("A", "O"), listOf(if (index == 0) "r" else "b"))
}
)
}
@ParameterizedTest
@CsvSource("-1,2", "0,99", "2,2", "3,1", "1,2", "4,6")
@DisplayName("잘못된 범위와 결합문자 또는 ZWJ 이모지를 자르는 범위를 거부한다")
fun shouldRejectOverlappingAndSplitGraphemeSpans(start: Int, end: Int) {
val inputs = pair("e\u0301x 👩‍💻 ok", "e\u0301x 👩‍💻 ok")
val review = reviewed(listOf(TitleOccurrence(1, start, end), TitleOccurrence(2, start, end)))
assertThrows(IllegalArgumentException::class.java) { review.validate(inputs) }
}
@Test
@DisplayName("서로 겹치는 공통 구간을 거부한다")
fun shouldRejectOverlappingSharedParts() {
val review = reviewed(
listOf(TitleOccurrence(1, 0, 5), TitleOccurrence(2, 0, 5)),
listOf(TitleOccurrence(1, 4, 8), TitleOccurrence(2, 4, 8))
)
assertThrows(IllegalArgumentException::class.java) { review.validate(pair("same text", "same text")) }
}
@Test
@DisplayName("구성원별 원문이 다르거나 언어가 다르면 검토 그룹을 거부한다")
fun shouldRejectMismatchedRawSharedTextAndMixedLanguages() {
val review = reviewed(listOf(TitleOccurrence(1, 0, 4), TitleOccurrence(2, 0, 5)))
val sameRanges = reviewed(listOf(TitleOccurrence(1, 0, 4), TitleOccurrence(2, 0, 4)))
assertThrows(IllegalArgumentException::class.java) { review.validate(pair("café", "cafe\u0301")) }
assertThrows(IllegalArgumentException::class.java) {
sameRanges.validate(listOf(TitleGroupingInput(1, "ko", "same"), TitleGroupingInput(2, "en", "same")))
}
}
@Test
@DisplayName("전체 scope에서 누락 중복 알 수 없는 구성원과 불완전한 part를 거부한다")
fun shouldRejectMissingDuplicateAndUnknownMembers() {
val inputs = pair("same", "same")
val group = reviewed(listOf(TitleOccurrence(1, 0, 4), TitleOccurrence(2, 0, 4))).groups.single()
val singleton = ReviewedTitleGroup(
"single",
listOf(1),
listOf(ReviewedSharedPart("only", listOf(TitleOccurrence(1, 0, 4))))
)
val invalid = listOf(
TitleGroupingReview(emptyList(), listOf(1)),
TitleGroupingReview(emptyList(), listOf(1, 1, 2)),
TitleGroupingReview(emptyList(), listOf(1, 2, 3)),
TitleGroupingReview(listOf(group), listOf(1)),
TitleGroupingReview(listOf(singleton), listOf(2)),
reviewed(listOf(TitleOccurrence(1, 0, 4))),
reviewed(listOf(TitleOccurrence(1, 0, 4), TitleOccurrence(1, 0, 4), TitleOccurrence(2, 0, 4)))
)
invalid.forEach { review -> assertThrows(IllegalArgumentException::class.java) { review.validate(inputs) } }
}
@Test
@DisplayName("빈 그룹과 중복된 그룹 또는 part 식별자를 거부한다")
fun shouldRejectEmptyPartsAndDuplicateIdentifiers() {
val inputs = pair("same", "same") + listOf(TitleGroupingInput(3, "en", "same"), TitleGroupingInput(4, "en", "same"))
val group = reviewed(listOf(TitleOccurrence(1, 0, 4), TitleOccurrence(2, 0, 4))).groups.single()
val otherPart = ReviewedSharedPart("other-part", listOf(TitleOccurrence(3, 0, 4), TitleOccurrence(4, 0, 4)))
val other = ReviewedTitleGroup("other", listOf(3, 4), listOf(otherPart))
val invalid = listOf(
TitleGroupingReview(listOf(group.copy(sharedParts = emptyList())), listOf(3, 4)),
TitleGroupingReview(listOf(group, other.copy(groupId = group.groupId)), emptyList()),
TitleGroupingReview(listOf(group, other.copy(sharedParts = listOf(otherPart.copy(partId = "p-1")))), emptyList())
)
invalid.forEach { review -> assertThrows(IllegalArgumentException::class.java) { review.validate(inputs) } }
}
@Test
@DisplayName("구문 전체를 residual로 유지하고 외부 구분자와 모든 code point 및 원문 fingerprint를 보존한다")
fun shouldPartitionReviewedTitlesLosslesslyAndRenderOrderedArrays() {
val inputs = pair(" \t[비 오는 날] <same> (05! e\u0301, 👩‍💻 06 날?) \n", "\tsame 06 / blue.")
val review = reviewed(listOf(TitleOccurrence(1, 12, 16), TitleOccurrence(2, 1, 5)))
val result = review.validate(inputs)
result.templates.forEachIndexed { index, template ->
assertEquals(inputs[index].title, template.render(listOf("same"), template.residualInputs))
val source = inputs[index].title
assertEquals(
(0 until source.codePointCount(0, source.length)).toList(),
template.segments.flatMap { it.startCodePoint until it.endCodePoint }
)
assertEquals(
ContentSourceSnapshot("en", source, "", emptyList()).fingerprint(ContentSourceFieldKey.TITLE),
template.sourceFingerprint
)
}
assertEquals(listOf("비 오는 날", "05! e\u0301, 👩‍💻 06 날"), result.templates.first().residualInputs)
assertEquals(listOf("06 / blue"), result.templates.last().residualInputs)
assertEquals(" \t[RAIN] <S> (ENDING?) \n", result.templates.first().render(listOf("S"), listOf("RAIN", "ENDING")))
assertThrows(IllegalArgumentException::class.java) {
result.templates.first().render(emptyList(), listOf("RAIN", "ENDING"))
}
assertThrows(IllegalArgumentException::class.java) { result.templates.first().render(listOf("S"), emptyList()) }
}
@Test
@DisplayName("모든 제목의 개별 처리와 빈 scope를 허용하고 중복 입력 ID는 거부한다")
fun shouldAcceptAllIndividualReviewAndRejectDuplicateInputIds() {
val result = TitleGroupingReview(emptyList(), listOf(2, 1)).validate(pair("one", "two"))
assertEquals(listOf(1L, 2L), result.individualContentIds)
assertEquals(emptyList<TitleTemplate>(), result.templates)
assertEquals(emptyList<TitleGroup>(), analyzer.analyze(emptyList()).groups)
assertThrows(IllegalArgumentException::class.java) {
analyzer.analyze(listOf(TitleGroupingInput(1, "en", "a"), TitleGroupingInput(1, "en", "b")))
}
}
private fun pair(first: String, second: String, language: String = "en") =
listOf(TitleGroupingInput(1, language, first), TitleGroupingInput(2, language, second))
private fun reviewed(vararg parts: List<TitleOccurrence>) = TitleGroupingReview(
listOf(
ReviewedTitleGroup(
"g",
listOf(1, 2),
parts.mapIndexed { index, occurrences -> ReviewedSharedPart("p-${index + 1}", occurrences) }
)
),
emptyList()
)
}
@@ -688,7 +688,6 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
LanguageProviderProperties(listOf(PAPAGO), listOf(PAPAGO)),
memoryRepository
),
contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java),
aiCharacterTranslationRepository = Mockito.mock(AiCharacterTranslationRepository::class.java),
contentThemeTranslationRepository = Mockito.mock(ContentThemeTranslationRepository::class.java),
seriesTranslationRepository = Mockito.mock(SeriesTranslationRepository::class.java),
@@ -697,7 +696,10 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
categoryTranslationRepository = Mockito.mock(CategoryTranslationRepository::class.java),
creatorCommunityRepository = creatorCommunityRepository,
creatorCommunityTranslationRepository = translationRepository,
entityManager = entityManager
entityManager = entityManager,
contentWriter = Mockito.mock(
kr.co.vividnext.sodalive.v2.contenttranslation.application.ContentTranslationWriteService::class.java
)
)
}
@@ -732,7 +734,8 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
TranslationJobScheduler(
translationJobRepository,
Mockito.mock(TranslationCoordinator::class.java),
Mockito.mock(ContentTranslationRepository::class.java)
Mockito.mock(ContentTranslationRepository::class.java),
entityManager
),
translationJobRepository
),
@@ -749,21 +752,23 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
val sourceHash = SourceTextNormalizer.hash(sourceText)
val translationJobRepository = Mockito.mock(TranslationJobRepository::class.java)
Mockito.`when`(
translationJobRepository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
translationJobRepository.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
postId,
"content",
"en",
sourceHash
sourceHash,
"ko"
)
).thenAnswer {
val existing = persistentTranslationJobRepository
.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHash(
.findByResourceTypeAndResourceIdAndFieldKeyAndTargetLanguageAndSourceHashAndSourceLanguage(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
postId,
"content",
"en",
sourceHash
sourceHash,
"ko"
)
if (existing == null) {
missingJobReads.countDown()