llm-service e yeni endpointler eklendi. AI PERFORMANCE FIXER MODÜLÜ KAPSAMINDA.

Author: omerada

llm-service/pom.xml

@@ -22,6 +22,7 @@
         <spring-cloud.version>2023.0.2</spring-cloud.version>
         <lombok.version>1.18.30</lombok.version>
         <netty.version>4.1.107.Final</netty.version>
+        <springdoc.version>2.2.0</springdoc.version>
     </properties>
 
     <dependencies>
@@ -146,6 +147,26 @@
             <groupId>com.fasterxml.jackson.datatype</groupId>
             <artifactId>jackson-datatype-jsr310</artifactId>
         </dependency>
+
+        <!-- Caching -->
+        <dependency>
+            <groupId>com.github.ben-manes.caffeine</groupId>
+            <artifactId>caffeine</artifactId>
+        </dependency>
+
+        <!-- Rate Limiting -->
+        <dependency>
+            <groupId>com.github.vladimir-bukhtoyarov</groupId>
+            <artifactId>bucket4j-core</artifactId>
+            <version>7.6.0</version>
+        </dependency>
+
+        <!-- API Documentation -->
+        <dependency>
+            <groupId>org.springdoc</groupId>
+            <artifactId>springdoc-openapi-starter-webflux-ui</artifactId>
+            <version>${springdoc.version}</version>
+        </dependency>
     </dependencies>
 
     <dependencyManagement>

llm-service/src/main/java/com/craftpilot/llmservice/cache/PerformanceAnalysisCache.java

@@ -8,6 +8,7 @@
 import reactor.core.publisher.Mono;
 
 import java.time.Duration;
+import java.util.function.Function;
 
 @Component
 @Slf4j
@@ -23,10 +24,14 @@ public PerformanceAnalysisCache() {
     }
 
     public Mono<PerformanceAnalysisResponse> getAnalysisResult(String url) {
-        return Mono.justOrEmpty(cache.getIfPresent(url))
-                .doOnSubscribe(subscription -> log.debug("Looking up URL in cache: {}", url))
-                .doOnNext(result -> log.debug("Cache hit for URL: {}", url))
-                .doOnEmpty(() -> log.debug("Cache miss for URL: {}", url));
+        PerformanceAnalysisResponse cachedResult = cache.getIfPresent(url);
+        if (cachedResult != null) {
+            log.debug("Cache hit for performance analysis: {}", url);
+            return Mono.just(cachedResult);
+        } else {
+            log.debug("Cache miss for performance analysis: {}", url);
+            return Mono.empty();
+        }
     }
 
     public void cacheAnalysisResult(String url, PerformanceAnalysisResponse result) {

llm-service/src/main/java/com/craftpilot/llmservice/model/performance/SuggestionsResponse.java

@@ -2,9 +2,11 @@
 
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 @Data
 @AllArgsConstructor
+@NoArgsConstructor
 public class SuggestionsResponse {
     private String content;
 }

llm-service/src/test/java/com/craftpilot/llmservice/service/PerformanceServiceTest.java

@@ -1,25 +1,30 @@
 package com.craftpilot.llmservice.service;
 
 import com.craftpilot.llmservice.cache.PerformanceAnalysisCache;
+import com.craftpilot.llmservice.model.AIRequest;
+import com.craftpilot.llmservice.model.AIResponse;
 import com.craftpilot.llmservice.model.performance.PerformanceAnalysisRequest;
 import com.craftpilot.llmservice.model.performance.PerformanceAnalysisResponse;
 import com.craftpilot.llmservice.model.performance.SuggestionsRequest;
 import com.craftpilot.llmservice.repository.PerformanceAnalysisRepository;
-import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.micrometer.core.instrument.MeterRegistry;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import java.time.Instant;
 import java.util.HashMap;
+import java.util.UUID;
 
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.when;
 
+@ExtendWith(MockitoExtension.class)
 class PerformanceServiceTest {
 
     private PerformanceService performanceService;
@@ -34,22 +39,27 @@ class PerformanceServiceTest {
     private PerformanceAnalysisCache performanceAnalysisCache;
 
     @Mock
-    private AiService aiService;
+    private LLMService llmService;
 
     @Mock
     private PromptService promptService;
 
+    @Mock
+    private MeterRegistry meterRegistry;
+    
+    @Mock
+    private ObjectMapper objectMapper;
+    
     @BeforeEach
     void setUp() {
-        MockitoAnnotations.openMocks(this);
-        
         performanceService = new PerformanceService(
-                lighthouseService, 
-                performanceAnalysisRepository, 
-                performanceAnalysisCache, 
-                aiService, 
+                lighthouseService,
+                performanceAnalysisRepository,
+                performanceAnalysisCache,
                 promptService,
-                new SimpleMeterRegistry()
+                meterRegistry,
+                llmService,
+                objectMapper
         );
     }
 
@@ -104,13 +114,20 @@ void analyzeWebsite_WhenCacheMiss_PerformsNewAnalysis() {
     }
 
     @Test
-    void generateSuggestions_ReturnsAiResponse() {
+    void generateSuggestions_ReturnsAiResponse() throws Exception {
         // Arrange
         SuggestionsRequest request = new SuggestionsRequest();
         request.setAnalysisData(new HashMap<String, Object>());
+        request.setUserId("test-user");
+        request.setLanguage("tr");
+        
+        AIResponse aiResponse = AIResponse.builder()
+                .response("AI response")
+                .success(true)
+                .build();
 
-        when(promptService.getPerformanceAnalysisPrompt(any())).thenReturn("test prompt");
-        when(aiService.generateAiResponse(anyString())).thenReturn(Mono.just("AI response"));
+        when(objectMapper.writeValueAsString(any())).thenReturn("{}");
+        when(llmService.processChatCompletion(any(AIRequest.class))).thenReturn(Mono.just(aiResponse));
 
         // Act & Assert
         StepVerifier.create(performanceService.generateSuggestions(request))