A “Shim-ple” Tutorial With Microsoft Fakes

I’ve written previously about using Rhino Mocks to write unit tests for hard-to-test code, but with the release of Visual Studio 2012 comes a new way to work around those not-so-test-friendly areas: Microsoft Fakes. For those of you familiar with Microsoft Research’s Moles project, Microsoft Fakes is simply the next version. Fortunately, Microsoft decided this offering was valuable enough to be included in the latest version of Visual Studio.

What is Fakes, you might be grammatically-awkwardly asking yourself. If I had to describe Microsoft Fakes in a sentence, I’d say this: Microsoft Fakes allows you to intercept any method call and provide a substitute implementation, including calls to static and non-virtual methods. Sounds powerful, right? Well, it is.

Getting started with MS Fakes is refreshingly easy, too. The integration with Visual Studio allows you to skip the hard parts and get right to the meat: hooking up the fakes to work with the code you’re testing. This post will show you how to write a unit test for a simple FileReader class that has a single Read method that–you guessed it–reads a file. I’ll walk you through the entire process from scratch to hopefully avoid any confusion. So let’s do it!

1. Open Visual Studio 2012
2. Create a new Visual C# Class Library project
3. Create the FileReader class:

   namespace adamprescott.net.FakesTutorial
   {
       using System.IO;
   
       public class FileReader
       {
           private readonly string _path;
           public FileReader (string path)
   	    {
               _path = path;
   	    }
   
           public string Read()
           {
               using (var fs = new FileStream(_path, FileMode.Open))
               {
                   var sr = new StreamReader(fs);
                   return sr.ReadToEnd();
               }
           }
       }
   }
   

4. Add a new Unit Test Project to the solution
5. Add a reference to the Class Library project from the Unit Test Project
6. Create the fakes assembly by right-clicking System in the Unit Test Project’s References and selecting “Add Fakes Assembly”
   
7. Create the FileReaderTest class:

   namespace adamprescott.net.FakesTutorial.Tests
   {
       using Microsoft.VisualStudio.TestTools.UnitTesting;
   
       [TestClass]
       public class FileReaderTest
       {
           [TestMethod]
           public void TestMethod1()
           {
               using (Microsoft.QualityTools.Testing.Fakes.ShimsContext.Create())
               {
                   // Arrange
                   const string path = "irrelevant";
                   const string expected = "contents";
                   var target = new FileReader(path);
   
                   // shim the FileStream constructor
                   System.IO.Fakes.ShimFileStream.ConstructorStringFileMode =
                       (@this, p, f) => {
                           var shim = new System.IO.Fakes.ShimFileStream(@this);
                       };
   
                   // shim the StreamReader constructor
                   System.IO.Fakes.ShimStreamReader.ConstructorStream =
                       (@this, s) => {
                           var shim = new System.IO.Fakes.ShimStreamReader(@this) {
                               // shim the ReadToEnd method
                               ReadToEnd = () => expected
                           };
                       };
   
                   // Act
                   var actual = target.Read();
   
                   // Assert
                   Assert.AreEqual(expected, actual);
               }
           }
       }
   }
   

8. Run the test, and feel great about yourself!

There are a few important things to note about the use of Fakes in the test above. First, the fakes are wrapped in a ShimsContext. This makes sense since you’re intercepting system calls; you don’t want to accidentally affect other areas being tested outside of your test. Next, note that I’m using fakes to override two different constructors. I needed to override FileStream‘s constructor to open the file and StreamReader‘s constructor to read the file. In the StreamReader shim, I also provide a shim for the ReadToEnd method and configure it to return the fake text for my test. I probably could have opted to shim just FileStream, but the faking might be less straightforward since success would rely on knowing exactly which methods StreamReader will use when ReadToEnd is called.

For more information about getting started with Microsoft Fakes, check out this article at MSDN.

Author: Adam Prescott

I'm enthusiastic and passionate about creating intuitive, great-looking software. I strive to find the simplest solutions to complex problems, and I embrace agile principles and test-driven development. View all posts by Adam Prescott