Typemock Isolator: A CLR Interception Approach to Unit Testing

Recently I have contacted Typemock and I was offered a license of Typemock Isolator, their flagship tool, in support of my OSS project LINQBridgeVS. Typemock Isolator is a viable tool to incorporate CLR interception for unit testing in .NET.

CLR is the acronym for Common Language Runtime and it is the virtual machine that manages the execution of .NET programs. Typemock Isolator intercepts CLR calls at run-time and offers a fluent API to fake almost anything: static and sealed classes, instances, virtual or non-virtual synchronous and asynchronous methods, P-invoke calls, private and static constructors and also LINQ queries.  Typemock Isolator comes as a Visual Studio extension compatible with Visual Studio from 2010 through 2017 with any .NET Framework version up to 4.7.2 and incorporates four different components: 

  • Typemock Isolate contains the Typemock Isolator Mocking API, a fluent API to fake and mock objects based on the Arrange-Act-Assert pattern, and Insight which gives detailed information about the behaviour setup during test debugging. 
  • Typemock Suggest suggests and creates tests, for either NUnit or MsTest, for methods and classes in legacy or mainstream code that have partial to no test cover. 
  • Typemock SmartRunner is the built-in test runner and identifies and runs only the impacted tests after the solution’s tests have run for the first time. This includes all modified tests and those tests that need to run because the code they test has changed. 
  • Typemock Coverage is a code coverage tool that displays code coverage for tests, methods, all classes or only those that have recently changed or the entire solution. It also display real-time code coverage while code is written.

Licensing System

Typemock Isolator for .NET has three different types of licenses which are offered in two versions: annual or perpetual. The price starts at €479 pa or (€899 perpetual) for Isolator Essential which comes with the mock framework, the test runner and method coverage. Isolator Complete adds Auto-generated test suggestions and it costs €799 pa (€1599 perpetual). The last one is Isolator for Build Server which adds support to run tests on up to five machines and comes at €1119 pa (€2499 perpetual) . For more information visit the pricing page. Typemock is free for MVPs and there is also support for open source projects, although not directly advertised through their website. If you’re interested in having a license for your open source project get in contact with them through the contact us form and send a brief description of your project.

Introduction

Writing unit and integrations tests is a vital part of the software development life-cycle. It is often underestimated and left as the last part of the development. Achieving an extended test coverage is extremely important for the creation of a reliable and stable product. Techniques and principles from Test Driven Development could be used by teams to make the creation of tests easier.

Reality is often different though. It is a rare opportunity to work on a brand new project where both the design and the development process can be decided from the beginning. Often enough a team determined to follow TDD principles ends up not allocating enough time to hit the desired coverage or tests are not strictly written first. In such cases it is preferred to offload developers and delegate QA teams to write automation tests or to test an individual feature manually. Clearly this approach is not scalable and doesn’t guarantee stability over time. When code changes are not monitored by both unit and integration tests it is very hard to estimate and also to predict the impact that a specific change will have to other parts of the system. 

Unless TDD principles are followed and a robust and clean design is made from the very beginning, the process of writing tests in isolation becomes increasingly more difficult as the project evolves and cannot be achieved without proper (and often painful) refactoring.

The Limitation of Mock Frameworks

Mock object frameworks simulate objects’ behaviour. A mock is something that is setup as part of a test so that it returns an expected result. Mocks in a way are determined at runtime since the code that sets the expectations has to run before they do anything. As a rule of thumb mocks are used to ‘fake’ dependencies of a class. When a method or a class is tested in isolation, i.e. when a a unit test is written for it, dependencies to other systems should be mocked.

There are a lot of free open source mock framework for C#: MoqRhinoMocksFakeItEasy and NSubstitute just to name a few. There is also a built in Visual Studio version called Microsoft Fakes.

The aforementioned frameworks (except for Microsoft Fakes) have one peculiar aspect in common: they can only mock a class given its interface or its base class as long as the base class is inheritable and it declares virtual methods for the behaviours to be setup. 

Testing using the Proxy pattern

Sealed classes, static classes and non-virtual methods cannot be mocked with the proxy pattern approach most mock frameworks use. A proxy is a class functioning as an interface to something else. The proxy has to implement the same interface as the Subject so that the Client doesn’t realise that it is using a proxy. Mock frameworks in fact create proxies at run-time based on interfaces or abstract classes and they are able to override any virtual method. 

The Proxy Pattern
The Proxy Pattern class diagram.
public class Auth
{
   public int AuthStatus { get; private set; }
   public virtual bool IsAuthValid(string user, string pwd)
   {
      return false; //this could be an external call to an auth server
   }

