test: 토큰 지금 관련 테스트 코드 추가

Author: ImGdevel

ProjectVG.Tests/Application/Services/Chat/ChatServiceSimpleTests.cs

@@ -21,54 +21,206 @@ public class ChatServiceSimpleTests
         private readonly Mock<IChatMetricsService> _mockMetricsService;
         private readonly Mock<IConversationService> _mockConversationService;
         private readonly Mock<ICharacterService> _mockCharacterService;
+        private readonly Mock<IServiceScopeFactory> _mockScopeFactory;
+        private readonly Mock<IServiceScope> _mockScope;
+        private readonly Mock<IServiceProvider> _mockServiceProvider;
+        private readonly Mock<ILogger<ChatService>> _mockLogger;
 
         public ChatServiceSimpleTests()
         {
             _mockMetricsService = new Mock<IChatMetricsService>();
             _mockConversationService = new Mock<IConversationService>();
             _mockCharacterService = new Mock<ICharacterService>();
+            _mockScopeFactory = new Mock<IServiceScopeFactory>();
+            _mockScope = new Mock<IServiceScope>();
+            _mockServiceProvider = new Mock<IServiceProvider>();
+            _mockLogger = new Mock<ILogger<ChatService>>();
+
+            // Setup scope factory chain
+            _mockScopeFactory.Setup(x => x.CreateScope()).Returns(_mockScope.Object);
+            _mockScope.Setup(x => x.ServiceProvider).Returns(_mockServiceProvider.Object);
+        }
+
+        #region Service Scope Management Tests
+
+        [Fact]
+        public void ChatService_Constructor_WithServiceScopeFactory_ShouldAcceptDependency()
+        {
+            // Arrange & Act & Assert
+            var act = () => CreateTestChatService();
+            act.Should().NotThrow("IServiceScopeFactory should be a valid dependency for ChatService");
         }
 
-        [Fact(Skip = "ChatService has complex dependencies that cannot be easily mocked. Integration tests should be used instead.")]
-        public void ChatService_Constructor_ShouldNotThrow()
+        [Fact]
+        public void ServiceScopeFactory_CreateScope_ShouldReturnValidScope()
         {
-            // This test is skipped because ChatService depends on concrete classes without interfaces,
-            // making it difficult to unit test. The service should be refactored to depend on interfaces.
+            // Arrange
+            var mockScope = new Mock<IServiceScope>();
+            var mockServiceProvider = new Mock<IServiceProvider>();
+            mockScope.Setup(x => x.ServiceProvider).Returns(mockServiceProvider.Object);
+
+            var mockScopeFactory = new Mock<IServiceScopeFactory>();
+            mockScopeFactory.Setup(x => x.CreateScope()).Returns(mockScope.Object);
+
+            // Act
+            var scope = mockScopeFactory.Object.CreateScope();
+
+            // Assert
+            scope.Should().NotBeNull();
+            scope.ServiceProvider.Should().NotBeNull();
+            mockScopeFactory.Verify(x => x.CreateScope(), Times.Once);
         }
 
-        [Fact(Skip = "ChatService has complex dependencies that cannot be easily mocked. Integration tests should be used instead.")]
-        public async Task EnqueueChatRequestAsync_WithValidCommand_ShouldCallMetricsService()
+        [Fact]
+        public void ServiceScope_ShouldImplementIDisposable()
         {
-            // This test is skipped because ChatService depends on concrete classes without interfaces,
-            // making it difficult to unit test. The service should be refactored to depend on interfaces.
-            await Task.CompletedTask;
+            // Arrange
+            var mockScope = new Mock<IServiceScope>();
+            
+            // Act & Assert
+            mockScope.Object.Should().BeAssignableTo<IDisposable>("IServiceScope should be disposable for proper resource management");
         }
 
