Fakes, Stubs, Shims, Moles and how to verify them?

Background

If you have been following my posts here and here before you probably know that when I have to I use Moles from Microsoft Research. So the other day a friend of mine mentioned this new cool thing called Fakes, Stubs and Shims in Visual Studio 11 so I decided to look into that.

The first thing I actually did was to ask the following question on Twitter because I was curious to see if Moles and Fakes were similar:

Ok so Fakes in VS 11 are derived from Moles. My next question to Peter was one I’ve been thinking about alot lately:

So Microsoft are looking into adding verify support to Fakes, great!!! this means that you don’t have to use this hack going forward 🙂 Thanks Peter for that fast feedback!

For all you using Moles this hack will still apply. And for all you SharePoint developers out there; YES this is for you guys because you need to be doing more TDD!

My next step was to create a bootable vhd with Windows 8 Consumer Preview and Visual Studio 11 using my preferred method here and start hacking away.

Step 1

Get up to speed with Fakes, Stubs, Shims by reading “Using shims to isolate calls to non-virtual functions in unit test methods” found here; go on I’ll wait until you’re finished.

You’ll probably end up with a test method looking like the one shown below:

    [TestClass]
    public class Y2KCheckerTests_Step1
    {
        [TestMethod]
        [ExpectedException(typeof(ApplicationException))]
        public void Check_WhenCalledWithTheDate_2000_1_1_ThenApplicationExceptionIsThrowned()
        {
            using(ShimsContext.Create())
            {
                ShimDateTime.NowGet = () => { return new DateTime(2000, 1, 1); };

                Y2KChecker.Check();
            }
        }
    }

Well this is all fine, but what if you have a thousand tests that want to detour DateTime.Now? If you read my previous post here I introduced a Testable object that encapsulates behaviour.

Step 2

So the next step is to encapsulate this into a Testable object that I call Y2KShimDateTime like the code below shows:

[TestClass]
public class Y2KCheckerTests_Step2
{
    [TestMethod]
    [ExpectedException(typeof(ApplicationException))]
    public void Check_WhenCalledWithY2KShimDateTime_ThenApplicationExceptionIsThrowned()
    {
        using (ShimsContext.Create())
        {
            Y2KShimDateTime shim = new Y2KShimDateTime();

            Y2KChecker.Check();
        }
    }
}

public class Y2KShimDateTime
{
    public Y2KShimDateTime()
    {
        ShimDateTime.NowGet = () => { return new DateTime(2000, 1, 1); };
    }
}

Wow now we’re getting somewhere. We can reuse our Y2KShimDateTime in all our test methods. But hey what if we really just want to verify that a specific method has been called? You could just add some counter to the Y2KShimDateTime and call a property like the recommendation here.

Step 3

I use Moq to Mock my code because it’s simple and I love the way I can control return values with setups but mostly I love the way I can verify that a certain method was called with a specific value! If you haven’t looked at Moq yet I strongly encourage you to do so!

To accomplish this with Fakes, Shims or Moles you will need to trick Moq a bit (a hack I know). First of all let’s take a look at my verifiable Y2KShimDateTime class called VY2KShimDateTime.

public class VY2KShimDateTime
{
    public void InitFake()
    {
        ShimDateTime.NowGet = () =>
        {
            return VNowGet();
        };
    }

    public virtual DateTime VNowGet()
    {
        return new DateTime();
    }
}

The first part of the trick is to move the initialization of the detour from the constructor to a public method. This enables us to initialize the detours from Moq as you will see soon. The next thing is to create a public virtual method (VNowGet in this case) that will be called by Moq. There you have it! Easy enough?

Lets see how we use the VY2KShimDateTime from Moq.

using (ShimsContext.Create())
{
    Mock mock = new Mock();
    mock.Object.InitFake();
    mock.Setup(v => v.VNowGet()).Returns(new DateTime(2000, 1, 1));

    Y2KChecker.Check();
}

As you can see from the highlighted row above we’re initializing our detours after we create our mock this way we can be sure our detours will work. And now we can use the usual setup from Moq to Control what our detour will return. Brilliant don’t you say?

Let’s throw a verify into this equation and look how that looks.

using (ShimsContext.Create())
{
    Mock mock = new Mock();
    mock.Object.InitFake();
    mock.Setup(v => v.VNowGet()).Returns(new DateTime(1, 1, 1));

    Y2KChecker.Check();

    //Uncomment line below to see verify that mock.Verify throws correct message
    //Y2KChecker.Check();

    mock.Verify(v => v.VNowGet(), Times.Once());
}

