How to mock Directory.getFiles in the same time make sure the production code run as well

Question

How to mock Directory.getFiles at the same time make sure the production code run as well. For example, if run the unit test it will run the mock data, if in runtime production and actually have parameter has passed it calls the System.io.Directory.

Answer 1

My recommendation is that you use System.IO.Abstractions, installable from NuGet. You then code to an interface, IFileSystem, rather than directly to the System.IO File, Directory, etc. objects.

So wherever you need to access these methods, you need to inject IFileSystem, which means an instance of FileSystem, exposed as IFileSystem has to be registered with your dependency injection controller, or you need to instantiate your service as new MyService(new FileSystem()), where there is a constructor parameter which takes IFileSystem. Note that DI is the preferred way to do this.

Let's create a simple service that returns the files in the current directory:

public class MyService
{
    private readonly IFileSystem _fileSystem;

    public MyService(IFileSystem fileSystem)
    {
        this._fileSystem = fileSystem;
    }

    public string[] GetFileNames()
    {
        return _fileSystem.Directory.GetFiles(_fileSystem.Directory.GetCurrentDirectory());
    }
}

Here you can see that we accept IFileSystem, which will be injected into our class. Our GetFileNames() method simply gets the current directory, gets the files in it, and returns them.

Now let's use it in our production code:

// FileSystem should be registered with your dependency injection container,
// as should MyService. MyService should be resolved through the container
// and not manually instantiated as here.
var fileSystem = new FileSystem();
var service = new MyService(fileSystem);

var files = service.GetFileNames();
foreach (var file in files)
{
    Console.WriteLine(file);
}

Hey presto, it prints out the expected file listing for the project's build folder.

Now, how do we test it? For the sake of this example, I'm using xUnit and Moq. I have included the System.IO.Abstractions NuGet package in my unit test project as well.

First, we need to mock the IFileSystem object:

var mockDirectory = new Mock<IDirectory>();
// set up the GetCurrentDirectory() method to return c:\
mockDirectory.Setup(g => g.GetCurrentDirectory()).Returns(@"c:\");
// Set up the GetFiles method to return c:\test.txt and c:\test2.txt where the path passed is c:\
mockDirectory.Setup(g => g.GetFiles(It.Is<string>(@"c:\"))).Returns(new[] { @"c:\test.txt", @"c:\test2.txt" });

var mockFileSystem = new Mock<IFileSystem>();
// Set up IFileSystem's .Directory property to return the mock of IDirectory that we created above
mockFileSystem.SetupGet(g => g.Directory).Returns(mockDirectory.Object);

// Create an instance of the mock that we can use in our service
var fileSystem = mockFileSystem.Object;

Now to test it we simply need to pass that into the service and call the mehtod:

var myService = new MyService(fileSystem);

var files = myService.GetFileNames();
var expected = new[] { @"c:\test.txt", @"c:\test2.txt" };

Assert.True(files.SequenceEqual(expected));

This will now use our mocked implementation of IFileSystem in the GetFileNames method, and thus we can test it. Note that if you're using different overloads of GetFiles, you'll need to mock the relevant method(s).

Answer 2

You could create your own wrapper class, like

    public interface IFileWrapper
    {
        FileInfo[] GetFiles(DirectoryInfo di);
    }

    public class FileWrapper : IFileWrapper
    {
        public FileInfo[] GetFiles(DirectoryInfo di)
        {
            return di.GetFiles();
        }
    }

you should be able then to mock out the result.

alternatively there are packages available which may have this already.

hope that helps