Kristofer Liljeblad

Unit testing with Microsoft Moles

KristoferL — Sun, 07 Mar 2010 13:58:38 GMT

I’ve been thinking for a while: “How come Microsoft doesn’t have a Mocking Library like Moq, Rhino Mock, NMock, Typemock, etc?”. Off course you could argue that we don’t need one of our own, you could use one of the existing once or you could just implement some stubs yourself. I’ve lately been drawn towards Moq for its great support for refactoring, but Rhino Mock is the framework I’ve used the most.

Last night, I discovered something fun though. It turns out that Microsoft Research have been busy with something called Microsoft Moles and a first release is now out for you to try out. Let me introduce Microsoft Moles to you by this example.

Let’s say you have this simplified WCF Order Service, implemented like this:

   1: using System;

   2: using System.ServiceModel;

3:

   4: namespace AI.ServiceLibrary

   5: {

   6:     // Service Contract

   7:     [ServiceContract(

   8:         Namespace = "http://assemblyinfo.com/Contracts/OrderService/2010/03",

   9:         Name = "OrderService")]

  10:     public interface IOrderService

  11:     {

  12:         [OperationContract]

  13:         int AddOrder(Order order);

  14:     }

15:

  16:     // Data Contracts

  17:     public class Order

  18:     {

  19:         public int ID { get; set; }

  20:         public DateTime OrderDate { get; set; }

  21:         public string CustomerName { get; set; }

  22:         public OrderDetail[] Details { get; set; }

  23:     }

24:

  25:     public class OrderDetail

  26:     {

  27:         public string ArticleNumber { get; set; }

  28:         public int Quantity { get; set; }

  29:     }

30:

  31:     // Simplified OrderService Implementation

  32:     public class OrderService : IOrderService

  33:     {

  34:         public int AddOrder(Order order)

  35:         {

  36:             // Set OrderDate to current date

  37:             order.OrderDate = DateTime.Now;

38:

  39:             // Save order using Order Repository

  40:             var repository = new OrderRepository();

  41:             int orderId = repository.SaveOrder(order);

42:

  43:             // Return Order ID generated by database

  44:             return orderId;

  45:         }

  46:     }

  47: }

So lets create some Unit Tests for this WCF Service, but first, let us recapture what a Unit Test really is. A Unit Test is a test that tests the smallest testable part of your code. In a unit test we don’t want to be dependent of other parts of our system and specially not dependent of other products like the file system, a SQL Server or any other third party application. Don’t get me wrong here, you could and perhaps should write automatic tests that test the integration between several components and applications, but those tests are not Unit Tests, those are Integration Tests. In a unit test we want to isolate our test to test only one (or the smallest) part of our code.

If you look at the implementation of OrderService above, you can see that we have a strict dependency for a class called OrderRepository at row 40, that seems to save our order to a database and returns a new OrderId. This is a problem for us because we can not test our OrderService without testing our OrderRepository as well.

Another problem can be found at row 37 where we set the OrderDate to the current date and time. How can we predict that value? We don’t know at what time our test is going to be run.

   1: [TestMethod]

   2: public void CanAddOrderWithoutMole()

   3: {

   4:     var service = new OrderService();

   5:     var order = new Order()

   6:     {

   7:         CustomerName = "Test Customer",

   8:         Details = new OrderDetail[]

   9:         {

  10:             new OrderDetail() {ArticleNumber="A123", Quantity=1 },

  11:             new OrderDetail() {ArticleNumber="B456", Quantity=2 }}

  12:     };

13:

  14:     var orderId = service.AddOrder(order);

15:

  16:     Assert.AreEqual( /* <What OrderID should I use here> */, orderId);

17:

  18:     // We can't control OrderDate because we don't know the exact time

  19:     // the test is executed. We could guess quite well, but if the call

  20:     // to AddOrder takes time, we can't be sure.

  21: }

The traditional way to fix this problem is to refactor the original code to implement some kind of pattern that helps us substitute our hard coded dependencies. One popular pattern is the Dependency Injection Pattern which essentially says that every class should take its dependent objects as in-parameters to its constructor (or through properties). I won’t go in to that pattern right now, but this is a good pattern and as I’ll try to cover in a follow up post, I’ll show you how Microsoft Mole might help you even though you have decided to use this pattern.

