[Refactor] analysis AI/question candidate 정리 (#271)

src/main/java/com/jobdri/jobdri_api/domain/analysis/dto/response/QuestionCandidateResponse.java

@@ -5,6 +5,7 @@ public record QuestionCandidateResponse(
         String content,
         int charLimit,
         boolean selected,
-        boolean custom
+        boolean custom,
+        String candidateKey
 ) {
 }

src/main/java/com/jobdri/jobdri_api/domain/analysis/service/question/CustomQuestionCandidatePersistenceService.java

@@ -0,0 +1,31 @@
+package com.jobdri.jobdri_api.domain.analysis.service.question;
+
+import com.jobdri.jobdri_api.domain.analysis.entity.CustomQuestionCandidate;
+import com.jobdri.jobdri_api.domain.analysis.repository.CustomQuestionCandidateRepository;
+import com.jobdri.jobdri_api.domain.mockapply.entity.MockApply;
+import jakarta.persistence.EntityManager;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Service
+public class CustomQuestionCandidatePersistenceService {
+    private final CustomQuestionCandidateRepository customQuestionCandidateRepository;
+    private final EntityManager entityManager;
+
+    public CustomQuestionCandidatePersistenceService(
+            CustomQuestionCandidateRepository customQuestionCandidateRepository,
+            EntityManager entityManager
+    ) {
+        this.customQuestionCandidateRepository = customQuestionCandidateRepository;
+        this.entityManager = entityManager;
+    }
+
+    @Transactional(propagation = Propagation.REQUIRES_NEW)
+    public CustomQuestionCandidate saveAndFlush(Long mockApplyId, String content, int charLimit) {
+        MockApply mockApplyReference = entityManager.getReference(MockApply.class, mockApplyId);
+        return customQuestionCandidateRepository.saveAndFlush(
+                CustomQuestionCandidate.create(mockApplyReference, content, charLimit)
+        );
+    }
+}

src/main/java/com/jobdri/jobdri_api/domain/analysis/service/question/QuestionCandidateCatalogService.java

@@ -12,6 +12,8 @@
 @Service
 // 기본 문항 후보와 후보 판별 규칙을 제공한다.
 public class QuestionCandidateCatalogService {
+    private static final String DEFAULT_CANDIDATE_PREFIX = "default:";
+    private static final String CUSTOM_CANDIDATE_PREFIX = "custom:";
     private static final List<QuestionCandidate> DEFAULT_CANDIDATES = List.of(
             new QuestionCandidate(1L, "지원 동기와 입사 후 목표를 작성해주세요.", 700),
             new QuestionCandidate(2L, "지원 직무와 관련된 경험 또는 역량을 구체적으로 작성해주세요.", 1000),
@@ -30,7 +32,8 @@ public List<QuestionCandidateResponse> getDefaultCandidateResponses(Set<String>
                         candidate.content(),
                         candidate.charLimit(),
                         selectedContents.contains(candidate.content()),
-                        false
+                        false,
+                        toDefaultCandidateKey(candidate.id())
                 ))
                 .toList();
     }
@@ -45,6 +48,14 @@ public void validateCustomCandidate(String content) {
         }
     }
 
+    public String toDefaultCandidateKey(Long candidateId) {
+        return DEFAULT_CANDIDATE_PREFIX + candidateId;
+    }
+
+    public String toCustomCandidateKey(Long candidateId) {
+        return CUSTOM_CANDIDATE_PREFIX + candidateId;
+    }
+
     private record QuestionCandidate(Long id, String content, int charLimit) {
     }
 }

src/main/java/com/jobdri/jobdri_api/domain/analysis/service/question/QuestionCommandService.java

@@ -41,21 +41,24 @@ public class QuestionCommandService {
     private final QuestionRepository questionRepository;
     private final QuestionAnalysisRepository questionAnalysisRepository;
     private final CustomQuestionCandidateRepository customQuestionCandidateRepository;
+    private final CustomQuestionCandidatePersistenceService customQuestionCandidatePersistenceService;
 
     public QuestionCommandService(
             QuestionDomainSupport questionDomainSupport,
             QuestionCandidateCatalogService questionCandidateCatalogService,
             MockApplyRepository mockApplyRepository,
             QuestionRepository questionRepository,
             QuestionAnalysisRepository questionAnalysisRepository,
-            CustomQuestionCandidateRepository customQuestionCandidateRepository
+            CustomQuestionCandidateRepository customQuestionCandidateRepository,
+            CustomQuestionCandidatePersistenceService customQuestionCandidatePersistenceService
     ) {
         this.questionDomainSupport = questionDomainSupport;
         this.questionCandidateCatalogService = questionCandidateCatalogService;
         this.mockApplyRepository = mockApplyRepository;
         this.questionRepository = questionRepository;
         this.questionAnalysisRepository = questionAnalysisRepository;
         this.customQuestionCandidateRepository = customQuestionCandidateRepository;
+        this.customQuestionCandidatePersistenceService = customQuestionCandidatePersistenceService;
     }
 
     @Transactional
@@ -77,7 +80,8 @@ public QuestionCandidateResponse addCustomQuestionCandidate(
                 candidate.getContent(),
                 candidate.getLimit(),
                 selected,
-                true
+                true,
+                questionCandidateCatalogService.toCustomCandidateKey(candidate.getId())
         );
     }
 
