Mehfuz's WebLog

Writing ASP.NET MVC bootstrapper with AutoBox

mehfuzh — Mon, 30 Jan 2012 15:47:10 GMT

This will post will show how you can use AutoBox to easily write a bootstrapper for ASP.NET MVC. I have used the latest version of AutoBox (available from nuget, this version also includes Castle.Windsor internally for managing dependencies rather using its own resolver and does not require interface to type naming convention [IAccountRepository –> AccountRepository]) . To understand what is AutoBox , how you can use it for caching using memcached and let it automatically handle dependencies for controllers and repositories, i would recommend to take a look at this post:

http://weblogs.asp.net/mehfuzh/archive/2011/11/06/introducing-autobox-on-the-fly-dependency-injection-and-caching-container.aspx

Moving forward , let’s consider a simple bootstrapper interface:

public interface IBootStrapperTask
{
void Execute();
}

The Execute() method will be invoked during initialization for registering routes, controllers, mappings (AutoMapper), etc. We will have one static factory (Ex. BootStrapper) that will initiate it through CommonServiceLocator.

public static class BootStrapper
{
/// <summary>
/// Executes registered tasks.
/// </summary>
public static void Execute()
{
ServiceLocator.Current.GetAllInstances<IBootStrapperTask>().ToList().ForEach(task =>task.Execute());
}
}

A typical example of a bootstrapping task could be RegisterRoutes:

