How I used Moles in a real life BizTalk scenario

Background

When you’re building BizTalk applications with TFS Build and then doing some deployment you pretty much end up with the situation where you DO NOT want to create BizTalk applications manually or automatically from some text-file. There is actually a place where this information is stored and it’s called a Bindings File.

A Binding File contains information specific for a BizTalk application and it’s in XML. If you really are into details I encourage you to read Structure of a Binding File article on MSDN. In short you should use Binding Files and only Binding Files as a part of your automatic deployment process. Thanks to Johan Hedberg and Mikael Håkansson for pointing this out.

Hey this has nothing to do with Moles! Be patient and start by installing Moles here are the free download links from the Visual Studio Code Gallery:

• x64 version of Moles http://visualstudiogallery.msdn.microsoft.com/22c07bda-ffc9-479a-9766-bfd6ccacabd4/
• x86 version of Moles http://visualstudiogallery.msdn.microsoft.com/b3b41648-1c21-471f-a2b0-f76d8fb932ee/

Moles

Moles is a lightweight framework for test stubs and detours in .NET that is based on delegates. Moles may be used to detour any .NET method, including non-virtual/static methods in sealed types. Moles is freely available on Visual Studio Gallery or bundled with Pex.

That’s what Microsoft Research introduces Moles as so now back to my real life scenario.

Writing extensions to the BindingInfo class with Moles

So there is actually a class in the assembly Microsoft.Biztalk.Deployment.dll that wraps the structure of a Binding File into a .Net class. So my thought was to write some helpful extensions methods that could help me in retrieving the name of the BizTalk application configured in the Binding File.

Are you still with me?

If we take a closer look at the BindingInfo class:

The BindingInfo has a default constructor that takes no parameters and then there is a LoadXml method that takes a string to the path of the Binding File. So now I have several options:

• I could create my own implementation of BindingInfo and create a subclass that I could mock
• I could use any other Mocking framework, like moq
• I could use strictly integration tests (tests that use external resources) to test my extension methods

In this case I decided to use Moles because I like to try out new stuff. (Mind you this is not the most common scenario on when to use Moles but just bare with me)

Have you installed it yet? Good lets move on.

Adding a reference to a Moled assembly

Right click any referenced assembly and choose Add Moles Assembly like so:

Rebuild your test project and you’ll find two new items added to your project.

The first new item is a reference to an assembly that is the Moles representation of (in this case) Microsoft.BizTalk.Deployment.Moles.

And the second new item is a .moles file is a simple XML file telling Moles which Moles representation should be created at build time. This is how my Microsoft.BizTalk.Deployment.moles looks like:

This can have implications on build performance that I will try to write another post about soon.

Now you have everything in place to start writing your tests right? Let’s goooo! First of all you’ll need to decorate all your test methods where you’re going to use Moled objects with the HostType attribute. I use my own code snippet for this (based on the TestMethod code snippet already in Visual Studio).

And then start writing test cases. But how do you find your Moled objects? Well I usually find my Molable object using the complete namespace to the stuff you want to Mole + Moles + M + intellisense. Look at the example below:

If you use complete namespace to the stuff you want to Mole + Moles + S + intellisense then you’ll get the stubbable instances instead like so:

In my scenario I wanted to make sure that when the LoadXml method is called on any BindingInfo object in my tests it doesn’t read stuff from my disk but it just returns or initializes any properties I’m interested in. This is how I would write this:

A quick recap:

• MBidingInfo was found using the complete namespace to the stuff you want to Mole + Moles + M + intellisense method mentioned above.
• AllInstances means that for all instances I want to replace some method with my own delegate.
• LoadXmlString is the method I want to Mole. After a while using Moles you’ll see that methods have there original name followed by the Type of the input parameters if any.
• Then I’ve written my delegate declaration and body that takes in two parameters called instance and path.

To make this even more interesting you can add Asserts in the delegate (I say you can, I’m not sure this is a good practice) like the following picture:

Now I can continue writing my test as if my BindingInfo objects had loaded the xml from file. But how can I verify that some Moled method has been called? Well Moles doesn’t intend to provide you with Mocking framework abilities that you might be used to. Instead you’ll have to do this yourself. Here is a simple example how to test if a method is called.

So this was a real short introduction to Moles that I hope helps you come up to speed quickly. The final point that I would like to make is that you can use this on any .Net object even static or sealed objects like DirectoryInfo for instance (try using the code below without Moles):

Big thanks to my colleague Marcus Hammarberg for challenging me to write this post!

Enjoy,

Hugo