It wouldn’t surprise me if nobody noticed, but I overhauled my NHibernate articles. They are now grouped together in one convenient location.
Maybe when I have time, I will write about all the things I was doing wrong and how I fixed them.
I’m going for a record: internet’s longest blog post title. FNHAMASPDNMVC3CWNUM is the official acronym of this post.
This is the fourth article in a series on using Fluent NHibernate with auto mappings. This time, I will cover unit testing with NUnit and Moq. If you haven’t already, you might want to catch up:
You may be asking yourself, “What is unit testing and why would I want to do it?” If that’s the case, then you should read my previous article: What is unit testing? Dependency injection?
Here’s what the completed project will look like:
If you don’t see the solution at the top of the Solution Explorer, go to the Tools menu > Options. In the Options window, ensure “Show all settings” is checked, then go to Projects and Solutions on the left and check “Always show solution” on the right:
This time, you don’t need to create a new ASP.NET MVC 3 web application. Instead, open the solution from last time, right click on the solution at the top of the Solution Explorer and choose Add > New Project…:
Choose Visual C# Class Library as the project template and name it CastleFluentNHibernateMvc3.Tests. Once the project has been added to the solution, delete the Class1 class. Next, right click on the Tests project in the Solution Explorer and choose Manage NuGet Packages… Search the online gallery for NUnit and install it. Also, search for and install Moq.
Once the packages have been downloaded and installed, add a folder to the Tests project named Controllers, then add a class to the Controllers folder named HomeControllerTest. Make this class public and prepend it with the TestFixture attribute, like so:
[TestFixture]
public class HomeControllerTest { }
Finally, we’re ready to write some tests!
Remember, a unit test typically covers a single unit of code. In the case of a MVC application, that means that each action and method deserves its own unit test. Depending on the complexity, some actions and methods deserve several unit tests. Because our application is so simple, however, our unit tests will be relatively simple as well. As you can tell from the previous step, we will be writing unit tests for the actions in our home controller, starting with the Index action. For convenience, here is the code:
public ActionResult Index()
{
storeRepository.BeginTransaction();
var stores = storeRepository.GetAll();
if ( stores == null || !stores.Any() )
{
storeRepository.Rollback();
return View( "Error" );
}
try
{
storeRepository.Commit();
return View( stores.ToList() );
}
catch
{
storeRepository.Rollback();
return View( "Error" );
}
}
We want to make sure that every time the Index action is called the store repository returns a list of stores and the action returns a view. Testing that the action returns a view is simple enough, so at first we might try something like this:
[Test]
public void Index()
{
// Arrange
var controller = new HomeController();
// Act
var result = controller.Index();
// Assert
Assert.IsInstanceOf<ViewResult>( result );
}
The first thing you’ll notice is that the Tests project requires a reference to CastleFluentNHibernateMvc3, as well as System.Web.Mvc. Once you’ve added these references, Visual Studio will display this compilation error:
'CastleFluentNHibernateMvc3.Controllers.HomeController' does not contain a constructor that takes 0 arguments
The reason we get this error is because we modified the home controller constructor last time to use dependency injection. We did this because we don’t want to use our real repository in our unit tests. Instead, we want to use a fake (or mock) repository. This is where Moq comes in handy, although it does require a little setup before we can use it. First, we need a field to store our fake repository in the HomeControllerTest class, which we need to reset after each test execution:
[TestFixture]
public class HomeControllerTest
{
private Mock<IRepository<Store>> storeRepositoryMock;
[SetUp]
public void Init()
{
storeRepositoryMock = new Mock<IRepository<Store>>();
}
// ...
}
Now, we can pass this value to the home controller constructor in our unit test, exposing its mocked instance with Moq’s Object property:
[Test]
public void Index()
{
// Arrange
var controller = new HomeController( storeRepositoryMock.Object );
// Act
var result = controller.Index();
// Assert
Assert.IsInstanceOf<ViewResult>( result );
}
Eventually, we may end up with lots of injected dependencies in our home controller constructor, so I like to extract the constructor call to a separate method:
[Test]
public void Index()
{
// Arrange
var controller = GetHomeController();
// Act
var result = controller.Index();
// Assert
Assert.IsInstanceOf<ViewResult>( result );
}
private HomeController GetHomeController()
{
return new HomeController( storeRepositoryMock.Object );
}
At this point, if we try running our application, we will get a nasty error. We can’t run a class library directly. There are two options for running NUnit tests:
Whichever option you choose, our test should pass with flying colors! Unfortunately, there’s a problem. We’ve made sure our action returns a view, but the view it’s returning is actually the Error view. We can verify this by debugging our test. In Visual Studio, go to Debug > Attach to process… find nunit-agent.exe (if you chose option one above) or VisualNUnitRunner.exe (if you chose option two) in the list of processes and click the Attach button.
Now, we can put a breakpoint in our test and take a closer look at our result. Sure enough, the ViewName is “Error”:
We could have caught this sooner by testing that the view is getting the right model. In this case, our view should be getting a list of stores as its model. We would test for that as follows:
[Test]
public void Index()
{
// Arrange
var controller = GetHomeController();
// Act
var result = controller.Index();
// Assert
Assert.IsInstanceOf<ViewResult>( result );
var view = (ViewResult)result;
Assert.IsInstanceOf<List<Store>>( view.Model );
}
If we run our test again, it should fail. NUnit will display the following error:
CastleFluentNHibernateMvc3.Tests.Controllers.HomeControllerTest.Index: Expected: instance of <System.Collections.Generic.List`1[CastleFluentNHibernateMvc3.Models.Store]> But was: null
Let’s put a breakpoint in our home controller this time and find out what’s going on. Doing this, we can see that our store repository is not returning any stores. And why should it? Remember, it’s a fake repository! We have to tell our fake repository what to do when it’s queried for a list of stores. But before we do that, make a copy of the Index test and rename it to Index_NoStoresFound. With a little modification, this test can still be useful:
[Test]
public void Index_NoStoresFound()
{
// Arrange
var controller = GetHomeController();
// Act
var result = controller.Index();
// Assert
Assert.IsInstanceOf<ViewResult>( result );
var view = (ViewResult)result;
Assert.AreEqual( "Error", view.ViewName );
}
Keeping this test will ensure that the Index action always returns the Error view when our store repository doesn’t return any stores. If this test ever fails (for instance, because the Index action returns the Index view), then something is wrong with our error handling.
Now, let’s fix our Index test. We can use Moq’s Setup method to tell Moq what to return when we ask it for a list of stores:
[Test]
public void Index()
{
// Arrange
var controller = GetHomeController();
var stores = new List<Store>
{
new Store()
};
storeRepositoryMock.Setup( s => s.GetAll() )
.Returns( stores.AsQueryable() )
.Verifiable();
// Act
var result = controller.Index();
// Assert
storeRepositoryMock.Verify();
Assert.IsInstanceOf<ViewResult>( result );
var view = (ViewResult)result;
Assert.IsInstanceOf<List<Store>>( view.Model );
}
Notice that we can return any list of stores we want, so long as we convert it to an IQueryable because that’s what Moq expects to get back from the GetAll method of our store repository.
That concludes my series on using Fluent NHibernate with auto mappings. As always, let me know if you have any questions or comments. Good luck!
The title of this article is so long, I briefly considered using an acronym. Unfortunately, FNHAMASPDNMVC3CW doesn’t communicate much except to the nerdiest of nerds.
This is the third article in a series on using Fluent NHibernate with auto mappings. The first one demonstrated its basic functionality in a console application, and the second one showed how to convert the first one into an ASP.NET MVC 3 application. This article will cover how to use Castle Windsor for dependency injection, which is important for unit testing. I won’t include any unit tests in this article, but will lay the foundation that will make unit testing possible for my next article.
Much of the code below is directly from the Castle Windsor documentation, which really is exceptional.
Here’s what the completed project will look like:
Once again, create a new ASP.NET MVC 3 web application in Microsoft Visual Studio 2010 and use the empty project template. This time, call your project CastleFluentNHibernateMvc3. Next, right click on the project in the Solution Explorer and choose Manage NuGet Packages… Search the online gallery for Fluent NHibernate and install it. We also need Castle Windsor, so search for that and install it too.
EDIT 12/18/2012: You can get the source code on GitHub.
Once you’ve installed the packages, copy the Controllers, Models and Repositories folders from our previous project to our new project. Also, copy the Views/Home folder to our new project. Make sure you change the namespace in each file accordingly.
The first thing we need is a Windsor controller factory. The Windsor controller factory overrides two methods of the default MVC controller factory and is central to how Castle Windsor resolves controller dependencies. Create this class in a new Windsor directory at the root level of the project:
namespace CastleFluentNHibernateMvc3.Windsor
{
public class WindsorControllerFactory : DefaultControllerFactory
{
private readonly IKernel kernel;
public WindsorControllerFactory( IKernel kernel )
{
this.kernel = kernel;
}
public override void ReleaseController( IController controller )
{
kernel.ReleaseComponent( controller );
}
protected override IController GetControllerInstance( RequestContext requestContext, Type controllerType )
{
if (controllerType == null)
{
throw new HttpException( 404, string.Format( "The controller for path '{0}' could not be found.", requestContext.HttpContext.Request.Path ) );
}
return (IController)kernel.Resolve( controllerType );
}
}
}
Next, we need to tell MVC to use the Windsor controller factory instead of the default one. To do that, we’ll add a couple of methods to the MvcApplication class, which resides in the Global.asax.cs file at the root of the project:
namespace CastleFluentNHibernateMvc3
{
public class MvcApplication : System.Web.HttpApplication
{
private static IWindsorContainer container;
private static void BootstrapContainer()
{
container = new WindsorContainer()
.Install( FromAssembly.This() );
var controllerFactory = new WindsorControllerFactory( container.Kernel );
ControllerBuilder.Current.SetControllerFactory( controllerFactory );
}
// RegisterGlobalFilters and RegisterRoutes methods go here...
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters( GlobalFilters.Filters );
RegisterRoutes( RouteTable.Routes );
BootstrapContainer();
}
protected void Application_End()
{
container.Dispose();
}
}
}
Now, we need to tell Windsor about our controllers, including where they reside and how to configure them. In other words, we’ll “register” our controllers with the Windsor “container.” We do this using an “installer.” Create this class in your Windsor directory:
namespace CastleFluentNHibernateMvc3.Windsor
{
public class ControllersInstaller : IWindsorInstaller
{
public void Install( IWindsorContainer container, IConfigurationStore store )
{
container.Register( Classes.FromThisAssembly()
.BasedOn<IController>()
.LifestyleTransient() );
}
}
}
Next, create a new class named PersistenceFacility in your Windsor directory, and move the CreateSessionFactory, CreateDbConfig, CreateMappings and UpdateSchema methods of our NHibernateSessionPerRequest class there:
namespace CastleFluentNHibernateMvc3.Windsor
{
public class PersistenceFacility : AbstractFacility
{
protected override void Init()
{
Kernel.Register(
Component.For<ISessionFactory>()
.UsingFactoryMethod( CreateSessionFactory ),
Component.For<ISession>()
.UsingFactoryMethod( OpenSession )
.LifestylePerWebRequest() );
}
private static ISession OpenSession( IKernel kernel )
{
return kernel.Resolve<ISessionFactory>().OpenSession();
}
// CreateSessionFactory, CreateDbConfig, CreateMappings and UpdateSchema methods go here...
}
}
In the Init method, we’re telling Castle Windsor what to do when it encounters a dependency on ISessionFactory or ISession. If we ask for an ISession, it will resolve the dependency using the OpenSession method. Notice that this method needs an ISessionFactory, which Castle Windsor will resolve by calling CreateSessionFactory.
We’re also telling Castle Windsor that an ISession instance should be bound to a web request. Since we aren’t specifying a lifestyle for ISessionFactory, the default value of singleton will be used. In other words, only one session factory will be instantiated during the lifetime of our app, and it will hang around in memory until our app dies. This is basically the same thing we did before with our custom HTTP module, except the dependencies will only be resolved when needed. We can verify this by placing breakpoints in the OpenSession and CreateSessionFactory methods and running the app.
Now, we need to register our persistence facility with the Windsor container. Again, we do this using an installer. Create this class in your Windsor directory:
namespace CastleFluentNHibernateMvc3.Windsor
{
public class PersistenceInstaller : IWindsorInstaller
{
public void Install( IWindsorContainer container, IConfigurationStore store )
{
container.AddFacility<PersistenceFacility>();
}
}
}
Next, we need to add a few more methods to our repository in order to manage NHibernate transactions: BeginTransaction, Commit and Rollback. Previously, we created a custom HTTP module to take care of these operations at the beginning and end of each web request. This time, we’ll manage each transaction ourselves, gaining more control and performance in the process. The GetAll, Get, SaveOrUpdateAll and SaveOrUpdate methods will stay the same:
namespace CastleFluentNHibernateMvc3.Repositories
{
public interface IRepository<T>
{
void BeginTransaction();
void Commit();
void Rollback();
// GetAll, Get, SaveOrUpdateAll and SaveOrUpdate signatures go here...
}
}
namespace CastleFluentNHibernateMvc3.Repositories
{
public class Repository<T> : IRepository<T>
{
private readonly ISession session;
public Repository( ISession session )
{
this.session = session;
}
public void BeginTransaction()
{
session.BeginTransaction();
}
public void Commit()
{
session.Transaction.Commit();
}
public void Rollback()
{
session.Transaction.Rollback();
}
// GetAll, Get, SaveOrUpdateAll and SaveOrUpdate implementations go here...
}
}
Notice that the repository constructor has been modified to accept an argument of type ISession. This is called dependency injection, and its benefits will become more clear when we use it in our home controller.
But first, we need to register our repositories with the Windsor container. How do we do that? Right! (You did say “use an installer,” right? Good.) Create this class in your Windsor directory:
namespace CastleFluentNHibernateMvc3.Windsor
{
public class RepositoriesInstaller : IWindsorInstaller
{
public void Install( IWindsorContainer container, IConfigurationStore store )
{
container.Register( Classes.FromThisAssembly()
.Where( Component.IsInSameNamespaceAs<Repository<Store>>() )
.WithService.DefaultInterfaces()
.LifestyleTransient() );
}
}
}
Now, modify the home controller constructor as follows:
// Constructs our home controller
public HomeController( IRepository<Store> storeRepository )
{
this.storeRepository = storeRepository;
}
The benefit of using dependency injection here is that we no longer have a dependency on a concrete repository. The home controller doesn’t care what the repository does with our data, as long as it implements IRepository. This way, we can change our repository methods without changing our controller actions. Later, when we write unit tests for our controller actions, we’ll be able to create an instance of the home controller using a fake repository so that our tests don’t touch our data.
Because we are no longer using a custom HTTP module to manage NHibernate transactions, we need to call the BeginTransaction method of our repository whenever we get data from or save data to the database. We also need to call the Commit method to flush the NHibernate session, and call the Rollback method if any errors occur:
// Gets all the stores from our database and returns a view that displays them
public ActionResult Index()
{
storeRepository.BeginTransaction();
var stores = storeRepository.GetAll();
if ( stores == null || !stores.Any() )
{
storeRepository.Rollback();
return View( "Error" );
}
try
{
storeRepository.Commit();
return View( stores.ToList() );
}
catch
{
storeRepository.Rollback();
return View( "Error" );
}
}
// Gets and modifies a single store from our database
public ActionResult Test()
{
storeRepository.BeginTransaction();
var barginBasin = storeRepository.Get( s => s.Name == "Bargin Basin" ).SingleOrDefault();
if (barginBasin == null)
{
storeRepository.Rollback();
return View( "Error" );
}
try
{
barginBasin.Name = "Bargain Basin";
storeRepository.Commit();
return RedirectToAction( "Index" );
}
catch
{
storeRepository.Rollback();
return View( "Error" );
}
}
// Adds sample data to our database
public ActionResult Seed()
{
// Create a couple of Stores each with some Products and Employees
var barginBasin = new Store { Name = "Bargin Basin" };
var superMart = new Store { Name = "SuperMart" };
var potatoes = new Product { Name = "Potatoes", Price = 3.60 };
var fish = new Product { Name = "Fish", Price = 4.49 };
var milk = new Product { Name = "Milk", Price = 0.79 };
var bread = new Product { Name = "Bread", Price = 1.29 };
var cheese = new Product { Name = "Cheese", Price = 2.10 };
var waffles = new Product { Name = "Waffles", Price = 2.41 };
var daisy = new Employee { FirstName = "Daisy", LastName = "Harrison" };
var jack = new Employee { FirstName = "Jack", LastName = "Torrance" };
var sue = new Employee { FirstName = "Sue", LastName = "Walkters" };
var bill = new Employee { FirstName = "Bill", LastName = "Taft" };
var joan = new Employee { FirstName = "Joan", LastName = "Pope" };
// Add Products to the Stores
// The Store-Product relationship is many-to-many
AddProductsToStore( barginBasin, potatoes, fish, milk, bread, cheese );
AddProductsToStore( superMart, bread, cheese, waffles );
// Add Employees to the Stores
// The Store-Employee relationship is one-to-many
AddEmployeesToStore( barginBasin, daisy, jack, sue );
AddEmployeesToStore( superMart, bill, joan );
storeRepository.BeginTransaction();
try
{
storeRepository.SaveOrUpdateAll( barginBasin, superMart );
storeRepository.Commit();
return RedirectToAction( "Index" );
}
catch
{
storeRepository.Rollback();
return View( "Error" );
}
}
You can now run your application. If you get any errors, make sure you have an empty database and a valid connection string. In that case, see my previous article for instructions on setting that up. If all you see is the word “Index,” it’s because you don’t have any data in your database yet. In your browser, navigate to the Seed action of the home controller. You should then see “Index” at the top followed by a list of stores, products and employees.
Next time, we’ll look as using NUnit and Moq for unit testing. Surprisingly, it’s relatively easy! As always, let me know if you have any difficulties. Good luck!
DaveDen 