public class RegisterRoutes : IBootStrapperTask
{
private readonly RouteCollection routes;
/// <summary>
/// Initializes the new instance of <see cref="RegisterRoutes"/> class.
/// </summary>
public RegisterRoutes()
: this(RouteTable.Routes)
{
// intentionally left blank.
}
/// <summary>
/// Initializes the new instance of <see cref="RegisterRoutes"/> class.
/// </summary>
internal RegisterRoutes(RouteCollection routes)
{
this.routes = routes;
}
public void Execute()
{
routes.Clear();
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.IgnoreRoute("{*favicon}", new {favicon = @"(.*/)?favicon.ico(/.*)?"});
Routes.Register(routes);
}

Here on line 29, i have added Routes.Register which is similar to the BootStrapper.Execute() that further narrows down to specific routing classes. For example. AccountRoutes.

public static void Register(RouteCollection routes)
{
ServiceLocator.Current.GetAllInstances<IRoutesRegistration>().ToList()
.ForEach(task => task.Register(routes));
}

The code inside Routes class again pretty straight forward and exactly identical to BootStrapper except the IRoutesRegistration interface. We can also have RegisterControllers but since the dependencies are automatically wired by AutoBox, we only need to specify (if required) what repository methods to be data cached and for what duration.

public class RegisterControllers : IBootStrapperTask
{
void IBootStrapperTask.Execute()
{
Container.Setup<ProductRepository>(x => x.GetProductDetails(0)).Caches(TimeSpan.FromMinutes(1)).VaryByArgs();
ControllerBuilder.Current.SetControllerFactory(new MyControllerFactory());
}
}

More on caching and how MyControllerFactory should look like; please check my previous post as well as the product documentation. Finally, it’s about gluing the whole thing together and we just need to have these lines in global.asax.cs

protected void Application_Start()
{
// Initializes autobox self.
Container.Init();
BootStrapper.Execute();
}

When you will run the project; if you followed the flow then it should work as you have expected it. The project page for AutoBox can be reached here: http://mehfuzh.github.com/AutoBox/ .

Hope that helps

Assert the order of expected calls over instances

mehfuzh — Fri, 27 Jan 2012 12:24:10 GMT

How you assert through unit test that an user is authenticated before doing withdraw operation? You can surely verify a method is invoked as expected but if you want to ensure the order right then you might require a little more. JustMock lets you specify the order in which your setups should be executed. This helps you identify the exact way in which a particular logic is implemented.

To begin, lets consider the following context:

User wants to withdraw money from his account. Withdraw operation should validate the following goals:

It should check if the user is authenticated
It should get the balance for the authenticated user and check if the amount to be withdrawn is less than or equals to what is specified.
Do the withdraw operation and return the remaining balance.

Now we have one IUserService interface

public interface IUserSerivce
{
bool IsAuthenticated { get; }
IUser GetUser();
}

One IAccountService interface to process the accounts operation:

public interface IAccountService
{
double Withdraw(double amount);
double GetBalance(IUser user);
}

The basic AccountRepository class with minimal implementation covering the above context looks like:

public class AccountRepsotory
{
public AccountRepsotory(IUserSerivce userService, IAccountService accountService)
{
this.userService = userService;
this.accountService = accountService;
}
public virtual double Withdraw(double amount)
{
if (userService.IsAuthenticated)
{
if (accountService.GetBalance(userService.GetUser()) >= amount)
{
return accountService.Withdraw(amount);
}
}
throw new ArgumentException("TODO");
}
private readonly IUserSerivce userService;
private readonly IAccountService accountService;
}

Ensuring every step to be executed in an orderly manner , we just need to specify an extra InOrder option in Mock.Arrange that will otherwise fail the test during assert for any change of the expected execution order.

[TestMethod]
public void ShouldCheckUserAndBalanceInOrderWhenSpecificAmountIsWithdrawn()
{
var userService = Mock.Create<IUserSerivce>();
var accountService = Mock.Create<IAccountService>();
var user = Mock.Create<IUser>();
Mock.Arrange(() => userService.IsAuthenticated).Returns(true).InOrder();
Mock.Arrange(() => userService.GetUser()).Returns(user).InOrder();
Mock.Arrange(() => accountService.GetBalance(user)).Returns(1000).InOrder();
Mock.Arrange(() => accountService.Withdraw(Arg.AnyDouble)).Returns((amount) => 1000 - amount).InOrder();
var repository = new AccountRepsotory(userService, accountService);
Assert.AreEqual(990, repository.Withdraw(10));
Mock.Assert(userService);
Mock.Assert(accountService);
}

Let’s remove the line# 13 from AccountRepository.Withdraw that yields:

public virtual double Withdraw(double amount)
{
if (userService.IsAuthenticated)
{
return accountService.Withdraw(amount);
}
throw new ArgumentException("TODO");
}

Since we broke the order, the test will fail with the following message:

Here one thing to notice that InOrder is applied to different mock instances within the test method scope that makes it effective in most practical and wide variety of scenarios. I have used Q3 SP build for the purpose (Also available via NuGet).

Hope that helps

Asserting a mock with test framework

mehfuzh — Fri, 09 Dec 2011 12:44:40 GMT

When asserting an expected call for its number of occurrences or may be just to verify if the setup/arrange is acted as intended, the tool generally raises assertion that points us to the reason why the test failed. Different mocking tools use different exception classes therefore there is no common way to consolidate them.

However, if we just take a look into the test framework unless its some alien one, they all have a common underlying structure for Assert.Throws or ExpectedException (MSTest).

MS Test (C# and Silverlight)

Microsoft.VisualStudio.TestTools.UnitTesting.AssertFailedException

NUnit

NUnit.Framework.AssertionException

XUnit

Xunit.Sdk.AssertException

MSpec

Machine.Specifications.SpecificationException

MbUnit

Gallio.Framework.Assertions.AssertionException

So the point here is that if we just use the existing exception class rather than thinking one of our own, it greatly increases the scope of the tooling support. For example, let’s consider the “Test Results” window inside visual studio 2010 that tells us that Foo.Echo() is never invoked as it is expected. Since, its just one line and shows only the reason rather the whole stack trace, it is definitely more user-friendly:

Comparing to the one below, for which you even need to expand and see what’s going wrong.

Here I mentioned the word “increased tooling support”, of course it means the tool vendors (who are creating runners) never need to know which mocking tool and update their formatting code over considering a test framework.

Technically , JustMock dynamically probes the underlying framework which is the idea very much got from this project at codeplex which I would like to point here:

http://fluentassertions.codeplex.com/

The feature is available from Q3 2011 in JustMock Free as well as in commercial edition.

Hope that helps

Future mocking with #IgnoreInstance

mehfuzh — Fri, 02 Dec 2011 11:36:41 GMT

In my previous post, i showed how JustMock picks mock expectations based on current context without the instance being injected. Based on feedback we found that It’s sometimes confusing and often does not work as intended. However, the context of this post is not to introduce future mocking rather a new feature that allows you to skip mock instance intentionally (when you can’t pass the dependency through a constructor or via method argument) instead the tool is applying it for you on behalf.

You can find more on future mocking and some abstract behind it from my previous post:

http://weblogs.asp.net/mehfuzh/archive/2011/09/30/future-mocking-revisited.aspx

Now moving forward, i will represent a code block that fails and then solve it with IgnoreInstance modifier. I am of course thankful to Lior Friedman for pointing me this. So the code that is very much similar to what he showed me:

Code that fails

var fakeUsed = Mock.Create<UsedClass>();
Mock.Arrange(() => fakeUsed.ReturnFive()).Returns(7);
Assert.AreEqual(7, fakeUsed.ReturnFive());
Assert.AreEqual(5, new UsedClass().ReturnFive());

Now , if the context resolve is implicit then both of the calls will return the same value. In this typical use case the search by context wont work because for some arrange I might want to ignore instance and for some other I want to execute the call as it is. Taking this into account, introduced more explicit ignoreInstance switch. This will not only let you ignore instance per setup for the same type also make it more pragmatic and to the point since now I know what I am doing, not the tool getting on my way.

Therefore only when you want to apply a particular setup for all instance, you will do it like:

var fakeUsed = Mock.Create<UsedClass>();
Mock.Arrange(() => fakeUsed.ReturnFive()).Returns(7).IgnoreInstance();
Assert.AreEqual(7, fakeUsed.ReturnFive());
Assert.AreEqual(7, new UsedClass().ReturnFive());

This is a new feature and available from Q3 2011 build and removes the implicit context search approach.

Hope that helps

P.S. We are gathering next cool feature for JustMock. Since we believe it’s a tool worth when there is a personal touch therefore please send me / us your ideas in the forum or via email or just a tweet.

Introducing AutoBox - On the fly dependency injection and caching container.

mehfuzh — Sat, 05 Nov 2011 22:00:29 GMT

Just when we have dependencies for a controller, we need to wrap around our heads to write a bootstrapper that will dynamically inject dependencies for a controller in runtime and once we we want to do data caching like a particular method in accounts repository need to get cached for a certain number of time and it should invalidate when someone calls update, things get complex and may be we get around this with some attribute based solution.

Therefore, I introduce to you AutoBox. It is a on the fly dependency injection and caching container. It dynamically injects dependencies based on convention. Also, let you cache repository calls to memcached (the most popular cross-platform caching system) which is originally implemented by LiveJournal and used by high volume site like Youtube.

Now getting started with AutoBox is simple. Lets consider that you have a ProductController and the constructor looks something like:

public ProductController(IProductRepository repository)
{
this.repository = repository;
}

ProductRepository is implemented in MyCoolWebSite.Repository folder where IProductRepository is under MyCoolWebSite.Repository.Abstraction (Not a required). In the global.ascx you first need to add the following line:

Container.Init();

Here to mention that AutoBox will do the mapping on demand thus making it lazy.

Next you need to override the GetControllerInstance from DefaultControllerFactory. Since AutoBox is implemented using CommonServiceLocator, therefore you can directly include ServiceLocator.Current.GetInstance that will return the target controller with dependencies properly injected.

public class CustomControllerFactory : DefaultControllerFactory
{
protected override IController GetControllerInstance(System.Web.Routing.RequestContext requestContext, Type controllerType)
{
return ServiceLocator.Current.GetInstance(controllerType) as IController;
}
}

Finally, at the end of global.ascx.cs you need to write the following line; so that all the controller get instance requests go through AutoBox:

ControllerBuilder.Current.SetControllerFactory(new CustomControllerFactory());

Hit F5 and and you are ready to roll with dependencies.

Now, moving forward there is a method in IProuductRepository lets say IProductReposiroty.GetAllProducts(). You just dont want to hit database all the time, unless invalidated. Therefore, you can further specify (you can also combine that with your bootstrapper that registers routes and mappings using AutoMapper):

Container.Setup<ProductRepository>(x => x.GetAllProducts()).Caches(TimeSpan.FromMinutes(1));

This tells AutoBox to cache the result of the call (using memcached) that will automatically invalidate after a minute. However you can explicitly specify the method that will invalidate it.

Container.Setup<ProductRepository>(x=> x.Create(Arg.Varies<Product>()).Invalidates(x => x.GetAllProducts());

You will notice here that I have used Arg.Varies{T}. Its similar to VaryByParams in output cache where it tells the tool to invalidate based on the variable argument value. Finally to make Memcached working you will need to have the following block in web.config (will be added automatically when installed from NuGet [Yes its NuGet]).

<?xml version="1.0" encoding="utf-8"?>
<configuration>
<configSections>
<section name="autoBox" type="AutoBox.AutoBoxSection, AutoBox" />
</configSections>
<autoBox cacheStore="localhost" cacheProvider="MemcachedProvider" />
</configuration>

Here you will notice that by default its pointing to localhost and MemcachedProvider. However it can be an external IP pointing to Amazon ElastiCache (released a few weeks ago).Here to note that memcached is a caching mechanism and therefore the tool is agnostic of any underlying cloud service that you may use.

To test caching locally, you can use the CouchBase’s Membase server (Not limited to), it gives you a nice web based GUI to monitor the cache usage, configure memory and clusters.

You can download it from this link:

http://www.couchbase.com/products-and-services/memcached/

You can get more information on this project, download source and contribute at the following URL:

http://mehfuzh.github.com/AutoBox/

As mentioned above, it is also possible to use the tool with a hand-rolled bootstrapper that uses IOC container (Ex. Ninject) and AutoMapper and can save you some lines in binding the controller dependencies and if you want to use high-performance caching mechanism like memcached and don’t want to pull your hair off on how to invalidate a repository call when saved a part of it then this tool can give you a boost.

Hope that helps

Future mocking revisited

mehfuzh — Fri, 30 Sep 2011 12:06:41 GMT

Previously , I have posted how it is possible to mock a method without passing the dependency through a constructor / calling method. This is something true for third party controls and tools where we have little control over how its created.

You can find more on that in the following post:

http://weblogs.asp.net/mehfuzh/archive/2011/07/21/fake-a-member-without-worrying-about-passing-the-dependency.aspx

Now the feature that lets you mock members without passing the dependency, we call it Future mocking. However it does not mean that Justmock ignores the instance completely but rather there is a workflow where it checks if there is no match for instance (of course it is a profiler intensive feature) and mocked within current context it tries to match any setup that is meant for.

One of the best example that I recently encountered through a community feedback that describes a UI case where based on some action against the form, raises an event which needs to be handled in a specific way in the unit test to assert the expected value.

Therefore, we have a Form class where the constructor looks something like:

public Form2()
{
InitializeComponent();
this.service = new EntryService();
service.Saved += new EventHandler<EntrySavedEventArgs>(service_Saved);
}

We have a SaveToDatabase method that on the other hand invokes the Save method in EntryService and finally raise an event when successfully saved.

public void SaveToDatabase(string value)
{
try
{
this.service.Save(value);
}
catch (DuplicateEntryException ex)
{
MessageBox.Show("Entry Duplicated " + ex.DuplicatedValue);
}
catch (ArgumentNullException)
{
this.label1.Text = "Valeur manquante";
}
}

Here for now lets consider our event target will have just the following block:

void service_Saved(object sender, EntrySavedEventArgs e)
{
this.label1.Text = "Saved string : " + e.EntryValue;
}

In the first snippet we can see that EntryService is created in the constructor of Form2 class and therefore not injected via some external class/agent. The thing that the particular user wanted to do is to raise the target event with the expected EntryValue that is passed during SaveToDatabase call. So the specification for it that verifies such follows:

[Subject(typeof(Form2))]
public class when_save_to_database_is_invoked_on_form
{
Establish context = () =>
{
IEntryService serviceMock = Mock.Create<EntryService>();
Mock.Arrange(() => serviceMock.Save(valueToSave)).Raises(() => serviceMock.Saved += null, new EntrySavedEventArgs(valueToSave));
sut = new Form2();
};
private Because of = () =>
{
sut.SaveToDatabase(valueToSave);
};
private It should_assert_that_label_contains_expected_valueToSave = () =>
sut.label1.Text.ShouldEqual("Saved string : " + valueToSave);
static Form2 sut;
const string valueToSave = "Raise Event";
}

Here we can see that although no instance is supplied to the target UI class JM picks up the intended setup from the context. Needless to mention that in code there are smells like labe1 is private and is accessed by specifying InternalsVIsibleTo for specification assembly but rather it should be implemented using MVVM and {Binding Label1 } way. But that is out of the scope of this post and leave that to the reader. I would further thank Vincent Grondin for the project and you can try this out with the latest release as of today.

You can further download the sample project here:

MockingExample.zip

Finally, hope this has given you an idea on getting started with future mocking.

Thanks

PostSharp and JustMock side by side.

mehfuzh — Fri, 05 Aug 2011 16:00:46 GMT

In this post I will show mocking a member call inside a PostSharp aspect. There were previously compatibility issues between both of the tools running side by side which is now been officially fixed with the most recent release of that tool (>= 2.1.2.8-1594). For those who don’t know what PostSharp is all about, it is a tool that lets you write aspects easily than you can imagine.

Personally , it took me just minutes to get started with a aspect that will authorize a call before invoking it. Consider that you want to authorize an asp.net MVC controller action and if you ever look into the code you will see that it validates the currently logged in user’s identity.

In the simplest way I have an Identity class that has a IsAuthenticated property which is not implemented for sure:

public class Identity
{
public static bool IsAuthenticated
{
get
{
throw new NotImplementedException("Mimic the code User.Identity.IsAuthenticated");
}
}
}

Next we have an Inventory class that places an order for an authorized user:

public class Inventory
{
[Authorize]
public bool PlaceOrder(Order order)
{
orders.Add(order);
return true;
}
public bool HasOrders()
{
return orders.Count > 0;
}
private IList<Order> orders = new List<Order>();
}

Now AuthorizeAttribute is implemented on MethodInterceptionAspect where we can write useful code during the execution of a particular action (return to login page if not authorized, etc). In this case it just skips call for invalid identity.

[Serializable]
public class AuthorizeAttribute : MethodInterceptionAspect
{
public override void OnInvoke(MethodInterceptionArgs args)
{
if (Identity.IsAuthenticated)
base.OnInvoke(args);
}
}

Here to note that SerializableAttribute is a required attribute by PostSharp. Once you compile the code it will actually write the necessary hooks inside the method based on the aspects you have declared.

Next is a simple test using MSpec where I ensured that if the identity is valid then it places the order to an inventory.

[Subject(typeof(Inventory))]
public class when_authorization_ensures_a_valid_identity
{
Establish context = () =>
{
Mock.Arrange(() => Identity.IsAuthenticated).Returns(true);
inventory = new Inventory();
};
private Because of = () =>
{
inventory.PlaceOrder(new Order("Talisker", 1) { OrderDate = DateTime.Now });
};
private It should_assert_that_order_place_was_successful = () =>
inventory.HasOrders().ShouldBeTrue();
static Inventory inventory;
}

Here I have mocked the static Identity call using the Justmock that intercepts it on top the PostSharp hooks during authorization. Further I used the PostSharp starter edition for the purpose.

you can find the sample project here :

JustMock+PostSharp.zip

Happy coding ~~

Fake a member without passing the instance via dependency

mehfuzh — Thu, 21 Jul 2011 10:36:00 GMT

I have came across this several times in forum (telerik) on how I can really fake an item yet I don’t want to pass the instance as an argument. Ideally, this is not a best design but there are third- partly libraries that you have little control over how its written. Anyway, whatever the case might be. This post will show you how you can achieve the above using JustMock. I will be using MSpec in conjunction for the example.

So here is the sample class that I am going to use:

public class LegacyCode
{
public int CheckUser(string userName, string password)
{
var _service = new LoginService();
return _service.ValidateUser(userName, password);
}
}

Here CheckUser is calling LoginService.ValidateUser that we are going replace with a fake call. Also here is the LoginService class that is not much significant just throws exception when ValidateUser is called that will even confirm if the correct variant is invoked.

public class LoginService
{
public int ValidateUser(string userName, string password)
{
throw new NotImplementedException("Nothing implemented yet.");
}
}

Here is the specification that I wrote with Justmock and MSpec

[Subject(typeof(LoginService))]
public class when_a_mock_is_called_without_instance_being_injected
{
Establish context = () =>
{
service = new LoginService();
Mock.Arrange(() => service.ValidateUser(userName, password)).MustBeCalled();
};
private Because of = () =>
{
var sut = new LegacyCode();
sut.CheckUser(userName, password);
};
private It must_assert_that_fake_setup_is_invoked_from_context = () =>
Mock.Assert(service);
static LoginService service;
readonly static string userName = "User";
readonly static string password = "Pwd";
}

This concludes that if you have a mock setup and you cant pass the instance via dependency injection, JustMock will still try to find the closest mock setup for arguments that it will replace the original call with when invoked. There is no extra setup call to be associated in that regard and keeps the tool more out of your way.

In addition I am attaching the sample project to let you have a look. Also you will be needing JustMock full edition installed to try this out.

JustMock_Legacy01.zip

Running JustMock profiler outside of Visual Studio

mehfuzh — Tue, 24 May 2011 14:54:13 GMT

In this post , I would be focusing on the issue that generally comes to query on how to run JustMock with standalone tools like nunit or msbuild console. Since mocking concrete method works initializing the .net profiler that is set using two variables in the runtime to let JustMock work the correct way.

COR_ENABLE_PROFILING, “0x1”
COR_PROFILER, "{D1087F67-BEE8-4f53-B27A-4E01F64F3DA8}"

Now while running msbuild or nunit console or standalone GUI tool, initialization is not always the easy / expected thing to get going. Therefore I created a tiny runner (unofficial) that will do just that and let you pipe your test DLL containing the tests with JustMock. All you have to do is create a batch file where you will pass the path to runner and test DLL in the following format:

JustMockRunner.exe "%Path to test runner%\nunit-console.exe” "%PathToDir%\JustMockTrialTests.dll"

Once the bat is executed, in this case it will open up the console, run the tests and print result from the test runner.

The runner along with a sample project (taken from a user’s post in JustMock forum) can be downloaded by clicking the link below:

JustRunner_with_samples.zip

P.S. To take the advantage of profiler intensive tests , JustMock full edition must be installed which actually registers the profiler. Also, please build the test project (output DLLs are removed) before running Run.bat .

Hope this helps

Update : JustMockRunner.exe to work in .net 3.5 and removed the extra Console.ReadLine that was causing problem in CI server integration.

Mocking MsCorlib members

mehfuzh — Thu, 12 May 2011 12:21:40 GMT

In this post , I will show how you can mock members from MsCorlib. This is more of an introductory post and shows what you need to do in order to successfully mock an MsCorlib member.

If you are planning to mock File or DateTime then the process is pretty straight forward , you just need to put a MockClassAttribute on top your test class. The process for intercepting such is bit different as we don’t want to get your code through the particular logic for every other type and make your test slower. Therefore, we limit it to an attribute declaration to mark that the test class has some framework members to mock ahead.

In a simple example, let’s say I want to assert a DateTime:

[TestMethod]
public void WhenDateTimeNowIsCalledItShouldReturnMockedValue()
{
Mock.Arrange(() => DateTime.Now).Returns(new DateTime(1900, 2, 1));
var now = DateTime.Now;
Assert.AreEqual(1900, now.Year);
}

Or Let’s say I want just want to check if File.Delete is invoked:

[TestMethod]
public void WhenFileIsDeletedItShouldInvokeTheMockedImplementation()
{
var filename = this.GetType().Assembly.ManifestModule.FullyQualifiedName;
var fi = new FileInfo(filename);
bool called = false;
Mock.Arrange(() => fi.Delete()).DoInstead(() => called = true);
fi.Delete();
Assert.IsTrue(called);
}

These require no special treatment other than the attribute declaration. But what about other types from MsCorlib and can we mock them ? Yes we can! We can mock virtually any MsCorlib type using JustMock. The only pre-requisite is to initialize it during the setup. The process is called pre-interception. It is required in a sense that you don’t have to include mock specific attribute in each test method and keep it in one place. Therefore, lets say I want to mock DriveInfo.GetDrives(). All is required that you initialize it during setup in the following way:

[ClassInitialize]
public static void Initialize(TestContext context)
{
Mock.Partial<DriveInfo>().For(() => DriveInfo.GetDrives());
}

The rest is plane old vanilla:

[TestMethod]
public void WhenDriveInfoGetDrivesIsCalledItShouldExecuteTheMockedSetup()
{
bool called = false;
Mock.Arrange(() => DriveInfo.GetDrives()).DoInstead(() => called = true);
DriveInfo.GetDrives();
Assert.IsTrue(called);
}

You can further elevate it to initialize all its member:

Mock.Initialize<DriveInfo>();

Hope that you find this useful. If you have any questions or ideas please directly contact the JustMock support team. Finally, this is a JustMock Commercial edition feature thus not available in the free version.

Thanks

Mocking constructor

mehfuzh — Tue, 22 Mar 2011 14:35:22 GMT

While unit testing a target type, it is likely that the test is failing during object creation because we forgot to include a mandatory configuration file or a line in the constructor is throwing exception because it is making call to some external service or data store which on the other hand requires a little more orchestration to get things going . To better illustrate this, let’s create an entity framework data container either new or from an existing database. Once we have completed the required steps, there will be an entry-point class where we will notice the following default constructor:

/// <summary>
/// Initializes a new NorthwindEntities object using the connection string found in the 'NorthwindEntities' section of the application configuration file.
/// </summary>
public NorthwindEntities() : base("name=NorthwindEntities", "NorthwindEntities")
{
this.ContextOptions.LazyLoadingEnabled = true;
OnContextCreated();
}

The comment clearly shows that by default it will search for a connection string named “NorthwindEntities” in the configuration file. Though this is not an ideal case where it makes the class more production oriented less TDD friendly (if you think it in a TDD purist way) but to avoid this kind of situation the newest release of Telerik JustMock (Free / Commercial) includes a way to mock such case comprehensively. Thus making it flexible for testers who don’t need to include a configuration file or initialize a default service.

Using the JustMock free edition, I can now easily test the above data container without going through any unnecessary configuration hassle:

[TestMethod]
public void ShouldAssertWhenSaveOperationIsExpected()
{
var context = Mock.Create<NorthwindEntities>(Constructor.Mocked);
Mock.Arrange(() => context.SaveChanges(Arg.IsAny<SaveOptions>())).MustBeCalled();
context.SaveChanges(SaveOptions.AcceptAllChangesAfterSave);
Mock.Assert(context);
}

The key here is the Consturctor.Mocked overload in Mock.Create<T>. By default it is set Constructor.NotMocked as general but incase your constructor is throwing some unknown exception and you have little control over its codebase then this could be just it.

# region Developer’s log:

As the feature is supported in JustMock free edition, it is right to say that there is no profiler involved. Therefore, it is not possible to use FormatterServices in that regard :

var context = FormatterServices.GetSafeUninitializedObject(typeof(NorthwindEntities));

If we just open up the NorthwindEntities class in IL dissembler , we will see something like this:

IL_0000: ldarg.0
IL_0001: ldarg.1
IL_0002: ldstr "NorthwindEntities"
IL_0007: call instance void [System.Data.Entity]System.Data.Objects.ObjectContext::.ctor(string,
string)
IL_000c: nop
IL_000d: nop
IL_000e: ldarg.0
IL_000f: call instance class [System.Data.Entity]System.Data.Objects.ObjectContextOptions [System.Data.Entity]System.Data.Objects.ObjectContext::get_ContextOptions()
IL_0014: ldc.i4.1
IL_0015: callvirt instance void [System.Data.Entity]System.Data.Objects.ObjectContextOptions::set_LazyLoadingEnabled(bool)
IL_001a: nop
IL_001b: nop
IL_001c: ret

Here on line 4 it is first calling the base constructor which is actually the case for all .net objects. Even If the class has no base, .net framework will still do an instance call to System.Object itself. But it is possible to skip the call during proxy initialization dynamically that framework wont let you do otherwise if the base class has no default constructor. Of course, this wont work with sealed class in that case profiler is the only resort. Also, Silverlight runtime does not allow it but you can still reference Silverlight class library from .net test project to make things work.

#endregion

Hope that you will find the Constructor.Mocked feature useful. You can download sample the project for this post here EntityFramework01.zip. Finally If you like NuGet, you can also try install-package JustMock to grab the latest bits.

Thanks

NuGet JustMock

mehfuzh — Wed, 22 Dec 2010 09:22:11 GMT

As most of us already know JustMock got a free edition. The free edition is not a stripped down of the features of the full edition but I would rather say its a strip down of the type you can mock. Technically, free version runs on proxy as full version runs on proxy + profiler. In full version, It switches to profiler when you are mocking final methods or sealed class or anything else that can not be done using inheritance. Like in full version you can mock non public methods , in free version you can still do it but it has to be virtual for protected or must be done through InternalsVisibleTo attribute for internal virtual methods (If you have access to the source and can apply the attribute).

Now, you can get a copy of free edition from the product page. Install it and off you go. But it is also exposed to NuGet. Those of you are not familiar with NuGet (that will be odd). But still NuGet is the centralized package manager from Microsoft that cuts the workflow of manual inclusion of libraries in your project. I think NuGet in future will limit the scope of “.vsi” packages and installers because of its ease (except in some cases). Its similar to ruby gems. In ruby, virtually you can install any library in this way “gem install <target_library>” and you are off to go. It will check the dependencies, install them or less prompt with the steps you need to do.

Now sticking to the post, to get started you first need to install NuGet package manager. Once you have completed the step pressing “Ctrl + W, Ctrl + Z” it will bring up an console like one below:

Once you are here, you just have to type “install-package justmock”

Next, it will should print the confirmation when the installation is complete:

Moving to visual studio solution explorer, you will now see:

Finally, NuGet is still in its early ages and steps that are shown here may not remain the same in coming releases, but feel free to enjoy what is out there right now. Regarding JustMock free edition, there is a nice post by Phil Japikse at Introducing JustMock Free Edition. I think its worth checking if not already.

Have fun and happy holidays!

Writing LINQ providers easily and elegantly (LinqExtender 3.0)

mehfuzh — Sun, 28 Nov 2010 14:17:00 GMT

When writing a custom LINQ provider, developer must focus into plenty of issues other than the main purpose of just creating a LINQ to something. Like how to deal with projection, how to parse valued expressions, how to parse members, how to do orderby and the list goes on.

This is the reason I came up with LinqExtender, it deals with all such issues. But over the time I found out that the idea of providing a fluent interface to lookup your query information is easy at some point but becomes really cluttered as the provider logic goes bigger and thus it greatly violates SRP (Single responsibility pattern). Over all, it inherits a base class that makes even impossible to include my own base. With all these in mind I came to push a new release that cuts all this issues.

Therefore, first rather having an iterative fluent interface, it is build on simplified AST (Abstract syntax tree) over the original System.Linq.Expressions with an intent more on making of custom LINQ providers easy, contextual, elegant and of course free of noises like how to deal with projection, what to be done if user invokes a method on the IQueryable, etc.

Moreover, as I don’t want to implement a base class, therefore just an interface should be sufficient enough to make the class queryable.

public interface IQueryContext<T>
{
  IEnumerable<T> Execute(Ast.Expression expression);  
}

Now, if we consider the following LINQ query:

var query = from book in context
    where (book.Id > 1) && (book.Author == "Scott" || book.Author == "Charlie")
    Select book

Things that come to mind on the first place are:

How do translate the logical groupings
How to deal with different opeartors
How to get the value that is compared for a member

Or if the where clause has expression like: book.Author == GetCurrentUsername(), we need to do some specific arts to invoke and reflect the value out of it. Will it not be nice, if the value is already there for us as intended. LinqExtender was/is focused to do all that for you.

The above expression is roughly translated into a simplified expression tree that looks similar to:

BlockExpression
    TypeExpression : Name == "Book", If NameAttribute applied then Name = "as specified".
    LambdaExpression
        LogicalExpresion - Contains the logical parts | Operator = LogicalOperator.AND
            BinaryExpression 
                MemberExpression 
                    Name == "Id"
                LiteralExpression
                    Value = 1    
            BinaryExpression
                LogicalExpression : Operator = LogicalOperator.OR
                    BinaryExpression
                        MemberExpression - 
                            Name == "Author"
                        LiteralExpression
                            Value = "Scott"    
                    BinaryExpression
                        MemberExpression - 
                            Name == "Author"
                        LiteralExpression
                            Value = "John"

The root is the BlockExpresion, it contains other expressions as specified in the query. Like in this case TypeExpression is for select, it is possible to get the TypeReference for the target object. LambdaExpression is for where clause, it can contain logical and/or binary expressions. LogicalExpresion on the other hand can contain N number of binary expressions and each BinaryExpression contains MemberExpression with the detail of the member followed by a LiteralEpxression with the reflected value from the query.

If we had an orderby clause in the expression, then BlockExpression would have contained an additional OrderByExpression.

Finally, visiting the expression (using Visitor Pattern) will produce a nice TSQL (Showed in the sample text provider => project homepage):

select * from Book
where
Book.Id > 10 && (Book.Author = "Scott"  OR Book.Author = "Charlie")

The is just an overview, i have pulled up a home page for the project (shows creating a custom text provider that prints out TSQL representation of the query to the console) along with link to the source and archive to download. You can find it here:

http://mehfuzh.github.com/LinqExtender/

However, I wont say that the tool is a feature complete, therefore feel to fork, update and use it as you like.

---

Here to mention that I moved the project from CodePlex(linqextender.codeplex.com) (that served it well and good), as github gives me more simplicity on how I manage the project and gives a way to pull up my own project homepage (which is also a GIT repository). Not to mention that I pulled the home page with Jekyll in no time with a minimalistic look and feel and of course its HTML 5.

The page may come different in IE8 (comes great with IE9, Chrome or FileFox , looks like border-radius is not working in IE8). Also, used highlight.js which is a great javascript syntax highlighter that works nicely with HTML5 “code” tag and has plenty of styles like ZenBurn, Idea, Vs, GitHub, etc and overall simple to include.

---

Enjoy!!

How to raise event for a mocked call.

mehfuzh — Wed, 06 Oct 2010 10:01:31 GMT

Recently, while i was working with a support issue , i found this interesting piece of test code that i would like to share here. This is actually written by Stefan Lieser (clean code developer from Germany forwarded to me by Jan from Telerik Germany). As the title states, it is to mock a specific event for an expected call.

Now Stefan wants to raise an event from WebClient class of System.Net for a download operation. Therefore, first the WebClient class is mocked during setup.

[SetUp]
public void Setup()
{
webClient = Mock.Create<WebClient>();
}

Next the mocking here takes place in two part. First, DownloadDataCompletedEventArgs is mocked to return an expected data when Result property is get.

var e = Mock.Create<DownloadDataCompletedEventArgs>();
var data = new byte[] { 1, 2, 3 };
Mock.Arrange(() => e.Result).Returns(data);

This is followed by an arrange that will raise the expected event when DownloadDataAsync is invoked.

Mock.Arrange(() => webClient.DownloadDataAsync(Arg.IsAny<Uri>()))
.Raises(() => webClient.DownloadDataCompleted += null, null, e);

Finally, the whole test method ends up like:

[Test]
public void ShouldAssertExepectedDataWhenDownloadIsCompleted()
{
var count = 0;
var e = Mock.Create<DownloadDataCompletedEventArgs>();
var data = new byte[] { 1, 2, 3 };
Mock.Arrange(() => e.Result).Returns(data);
Mock.Arrange(() => webClient.DownloadDataAsync(Arg.IsAny<Uri>()))
.Raises(() => webClient.DownloadDataCompleted += null, null, e);
byte[] exepectedData = null;
webClient.DownloadDataCompleted += delegate(object sender, DownloadDataCompletedEventArgs de)
{
exepectedData = de.Result;
count++;
};
webClient.DownloadDataAsync(new Uri("http://example.de"));
Assert.That(count, Is.EqualTo(1));
Assert.That(exepectedData.Length, Is.EqualTo(data.Length));
}

The above example is done using JustMock SP1. You can further download the code here:

WebClientTest001.zip

Happy coding !!

Mocking SPContext.Current with JustMock

mehfuzh — Mon, 27 Sep 2010 12:42:49 GMT

Today, I happen to find an interesting post on mocking SharePoint context using TypeMock. Being a JustMocker, i thought rather to follow the footsteps and see if can do the same with JustMock. I am no SharePoint expert. Occasionally, I use a Windows 2003 VM with SharePoint server installed which gives me the required flavor of SharePoint for testing SP capabilities of JM.

Anyway, here is the original post that i am going to recycle using JustMock.

http://meronymy.blogspot.com/2010/09/mocking-spcontextcurrent-with-typemock.html

The scenario here is pretty simple. There is a method that returns an URL from the current SPContext which i am going to mock in order to return my expected URL.

Therefore, the class for which the behavior to be mocked is similar to:

public class Site
{
public static string GetHomePageUrl()
{
return SPContext.Current.Site.Url;
}
}

Finally, the test that creates fake instance of SPSite and passes it to the current context:

[TestMethod]
public void ShouldAssertSPSiteUrlWithExpected()
{
var fakeSiteUrl = "http://www.telerik.com";
var fakeSharepointSite = Mock.Create<SPSite>();
// Arrange
Mock.Arrange(() => SPContext.Current.Site).Returns(fakeSharepointSite);
Mock.Arrange(() => fakeSharepointSite.Url).Returns(fakeSiteUrl);
// Act
string actualUrl = Site.GetHomePageUrl();
Assert.AreEqual(fakeSiteUrl, actualUrl);
}

I have used JustMock SP1 for the purpose and thanks to the original author for this sample.

Hope that helps