Mocking Registry and File System

Question

If I am to write unit tests for reading/writing/creating registry entries or files, my understanding is that I should not be using real registry and file system but should mock them in a light weight manner.

What mocking framework would you recommend for mocking these in C# desktop/WPF style apps? What would be a good introductory reading into this topic?

Answer 1

OK, here's an example.

Given these classes:

public interface IRegistryActions
{
     bool WriteValue(string key, string value);
}

public class RegistryActions : IRegistryActions
{
    public bool WriteValue(string key, string value)
    {
        // pseudocode
        // var key = Registry.OpenKey(key);
        // Registry.WriteValue(key, value);
    }
}

And this class that uses them: the class which will perform the actions is passed to the constructor in this example, but could as easily be a property. This means that whenever you want to actually use the class in your actual code, you can explicitly pass a class that implements IRegistryActions as a parameter - e.g. var exampleClass = new ExampleClass(new RegistryActions()); - or alternatively default to the actual implementation if passed null, i.e. this.registryActions = registryActions ?? new RegistryActions();

public class ExampleClass
{
     private IRegistryActions registryActions;

     public ExampleClass(IRegistryActions registryActions)
     {
          this.registryActions = registryActions;
     }

     public bool WriteValue(string key, string value)
     {
          return registryActions.WriteValue(key, value);
     }
}

So in your unit test you want to verify that the call is made with the right parameters. How exactly you do this depends on what mocking framework you use, which is generally either a matter of personal choice or you use what's already used.

[Test]
public void Test_Registry_Writes_Correct_Values()
{
     string key = "foo";
     string value = "bar";

     // you would normally do this next bit in the Setup method or test class constructor rather than in the test itself
     Mock<IRegistryActions> mock = MockFramework.CreateMock<IRegistryActions>();

    var classToTest = new ExampleClass(mock); // some frameworks make you pass mock.Object

    // Tell the mock what you expect to happen to it
    mock.Expect(m => m.WriteValue(key, value));

   // Call the action:
   classToTest.WriteValue(key, value);

   // Check the mock to make sure it happened:
   mock.VerifyAll();
}

In this you're asserting that your class has called the correct method on the interface, and passed the correct values.