But if we don’t want to or are unable to refactor our code, how do we do then? This is when Microsoft Moles comes as a savior. With Microsoft Mole, you can substitute almost any .NET method with a version of your own. Yeah, that’s right. If you don’t like the current implementation of DateTime.Now, you could substitute it to always return a date that you control or if you don’t have full control of what the AddOrder method on the OrderRepository does, then substitute it for another implementation. Let me show you.

   1: [TestMethod]

   2: [HostType("Moles")]

   3: public void CanAddOrderWithoutMole()

   4: {

   5:     int callesToSaveOrder = 0;

6:

   7:     // Replace the current implementation of DateTime.Now

   8:     // with one that allways return the same date

   9:     MDateTime.NowGet = () => new DateTime(2010, 03, 07, 14, 20, 0);

10:

  11:     MOrderRepository.AllInstances.SaveOrderOrder = (r, o) =>

  12:         {

  13:             // Increase counter to be sure of how many times

  14:             // our implementation of SaveOrder gets called

  15:             callesToSaveOrder++;

16:

  17:             // Customer name should be the one we provided

  18:             Assert.AreEqual("Test Customer", o.CustomerName);

19:

  20:             // Order date should be the 2010-03-07 14:20:00, because

  21:             // we just replaced the implementation of DateTime.Now

  22:             Assert.AreEqual(new DateTime(2010, 03, 07, 14, 20, 0), o.OrderDate);

23:

  24:             // Allways return 42 as OrderID

  25:             return 42;

  26:         };

27:

  28:     var service = new OrderService();

  29:     var order = new Order()

  30:     {

  31:         CustomerName = "Test Customer",

  32:         Details = new OrderDetail[]

  33:         {

  34:             new OrderDetail() {ArticleNumber="A123", Quantity=1 },

  35:             new OrderDetail() {ArticleNumber="B456", Quantity=2 }}

  36:     };

37:

  38:     var orderId = service.AddOrder(order);

39:

  40:     // Make sure the OrderID is 42 ...

  41:     Assert.AreEqual(42, orderId);

  42:     // ... and that we only made one call to SaveOrder

  43:     Assert.AreEqual(1, callesToSaveOrder);

  44: }

At line 9 above, you can see how I substitute the current implementation of DateTime.Now with an own implementation that always returns 2010-03-07 14:20:00. You can see that I use a “Magic Class” called MDateTime to do that. And on line 11 you can see how I replace the current implementation of SaveOrder of the OrderRepository class by interacting with another “Magic Class” called MOrderRepository. As it turns out, this is no magic at all.

Microsoft Moles generates classes for me according to my specifications in .moles files and in this example I’ve configured Moles to generate Mole Types for mscorlib.dll and my service library. You can configure exactly what classes gets generated to save some execution and generation times, but in this example I’ve just let Moles to generate Mole Types for the complete assemblies.

Content of: mscorlib.moles

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <Moles xmlns="http://schemas.microsoft.com/moles/2010/">

   3:   <Assembly Name="mscorlib" />

   4: </Moles>

Content of: AI.ServiceLigrary.moles

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <Moles xmlns="http://schemas.microsoft.com/moles/2010/">

   3:   <Assembly Name="AI.ServiceLibrary" />

   4: </Moles>

Moles also made me aware that I had to add the following attribute at assembly level, which I did in my AssemblyInfo.cs file:

   1: [assembly: MoledType(typeof(System.DateTime))]

So, that’s it, when I run my Unit Test, and yes this is really a Unit Test and not an Integration Test, it passes and informs me that my AddOrder method inside my OrderService works as it should. Just to prove that I’m not doing Integration Testing here I’ll even show you my implementation of my OrderRepository:

   1: public class OrderRepository

   2: {

   3:     public int SaveOrder(Order order)

   4:     {

   5:         throw new NotImplementedException();

   6:     }

   7: }

Amazing, isn’t it? We have just made a Unit Test out of code that normally isn’t Unit Testable at all. With that said, I still like to point out the following:

Microsoft Mole is a great! It can help you Unit Test what wasn’t unit testable before (actually some Mocking Frameworks like Typemock have made this possible before).
I still want my systems to be loosely coupled and would still recommend you to implement some patterns to make your system just that. Just because Moles might save you some troubles of implementing one of those patterns, doesn’t make it necessary a good thing.
Make sure you understand how to implement the Dependency Injection Pattern and know how to use Inversion of Control Containers like Unity, NSpring, etc. Microsoft Moles can also help you implement the stubs you would need to Unit Test you components that implements the Dependency Injection Pattern.
Microsoft PEX is a tool that will help you implement Unit Tests with high code coverage and is a very interesting technology. Make sure you’ll have a look at that as well. I might even cover that topic later as well.

Please look at this post on the Visual Studio Team Test blog to find out more information and how you can download Pex and Moles.

Creating and Hosting an even more Minimal WCF Service in .NET 4 using F#

KristoferL — Mon, 01 Mar 2010 23:17:17 GMT

Visual Studio 2010 and .NET 4 will include support for a new language called F#. I must admit that you have to learn how to love F#, it’s not that often love at first sight, because you just can’t figure out what is going on. Even though I’m beginning to like F# more and more and who knows… I might even love it some time soon. Today I got the time to think a lot, during a drive to and from a customer of mine, about how it should be to implement my minimal WCF 4 Service using F#, and it turned out to be pretty straight forward. I think I’ll be trying to use more of F# later on.

