12. 로깅 테스트 전략 🧪

로깅은 애플리케이션의 중요한 부분이지만, 종종 테스트에서 간과되곤 해. 하지만 로깅 코드도 버그가 있을 수 있고, 성능에 영향을 미칠 수 있어. 어떻게 로깅 코드를 효과적으로 테스트할 수 있는지 알아보자!

로깅 테스트의 중요성 🎯

로깅 코드를 테스트해야 하는 이유:

1. 정확성 검증: 올바른 정보가 로깅되는지 확인
2. 성능 영향 측정: 로깅이 애플리케이션 성능에 미치는 영향 평가
3. 보안 검증: 민감 정보가 로깅되지 않는지 확인
4. 예외 상황 처리: 로깅 자체에서 예외가 발생하지 않는지 확인

단위 테스트에서 로깅 검증 🔍

로깅 출력을 캡처하고 검증하는 방법:

1. 인메모리 싱크 사용 (Serilog)

// NuGet: Install-Package Serilog.Sinks.TestCorrelator

[Fact]
public void Should_Log_User_Login_Attempt()
{
    // Arrange
    using (TestCorrelator.CreateContext())
    {
        var logger = new LoggerConfiguration()
            .MinimumLevel.Debug()
            .WriteTo.TestCorrelator()
            .CreateLogger();
            
        var authService = new AuthenticationService(logger);
        
        // Act
        var result = authService.Login("testuser", "password");
        
        // Assert
        var logEvents = TestCorrelator.GetLogEventsFromCurrentContext();
        
        Assert.Contains(logEvents, e => 
            e.Level == LogEventLevel.Information && 
            e.MessageTemplate.Text.Contains("로그인 시도") &&
            e.Properties.ContainsKey("Username") &&
            e.Properties["Username"].ToString() == "\"testuser\"");
            
        if (!result.Success)
        {
            Assert.Contains(logEvents, e => 
                e.Level == LogEventLevel.Warning && 
                e.MessageTemplate.Text.Contains("로그인 실패"));
        }
    }
}

2. 로거 모킹 (Moq 사용)

// NuGet: Install-Package Moq

[Fact]
public void Should_Log_Order_Creation()
{
    // Arrange
    var loggerMock = new Mock<ILogger<OrderService>>();
    var orderService = new OrderService(loggerMock.Object, orderRepository);
    
    var order = new Order { /* ... */ };
    
    // Act
    orderService.CreateOrder(order);
    
    // Assert
    loggerMock.Verify(
        x => x.Log(
            LogLevel.Information,
            It.IsAny<EventId>(),
            It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("주문 생성")),
            It.IsAny<Exception>(),
            It.IsAny<Func<It.IsAnyType, Exception, string>>()),
        Times.Once);
}

3. 로그 메시지 템플릿 테스트

[Theory]
[InlineData("user1", "product1", 2)]
[InlineData("user2", "product2", 5)]
public void Should_Format_Log_Message_Correctly(string userId, string productId, int quantity)
{
    // Arrange
    var formatter = new MessageTemplateFormatter();
    var template = "사용자 {UserId}가 상품 {ProductId}을 {Quantity}개 장바구니에 추가했습니다.";
    
    // Act
    var message = formatter.Format(template, new object[] { userId, productId, quantity });
    
    // Assert
    Assert.Equal($"사용자 {userId}가 상품 {productId}을 {quantity}개 장바구니에 추가했습니다.", message);
}

통합 테스트에서 로깅 검증 🔄

실제 로깅 구성과 함께 테스트하는 방법:

1. 파일 로깅 테스트

[Fact]
public void Should_Write_Logs_To_File()
{
    // Arrange
    var logFilePath = Path.Combine(Path.GetTempPath(), $"test_log_{Guid.NewGuid()}.txt");
    
    var logger = new LoggerConfiguration()
        .WriteTo.File(logFilePath)
        .CreateLogger();
        
    var service = new UserService(logger);
    
    // Act
    service.CreateUser(new User { Name = "Test User" });
    
    // 로그가 파일에 기록될 시간을 주기 위해 잠시 대기
    Thread.Sleep(100);
    
    // Assert
    var logContent = File.ReadAllText(logFilePath);
    Assert.Contains("사용자 생성", logContent);
    Assert.Contains("Test User", logContent);
    
    // 정리
    File.Delete(logFilePath);
}

2. 구조화된 로깅 테스트

[Fact]
public void Should_Log_Structured_Data()
{
    // Arrange
    var logFilePath = Path.Combine(Path.GetTempPath(), $"test_log_{Guid.NewGuid()}.json");
    
    var logger = new LoggerConfiguration()
        .WriteTo.File(new JsonFormatter(), logFilePath)
        .CreateLogger();
        
    var orderService = new OrderService(logger);
    var order = new Order { Id = 12345, CustomerId = "C789", Total = 99.99m };
    
    // Act
    orderService.ProcessOrder(order);
    
    // 로그가 파일에 기록될 시간을 주기 위해 잠시 대기
    Thread.Sleep(100);
    
    // Assert
    var logContent = File.ReadAllText(logFilePath);
    var logEntries = logContent.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries)
        .Select(line => JsonConvert.DeserializeObject<JObject>(line))
        .ToList();
        
    var orderProcessedLog = logEntries.FirstOrDefault(e => 
        e["MessageTemplate"]?.ToString().Contains("주문 처리") == true);
        
    Assert.NotNull(orderProcessedLog);
    Assert.Equal("12345", orderProcessedLog["Properties"]["OrderId"].ToString());
    Assert.Equal("C789", orderProcessedLog["Properties"]["CustomerId"].ToString());
    Assert.Equal("99.99", orderProcessedLog["Properties"]["Total"].ToString());
    
    // 정리
    File.Delete(logFilePath);
}

