fix(i18n): 메타데이터 조회와 요청에서 현재 원문의 실패 번역을 재개한다

This commit is contained in:
2026-11-16 21:47:54 +09:00
parent d1c9f3a3d8
commit 081f22b2c0
16 changed files with 846 additions and 6 deletions
@@ -186,6 +186,11 @@ class ChatCharacterController(
var translated: TranslatedAiCharacterDetail? = null var translated: TranslatedAiCharacterDetail? = null
if (langContext.lang.code != character.languageCode) { if (langContext.lang.code != character.languageCode) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CHARACTER,
listOf(characterId),
langContext.lang.code
)
val existing = aiCharacterTranslationRepository val existing = aiCharacterTranslationRepository
.findByCharacterIdAndLocale(character.id!!, langContext.lang.code) .findByCharacterIdAndLocale(character.id!!, langContext.lang.code)
@@ -28,8 +28,15 @@ class OriginalWorkTranslationService(
return null return null
} }
val originalWorkId = requireNotNull(originalWork.id)
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.ORIGINAL_WORK,
listOf(originalWorkId),
target
)
// 기존 번역 조회 // 기존 번역 조회
val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWork.id!!, target) val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWorkId, target)
val existedPayload = existed?.renderedPayload val existedPayload = existed?.renderedPayload
if (existedPayload != null) { if (existedPayload != null) {
val t = existedPayload.title.trim() val t = existedPayload.title.trim()
@@ -51,7 +58,7 @@ class OriginalWorkTranslationService(
resourceTranslationJobScheduler.scheduleResourceTranslation( resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.ORIGINAL_WORK, resourceType = LanguageTranslationTargetType.ORIGINAL_WORK,
resourceId = originalWork.id!!, resourceId = originalWorkId,
targetLanguage = target targetLanguage = target
) )
return null return null
@@ -896,6 +896,11 @@ class AudioContentService(
audioContent.languageCode!!.isNotBlank() && audioContent.languageCode!!.isNotBlank() &&
audioContent.languageCode != langContext.lang.code audioContent.languageCode != langContext.lang.code
) { ) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CONTENT,
listOf(id),
langContext.lang.code
)
val existing = contentTranslationRepository val existing = contentTranslationRepository
.findByContentIdAndLocale(audioContent.id!!, langContext.lang.code) .findByContentIdAndLocale(audioContent.id!!, langContext.lang.code)
@@ -141,6 +141,11 @@ class CategoryService(
val categoryIds = baseList.map { it.categoryId } val categoryIds = baseList.map { it.categoryId }
val entities = repository.findAllById(categoryIds) val entities = repository.findAllById(categoryIds)
val entityMap = entities.associateBy { it.id!! } val entityMap = entities.associateBy { it.id!! }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY,
categoryIds,
locale
)
// 요청 로케일로 이미 저장된 번역 일괄 조회 // 요청 로케일로 이미 저장된 번역 일괄 조회
val translations = categoryTranslationRepository val translations = categoryTranslationRepository
@@ -98,6 +98,11 @@ class ContentSeriesService(
if (currentLang == Lang.EN || currentLang == Lang.JA) { if (currentLang == Lang.EN || currentLang == Lang.JA) {
val targetLocale = currentLang.code val targetLocale = currentLang.code
val ids = genres.map { it.id } val ids = genres.map { it.id }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.SERIES_GENRE,
ids,
targetLocale
)
// 기존 번역 일괄 조회 // 기존 번역 일괄 조회
val existing = if (ids.isNotEmpty()) { val existing = if (ids.isNotEmpty()) {
@@ -278,6 +283,11 @@ class ContentSeriesService(
val languageCode = series.languageCode val languageCode = series.languageCode
// 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리 // 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리
if (!languageCode.isNullOrBlank() && languageCode != locale) { if (!languageCode.isNullOrBlank() && languageCode != locale) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.SERIES,
listOf(seriesId),
locale
)
val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale) val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale)
if (existing != null) { if (existing != null) {
val payload = existing.renderedPayload val payload = existing.renderedPayload
@@ -58,6 +58,11 @@ class AudioContentThemeService(
val targetLocale = currentLang.code val targetLocale = currentLang.code
// 1) 기존 번역을 한 번에 조회 // 1) 기존 번역을 한 번에 조회
val ids = themesWithIds.map { it.id } val ids = themesWithIds.map { it.id }
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CONTENT_THEME,
ids,
targetLocale
)
val existingTranslations = if (ids.isNotEmpty()) { val existingTranslations = if (ids.isNotEmpty()) {
contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale) contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale)
} else { } else {
@@ -2,12 +2,15 @@ package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.annotation.Transactional
import java.time.LocalDateTime
@Service @Service
class ResourceTranslationJobScheduler( class ResourceTranslationJobScheduler(
private val sourceExtractor: TranslationSourceExtractor, private val sourceExtractor: TranslationSourceExtractor,
private val translationJobScheduler: TranslationJobScheduler private val translationJobScheduler: TranslationJobScheduler,
private val translationJobRepository: TranslationJobRepository
) { ) {
@Transactional @Transactional
fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) { fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) {
@@ -27,6 +30,45 @@ class ResourceTranslationJobScheduler(
scheduleSource(source, targetLanguage) scheduleSource(source, targetLanguage)
} }
@Transactional(propagation = Propagation.REQUIRES_NEW)
fun restartFailedResourceTranslations(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String
) {
restartFailedResourceTranslationsInCurrentTransaction(resourceType, resourceIds, targetLanguage)
}
@Transactional
fun restartFailedResourceTranslationsInCurrentTransaction(
resourceType: LanguageTranslationTargetType,
resourceIds: Collection<Long>,
targetLanguage: String
) {
if (resourceIds.isEmpty()) return
val target = targetLanguage.lowercase()
val candidates = translationJobRepository.findByResourceTypeAndResourceIdInAndTargetLanguageAndStatus(
resourceType,
resourceIds,
target,
TranslationJobStatus.FAILED
)
val now = LocalDateTime.now()
candidates.groupBy { it.resourceId }.forEach { (resourceId, failedJobs) ->
val source = sourceExtractor.extract(resourceType, resourceId) ?: return@forEach
val sourceLanguage = source.sourceLanguage.lowercase()
if (!TranslationLanguages.isSupported(sourceLanguage) || sourceLanguage == target) return@forEach
val sourceHashes = source.fields.associate { it.fieldKey to SourceTextNormalizer.hash(it.sourceText) }
failedJobs.filter { job ->
job.sourceLanguage == sourceLanguage && job.sourceHash == sourceHashes[job.fieldKey]
}.forEach { job ->
translationJobRepository.restartFailedJob(requireNotNull(job.id), now)
}
}
}
private fun scheduleSource(source: TranslationSource, targetLanguage: String) { private fun scheduleSource(source: TranslationSource, targetLanguage: String) {
source.fields.forEach { field -> source.fields.forEach { field ->
translationJobScheduler.scheduleMissingTranslation( translationJobScheduler.scheduleMissingTranslation(
@@ -35,6 +35,17 @@ class CreatorCommunityTranslationService(
val normalizedLocale = locale.lowercase() val normalizedLocale = locale.lowercase()
val posts = creatorCommunityRepository.findAllById(postIds).filter { it.isActive } val posts = creatorCommunityRepository.findAllById(postIds).filter { it.isActive }
val translationPostIds = posts.filter { post ->
val sourceLanguage = post.languageCode?.lowercase()
!sourceLanguage.isNullOrBlank() && sourceLanguage != normalizedLocale
}.mapNotNull { it.id }
if (translationPostIds.isNotEmpty()) {
resourceTranslationJobScheduler.restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
translationPostIds,
normalizedLocale
)
}
val translations = creatorCommunityTranslationRepository val translations = creatorCommunityTranslationRepository
.findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale) .findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale)
.associateBy { it.creatorCommunityId } .associateBy { it.creatorCommunityId }
@@ -62,6 +73,11 @@ class CreatorCommunityTranslationService(
targetLanguages targetLanguages
.filter { it != sourceLanguage } .filter { it != sourceLanguage }
.forEach { language -> .forEach { language ->
resourceTranslationJobScheduler.restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(postId),
language
)
if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) { if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) {
resourceTranslationJobScheduler.scheduleResourceTranslation( resourceTranslationJobScheduler.scheduleResourceTranslation(
resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY, resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY,
@@ -0,0 +1,113 @@
package kr.co.vividnext.sodalive.i18n.translation
import com.fasterxml.jackson.databind.ObjectMapper
import kr.co.vividnext.sodalive.aws.cloudfront.AudioContentCloudFront
import kr.co.vividnext.sodalive.aws.s3.S3Uploader
import kr.co.vividnext.sodalive.content.AudioContent
import kr.co.vividnext.sodalive.content.AudioContentRepository
import kr.co.vividnext.sodalive.content.AudioContentService
import kr.co.vividnext.sodalive.content.PlaybackTrackingRepository
import kr.co.vividnext.sodalive.content.comment.AudioContentCommentRepository
import kr.co.vividnext.sodalive.content.hashtag.HashTagRepository
import kr.co.vividnext.sodalive.content.like.AudioContentLikeRepository
import kr.co.vividnext.sodalive.content.order.LimitedEditionOrderRepository
import kr.co.vividnext.sodalive.content.order.OrderRepository
import kr.co.vividnext.sodalive.content.pin.PinContentRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentTheme
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository
import kr.co.vividnext.sodalive.content.translation.ContentTranslation
import kr.co.vividnext.sodalive.content.translation.ContentTranslationPayload
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.i18n.SodaMessageSource
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.MemberRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.support.originalLocalizedNameService
import kr.co.vividnext.sodalive.v2.home.following.application.HomeFollowingNewsPublishService
import kr.co.vividnext.sodalive.v2.recommendation.application.CreatorContentViewHistoryService
import kr.co.vividnext.sodalive.v2.subtitle.application.SubtitleJobService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher
import java.util.Optional
class AudioContentReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var translations: ContentTranslationRepository
@Test
@DisplayName("오디오 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedContentWhilePreservingRenderedDetail() {
val source = givenSource(LanguageTranslationTargetType.CONTENT, "title", "현재 제목")
val job = failedJob(source)
persistRendered(
ContentTranslation(10L, "en", ContentTranslationPayload("Old title", "Old detail", "old tags")),
"content_translation",
"""{"title":"Old title","detail":"Old detail","tags":"old tags"}"""
)
val member = Member(password = "password", nickname = "creator").apply { id = 100L }
val content = AudioContent("현재 제목", "현재 설명", "ko", isCommentAvailable = false).apply {
id = 10L
this.member = member
theme = AudioContentTheme("테마", "theme.png").apply { id = 20L }
this.content = "output/audio.mp3"
coverImage = "cover.png"
duration = "00:01:00"
isActive = true
}
val repository = Mockito.mock(AudioContentRepository::class.java)
val explorer = Mockito.mock(ExplorerQueryRepository::class.java)
val orders = Mockito.mock(OrderRepository::class.java)
val cloudFront = Mockito.mock(AudioContentCloudFront::class.java)
Mockito.`when`(repository.findById(10L)).thenReturn(Optional.of(content))
Mockito.`when`(explorer.getMember(100L)).thenReturn(member)
Mockito.`when`(orders.isExistOrderedAndOrderType(100L, 10L)).thenReturn(false to null)
Mockito.`when`(cloudFront.generateSignedURL("output/audio.mp3", 7_200_000L)).thenReturn("https://signed.test/audio")
val service = AudioContentService(
repository = repository,
explorerQueryRepository = explorer,
blockMemberRepository = Mockito.mock(BlockMemberRepository::class.java),
hashTagRepository = Mockito.mock(HashTagRepository::class.java),
orderRepository = orders,
limitedEditionOrderRepository = Mockito.mock(LimitedEditionOrderRepository::class.java),
themeQueryRepository = Mockito.mock(AudioContentThemeQueryRepository::class.java),
playbackTrackingRepository = Mockito.mock(PlaybackTrackingRepository::class.java),
creatorContentViewHistoryService = Mockito.mock(CreatorContentViewHistoryService::class.java),
commentRepository = Mockito.mock(AudioContentCommentRepository::class.java),
audioContentLikeRepository = Mockito.mock(AudioContentLikeRepository::class.java),
pinContentRepository = Mockito.mock(PinContentRepository::class.java),
memberRepository = Mockito.mock(MemberRepository::class.java),
resourceTranslationJobScheduler = scheduler,
contentTranslationRepository = translations,
s3Uploader = Mockito.mock(S3Uploader::class.java),
objectMapper = ObjectMapper(),
audioContentCloudFront = cloudFront,
applicationEventPublisher = Mockito.mock(ApplicationEventPublisher::class.java),
messageSource = SodaMessageSource(),
langContext = langContext,
localizedNameService = originalLocalizedNameService(),
contentThemeTranslationRepository = Mockito.mock(ContentThemeTranslationRepository::class.java),
homeFollowingNewsPublishService = Mockito.mock(HomeFollowingNewsPublishService::class.java),
memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java),
subtitleJobService = Mockito.mock(SubtitleJobService::class.java),
transactionManager = transactionManager,
audioContentBucket = "audio-bucket",
coverImageBucket = "cover-bucket",
coverImageHost = "https://cdn.test"
)
val response = service.getDetail(10L, member, false, "Asia/Seoul")
assertEquals("현재 제목", response.title)
assertEquals("Old title", response.translated?.title)
assertEquals("Old detail", response.translated?.detail)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
}
@@ -0,0 +1,78 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.chat.character.ChatCharacter
import kr.co.vividnext.sodalive.chat.character.comment.CharacterCommentService
import kr.co.vividnext.sodalive.chat.character.controller.ChatCharacterController
import kr.co.vividnext.sodalive.chat.character.curation.CharacterCurationQueryService
import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterBannerService
import kr.co.vividnext.sodalive.chat.character.service.ChatCharacterService
import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslation
import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationRenderedPayload
import kr.co.vividnext.sodalive.chat.character.translate.AiCharacterTranslationRepository
import kr.co.vividnext.sodalive.chat.room.service.ChatRoomService
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import kr.co.vividnext.sodalive.member.contentpreference.ViewerContentPreference
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
class CharacterReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var translations: AiCharacterTranslationRepository
@Test
@DisplayName("캐릭터 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedCharacterWhilePreservingRenderedDetail() {
val source = givenSource(LanguageTranslationTargetType.CHARACTER, "name", "현재 이름")
val job = failedJob(source)
persistRendered(
AiCharacterTranslation(
10L,
"en",
AiCharacterTranslationRenderedPayload("Old name", "Old description", "", "", "", "", "", "")
),
"ai_character_translation",
"""
{"name":"Old name","description":"Old description","gender":"","personalityTrait":"",
"personalityDescription":"","backgroundTopic":"","backgroundDescription":"","tags":""}
""".trimIndent()
)
val member = Member(password = "password", nickname = "viewer").apply { id = 100L }
val character = ChatCharacter(
characterUUID = "character-10",
name = "현재 이름",
description = "현재 설명",
systemPrompt = "prompt",
languageCode = "ko"
).apply { id = 10L }
val characterService = Mockito.mock(ChatCharacterService::class.java)
val preferenceService = Mockito.mock(MemberContentPreferenceService::class.java)
Mockito.`when`(characterService.getCharacterDetail(10L)).thenReturn(character)
Mockito.`when`(preferenceService.getStoredPreference(member))
.thenReturn(ViewerContentPreference("KR", true, ContentType.ALL, true))
val controller = ChatCharacterController(
service = characterService,
bannerService = Mockito.mock(ChatCharacterBannerService::class.java),
chatRoomService = Mockito.mock(ChatRoomService::class.java),
characterCommentService = Mockito.mock(CharacterCommentService::class.java),
curationQueryService = Mockito.mock(CharacterCurationQueryService::class.java),
resourceTranslationJobScheduler = scheduler,
aiCharacterTranslationRepository = translations,
langContext = langContext,
memberContentPreferenceService = preferenceService,
imageHost = "https://cdn.test"
)
val response = controller.getCharacterDetail(10L, member)
assertEquals("현재 이름", response.data?.name)
assertEquals("Old name", response.data?.translated?.name)
assertEquals("Old description", response.data?.translated?.description)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
}
@@ -0,0 +1,101 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.admin.content.series.genre.SeriesGenre
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.order.OrderRepository
import kr.co.vividnext.sodalive.content.series.ContentSeriesRepository
import kr.co.vividnext.sodalive.content.series.ContentSeriesService
import kr.co.vividnext.sodalive.content.series.GetSeriesGenreListResponse
import kr.co.vividnext.sodalive.content.series.content.ContentSeriesContentRepository
import kr.co.vividnext.sodalive.content.series.content.GetSeriesContentMinMaxPriceResponse
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslation
import kr.co.vividnext.sodalive.content.series.translation.SeriesGenreTranslationRepository
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslation
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationPayload
import kr.co.vividnext.sodalive.content.series.translation.SeriesTranslationRepository
import kr.co.vividnext.sodalive.content.translation.ContentTranslationRepository
import kr.co.vividnext.sodalive.creator.admin.content.series.Series
import kr.co.vividnext.sodalive.creator.admin.content.series.SeriesSortType
import kr.co.vividnext.sodalive.explorer.ExplorerQueryRepository
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import java.time.LocalDateTime
class ContentSeriesReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var seriesTranslations: SeriesTranslationRepository
@Autowired
private lateinit var genreTranslations: SeriesGenreTranslationRepository
private val repository = Mockito.mock(ContentSeriesRepository::class.java)
private val contents = Mockito.mock(ContentSeriesContentRepository::class.java)
@Test
@DisplayName("시리즈 상세는 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedSeriesWhilePreservingRenderedDetail() {
val source = givenSource(LanguageTranslationTargetType.SERIES, "title", "현재 제목")
val job = failedJob(source)
persistRendered(
SeriesTranslation(10L, "en", SeriesTranslationPayload("Old title", "Old introduction", listOf("old"))),
"series_translation",
"""{"title":"Old title","introduction":"Old introduction","keywords":["old"]}"""
)
val member = Member(password = "password", nickname = "viewer").apply { id = 100L }
val series = Series("현재 제목", "현재 소개", "ko").apply {
id = 10L
this.member = member
genre = SeriesGenre("현재 장르").apply { id = 20L }
createdAt = LocalDateTime.of(2026, 1, 1, 0, 0)
}
Mockito.`when`(repository.getSeriesDetail(10L, false, ContentType.ALL)).thenReturn(series)
Mockito.`when`(repository.getSeriesContentMinMaxPrice(10L)).thenReturn(GetSeriesContentMinMaxPriceResponse(0, 0))
Mockito.`when`(contents.getContentList(10L, false, ContentType.ALL, "https://cdn.test", SeriesSortType.NEWEST, 0, 5))
.thenReturn(emptyList())
val response = service().getSeriesDetail(10L, false, ContentType.ALL, member)
assertEquals("현재 제목", response.title)
assertEquals("Old title", response.translated?.title)
assertEquals("Old introduction", response.translated?.introduction)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
@Test
@DisplayName("장르 목록은 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedGenreWhilePreservingRenderedList() {
val source = givenSource(LanguageTranslationTargetType.SERIES_GENRE, "genre", "현재 장르")
val job = failedJob(source)
persist(SeriesGenreTranslation(10L, "en", "Old genre"))
Mockito.`when`(repository.getGenreList(false, 100L, ContentType.ALL))
.thenReturn(listOf(GetSeriesGenreListResponse(10L, "현재 장르")))
val response = service().getGenreList(100L, false, ContentType.ALL)
assertEquals(listOf(GetSeriesGenreListResponse(10L, "Old genre")), response)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
private fun service() = ContentSeriesService(
repository = repository,
orderRepository = Mockito.mock(OrderRepository::class.java),
blockMemberRepository = Mockito.mock(BlockMemberRepository::class.java),
explorerQueryRepository = Mockito.mock(ExplorerQueryRepository::class.java),
seriesContentRepository = contents,
langContext = langContext,
seriesTranslationRepository = seriesTranslations,
seriesGenreTranslationRepository = genreTranslations,
contentTranslationRepository = Mockito.mock(ContentTranslationRepository::class.java),
resourceTranslationJobScheduler = scheduler,
memberContentPreferenceService = Mockito.mock(MemberContentPreferenceService::class.java),
coverImageHost = "https://cdn.test"
)
}
@@ -0,0 +1,114 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.explorer.profile.creatorCommunity.CreatorCommunity
import kr.co.vividnext.sodalive.member.Member
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslation
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.adapter.out.persistence.CreatorCommunityTranslationRepository
import kr.co.vividnext.sodalive.v2.creator.channel.community.translation.application.CreatorCommunityTranslationService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.ValueSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Import
@Import(CreatorCommunityTranslationService::class)
class CreatorCommunityReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var service: CreatorCommunityTranslationService
@MockBean
private lateinit var materializer: TranslationReadModelMaterializer
@Autowired
private lateinit var translations: CreatorCommunityTranslationRepository
private lateinit var post: CreatorCommunity
private lateinit var job: TranslationJob
@BeforeEach
fun givenCurrentFailedPost() {
val creator = persist(Member(password = "password", nickname = "retry-creator"))
post = persist(
CreatorCommunity("현재 본문", 0, true, false, languageCode = "ko", contentRevision = 2).apply {
member = creator
}
)
val source = TranslationSource(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
requireNotNull(post.id),
"ko",
listOf(TranslationSourceField("content", "현재 본문")),
sourceRevision = 2
)
Mockito.`when`(sourceExtractor.extract(source.resourceType, source.resourceId)).thenReturn(source)
job = failedJob(source)
}
@ParameterizedTest
@ValueSource(booleans = [true, false])
@DisplayName("커뮤니티 표시 조회는 현재 FAILED를 재개하고 개정에 따른 번역과 원문 fallback을 보존한다")
fun shouldRestartFailedDisplayReadWhilePreservingRevisionFallback(currentRevision: Boolean) {
val postId = requireNotNull(post.id)
persist(
CreatorCommunityTranslation(
creatorCommunityId = postId,
locale = "en",
content = "Rendered content",
sourceRevision = if (currentRevision) 2 else 1,
sourceHash = SourceTextNormalizer.hash("현재 본문"),
sourceLanguage = "ko"
)
)
val response = service.findDisplayContents(listOf(postId), "EN")
assertEquals(if (currentRevision) "Rendered content" else "현재 본문", response[postId]?.content)
assertEquals(currentRevision, response[postId]?.hasValidTranslation)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
@Test
@DisplayName("커뮤니티 표시 조회는 재개할 작업이 없으면 원문을 반환하고 누락 작업을 새로 만들지 않는다")
fun shouldPreserveOriginalWithoutCreatingMissingJobsFromDisplayRead() {
jobs.deleteById(requireNotNull(job.id))
val postId = requireNotNull(post.id)
val response = service.findDisplayContents(listOf(postId), "en")
assertEquals("현재 본문", response[postId]?.content)
assertEquals(false, response[postId]?.hasValidTranslation)
assertEquals(emptyList<TranslationJob>(), jobs.findAll())
}
@Test
@DisplayName("커뮤니티 잠금 요청은 메모리 재료화에 성공해도 같은 트랜잭션에서 FAILED 작업을 재개한다")
fun shouldRestartFailedRequestEvenWhenMemoryMaterializesUnderPostLock() {
val postId = requireNotNull(post.id)
val rendered = persist(
CreatorCommunityTranslation(
creatorCommunityId = postId,
locale = "en",
content = "Rendered content",
sourceRevision = 2,
sourceHash = SourceTextNormalizer.hash("현재 본문"),
sourceLanguage = "ko"
)
)
Mockito.`when`(materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, "en"))
.thenReturn(true)
service.requestTranslations(postId, "EN")
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
val preserved = translations.findByCreatorCommunityIdAndLocale(postId, "en")
assertEquals(rendered.id, preserved?.id)
assertEquals("Rendered content", preserved?.content)
}
}
@@ -0,0 +1,92 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.content.AudioContentRepository
import kr.co.vividnext.sodalive.content.ContentType
import kr.co.vividnext.sodalive.content.category.Category
import kr.co.vividnext.sodalive.content.category.CategoryContentRepository
import kr.co.vividnext.sodalive.content.category.CategoryRepository
import kr.co.vividnext.sodalive.content.category.CategoryService
import kr.co.vividnext.sodalive.content.category.CategoryTranslation
import kr.co.vividnext.sodalive.content.category.CategoryTranslationRepository
import kr.co.vividnext.sodalive.content.category.GetCategoryListResponse
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeQueryRepository
import kr.co.vividnext.sodalive.content.theme.AudioContentThemeService
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslation
import kr.co.vividnext.sodalive.content.theme.translation.ContentThemeTranslationRepository
import kr.co.vividnext.sodalive.member.block.BlockMemberRepository
import kr.co.vividnext.sodalive.member.contentpreference.MemberContentPreferenceService
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.context.ApplicationEventPublisher
class MetadataListReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var themeTranslations: ContentThemeTranslationRepository
@Autowired
private lateinit var categoryTranslations: CategoryTranslationRepository
@Test
@DisplayName("활성 테마 목록은 이전 번역을 반환하면서 제외되지 않은 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedThemeWhilePreservingRenderedListAndExclusions() {
val source = givenSource(LanguageTranslationTargetType.CONTENT_THEME, "theme", "현재 테마")
val job = failedJob(source)
val excludedSource = source.copy(resourceId = 20L, fields = listOf(TranslationSourceField("theme", "제외 테마")))
val excluded = failedJob(excludedSource)
Mockito.`when`(sourceExtractor.extract(excludedSource.resourceType, excludedSource.resourceId)).thenReturn(excludedSource)
persist(ContentThemeTranslation(10L, "en", "Old theme"))
val query = Mockito.mock(AudioContentThemeQueryRepository::class.java)
Mockito.`when`(query.getActiveThemeWithIdsOfContent(false, false, false, ContentType.ALL)).thenReturn(
listOf(
AudioContentThemeQueryRepository.ThemeIdAndName(10L, "현재 테마"),
AudioContentThemeQueryRepository.ThemeIdAndName(20L, "제외 테마")
)
)
val service = AudioContentThemeService(
query,
Mockito.mock(AudioContentRepository::class.java),
themeTranslations,
scheduler,
langContext,
Mockito.mock(MemberContentPreferenceService::class.java)
)
val response = service.getActiveThemeOfContent(contentType = ContentType.ALL, excludeThemes = listOf("제외 테마"))
assertEquals(listOf("Old theme"), response)
assertRestarted(job)
assertEquals(TranslationJobStatus.FAILED, jobs.findById(requireNotNull(excluded.id)).orElseThrow().status)
assertEquals(setOf(job.id, excluded.id), jobs.findAll().map { it.id }.toSet())
}
@Test
@DisplayName("카테고리 목록은 이전 번역을 반환하면서 현재 FAILED 작업을 재개한다")
fun shouldRestartFailedCategoryWhilePreservingRenderedList() {
val source = givenSource(LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY, "category", "현재 분류")
val job = failedJob(source)
persist(CategoryTranslation(10L, "en", "Old category"))
val repository = Mockito.mock(CategoryRepository::class.java)
val category = Category("현재 분류", languageCode = "ko").apply { id = 10L }
Mockito.`when`(repository.findByCreatorId(100L)).thenReturn(listOf(GetCategoryListResponse(10L, "현재 분류")))
Mockito.`when`(repository.findAllById(listOf(10L))).thenReturn(listOf(category))
val service = CategoryService(
repository,
Mockito.mock(AudioContentRepository::class.java),
Mockito.mock(BlockMemberRepository::class.java),
Mockito.mock(CategoryContentRepository::class.java),
categoryTranslations,
langContext,
Mockito.mock(ApplicationEventPublisher::class.java),
scheduler
)
val response = service.getCategoryList(100L, 200L)
assertEquals(listOf(GetCategoryListResponse(10L, "Old category")), response)
assertRestarted(job)
assertEquals(listOf(job.id), jobs.findAll().map { it.id })
}
}
@@ -0,0 +1,111 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.common.BaseEntity
import kr.co.vividnext.sodalive.configs.QueryDslConfig
import kr.co.vividnext.sodalive.i18n.Lang
import kr.co.vividnext.sodalive.i18n.LangContext
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNull
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.mock.mockito.MockBean
import org.springframework.context.annotation.Import
import org.springframework.transaction.PlatformTransactionManager
import org.springframework.transaction.annotation.Propagation
import org.springframework.transaction.annotation.Transactional
import org.springframework.transaction.support.TransactionTemplate
import java.time.LocalDateTime
import javax.persistence.EntityManager
@DataJpaTest(
properties = [
"spring.cache.type=none",
"spring.datasource.url=jdbc:h2:mem:metadata-read-retry;MODE=MySQL;NON_KEYWORDS=VALUE;DB_CLOSE_ON_EXIT=FALSE"
]
)
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Import(QueryDslConfig::class, ResourceTranslationJobScheduler::class, TranslationJobScheduler::class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
abstract class MetadataReadRetryTestSupport {
@Autowired
protected lateinit var scheduler: ResourceTranslationJobScheduler
@Autowired
protected lateinit var jobs: TranslationJobRepository
@Autowired
protected lateinit var transactionManager: PlatformTransactionManager
@Autowired
protected lateinit var entityManager: EntityManager
@MockBean
protected lateinit var sourceExtractor: TranslationSourceExtractor
protected val langContext = LangContext().apply { setLang(Lang.EN) }
protected val previousRetryAt = LocalDateTime.of(2040, 1, 1, 0, 0)
private val fixtures = mutableListOf<BaseEntity>()
protected fun givenSource(type: LanguageTranslationTargetType, fieldKey: String, text: String): TranslationSource {
val source = TranslationSource(type, 10L, "ko", listOf(TranslationSourceField(fieldKey, text)))
Mockito.`when`(sourceExtractor.extract(type, source.resourceId)).thenReturn(source)
return source
}
protected fun failedJob(source: TranslationSource, targetLanguage: String = "en"): TranslationJob {
val field = source.fields.first()
return persist(
TranslationJob(
resourceType = source.resourceType,
resourceId = source.resourceId,
fieldKey = field.fieldKey,
sourceHash = SourceTextNormalizer.hash(field.sourceText),
sourceText = field.sourceText,
sourceLanguage = source.sourceLanguage,
targetLanguage = targetLanguage,
status = TranslationJobStatus.FAILED,
retryCount = 6,
lastErrorMessage = "exhausted",
nextRetryAt = previousRetryAt
)
)
}
protected fun <T : BaseEntity> persist(entity: T): T {
TransactionTemplate(transactionManager).executeWithoutResult { entityManager.persist(entity) }
fixtures.add(entity)
return entity
}
protected fun <T : BaseEntity> persistRendered(entity: T, table: String, payload: String): T {
persist(entity)
TransactionTemplate(transactionManager).executeWithoutResult {
// H2 JSON 컬럼에는 문자열 대신 JSON 객체를 적재한다.
entityManager.createNativeQuery("update $table set rendered_payload = :payload format json where id = :id")
.setParameter("payload", payload)
.setParameter("id", entity.id)
.executeUpdate()
}
return entity
}
protected fun assertRestarted(job: TranslationJob) {
val restarted = jobs.findById(requireNotNull(job.id)).orElseThrow()
assertEquals(TranslationJobStatus.PENDING, restarted.status)
assertEquals(0, restarted.retryCount)
assertNull(restarted.lastErrorMessage)
}
@AfterEach
fun removeFixtures() {
TransactionTemplate(transactionManager).executeWithoutResult {
jobs.deleteAllInBatch()
fixtures.asReversed().filterNot { it is TranslationJob }.forEach { fixture ->
entityManager.remove(entityManager.find(fixture.javaClass, fixture.id))
}
}
}
}
@@ -0,0 +1,124 @@
package kr.co.vividnext.sodalive.i18n.translation
import kr.co.vividnext.sodalive.chat.original.OriginalWork
import kr.co.vividnext.sodalive.chat.original.service.OriginalWorkTranslationService
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslation
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationPayload
import kr.co.vividnext.sodalive.chat.original.translation.OriginalWorkTranslationRepository
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertNotEquals
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.EnumSource
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.transaction.support.TransactionTemplate
class OriginalWorkReadRetryTest : MetadataReadRetryTestSupport() {
@Autowired
private lateinit var translations: OriginalWorkTranslationRepository
@Test
@DisplayName("이전 원작 번역을 반환해도 읽기 전용 트랜잭션과 별도로 현재 FAILED 작업만 재개한다")
fun shouldRestartOnlyCurrentFailedJobDespiteRenderedTranslationAndReadOnlyRollback() {
val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
val current = failedJob(source)
val stale = failedJob(source.copy(fields = listOf(TranslationSourceField("title", "이전 제목"))))
val otherTarget = failedJob(source, targetLanguage = "ja")
val otherLanguage = failedJob(
source.copy(sourceLanguage = "ja", fields = listOf(TranslationSourceField("category", "장르")))
)
val currentSource = source.copy(
fields = source.fields + listOf(
TranslationSourceField("category", "장르"),
TranslationSourceField("description", "현재 설명")
)
)
Mockito.`when`(sourceExtractor.extract(source.resourceType, source.resourceId)).thenReturn(currentSource)
val rendered = givenRenderedTranslation()
val original = OriginalWork("현재 제목", "소설", "장르", description = "현재 설명", languageCode = "ko").apply { id = 10L }
val service = OriginalWorkTranslationService(translations, scheduler)
val response = TransactionTemplate(transactionManager).apply { isReadOnly = true }.execute { transaction ->
service.ensureTranslated(original, "EN").also { transaction.setRollbackOnly() }
}
assertEquals("Old title", response?.title)
assertEquals("Old description", response?.description)
assertRestarted(current)
assertNotEquals(previousRetryAt, jobs.findById(requireNotNull(current.id)).orElseThrow().nextRetryAt)
val preserved = jobs.findAll().filter { it.id != current.id }
assertEquals(setOf(stale.id, otherTarget.id, otherLanguage.id), preserved.map { it.id }.toSet())
preserved.forEach {
assertEquals(TranslationJobStatus.FAILED, it.status)
assertEquals(6, it.retryCount)
assertEquals("exhausted", it.lastErrorMessage)
assertEquals(previousRetryAt, it.nextRetryAt)
}
assertEquals(rendered.id, translations.findByOriginalWorkIdAndLocale(10L, "en")?.id)
}
@ParameterizedTest
@EnumSource(TranslationJobStatus::class, names = ["PENDING", "RUNNING", "COMPLETED"])
@DisplayName("이전 원작 번역 조회는 진행 중이거나 완료된 작업의 재시도 예산을 보존한다")
fun shouldPreserveActiveOrCompletedJobWhenRenderedTranslationExists(status: TranslationJobStatus) {
val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
val job = failedJob(source)
TransactionTemplate(transactionManager).executeWithoutResult {
jobs.findById(requireNotNull(job.id)).orElseThrow().status = status
}
givenRenderedTranslation()
val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L }
OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en")
val preserved = jobs.findAll().single()
assertEquals(job.id, preserved.id)
assertEquals(status, preserved.status)
assertEquals(6, preserved.retryCount)
assertEquals("exhausted", preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
@Test
@DisplayName("번역이 없는 원작 조회도 다른 원문 언어의 FAILED 작업을 재개하지 않는다")
fun shouldPreserveOtherSourceLanguageWithoutRenderedTranslation() {
val source = givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
val job = failedJob(source.copy(sourceLanguage = "ja"))
val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L }
val response = OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en")
assertEquals(null, response)
val preserved = jobs.findAll().single()
assertEquals(job.id, preserved.id)
assertEquals(TranslationJobStatus.FAILED, preserved.status)
assertEquals(6, preserved.retryCount)
assertEquals("exhausted", preserved.lastErrorMessage)
assertEquals(previousRetryAt, preserved.nextRetryAt)
}
@Test
@DisplayName("번역이 있는 원작 조회는 존재하지 않는 다른 필드 작업을 새로 만들지 않는다")
fun shouldNotCreateMissingJobsWhenRenderedTranslationExists() {
givenSource(LanguageTranslationTargetType.ORIGINAL_WORK, "title", "현재 제목")
givenRenderedTranslation()
val original = OriginalWork("현재 제목", "소설", "장르", languageCode = "ko").apply { id = 10L }
val response = OriginalWorkTranslationService(translations, scheduler).ensureTranslated(original, "en")
assertEquals("Old title", response?.title)
assertEquals(emptyList<TranslationJob>(), jobs.findAll())
}
private fun givenRenderedTranslation() = persistRendered(
OriginalWorkTranslation(
10L,
"en",
OriginalWorkTranslationPayload("Old title", "Novel", "Drama", "Old description", emptyList())
),
"original_work_translation",
"""{"title":"Old title","contentType":"Novel","category":"Drama","description":"Old description","tags":[]}"""
)
}
@@ -146,7 +146,13 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
assertEquals("original", contents[3L]?.content) assertEquals("original", contents[3L]?.content)
assertTrue(contents[3L]?.hasValidTranslation == false) assertTrue(contents[3L]?.hasValidTranslation == false)
assertTrue(4L !in contents) assertTrue(4L !in contents)
Mockito.verifyNoInteractions(sourceExtractor, materializer, scheduler) Mockito.verifyNoInteractions(sourceExtractor, materializer)
Mockito.verify(scheduler).restartFailedResourceTranslations(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(1L, 2L),
"en"
)
Mockito.verifyNoMoreInteractions(scheduler)
} }
@Test @Test
@@ -231,7 +237,12 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
service.requestTranslations(1L, "EN") service.requestTranslations(1L, "EN")
Mockito.verify(materializer).materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, 1L, "en") Mockito.verify(materializer).materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, 1L, "en")
Mockito.verifyNoInteractions(scheduler) Mockito.verify(scheduler).restartFailedResourceTranslationsInCurrentTransaction(
LanguageTranslationTargetType.CREATOR_COMMUNITY,
listOf(1L),
"en"
)
Mockito.verifyNoMoreInteractions(scheduler)
} }
@Test @Test
@@ -718,7 +729,8 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor(
materializer = persistentMaterializer(sourceExtractor), materializer = persistentMaterializer(sourceExtractor),
resourceTranslationJobScheduler = ResourceTranslationJobScheduler( resourceTranslationJobScheduler = ResourceTranslationJobScheduler(
sourceExtractor, sourceExtractor,
TranslationJobScheduler(translationJobRepository) TranslationJobScheduler(translationJobRepository),
translationJobRepository
), ),
applicationEventPublisher = applicationEventPublisher, applicationEventPublisher = applicationEventPublisher,
entityManager = entityManager entityManager = entityManager