In this case we’ll have to supply a date other than Y2K because otherwise we’ll get an exception but as you can see in the verify method we verify that DateTime.Now is called only once. If I would to uncomment the second Y2KChecker.Clean(); call the verify on our mock would throw an exception.

Summary

I’ve showed how to create verifiable Fakes, Stubs and Shims (works for Moles as well) using a small hack. I use this approach daily when I work with Moles because I really like the combination of Moq verify and setup and Fakes/Moles isolation and detouring.

Hopefully Microsoft will incorporate this in a near future in Fakes but until then give this a try.

All code can be downloaded from GitHub here.

Cheers,

Hugo

TFS 2010 better with SharePoint

Lately I’ve got some questions concerning TFS 2010 with or without SharePoint and this blog post does a fair attempt to answers some of those questions. If you don’t have any hesitations and like to use SharePoint you should read this post to figure out which version of SharePoint you should use.

Background

SharePoint is no longer a required component when you install TFS 2010 and therefore some customers are asking questions about having SharePoint integrated with TFS 2010 or not.

Dashboards

You wouldn’t buy a car without a dashboard or would you?

If we take a look at the Dashboard for the MSF Agile process template you’ll should see something like so:

image

Speed

You have detailed information of your projects current speed much like the speedometer in your car like so:

image

Work Item overview

You get an overview of the contents of your project like so:

image

You could compare this to your gas gauge in your car or any other information gauges that tell you detailed information about the car.

Builds

Visualize the state of your build for all projectmembers and answers questions like why are builds breaking by drilling down to the individual builds directly from SharePoint.

image

Checkins

You also get an overview of the latest checkins and you drill into the details directly from SharePoint.

image

Work with your Work Items

You can even get down and work with your Work Items directly from SharePoint in various ways:

image

Interested in a specific Work Item? Use this shortcut:

image

Document Management

You get a state of the art document management system with lots and lots of possibilities and customizations that will make the management of your project documents a joy. Read more about it here.

Search

With SharePoint comes a great search engine that will help you search for information throughout your team portal.

And a whole lot more

Blogs, Wikis, announcements, calendars and a whole lot more goodies are there to make your collaboration experience the best.

Summary

TFS is a great product without your team portal in SharePoint but it’s truly the best collaboration platform for development projects in the world with SharePoint and I highly recommend you installing it when you install TFS 2010.

Have a nice one!

Hugo

Creating a bootable VHD the easy way…continued

You might have read and tried the scripts from my first blog about creating a bootable vhd here, and in this blog post I’ll continue where I left with some information about my usage of difference discs and bootable vhd’s.

First of all I started by creating a bootable vhd with my script with the following options:

Name Type Size
Base2k8r2.vhd Expandable 80 000 Mb (Remember that you need this much free space on your disc even if the vhd doesn’t have the size from start)

This left me with a vhd-file that took about 7Gb on my internal disc. I restarted my machine to make sure that my bootable vhd was working correctly.

After the health-check and some customizations like folder options in explorer I opened up a command prompt and entered shutdown /r /f, this way I don’t have to enter a reason to restart my Windows Server 2008 R2 OS Blinkar

Back in Windows 7 I took these steps to create a difference disc to keep my base disc clean:

  1. Start a command prompt as Administrator
  2. Write BCDEDIT /v and hit enter
  3. You will see the boot entries and their GUIDs
  4. Write BCDEDIT /delete {guid to the entry with a the path to your bootable vhd}
    WARNING this will delete a boot entry, make sure you enter the GUID to the entry where the device/osdevice points the path of your bootable vhd. Entering the wrong guid could make your computer UNBOOTABLE.
  5. Write DiskPart and hit enter
  6. Enter CREATE VDISK FILE="<Path to difference vhd>" PARENT="<Path to parent vhd>"
    You must specify a valid folder name or you’ll get an error.
  7. Write SELECT VDISK FILE=”<Path to difference vhd>” and hit enter
  8. Write ATTACH VDISK and hit enter
  9. Write Exit and hit enter
  10. Write BCDBOOT <your assigned drive letter>:\Windows and hit enter
  11. If you write BCDEDIT /v and hit enter you should see a new boot entry that points to your new difference disc.
  12. Restart your machine and make sure that your bootable difference disc starts correctly.

When I get some time I’ll try to automate these steps into a handy batch-file or application. I hope you found this post interesting.

Cheers!

Hugo