Notice how I decided to use the F# function printfn to output text to the console instead of Console.WriteLine which I could have used if I’d liked to.

   1: open System

   2: open System.ServiceModel

   3: open System.ServiceModel.Description

4:

   5: [<ServiceContract>]

   6: type TimeService() =

   7:     [<OperationContract>]

   8:     member this.GetTime() =

   9:         DateTime.Now

10:

  11: let main =

  12:     use host = new ServiceHost(typeof<TimeService>, new Uri("http://localhost:4711"))

  13:     host.Description.Behaviors.Add(new ServiceMetadataBehavior(HttpGetEnabled = true));

  14:     host.Open()

15:

  16:     printfn "Service is up'n running at %s" (host.Description.Endpoints.[0].Address.ToString())

  17:     printfn "Press any key to shut down service"

  18:     Console.ReadKey()

Creating and hosting a minimal WCF Service in .NET 4

KristoferL — Thu, 11 Feb 2010 23:27:43 GMT

12th of March… that’s the date when we release Visual Studio 2010 and .NET Framework 4. I’m so excited and if you have a MSDN Subscription you can already download the Release Candidate right now. If you don’t have a MSDN Subscription you’ll have to wait some more hours before you can download the release candidate.

Anyway, I got into a discussion with my colleague about WCF and as I went along testing what we discussed I couldn’t help admiring how simple it is to get up and running with a WCF Service in .NET 4. The following example creates and hosts a WCF Service as a Web Service using basicHttpBinding and exposes the metadata, WSDL, if you just steer your browser to the address of the service. In this example http://localhost:4711/?wsdl . Also notice that no other configuration… I repeat. No other configuration is needed!

WCF will create default endpoints using default bindings and if you want to, you could override default behavior in this app by adding information in your application config file (app.config or web.config), but you don’t need to. This will make it tremendously easier to get up and running with your WCF Services.

Here you go:

   1: using System;

   2: using System.ServiceModel;

   3: using System.ServiceModel.Description;

4:

   5: namespace MinimalWebService

   6: {

   7:     class Program

   8:     {

   9:         static void Main()

  10:         {

  11:             using (var host = new ServiceHost(typeof(TimeService), new Uri("http://localhost:4711")))

  12:             {

  13:                 host.Description.Behaviors.Add(new ServiceMetadataBehavior() { HttpGetEnabled = true });

  14:                 host.Open();

15:

  16:                 Console.WriteLine("Service is up'n running at {0}", host.Description.Endpoints[0].Address);

  17:                 Console.WriteLine("Press any key to shut down service");

  18:                 Console.ReadKey();

  19:             }

  20:         }

  21:     }

22:

  23:     [ServiceContract]

  24:     public class TimeService

  25:     {

  26:         [OperationContract]

  27:         public DateTime GetTime()

  28:         {

  29:             return DateTime.Now;

  30:         }

  31:     }

  32: }

Installing the Visual Studio 2008 Development Stack… in the right order

KristoferL — Tue, 05 May 2009 01:07:00 GMT

I just installed Windows 7 RC and once again found myself sitting with a clean Windows installation with no applications installed. That might be a nice feeling, but if you are like me, you will start to feel bored and actually a little bit lost within a couple of minutes without Visual Studio :-)

So how do you go ahead and install Visual Studio nowadays? Well, gone are the days where there only where one installer and you where done. Today there are several installers you have to run, just to setup Visual Studio 2008 to an updated application. This is due to extensions and service packs that have been released after the initial release of Visual Studio 2008. So is it not just to install all of these updates then? Well, yes and no. You should probably install them all, but it’s important that you do it in the right order.

That’s why I completed a list of the order you ought to install Visual Studio and some of the additional updates. Here you go:

Install Visual Studio 2008

If you have Visual Studio Team System 2008 Database Edition och Development Edition, make sure you install both, cause they are since October 1st, 2008, one product.
If you have Visual Studio 2008 Professional or any other version of Visual Studio Team System 2008 Team Suite, just install that version and continue to #2

Install Visual Studio 2008 Team Explorer
… if you are connecting to a Team Foundation Server instance… and you are, right? Make sure you install Team Explorer before #3
Download here.
Install Visual Studio 2008 Service Pack 1
If you ever find yourself in the position that you have installed Visual Studio 2008 Team Explorer after you have installed Visual Studio 2008 Service Pack 1, then you have to reinstall the Service Pack once again.
Download here.
Install Visual Studio Team System 2008 Database Edition GDR R2
… if you have installed Database Edition or Team Suite.
Download here.
Install MSDN Library for Visual Studio 2008 SP1
Download here.
Install any additional applications and extensions to Visual Studio you would like

