From 081f22b2c09a68f962c7355a4dc0af995734762c Mon Sep 17 00:00:00 2001 From: Klaus Date: Mon, 16 Nov 2026 21:47:54 +0900 Subject: [PATCH] =?UTF-8?q?fix(i18n):=20=EB=A9=94=ED=83=80=EB=8D=B0?= =?UTF-8?q?=EC=9D=B4=ED=84=B0=20=EC=A1=B0=ED=9A=8C=EC=99=80=20=EC=9A=94?= =?UTF-8?q?=EC=B2=AD=EC=97=90=EC=84=9C=20=ED=98=84=EC=9E=AC=20=EC=9B=90?= =?UTF-8?q?=EB=AC=B8=EC=9D=98=20=EC=8B=A4=ED=8C=A8=20=EB=B2=88=EC=97=AD?= =?UTF-8?q?=EC=9D=84=20=EC=9E=AC=EA=B0=9C=ED=95=9C=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../controller/ChatCharacterController.kt | 5 + .../service/OriginalWorkTranslationService.kt | 11 +- .../sodalive/content/AudioContentService.kt | 5 + .../content/category/CategoryService.kt | 5 + .../content/series/ContentSeriesService.kt | 10 ++ .../content/theme/AudioContentThemeService.kt | 5 + .../ResourceTranslationJobScheduler.kt | 44 ++++++- .../CreatorCommunityTranslationService.kt | 16 +++ .../translation/AudioContentReadRetryTest.kt | 113 ++++++++++++++++ .../translation/CharacterReadRetryTest.kt | 78 +++++++++++ .../translation/ContentSeriesReadRetryTest.kt | 101 ++++++++++++++ .../CreatorCommunityReadRetryTest.kt | 114 ++++++++++++++++ .../translation/MetadataListReadRetryTest.kt | 92 +++++++++++++ .../MetadataReadRetryTestSupport.kt | 111 ++++++++++++++++ .../translation/OriginalWorkReadRetryTest.kt | 124 ++++++++++++++++++ .../CreatorCommunityTranslationServiceTest.kt | 18 ++- 16 files changed, 846 insertions(+), 6 deletions(-) create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt create mode 100644 src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt b/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt index e1fc899e..a8db80d7 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/chat/character/controller/ChatCharacterController.kt @@ -186,6 +186,11 @@ class ChatCharacterController( var translated: TranslatedAiCharacterDetail? = null if (langContext.lang.code != character.languageCode) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CHARACTER, + listOf(characterId), + langContext.lang.code + ) val existing = aiCharacterTranslationRepository .findByCharacterIdAndLocale(character.id!!, langContext.lang.code) diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt index 41fdcc75..ab6fc5ad 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/chat/original/service/OriginalWorkTranslationService.kt @@ -28,8 +28,15 @@ class OriginalWorkTranslationService( return null } + val originalWorkId = requireNotNull(originalWork.id) + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.ORIGINAL_WORK, + listOf(originalWorkId), + target + ) + // 기존 번역 조회 - val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWork.id!!, target) + val existed = translationRepository.findByOriginalWorkIdAndLocale(originalWorkId, target) val existedPayload = existed?.renderedPayload if (existedPayload != null) { val t = existedPayload.title.trim() @@ -51,7 +58,7 @@ class OriginalWorkTranslationService( resourceTranslationJobScheduler.scheduleResourceTranslation( resourceType = LanguageTranslationTargetType.ORIGINAL_WORK, - resourceId = originalWork.id!!, + resourceId = originalWorkId, targetLanguage = target ) return null diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt index 5be729a1..6276963f 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/AudioContentService.kt @@ -896,6 +896,11 @@ class AudioContentService( audioContent.languageCode!!.isNotBlank() && audioContent.languageCode != langContext.lang.code ) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CONTENT, + listOf(id), + langContext.lang.code + ) val existing = contentTranslationRepository .findByContentIdAndLocale(audioContent.id!!, langContext.lang.code) diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt index 4a83f966..b743fbbc 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/category/CategoryService.kt @@ -141,6 +141,11 @@ class CategoryService( val categoryIds = baseList.map { it.categoryId } val entities = repository.findAllById(categoryIds) val entityMap = entities.associateBy { it.id!! } + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CREATOR_CONTENT_CATEGORY, + categoryIds, + locale + ) // 요청 로케일로 이미 저장된 번역 일괄 조회 val translations = categoryTranslationRepository diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt index 2ead853c..4ad4f917 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/series/ContentSeriesService.kt @@ -98,6 +98,11 @@ class ContentSeriesService( if (currentLang == Lang.EN || currentLang == Lang.JA) { val targetLocale = currentLang.code val ids = genres.map { it.id } + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.SERIES_GENRE, + ids, + targetLocale + ) // 기존 번역 일괄 조회 val existing = if (ids.isNotEmpty()) { @@ -278,6 +283,11 @@ class ContentSeriesService( val languageCode = series.languageCode // 원본 언어가 존재하고, 요청 언어와 다를 때만 번역 처리 if (!languageCode.isNullOrBlank() && languageCode != locale) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.SERIES, + listOf(seriesId), + locale + ) val existing = seriesTranslationRepository.findBySeriesIdAndLocale(seriesId = seriesId, locale = locale) if (existing != null) { val payload = existing.renderedPayload diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt index ece624e8..36c1408a 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/content/theme/AudioContentThemeService.kt @@ -58,6 +58,11 @@ class AudioContentThemeService( val targetLocale = currentLang.code // 1) 기존 번역을 한 번에 조회 val ids = themesWithIds.map { it.id } + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CONTENT_THEME, + ids, + targetLocale + ) val existingTranslations = if (ids.isNotEmpty()) { contentThemeTranslationRepository.findByContentThemeIdInAndLocale(ids, targetLocale) } else { diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt index 5c5013b4..f141efb8 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/i18n/translation/ResourceTranslationJobScheduler.kt @@ -2,12 +2,15 @@ package kr.co.vividnext.sodalive.i18n.translation import kr.co.vividnext.sodalive.i18n.translation.TranslationLanguages.getTranslatableLanguageCodes import org.springframework.stereotype.Service +import org.springframework.transaction.annotation.Propagation import org.springframework.transaction.annotation.Transactional +import java.time.LocalDateTime @Service class ResourceTranslationJobScheduler( private val sourceExtractor: TranslationSourceExtractor, - private val translationJobScheduler: TranslationJobScheduler + private val translationJobScheduler: TranslationJobScheduler, + private val translationJobRepository: TranslationJobRepository ) { @Transactional fun scheduleResourceTranslations(resourceType: LanguageTranslationTargetType, resourceId: Long) { @@ -27,6 +30,45 @@ class ResourceTranslationJobScheduler( scheduleSource(source, targetLanguage) } + @Transactional(propagation = Propagation.REQUIRES_NEW) + fun restartFailedResourceTranslations( + resourceType: LanguageTranslationTargetType, + resourceIds: Collection, + targetLanguage: String + ) { + restartFailedResourceTranslationsInCurrentTransaction(resourceType, resourceIds, targetLanguage) + } + + @Transactional + fun restartFailedResourceTranslationsInCurrentTransaction( + resourceType: LanguageTranslationTargetType, + resourceIds: Collection, + 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) { source.fields.forEach { field -> translationJobScheduler.scheduleMissingTranslation( diff --git a/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt b/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt index 7c1b4972..f001caea 100644 --- a/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt +++ b/src/main/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/application/CreatorCommunityTranslationService.kt @@ -35,6 +35,17 @@ class CreatorCommunityTranslationService( val normalizedLocale = locale.lowercase() val posts = creatorCommunityRepository.findAllById(postIds).filter { it.isActive } + val translationPostIds = posts.filter { post -> + val sourceLanguage = post.languageCode?.lowercase() + !sourceLanguage.isNullOrBlank() && sourceLanguage != normalizedLocale + }.mapNotNull { it.id } + if (translationPostIds.isNotEmpty()) { + resourceTranslationJobScheduler.restartFailedResourceTranslations( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + translationPostIds, + normalizedLocale + ) + } val translations = creatorCommunityTranslationRepository .findByCreatorCommunityIdInAndLocale(posts.mapNotNull { it.id }, normalizedLocale) .associateBy { it.creatorCommunityId } @@ -62,6 +73,11 @@ class CreatorCommunityTranslationService( targetLanguages .filter { it != sourceLanguage } .forEach { language -> + resourceTranslationJobScheduler.restartFailedResourceTranslationsInCurrentTransaction( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + listOf(postId), + language + ) if (!materializer.materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, postId, language)) { resourceTranslationJobScheduler.scheduleResourceTranslation( resourceType = LanguageTranslationTargetType.CREATOR_COMMUNITY, diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt new file mode 100644 index 00000000..5b194151 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/AudioContentReadRetryTest.kt @@ -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 }) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt new file mode 100644 index 00000000..c0751e3b --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CharacterReadRetryTest.kt @@ -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 }) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt new file mode 100644 index 00000000..4502871d --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/ContentSeriesReadRetryTest.kt @@ -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" + ) +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt new file mode 100644 index 00000000..9ccc6851 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/CreatorCommunityReadRetryTest.kt @@ -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(), 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) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt new file mode 100644 index 00000000..aa41e8e5 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataListReadRetryTest.kt @@ -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 }) + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt new file mode 100644 index 00000000..a98b1a1e --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/MetadataReadRetryTestSupport.kt @@ -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() + + 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 persist(entity: T): T { + TransactionTemplate(transactionManager).executeWithoutResult { entityManager.persist(entity) } + fixtures.add(entity) + return entity + } + + protected fun 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)) + } + } + } +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt new file mode 100644 index 00000000..222ff496 --- /dev/null +++ b/src/test/kotlin/kr/co/vividnext/sodalive/i18n/translation/OriginalWorkReadRetryTest.kt @@ -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(), 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":[]}""" + ) +} diff --git a/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt b/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt index 77856bae..2a4110e5 100644 --- a/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt +++ b/src/test/kotlin/kr/co/vividnext/sodalive/v2/creator/channel/community/translation/CreatorCommunityTranslationServiceTest.kt @@ -146,7 +146,13 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor( assertEquals("original", contents[3L]?.content) assertTrue(contents[3L]?.hasValidTranslation == false) assertTrue(4L !in contents) - Mockito.verifyNoInteractions(sourceExtractor, materializer, scheduler) + Mockito.verifyNoInteractions(sourceExtractor, materializer) + Mockito.verify(scheduler).restartFailedResourceTranslations( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + listOf(1L, 2L), + "en" + ) + Mockito.verifyNoMoreInteractions(scheduler) } @Test @@ -231,7 +237,12 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor( service.requestTranslations(1L, "EN") Mockito.verify(materializer).materialize(LanguageTranslationTargetType.CREATOR_COMMUNITY, 1L, "en") - Mockito.verifyNoInteractions(scheduler) + Mockito.verify(scheduler).restartFailedResourceTranslationsInCurrentTransaction( + LanguageTranslationTargetType.CREATOR_COMMUNITY, + listOf(1L), + "en" + ) + Mockito.verifyNoMoreInteractions(scheduler) } @Test @@ -718,7 +729,8 @@ class CreatorCommunityTranslationServiceTest @Autowired constructor( materializer = persistentMaterializer(sourceExtractor), resourceTranslationJobScheduler = ResourceTranslationJobScheduler( sourceExtractor, - TranslationJobScheduler(translationJobRepository) + TranslationJobScheduler(translationJobRepository), + translationJobRepository ), applicationEventPublisher = applicationEventPublisher, entityManager = entityManager