   public void AuthenticateUser(string user, string pwd)
   {
      if ( IsAuthValid(user, pwd) )
           AuthStatus = 10;
   }
}

 // Arrange
 var moqAuth = new Mock();
 moqAuth
   .Setup(p => p.IsAuthValid(It.IsAny<string>(), It.IsAny<string>()))
   .Returns(true);
 // Act
 moqAuth.Object.AuthenticateUser("myUser", "myPwd");
 // Assert
 Assert.IsTrue(moqAuth.Object.AuthStatus == 10);

In the arrange section of the snippet above, Moq creates a proxy that inherits from the class Auth. During the setup, a call to IsAuthValid is overridden so an expected value is returned by default when the method is invoked. The method IsAuthValid however must be virtual, otherwise Moq won’t be able override it and will raise an exception. 

Testing using CLR Interception

Let’s see how the test and the class Auth could be re-written using the CLR interception approach adopted by the Typemock API:

public sealed class Auth 
{ 
   public int AuthStatus { get; private set; } 
   public bool IsAuthValid(string user, string pwd) 
   { 
     return false; //this could be an external call to a server or db 
   } 

   public void AuthenticateUser(string user, string pwd)
   { 
      if ( IsAuthValid(user, pwd) )            
         AuthStatus = 10; 
   }
}

//Arrange
var auth = new Auth(); 
Isolate 
 .WhenCalled(() => auth.IsAuthValid(string.Empty, string.Empty)) 
 .WillReturn(true);

//Act
auth.AuthenticateUser("myUser","myPwd");

//Assert 
Assert.IsTrue(auth.AuthStatus == 10);

I changed the class Auth to be sealed instead and I also made the method IsAuthValid non virtual. Classes should either be designed for inheritance or prohibit it. There is a cost to designing for inheritance, and unless there is a good reason, it should be avoided.

In the test code above there is no mock created. The behaviour is overridden directly on the instance of the object. Typemock intercepts the call to the object’s method at runtime and redirects it to return the value setup instead. If I wanted to make the method private it would also require a small change in the test:

Isolate.NonPublic.WhenCalled(auth, "IsAuthValid").WillReturn(true);

Private or non-virtual methods cannot be tested using a proxy based mock framework. The alternative is using Microsoft Fakes, which I mentioned earlier, and it has similar features to Typemock Isolator.
Microsoft Fakes has support for either proxy-based mocks, which are called stubs, and method interception mocks called shims, which diverts method calls at run time. With Microsoft Fakes every assembly needs to be faked manually. For example if you need to generate a mock for a .NET system type, like DateTime, then a Fake for the System.dll must be created and referenced in the test project. Microsoft Fakes has also some other limitations. Please refer to this link for a detailed comparison of Microsoft Fakes vs Typemock.

Improved design using the Bridge pattern

At this stage one could argue that the current design for the Auth class is poor and a better one would be to abstract away the dependency that authenticates the user from the Auth class.

The Bridge Pattern class diagram.

The Bridge pattern, initially designed by the Gang-of-four, is the best structural pattern to decouple an abstraction from its implementation so that the two can vary independently. It removes the compile-time binding and the implementation can be selected at run-time. Let’s use the Bridge pattern in the Auth class, and let’s add two more dependencies for logging and for db access:

public interface IAuthSystem
{
   bool IsAuthValid(string user, string pwd);
}

public interface ILogging
{
   void Log(string msg);
}

public interface IRepository
{
   IEnumerable<T> Get<T>();
}

public sealed class Auth
{
  private readonly IAuthSystem _authSystem;
  private readonly ILogging _logging;
  private readonly IRepository _repository;

  public int AuthStatus { get; private set; }
  
  public Auth(IAuthSystem authSystem, ILogging logging, IRepository repository)
  {
     _authSystem = authSystem;
     _logging = logging;
     _repository = repository;
  }

  private bool FindUser(string userName)
  {
     var result = from user in _repository.Get<User>()
                where user.UserName.Equals(userName)
                select user;

     return result.Any();
  }
  public void AuthenticateUser(string user, string pwd)
  {
       _logging.Log($"User logging in {user}");

      if ( FindUser(userName) && _authSystem.IsAuthValid(user, pwd))
         AuthStatus = 10;
  }
}
//Moq
  //Arrange
  var authSystem = new Mock<IAuthSystem>();
  var logging = new Mock<ILogging>();
  var repository = new Mock<IRepository>();
  
  authSystem
    .Setup(p => p.IsAuthValid(It.Is<string>(s => s == "Coding"), It.Is<string>(w => w == "Adventures")))
    .Returns(true);

  repository
    .Setup(p => p.Get<User>())
    .Returns(new List<User>{ new User{UserName = "Coding"}});
  
  //Act
  var auth = new Auth(authSystem.Object, logging.Object, repository.Object);
  auth.AuthenticateUser("Coding", "Mock");

  //Assert
  Assert.IsTrue(auth.AuthStatus == 10);

