How do I MOQ the System.IO.FileInfo class... or any other class without an interface?

I am writing a number of unit tests for a logger class I created and I want to simulate the file class. I can't find the interface that I need to use to create the MOQ... so how do you successfully MOQ a class without an interface?

It also isn't clear to m开发者_JAVA技巧e how I can use dependency injection without having an interface available:

private FileInfo _logFile;

public LogEventProcessorTextFile(FileInfo logFile) {
    _logFile = logFile;
}

When I really want to do something like this (note IFileInfo instead of FileInfo):

private IFileInfo _logFile;

public LogEventProcessorTextFile(IFileInfo logFile) {
    _logFile = logFile;
}

Design your code so that instead of accessing the FileInfo class directly, access an interface (named for example IFileInfo) with the same capabilities. In production code you will use a class that just delegates all its functionality to the system FileInfo class, but for unit testing you can mock the interface.

For example, in an application I made that acted differently depending on the current date, I declared the following interface:

interface IDateTimeProvider
{
    DateTime Today();
}

And the production class was just:

class DateTimeProvider : IDateTimeProvider
{
    public DateTime Today()
    {
        return DateTime.Today;
    }
}

You can complement this approach with the usage of a dependency injection engine to decide whether a real class or a mock should be used in each case.

Use SystemWrapper, a library which provides interfaces and mockable wrappers classes for many .NET classes which don't implement interfaces themselves.

This might help you to ease the creation of wrapper classes for static or non-mockable 3rd party classes. This tool will generated Interface and a concrete wrapper class of any existing class such as System.IO right on your Visual Studio Project.

https://www.nuget.org/packages/Digitrish.WrapperGenerator/

Add the following nuget package to your csproj:

<ItemGroup>
  <PackageReference Include="System.IO.Abstractions" Version="13.2.29" />
</ItemGroup>

Inject System.IO.Abstractions.FileSystem into your class:

  public class FileLogger
  {
    private readonly IFileSystem fileSystem;

    public FileLogger(System.IO.Abstractions.IFileSystem fileSystem) // new FileSystem()
    {
      this.fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
    }
    
    public void LogEventProcessorTextFile(string filePath)
    {
      IFileInfo fileInfo = fileSystem.FileInfo.FromFileName(filePath);

      LogEventProcessorTextFile(fileInfo);
    }

    private System.IO.Abstractions.IFileInfo _logFile;

    public void LogEventProcessorTextFile(IFileInfo logFile) {
      _logFile = logFile;
    }
  }

Moq examples:

private Mock<IFileSystem> FileSystemMock { get; set; }

[SetUp]
public void Setup()
{
  var file = Mock.Of<IFileInfo>();
  var directoryInfo = Mock.Of<IDirectoryInfo>();

  Mock.Get(file).Setup(c => c.Exists).Returns(true);

  FileSystemMock = new Mock<IFileSystem>();

  FileSystemMock.Setup(c => c.FileInfo.FromFileName(It.IsAny<string>())).Returns(file);
  FileSystemMock.Setup(c => c.DirectoryInfo.FromDirectoryName("Settings")).Returns(directoryInfo);
}

This is more limited in that you can only use exact files, but can also be good because you control exactly what is in your file for the unit test....You could create a folder in your unit test project to keep pretend log files in. Then get current directory in your unit test using:

var currentDirectory = Environment.CurrentDirectory

then hop one level down into your test folder and grab the test files with:

var testFileInfos = Directory.GetFiles(
    Path.Combine(currentDirectory, "testFolderName"));

Then use those FileInfo objects as needed in your tests.