-        private ChatService? TryCreateChatService()
+        [Fact]
+        public void ServiceProvider_GetRequiredService_ShouldResolveServicesCorrectly()
         {
-            try
-            {
-                // Create a minimal service collection with all required services
-                var services = new ServiceCollection();
-                
-                // Add required services with mocks
-                services.AddSingleton(_mockMetricsService.Object);
-                services.AddSingleton(_mockConversationService.Object);
-                services.AddSingleton(_mockCharacterService.Object);
-                
-                // Add logging
-                services.AddLogging(builder => builder.AddConsole().SetMinimumLevel(LogLevel.Warning));
-                
-                // Note: Due to the complex dependency graph of ChatService with concrete classes,
-                // we cannot easily mock all dependencies. This is a limitation of the current design.
-                // For proper unit testing, the ChatService should depend on interfaces, not concrete classes.
-                
-                return null; // Indicates that ChatService cannot be easily unit tested with its current design
-            }
-            catch
+            // Arrange
+            var mockChatSuccessHandler = new Mock<ChatSuccessHandler>();
+            var mockChatResultProcessor = new Mock<ChatResultProcessor>();
+            
+            _mockServiceProvider.Setup(x => x.GetRequiredService<ChatSuccessHandler>())
+                .Returns(mockChatSuccessHandler.Object);
+            _mockServiceProvider.Setup(x => x.GetRequiredService<ChatResultProcessor>())
+                .Returns(mockChatResultProcessor.Object);
+
+            // Act
+            var successHandler = _mockServiceProvider.Object.GetRequiredService<ChatSuccessHandler>();
+            var resultProcessor = _mockServiceProvider.Object.GetRequiredService<ChatResultProcessor>();
+
+            // Assert
+            successHandler.Should().NotBeNull();
+            resultProcessor.Should().NotBeNull();
+            successHandler.Should().BeSameAs(mockChatSuccessHandler.Object);
+            resultProcessor.Should().BeSameAs(mockChatResultProcessor.Object);
+        }
+
+        [Fact]
+        public async Task ProcessChatRequestInternalAsync_ShouldCreateNewScopeForBackgroundTasks()
+        {
+            // This test verifies the concept of scope creation for background tasks
+            // The actual method is private and complex, so we test the scope creation pattern
+
+            // Arrange
+            var mockChatSuccessHandler = new Mock<ChatSuccessHandler>();
+            var mockChatResultProcessor = new Mock<ChatResultProcessor>();
+            
+            _mockServiceProvider.Setup(x => x.GetRequiredService<ChatSuccessHandler>())
+                .Returns(mockChatSuccessHandler.Object);
+            _mockServiceProvider.Setup(x => x.GetRequiredService<ChatResultProcessor>())
+                .Returns(mockChatResultProcessor.Object);
+
+            // Act - Simulate the scope creation pattern used in ChatService
+            using var scope = _mockScopeFactory.Object.CreateScope();
+            var successHandler = scope.ServiceProvider.GetRequiredService<ChatSuccessHandler>();
+            var resultProcessor = scope.ServiceProvider.GetRequiredService<ChatResultProcessor>();
+
+            // Assert
+            _mockScopeFactory.Verify(x => x.CreateScope(), Times.Once);
+            successHandler.Should().NotBeNull();
+            resultProcessor.Should().NotBeNull();
+            
+            // Verify both services come from the same scope
+            _mockServiceProvider.Verify(x => x.GetRequiredService<ChatSuccessHandler>(), Times.Once);
+            _mockServiceProvider.Verify(x => x.GetRequiredService<ChatResultProcessor>(), Times.Once);
+
+            await Task.CompletedTask; // To satisfy async context
+        }
+
+        [Fact]
+        public void UsingScope_ShouldDisposeProperlyAndPreventObjectDisposedException()
+        {
+            // Arrange
+            var disposeCalled = false;
+            _mockScope.Setup(x => x.Dispose()).Callback(() => disposeCalled = true);
+
+            // Act
+            using (var scope = _mockScopeFactory.Object.CreateScope())
             {
-                return null;
+                scope.Should().NotBeNull();
+                disposeCalled.Should().BeFalse("Scope should not be disposed while in using block");
             }
+
+            // Assert
+            disposeCalled.Should().BeTrue("Scope should be disposed after using block");
+            _mockScope.Verify(x => x.Dispose(), Times.Once);
+        }
+
+        [Fact]
+        public void ServiceScope_MultipleServiceResolution_ShouldUseSameProvider()
+        {
+            // This test verifies that multiple services resolved from the same scope
+            // use the same service provider instance, preventing DbContext disposal issues
+
+            // Arrange
+            var mockChatSuccessHandler = new Mock<ChatSuccessHandler>();
+            var mockChatResultProcessor = new Mock<ChatResultProcessor>();
+            
+            _mockServiceProvider.Setup(x => x.GetRequiredService<ChatSuccessHandler>())
+                .Returns(mockChatSuccessHandler.Object);
+            _mockServiceProvider.Setup(x => x.GetRequiredService<ChatResultProcessor>())
+                .Returns(mockChatResultProcessor.Object);
+
+            // Act
+            using var scope = _mockScopeFactory.Object.CreateScope();
+            var provider1 = scope.ServiceProvider;
+            var provider2 = scope.ServiceProvider;
+            
+            var service1 = provider1.GetRequiredService<ChatSuccessHandler>();
+            var service2 = provider2.GetRequiredService<ChatResultProcessor>();
+
+            // Assert
+            provider1.Should().BeSameAs(provider2, "Same scope should always return same ServiceProvider");
+            service1.Should().NotBeNull();
+            service2.Should().NotBeNull();
+            
+            // Both services should be resolved from the same provider instance
+            _mockServiceProvider.Verify(x => x.GetRequiredService<ChatSuccessHandler>(), Times.Once);
+            _mockServiceProvider.Verify(x => x.GetRequiredService<ChatResultProcessor>(), Times.Once);
         }
+
+        #endregion
+
+        #region Helper Methods
+
+        private ChatService CreateTestChatService()
+        {
+            // Create minimal mocks for all required dependencies
+            var mockValidator = new Mock<ChatRequestValidator>();
+            var mockMemoryPreprocessor = new Mock<MemoryContextPreprocessor>();
+            var mockInputProcessor = new Mock<ICostTrackingDecorator<UserInputAnalysisProcessor>>();
+            var mockActionProcessor = new Mock<UserInputActionProcessor>();
+            var mockLLMProcessor = new Mock<ICostTrackingDecorator<ChatLLMProcessor>>();
+            var mockTTSProcessor = new Mock<ICostTrackingDecorator<ChatTTSProcessor>>();
+            var mockResultProcessor = new Mock<ChatResultProcessor>();
+            var mockFailureHandler = new Mock<ChatFailureHandler>();
+
+            return new ChatService(
+                _mockMetricsService.Object,
+                _mockScopeFactory.Object,
+                _mockLogger.Object,
+                _mockConversationService.Object,
+                _mockCharacterService.Object,
+                mockValidator.Object,
+                mockMemoryPreprocessor.Object,
+                mockInputProcessor.Object,
+                mockActionProcessor.Object,
+                mockLLMProcessor.Object,
+                mockTTSProcessor.Object,
+                mockResultProcessor.Object,
+                mockFailureHandler.Object
+            );
+        }
+
+        #endregion
     }
 }