@@ -218,12 +222,13 @@ private CustomQuestionCandidate saveCustomCandidate(
             String content,
             Integer charLimit
     ) {
+        int resolvedCharLimit = questionDomainSupport.resolveCharLimit(charLimit);
         try {
-            return customQuestionCandidateRepository.saveAndFlush(CustomQuestionCandidate.create(
-                    mockApply,
+            return customQuestionCandidatePersistenceService.saveAndFlush(
+                    mockApply.getId(),
                     content,
-                    questionDomainSupport.resolveCharLimit(charLimit)
-            ));
+                    resolvedCharLimit
+            );
         } catch (DataIntegrityViolationException e) {
             return customQuestionCandidateRepository
                     .findByMockApplyIdAndContent(mockApply.getId(), content)

src/main/java/com/jobdri/jobdri_api/domain/analysis/service/question/QuestionQueryService.java

@@ -54,7 +54,8 @@ public List<QuestionCandidateResponse> getQuestionCandidates(User user, Long moc
                         candidate.getContent(),
                         candidate.getLimit(),
                         selectedContents.contains(candidate.getContent()),
-                        true
+                        true,
+                        questionCandidateCatalogService.toCustomCandidateKey(candidate.getId())
                 ))
                 .forEach(candidates::add);
 

src/test/java/com/jobdri/jobdri_api/domain/analysis/service/ai/AnalysisAiClientTest.java

@@ -20,9 +20,6 @@
 import com.jobdri.jobdri_api.domain.corpus.service.CorpusRetrievalService;
 import com.jobdri.jobdri_api.domain.corpus.service.CorpusRetrievalService.RetrievalContext;
 import com.jobdri.jobdri_api.domain.jobposting.entity.JobPosting;
-import com.jobdri.jobdri_api.global.config.LlmConcurrencyLimiter;
-import com.jobdri.jobdri_api.global.metrics.AsyncMetricsRecorder;
-import com.openai.client.OpenAIClient;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.test.util.ReflectionTestUtils;
@@ -52,14 +49,7 @@ class AnalysisAiClientTest {
     );
     private final OpenAiAnalysisAdapter openAiAnalysisAdapter = mock(OpenAiAnalysisAdapter.class);
     private final AnalysisAiClient analysisAiClient = new AnalysisAiClient(
-            mock(OpenAIClient.class),
             mock(CorpusRetrievalService.class),
-            mock(LlmConcurrencyLimiter.class),
-            new FewShotPromptProvider(),
-            fewShotSearchService,
-            fewShotProperties,
-            mock(AsyncMetricsRecorder.class),
-            objectMapper,
             analysisPromptBuilder,
             analysisResponseParser,
             openAiAnalysisAdapter

src/test/java/com/jobdri/jobdri_api/domain/analysis/service/question/QuestionCandidateCatalogServiceTest.java

@@ -0,0 +1,26 @@
+package com.jobdri.jobdri_api.domain.analysis.service.question;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class QuestionCandidateCatalogServiceTest {
+
+    private final QuestionCandidateCatalogService questionCandidateCatalogService =
+            new QuestionCandidateCatalogService();
+
+    @Test
+    @DisplayName("기본 후보와 custom 후보는 서로 다른 prefix의 candidateKey를 사용한다")
+    void candidateKeysUseDistinctPrefixes() {
+        var defaultCandidates = questionCandidateCatalogService.getDefaultCandidateResponses(Set.of());
+
+        assertThat(defaultCandidates).isNotEmpty();
+        assertThat(defaultCandidates.getFirst().candidateKey()).isEqualTo("default:1");
+        assertThat(questionCandidateCatalogService.toCustomCandidateKey(1L)).isEqualTo("custom:1");
+        assertThat(defaultCandidates.getFirst().candidateKey())
+                .isNotEqualTo(questionCandidateCatalogService.toCustomCandidateKey(1L));
+    }
+}

src/test/java/com/jobdri/jobdri_api/domain/analysis/service/question/QuestionCommandServiceTest.java

@@ -0,0 +1,102 @@
+package com.jobdri.jobdri_api.domain.analysis.service.question;
+
+import com.jobdri.jobdri_api.domain.analysis.dto.request.QuestionCandidateCreateRequest;
+import com.jobdri.jobdri_api.domain.analysis.dto.response.QuestionCandidateResponse;
+import com.jobdri.jobdri_api.domain.analysis.entity.CustomQuestionCandidate;
+import com.jobdri.jobdri_api.domain.analysis.repository.CustomQuestionCandidateRepository;
+import com.jobdri.jobdri_api.domain.analysis.repository.QuestionAnalysisRepository;
+import com.jobdri.jobdri_api.domain.analysis.repository.QuestionRepository;
+import com.jobdri.jobdri_api.domain.mockapply.entity.MockApply;
+import com.jobdri.jobdri_api.domain.mockapply.repository.MockApplyRepository;
+import com.jobdri.jobdri_api.domain.user.entity.User;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.test.util.ReflectionTestUtils;
+
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+@ExtendWith(MockitoExtension.class)
+class QuestionCommandServiceTest {
+
+    @Mock
+    private QuestionDomainSupport questionDomainSupport;
+
+    @Mock
+    private QuestionCandidateCatalogService questionCandidateCatalogService;
+
+    @Mock
+    private MockApplyRepository mockApplyRepository;
+
+    @Mock
+    private QuestionRepository questionRepository;
+
+    @Mock
+    private QuestionAnalysisRepository questionAnalysisRepository;
+
+    @Mock
+    private CustomQuestionCandidateRepository customQuestionCandidateRepository;
+
+    @Mock
+    private CustomQuestionCandidatePersistenceService customQuestionCandidatePersistenceService;
+
+    @Test
+    @DisplayName("custom candidate 저장 충돌 시 기존 후보를 재조회해 정상 응답한다")
+    void addCustomQuestionCandidateRecoversAfterUniqueConflict() {
+        QuestionCommandService questionCommandService = new QuestionCommandService(
+                questionDomainSupport,
+                questionCandidateCatalogService,
+                mockApplyRepository,
+                questionRepository,
+                questionAnalysisRepository,
+                customQuestionCandidateRepository,
+                customQuestionCandidatePersistenceService
+        );
+        User user = User.signup("테스트 사용자", "question-command@example.com", "encoded-password");
+        MockApply mockApply = mock(MockApply.class);
+        when(mockApply.getId()).thenReturn(10L);
+
+        CustomQuestionCandidate existingCandidate = CustomQuestionCandidate.create(
+                mockApply,
+                "새로운 지원 동기를 작성해주세요.",
+                900
+        );
+        ReflectionTestUtils.setField(existingCandidate, "id", 7L);
+
+        when(questionDomainSupport.getOwnedMockApply(user, 10L)).thenReturn(mockApply);
+        doNothing().when(questionCandidateCatalogService).validateCustomCandidate("새로운 지원 동기를 작성해주세요.");
+        when(questionCandidateCatalogService.toCustomCandidateKey(7L)).thenReturn("custom:7");
+        when(questionDomainSupport.resolveCharLimit(900)).thenReturn(900);
+        when(customQuestionCandidateRepository.findByMockApplyIdAndContent(10L, "새로운 지원 동기를 작성해주세요."))
+                .thenReturn(Optional.empty(), Optional.of(existingCandidate));
+        when(customQuestionCandidatePersistenceService.saveAndFlush(10L, "새로운 지원 동기를 작성해주세요.", 900))
+                .thenThrow(new DataIntegrityViolationException("duplicate candidate"));
+        when(questionRepository.existsByMockApplyIdAndContent(10L, "새로운 지원 동기를 작성해주세요."))
+                .thenReturn(false);
+
+        QuestionCandidateResponse response = questionCommandService.addCustomQuestionCandidate(
+                user,
+                10L,
+                new QuestionCandidateCreateRequest("  새로운 지원 동기를 작성해주세요.  ", 900)
+        );
+
+        assertThat(response.questionId()).isEqualTo(7L);
+        assertThat(response.content()).isEqualTo("새로운 지원 동기를 작성해주세요.");
+        assertThat(response.charLimit()).isEqualTo(900);
+        assertThat(response.selected()).isFalse();
+        assertThat(response.custom()).isTrue();
+        assertThat(response.candidateKey()).isEqualTo("custom:7");
+        verify(customQuestionCandidatePersistenceService).saveAndFlush(10L, "새로운 지원 동기를 작성해주세요.", 900);
+        verify(customQuestionCandidateRepository, never()).saveAndFlush(existingCandidate);
+    }
+}