//Typemock
  //Arrange
  var auth = Isolate.Fake.Dependencies<Auth>();
  
  var fakeAuthSystem = Isolate.GetFake<IAuthSystem>(auth);
  var fakeRepository = Isolate.GetFake<IRepository>(auth);
  
  Isolate
     .WhenCalled(() => fakeAuthSystem.IsAuthValid("Coding", "Adventures"))
     .WithExactArguments()
     .WillReturn(true);

  Isolate
     .WhenCalled(() => fakeRepository.Get<User>())
     .WillReturnCollectionValuesOf(new List<User> {new User {UserName = "Coding"}});

   //Act
   auth.AuthenticateUser("Coding", "Adventures");
   //Assert
   Assert.IsTrue(auth.AuthStatus == 10);

With this new design it is much easier to mock away the dependency to IAuthSystem, ILogging and also IRepository. In Moq a mock must be created, setup and an instance passed to the constructor of Auth for each dependency declared in the constructorIn Typemock API there is a shortcut instead to fake all dependencies declared in a constructor using the Isolate.Fake.Dependencies<T>() method. With Isolate.GetFake<T>(object) the corresponding faked dependency can be retrieved to setup behaviours on it:

Auth authObject = Isolate.Fake.Dependencies<Auth>();

IAuthSystem fakeDependency = Isolate.GetFake<IAuthSystem>(authObject);
IRepository fakeRepository = Isolate.GetFake<IRepository>(auth);

Mocking static methods

One thing I always wanted to do freely is using static methods or static classes and also have the ability to override behaviours without having to wrap dependencies with an abstraction layer. For example in my OSS project I have a class called CommonRegistryConfigurations that has a lot of helper methods to access the Windows registry. I always refused to create an abstraction layer that wrapped the Registry class to access the windows registry. I  would eventually end up having parts of my code that rely on these helper class un-tested. Typemock supports faking static methods on static classes, so I was able to setup my object behaviour to mock the call to the static method that access the registry:

public static bool IsSolutionEnabled()
{
   string keyPath = "aKey";

   using (var key = Registry.CurrentUser.OpenSubKey(keyPath))
       return (bool)key.GetValue("myValue");
}

// Test 
Isolate
  .WhenCalled(() => 
     CommonRegistryConfigurations.IsSolutionEnabled())
  .WillReturn(true);

There is one important caveat to keep in mind though. When Isolate.WhenCalled is used to define a fake behaviour on static methods and/or static classes, the behaviour has a global scope. This means that the setup will redirect calls from other unit tests also. It is in fact good practice to mark the test class with a specific attribute available in the Typemock API called IsolateAttribute which makes sure all behaviors are reset at the end of a test method.

Typemock and LINQ Queries

Abstracting away the access to a database is no easy task. One common route is to implement the Repository pattern to abstract away the data access logic, so unit tests can use stubs or mocks as implementations of the IRepository interface. Another solution, if an ORM like Entity Framework is used, could involve faking the DbContext itself instead of wrapping everything with the Repository pattern. There’s a good article here with a thorough explanation on the topic. 

A feature that has really caught my attention is the ability to fake the result of a LINQ query.  Let’s look at the following code:

public bool FindUser(string userName)
{
   var result = from user in _repository.Get<User>()
                where user.UserName.Equals(userName)
                select user;

   return result.Any();
}

// Typemock
 //Arrange
 var auth = Isolate.Fake.Dependencies<Auth>();
            
 Isolate
    .WhenCalled(() => from user in Enumerable.Empty<User>()
                    where user.UserName.Equals(string.Empty)
                    select user)
    .WillReturnCollectionValuesOf(new List<User> { new User() });
 //Act
 bool userExists = auth.FindUser("Adventure");

 //Assert
 Assert.IsTrue(userExists);

In the snippet above, the method FindUser fetches users from a repository using a LINQ query. Instead of changing the behaviour of the method, or faking the repository, it is also possible to fake the result of the query itself. It’s a bit obscure to me though the criteria the API uses to swap the original LINQ query with the one setup in the unit test. I looked up at their official documentation on the topic, but I couldn’t found anything that hints at how linq expressions are swapped around. Regardless of the gore details this feature is very powerful.

