使用Moq和Autofac进行单元测试

Question

I have the following logger logger class and I want to know the best to unit testing it.

Some observations:

1. I needed to create the interface IFileWrapper in order to break dependency with System.IO dependency and been able to user dependency injection (Autofac)

2. I was able to unit testing the method FileWrapper.WriteLog by implementing IFileWrapper using a MemoryString but if I wanted to test a expected behavior inside the method I won't be able (eg: throwing exceptions, incorrect path and filename, etc.)

    /// <summary> /// Creates an instance of type <see cref="FileLogger"/> /// </summary> /// <remarks>Implements the Singleton Pattern</remarks> private FileLogger() { FileName = string.Format("\\\\{0: MMM dd, yy}.log", DateTime.Now); Path = Environment.CurrentDirectory; FileWrapper = ContainerBuilderFactory.Container.Resolve<IFileWrapper>(); } /// <summary> /// Log the <paramref name="Message"/> in the <paramref name="Path"/> specified. /// The <paramref name="UserName"/>, <paramref name="Host"/> must be supplied /// </summary> /// <example> /// <code> /// var handler = new LoggerHandlerFactory(); /// var logger = handler.GetHandler<FileLogger>(); /// logger.Log("Hello CSharpLogger"); /// </code> /// </example> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="ArgumentException"></exception> /// <exception cref="NotSupportedException"></exception> /// <exception cref="FileNotFoundException"></exception> /// <exception cref="IOException"></exception> /// <exception cref="SecurityException"></exception> /// <exception cref="DirectoryNotFoundException"></exception> /// <exception cref="UnauthorizedAccessException"></exception> /// <exception cref="PathTooLongException"></exception> /// <exception cref="ArgumentOutOfRangeException"></exception> /// <exception cref="FormatException"></exception> public void Log(string message, LogLevel level = LogLevel.INFO) { lock (_current) { var configLevel = CSharpLoggerConfiguration.Configuration.GetLogLevel(); if (configLevel != LogLevel.OFF & level != LogLevel.OFF && configLevel >= level) { try { FileWrapper.WriteLog(string.Concat(Path, FileName), message, level); } catch (CSharpLoggerException) { throw; } } } } 

So, I created the following UnitTesting using Moq:

 //arrange
        CSharpLoggerConfiguration.Configuration.SetLogLevel(LogLevel.DEBUG);

        var mock = new Mock<IFileWrapper>();
        mock.Setup(x => x.WriteLog(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<LogLevel>()));

        logger.FileWrapper = mock.Object;

        //act
        logger.Log("Hello CSharpLogger", LogLevel.DEBUG);
        logger.Log("Hello CSharpLogger", LogLevel.WARN);

        //assert 
        mock.Verify(x => x.WriteLog(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<LogLevel>()), Times.Exactly(2));

So far so good. What I'm not confortable is with this line: logger.FileWrapper = mock.Object; I would like to keep FileWrapper propety private.

Any advise is welcome.

I'll be publishing the code http://csharplogger.codeplex.com/ in case you want more details.

Answer 1

Use constructor injection . In short; instead of providing the service (in this case the file wrapper) by setting a property, make the logger have a public constructor which takes an IFileWrapper argument.

public class Logger
{
    public Logger(IFileWrapper fileWrapper)
    {
        FileWrapper = fileWrapper;
    }

    public IFileWrapper FileWrapper { get; }
}

// in your test:
var logger = new Logger(mock.Object);

To answer the question about having a singleton file wrapper more thoroughly, here's a code sample for the application (non-test) code:

public static class FileWrapperFactory
{
    private static IFileWrapper _fileWrapper;

    public static IFileWrapper GetInstance()
    {
        return _fileWrapper ?? (_fileWrapper = CreateInstance());
    }

    private static IFileWrapper CreateInstance()
    {
        // do all the necessary setup here
        return new FileWrapper();
    }
}


public class StuffDoer
{
    public void DoStuff()
    {
        var logger = new FileLogger(FileWrapperFactory.GetInstance());

        logger.WriteLog("Starting to do stuff...");

        // do stuff

        logger.WriteLog("Stuff was done.");
    }
}

Since the FileWrapperFactory maintains a static instance of the file wrapper, you'll never have more than one. However, you can create multiple loggers like that, and they don't have to care. If you, in the future, decide that it's OK to have many file wrappers, the logger code doesn't have to change.

In a real-world application, I'd advice you to choose some kind of DI framework to handle all this book-keeping for you; most have excellent support for singleton instances, doing essentially what the FileWrapperFactory above does (but usually in a more sophisticated and robust way. FileWrapperFactory isnt' thread-safe, for example...).

Answer 2

Since your code comments show that your logger is a singleton, you need a way other than constructor injection for setting the dependency. In his book on Legacy Code, Mike Feathers suggests a function for such purposes, which is adequately named, something like

public void SetInstanceForTesting(IFileWrapper fileWrapper) {...}

Now this function won't hopefully be used for different purposes...