Ubiquitous Technology

Last time I showed one alternative way of testing routes using Moq and NUnit. It works well but it adds code bloat. The MVC Contrib project has a nice set of test helper methods which simplifies it.

It assumes you use NUnit and RhinoMocks. It also assumes you set your routes in the ASP.NET MVC RouteCollection object. If you reference your routes in your test project like I do, then this shouldn't be a big issue either.

Our previous test method looked like this:

[Test]
public void Test_If_Product_Route_Returns_Expected_Result()
{
 RouteCollection routes = new RouteCollection();
 POC_Stuff.MvcApplication.RegisterRoutes(routes);

 var context = MvcMockHelpers.FakeHttpContext("~/products/videogames/nintendo");
 RouteData routeData = routes.GetRouteData(context);

 Assert.That(routeData.Values["category"].ToString() == "videogames");
 Assert.That(routeData.Values["subcategory"].ToString() == "nintendo");
 Assert.That(routeData.Values["controller"].ToString() == "Catalog");
}

The new test method using the MVC Contrib test helpers will look like this:

[Test]
public void Test_If_Product_Route_Returns_Expected_Result()
{
  "~/products/videogames/nintendo".ShouldMapTo(x => x.Index("videogames", "nintendo"));
}

I don't think you can make it much more compact! It will even do the assertions for you, the test helper will assert the route data, the controller, the method and its parameters. If you want to make additional asserts, that is possible as well since it returns a RouteData object from the System.Web.Routing namespace.

The main test class in the MVC Contrib project is called RouteTestingExtensionsand the method that will assert the route for us is called ShouldMapTo and the code as of when this post was written looks like this:

/// 

/// Asserts that the route matches the expression specified.  Checks controller, action, and any method arguments
/// into the action as route values.
/// 

/// The controller.
/// The routeData to check
/// The action to call on TController.
public static RouteData ShouldMapTo(this RouteData routeData, Expression> action)
 where TController : Controller
{         
 routeData.ShouldNotBeNull("The URL did not match any route");

 //check controller
 routeData.ShouldMapTo();

 //check action
 var methodCall = (MethodCallExpression) action.Body;
 string actualAction = routeData.Values.GetValue("action").ToString();
 string expectedAction = methodCall.Method.Name;
 actualAction.AssertSameStringAs(expectedAction);
          
 //check parameters
 for (int i = 0; i < methodCall.Arguments.Count; i++)
 {
    string name = methodCall.Method.GetParameters()[i].Name;
    object value = null;

    switch ( methodCall.Arguments[ i ].NodeType )
    {
        case ExpressionType.Constant:
           value = ( (ConstantExpression)methodCall.Arguments[ i ] ).Value;
           break;
         case ExpressionType.MemberAccess:
           value = Expression.Lambda(methodCall.Arguments[ i ]).Compile().DynamicInvoke();
           break;
    }   
    value = (value == null ? value : value.ToString());
    routeData.Values.GetValue(name).ShouldEqual(value,"Value for parameter did not match");

These doesn't seem to be too many developers in the community talking about this great test helper but I hope you see the value it adds.