C# Statyczny Rejestrator log4net tylko do odczytu, w jaki sposób można zmienić rejestrator w jednostce testowej?

Question

Moja klasa ma ten wiersz:

private static readonly ILog log = LogManager.GetLogger(typeof(Prim)); 

Kiedy idę do testów jednostkowych, nie mogę wstrzyknąć rejestratora Min do tego interfejsu, więc mogłem liczyć połączenia zalogować.

Czy istnieje sposób, aby to zrobić? Log4net zaleca statyczny wzorzec tylko do odczytu dla rejestratorów. Jaki jest najlepszy sposób, aby sobie z tym poradzić?

Answer 1

Podczas gdy log4net zaleca ten wzór, nic nie stoi na przeszkodzie, aby utworzyć rejestrator poza klasą i wstrzyknąć go. Większość IoC można skonfigurować do wstrzykiwania jednej i tej samej instancji. W ten sposób do testów jednostkowych można wstrzyknąć próbę.

Polecam otoki wokół LogManager.GetLogger, która zwraca zawsze jeden i ten sam przypadek rejestratora za typu:

namespace StackOverflowExample.Moq 
{ 
    public interface ILogCreator 
    { 
     ILog GetTypeLogger<T>() where T : class; 
    } 

    public class LogCreator : ILogCreator 
    { 
     private static readonly IDictionary<Type, ILog> loggers = new Dictionary<Type, ILog>(); 
     private static readonly object lockObject; 

     public ILog GetTypeLogger<T>() where T : class 
     { 
      var loggerType = typeof (T); 
      if (loggers.ContainsKey(loggerType)) 
      { 
       return loggers[typeof (T)]; 
      } 

      lock (lockObject) 
      { 
       if (loggers.ContainsKey(loggerType)) 
       { 
        return loggers[typeof(T)]; 
       } 
       var logger = LogManager.GetLogger(loggerType); 
       loggers[loggerType] = logger; 
       return logger; 
      } 
     } 
    } 

    public class ClassWithLogger 
    { 
     private readonly ILog logger; 
     public ClassWithLogger(ILogCreator logCreator) 
     { 
      logger = logCreator.GetTypeLogger<ClassWithLogger>(); 
     } 

     public void DoSomething() 
     { 
      logger.Debug("called"); 
     } 
    } 

    [TestFixture] 
    public class Log4Net 
    { 
     [Test] 
     public void DoSomething_should_write_in_debug_logger() 
     { 
      //arrange 
      var logger = new Mock<ILog>(); 
      var loggerCreator = Mock.Of<ILogCreator>(
       c => 
       c.GetTypeLogger<ClassWithLogger>() == logger.Object); 

      var sut = new ClassWithLogger(loggerCreator); 

      //act 
      sut.DoSomething(); 

      //assert 
      logger.Verify(l=>l.Debug("called"), Times.Once()); 
     } 
    } 
} 

Answer 2

Można użyć MemoryAppender zamiast się wyśmiewali rejestratora. Dzięki takiemu podejściu można skonfigurować protokół log4net w taki sposób, aby gromadził zdarzenia z pamięci w pamięci i pobierać je w celu zweryfikowania przez GetEvents().

znalazłem tych użytecznych przykładów:

• https://gist.github.com/plaurin/3563082#file-trycache-cs
• http://jake.ginnivan.net/verifying-logged-messages-with-log4net/

Oto pierwszy:

[SetUp] 
public void SetUp() 
{ 
    this.memoryAppender = new MemoryAppender(); 
    BasicConfigurator.Configure(this.memoryAppender); 

    ... 
} 

[Test] 
public void TestSomething() 
{ 
    ... 

    // Assert 
    Assert.IsFalse(
     this.memoryAppender.GetEvents().Any(le => le.Level == Level.Error), 
     "Did not expect any error messages in the logs"); 
} 

A im bardziej szczegółowe:

public static class Log4NetTestHelper 
{ 
    public static string[] RecordLog(Action action) 
    { 
     if (!LogManager.GetRepository().Configured) 
      BasicConfigurator.Configure(); 
     var logMessages = new List<string>(); 
     var root = ((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root; 
     var attachable = root as IAppenderAttachable; 

     var appender = new MemoryAppender(); 
     if (attachable != null) 
      attachable.AddAppender(appender); 

     try 
     {   
      action(); 
     } 
     finally 
     { 
      var loggingEvents = appender.GetEvents(); 
      foreach (var loggingEvent in loggingEvents) 
      { 
       var stringWriter = new StringWriter(); 
       loggingEvent.WriteRenderedMessage(stringWriter); 
       logMessages.Add(string.Format("{0} - {1} | {2}", loggingEvent.Level.DisplayName, loggingEvent.LoggerName, stringWriter.ToString())); 
      } 
      if (attachable != null) 
       attachable.RemoveAppender(appender); 
     } 

     return logMessages.ToArray(); 
    } 
}