Ruby Style Mocking in .NET

Eli Lopian    .NET Tests    

I had a great discussion with a college about the difficulties of understanding the technical parts of the automated Mocking frameworks.

The one point that takes some time to grasp is the fact that  methods are written within the test that are not actually called, but are stubs/mocks that will be called at a later time. This is true to all frameworks. He then suggested that having the ability to swap one type with another would help in understanding the flow of the test. So I whipped together some code to do just that.

Using this code it is possible to swap one type with another. The two types must have the same methods, but the swapping type doesn’t need to have all the methods of the original type.

Here is an example:

public class OriginalClass
{
    public int ReturnOne()
    {
        return 1;
    }
    public static int StaticReturnOne()
    {
        return 1;
    }
}

Static Method Swapping

Suppose we want to fake the static methods of the OriginalClass, we simply write a new class.

public class FakeClass
{
    public static int StaticReturnOne()
    {
        return 2;
    }
}

Note: apart from the names of the methods the two classes are not related.

Here is how we fake the calls,

• We Swap the OriginalClass with the FakeClass by: Swap.StaticCalls()
• All static calls to OriginalClass methods that exist in the FakeClass are diverted to the FakeClass.
• We Unswap the types at the end of the test by Swap.Rollback()

[TestMethod]
public void SwapStatic_CallsFake()
{
    Swap.StaticCalls<OriginalClass, FakeClass>();
    Assert.AreEqual(2, OriginalClass.StaticReturnOne());
    Swap.Rollback();
}

Instance Swapping

We can do the same with instances, we can create a new FakeClass and swap the instances.

public class FakeClass
{
    public int ReturnOne()
    {
        return 2;
    }
}

Note: again, apart from the names of the methods the two classes are not related, but they both might implement the same interface or base class and thus support refactoring.

Here is how we fake the calls,

• We Swap the next new OriginalClass with the FakeClass by Swap.NextNew().
• All calls to that OriginalClass method which exist in the FakeClass are diverted to the FakeClass.

[TestMethod]
public void SwapInstance_CallsFake()
{
    Swap.NextNew<OriginalClass, FakeClass>();
    OriginalClass swappedInstance = new OriginalClass();
    Assert.AreEqual(2, swappedInstance.ReturnOne());
}

Missing Methods

At this stage the missing methods of the swapped type can have 2 behaviors:

• Call the original class (Default or UndefinedMethods.CallOriginal)
• Do nothing and Return a default value (UndefinedMethods.Ignore)

This is set in the swap statements.

Downloads

• Source along with tests
• Binaries for the project

If you enjoyed this article please consider sharing it!