Visual Studio Team System 2008 Team Foundation Server Power Tools
Download here.
Microsoft Silverlight 2 Tools for Visual Studio 2008 SP1
Download here.
Any Microsoft SDKs
Find links to every SDK here.
Microsoft Expression Studio 2
SQL Server 2008 Development Edition
Etc.

I hope this helps some of you getting started with a fresh installation of Visual Studio 2008.

Silverlight 2

KristoferL — Wed, 15 Oct 2008 10:45:41 GMT

Yesterday, we released Silverlight 2. You can learn more about Silverlight 2 and install it on the official Microsoft Silverlight Site. I for sure will dig deep into Silverlight in a couple of days.

silverlight.RealeaseNewVersionToPublic(new Version(2, 0)); // See you around!

Test Driven Development, TDD, will become quicker and better with Visual Studio Team System 2010

KristoferL — Wed, 08 Oct 2008 21:57:13 GMT

We have just recently started to talk about our next developer tool, Visual Studio Team System 2010, and I must say that I’m in love with one new feature already. Ok, I haven’t really tried it yet for myself, but just to read about this feature makes my Test Driven heart pump a little bit faster.

Identification of Impacted Tests – Visual Studio Team System 2010 will have a Test Impact View, that identifies all the tests that should be run to validate a code change. That is great, cause TDD is all about:

Red – Make sure you have a test that fails, by running all tests. If no tests fail, then write a new one that does fail!
Green – Fix the failing test by least effort.
Refactor – Make the code better, without changing any behavior of the code.

Now this has worked well before, but the first bullet point might take some time when you have a couple of thousand tests. Well you might think that the application should be better partitioned so that you don’t end up with that many tests, but the reality is that you might get there anyway (and some tests might even be integration tests that tests complicated interactions between several components and sometime you want to run those too). Anyway, I’ve been there, where the tests take too long time to run, that you start to cheat. You try to guess what tests that are impacted of a specific code change and only run those. Perhaps you run all tests before you check-in your code, but perhaps you cheat even there (even though you know you shouldn’t… shame on you if you commit this sin… shame on me if I have sinned).

This new feature in Visual Studio Team System 2010 will help you to figure out what tests are actually impacted by the code change you are about to introduce and will therefore speed up testing and development. Especially when using TDD.

Read more about this feature and other new features in Visual Studio Team System 2010 here:

http://msdn.microsoft.com/sv-se/vsts2008/products/bb725993(en-us).aspx

VSTS Developer Edition merges with Database Edition

KristoferL — Mon, 06 Oct 2008 11:25:19 GMT

Good news for all you developers that are also working with databases (I know... that's probably all of you.) We have made changes to Visual Studio Team System Editions. From now on Developer Edition and Database Edtion can be seen as one Edition.

If you own or are about to buy one of these editions, you can get the other edition for free, right away.

More info on:

In the next version of Visual Studio Team System, code name "Rosario", these editions will be merged into one new edition.

Refreshing my Linq skills

KristoferL — Fri, 03 Oct 2008 23:50:00 GMT

... and just thought I could share my experience with you.

My training in the US is over and I’ve been back in Sweden for two weeks. It’s been two busy weeks with several customer meetings and an ALM Workshop… and ALM is Application Lifecycle Management. My fingers are itching to write some code, so here we go…

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Linq;

4:

   5: namespace AI.Linq01

   6: {

   7:     class Contact

   8:     {

   9:         // New Feature: Auto-Implemented Properties

  10:         public int ID { get; set; }

  11:         public string Name { get; set; }

  12:     }

13:

  14:     class Program

  15:     {

  16:         static void Main(string[] args)

  17:         {

  18:             // New Feature: Implicity Typed Local Variable

  19:             var contacts = new List<Contact>

  20:             {

  21:                 // New Feature: Object Initializer

  22:                 new Contact(){ID = 1, Name = "Kristofer"},

  23:                 new Contact(){ID = 2, Name = "Qiang"},

  24:                 new Contact(){ID = 3, Name = "Scott"}

  25:             };

26:

  27:             // New Feature: Linq Query

  28:             // Retriev every contact with ID less than 2

  29:             var result1 = from contact in contacts

  30:                            where contact.ID < 2

  31:                            select contact;

32:

  33:             // Write the result to the Console

  34:             foreach (var c in result1)

  35:                 Console.WriteLine(c.Name);

36:

  37:             // Wait for a key to be pressed

  38:             Console.ReadKey();

  39:         }

  40:     }

  41: }

Output of this program is:

Kristofer

Doesn’t seem so much, but I’ll dig deeper and deeper into Linq in the upcoming blog posts.

blogStream.Close();