Build Server Integration

Typemock Isolator integrates with the several famous build and continuous integration servers like CruiseControl.NET, Jenkins CI, TeamCity and Team Foundation Server, as well as custom build servers. There is a good bit of documentation on their website about Server-side integration. I personally use Appveyor, a free continuos integration solution for Windows and Linux that integrates nicely with GitHub.

Typemock doesn’t integrate with Appveyor as easily as it does with the official supported build servers. Tests that use CLR interception must be run by TMockRunner, a utility part of Typemock Isolator that launches external programs like code coverage tools or a unit test runner like MSTest.

There is some documentation that explains how to run TMockRunner and also how to install it on a custom build server. I’d have preferred to have everything in a single page (or section) so I didn’t have to jump around to find what I needed.

It took me a while to figure out a powershell script that worked nicely with Appveyor. Appveyor runs any custom script with low privileges, thus access to the windows registry is forbidden. TMockRunner needs to access the registry for the initial setup, so I had to come up with a hack to set some specific environment variables to trick TMockRunner into thinking there was no windows registry available. Luckily the support team in Typemock offered a better solution by suggesting to elevate the privileges of my custom powershell script.

I’ll share with you both solutions, in case you need to setup TMockRunner in Appveyor like I did. In the first solution I had to setup the following environment variables in my yml file:

TM_INSTALLDIR: c:\PathToTMockRunner\ 
TMOCK_NO_REGISTRY: 0x1 #this actually tells TMockRunner
there's no registry available
TM_LICENSE:
secure: the encrypted licence number
TM_COMPANY_NAME:
secure: the encrypted company name

Which lead me to this powershell script:

TMockRunner.exe 
   -deploy AutoDeployFolder 
    vstest.console.exe "mytest.dll" "mytest2.dll" 
    /logger:Appveyor

The proper fix though involved elevating the privileges of the powershell script. Then the setup of those four environment variables was no longer needed:

$args = TMockRunner.exe 
   -deploy AutoDeployFolder 
   -register yourLicense vstest.console.exe 
   "test.dll" "test2.dll" /logger:Appveyor

Start-Process powershell -Verb runAs -ArgumentList '$args'

Conclusions

The ability to override methods and classes everywhere, and also in some .NET  classes, is very powerful. It enable developers to write unit tests in isolation in both legacy code where there is none to very little degree of freedom and also in mainstream code. Such freedom shouldn’t be an encouragement to write poorly designed software and TDD (or BDD) should always be the preferred approach when possible so that tests are guaranteed to be part of the product from the very early stages.

The other side of the coin is that a software architecture should always be designed around the problems it solves and the tasks it performs. Being forced to declare methods virtual, avoid sealed or static classes or create a lot of interfaces to abstract any dependency, if not for some technical limitation of mock frameworks, is in my opinion unnecessary. 

On the cons Typemock is not yet compatible with .NET Core and I guess the reason is the different common language runtime (the CoreCLR) .NET Core uses. Also Typemock Suggest needs to be disabled or it will crash if you’re working on a .NET Core project.

I also struggled a bit to setup Typemock in Appveyor, adding the relevant steps I highlighted in this article in their official documentation would be of great help. Another improvement is keeping the Visual Studio extension in sync with the version of the Typemock API. If they mismatch, e.g. you update the Typemock API to a newer version using NuGet but not the extension then an exception is thrown when unit tests are run. 

I really had fun creating tests on my OSS project using Typemock.
For long time I didn’t have much test coverage and finally I was able to increase it in relative short time without doing a huge refactor. The fluent API is very intuitive and easy to use. I hope Typemock will add support for .NET Core in the near future.

This is it, I hope you enjoyed reading this article, see you soon!

Unity Mono Runtime – The Truth about Disposable Value Types

When I started making games using Unity, after almost 10 years of C# development, I was very concerned to acknowledge that foreach loops are highly avoided in Unity because they allocate unnecessary memory on the heap. Personally I love the clean syntax of a foreach. It aids readably and clarity and it also increases the abstraction level. However a very clear and neat explanation of the memory issue problem can be found in a blog article posted on Gamasutra by Wendelin Reich.

From Wendelin’s analysis it emerged that the version of the Mono compiler adopted in Unity has a different behaviour from Microsoft implementation. In particular enumerators, which are usually implemented in the .NET framework as mutable value types, are boxed by the compiler, causing an unnecessary generation of garbage. Boxing is the process of converting a value type (allocated on the stack) into a reference type, thus allocating a new instance on the heap.  Continue reading “Unity Mono Runtime – The Truth about Disposable Value Types”