로깅 성능 테스트 ⚡

로깅이 애플리케이션 성능에 미치는 영향을 측정하는 방법:

[Fact]
public void Logging_Performance_Test()
{
    // 로깅 비활성화 상태에서 성능 측정
    var stopwatch = Stopwatch.StartNew();
    
    for (int i = 0; i < 10000; i++)
    {
        var service = new UserService(NullLogger.Instance);
        service.GetUserById(i);
    }
    
    stopwatch.Stop();
    var withoutLoggingTime = stopwatch.ElapsedMilliseconds;
    
    // 로깅 활성화 상태에서 성능 측정
    var inMemorySink = new InMemorySink();
    var logger = new LoggerConfiguration()
        .WriteTo.Sink(inMemorySink)
        .CreateLogger();
        
    stopwatch.Restart();
    
    for (int i = 0; i < 10000; i++)
    {
        var service = new UserService(logger);
        service.GetUserById(i);
    }
    
    stopwatch.Stop();
    var withLoggingTime = stopwatch.ElapsedMilliseconds;
    
    // 로깅으로 인한 성능 저하가 10% 이내인지 확인
    var performanceImpact = (withLoggingTime - withoutLoggingTime) / (double)withoutLoggingTime * 100;
    Assert.True(performanceImpact < 10, $"로깅으로 인한 성능 저하가 10%를 초과합니다: {performanceImpact:F2}%");
    
    // 로그 메시지 수 확인
    Assert.Equal(10000, inMemorySink.LogEvents.Count);
}

// 테스트용 인메모리 싱크
public class InMemorySink : ILogEventSink
{
    public List<LogEvent> LogEvents { get; } = new List<LogEvent>();
    
    public void Emit(LogEvent logEvent)
    {
        LogEvents.Add(logEvent);
    }
}

로깅 보안 테스트 🔒

로그에 민감 정보가 포함되지 않는지 확인하는 방법:

[Fact]
public void Should_Not_Log_Sensitive_Information()
{
    // Arrange
    using (TestCorrelator.CreateContext())
    {
        var logger = new LoggerConfiguration()
            .MinimumLevel.Debug()
            .WriteTo.TestCorrelator()
            .CreateLogger();
            
        var authService = new AuthenticationService(logger);
        var user = new User
        {
            Username = "testuser",
            Password = "P@ssw0rd",
            CreditCardNumber = "1234-5678-9012-3456",
            SocialSecurityNumber = "123-45-6789"
        };
        
        // Act
        authService.RegisterUser(user);
        
        // Assert
        var logEvents = TestCorrelator.GetLogEventsFromCurrentContext();
        var logMessages = logEvents.Select(e => e.RenderMessage()).ToList();
        
        // 민감 정보가 로그에 포함되지 않는지 확인
        Assert.DoesNotContain(logMessages, m => m.Contains("P@ssw0rd"));
        Assert.DoesNotContain(logMessages, m => m.Contains("1234-5678-9012-3456"));
        Assert.DoesNotContain(logMessages, m => m.Contains("123-45-6789"));
        
        // 마스킹된 형태로만 포함되는지 확인
        Assert.Contains(logMessages, m => m.Contains("****"));
    }
}

로깅 예외 처리 테스트 ⚠️

로깅 자체에서 예외가 발생했을 때 애플리케이션이 계속 작동하는지 확인하는 방법:

[Fact]
public void Application_Should_Continue_When_Logging_Fails()
{
    // Arrange
    var failingLoggerMock = new Mock<ILogger<UserService>>();
    failingLoggerMock
        .Setup(x => x.Log(
            It.IsAny<LogLevel>(),
            It.IsAny<EventId>(),
            It.IsAny<It.IsAnyType>(),
            It.IsAny<Exception>(),
            It.IsAny<Func<It.IsAnyType, Exception, string>>()))
        .Throws(new Exception("로깅 실패"));
        
    var userService = new UserService(failingLoggerMock.Object);
    
    // Act & Assert
    // 로깅 실패에도 불구하고 서비스는 계속 작동해야 함
    var user = userService.GetUserById(123);
    Assert.NotNull(user);
}

로깅 테스트 모범 사례 🌟

1. 테스트 환경 로깅 구성 분리

   테스트 환경에서는 별도의 로깅 구성을 사용해. 파일이나 데이터베이스 대신 인메모리 싱크를 활용해.




2. 로그 메시지 템플릿 테스트

   로그 메시지 템플릿이 예상대로 형식화되는지 테스트해.




3. 로그 레벨 테스트

   적절한 로그 레벨이 사용되는지 확인해. 예를 들어, 오류는 Error 레벨로 로깅되어야 해.




4. 구조화된 데이터 테스트

   구조화된 로깅을 사용할 때는 속성 이름과 값이 올바르게 로깅되는지 확인해.




5. 로깅 성능 영향 모니터링

   로깅이 애플리케이션 성능에 미치는 영향을 정기적으로 측정해.

로깅 코드도 애플리케이션의 중요한 부분이므로 테스트가 필요해. 특히 재능넷과 같은 플랫폼에서는 로깅이 문제 해결과 사용자 행동 분석에 중요한 역할을 하므로, 로깅 코드의 품질을 보장하는 것이 중요해!