Using System.Web.Abstractions in Your WebForms Apps

With the release of .net 3.5 SP1 we now have a new assembly called System.Web.Abstractions. In this namespace you will find several new classes:

Many of you are familiar with ASP.NET MVC and already know what these classes are for, but for those that are not, these are wrapper classes around most of the static HttpContext rooted classes in asp.net. These classes allow for you to Mock out the HttpContext, Request, Response, etc… They also provide base classes which allow for you to create your own custom implementation or stubs, and override different methods as you see fit.

What most people may not realize is that these classes aren’t limited to being used in your ASP.NET MVC applications, and they don’t require you to do anything special other than to be a bit more rigorous about retrieving your HttpContext objects.

So, lets say that I want to start using the HttpContextBase in order to wrap my HttpContext so that I can make my application easier to test. First I would declare a class which I am going to start using called HttpContextFactory:

public static class HttpContextFactory
{
    [ThreadStatic]
    private static HttpContextBase mockHttpContext;

    public static void SetHttpContext(HttpContextBase httpContextBase)
    {
        mockHttpContext = httpContextBase;
    }

    public static void ResetHttpContext()
    {
        mockHttpContext = null;
    }
    
    public static HttpContextBase GetHttpContext()
    {
        if (mockHttpContext != null)
        {                
            return mockHttpContext;    
        }

        if (HttpContext.Current != null)
        {
            return new HttpContextWrapper(HttpContext.Current);    
        }
        return null;
    }
}

This class has a method called "GetHttpContext" which returns an HttpContextBase. As you can see, we also have a "SetHttpContext" and "ResetHttpContext". Inside of your application, if you wanted to use the HttpContext, then you could access it like this:

HttpContextBase httpContextBase = HttpContextFactory.GetHttpContext();
var page = httpContextBase.Handler as Page;

And all is well. The httpContextBase should look exactly like the normal HttpContext class when you interact with it. The difference now is that when you are writing your tests, you can create a mock httpContextBase and use that to test your UI components:

var mockHttpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
var page = new Page();
mockHttpContext.Expect(h => h.Handler).Returns(page);

Here we are using Moq to mock out our http context and then setting an expectation when the "Handler" property is accessed to return a page that we have instantiated. If you aren’t familiar with using mocks, then you might check out their quick-start.

Here we are actually declaring a new Page class and using it, which means that we are still going to be quite limited in what we can do since we aren’t running inside of an actual request. This can help a lot though if you have created a base page class which some of your custom controls depend on, or if you have methods which need to write out to the HttpContext response and you need to intercept their calls.

I will now show you a fake test which will mimic some component using our http context factory and using it to write our to the response:

[Test]
public void FakeTest()
{
    // create our mocks
    var mockHttpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
    var mockHttpResponse = new Mock<HttpResponseBase>();
    
    //set our expectations
    string output = "";            
    mockHttpContext.Expect(mhc => mhc.Response).Returns(mockHttpResponse.Object);
    mockHttpResponse.Expect(mhr => mhr.Write(It.IsAny<string>())).Callback<string>(s => output += s);
    
    //set the mock context
    HttpContextFactory.SetHttpContext(mockHttpContext.Object);

    // This would be an external component writing to the response
    HttpContextBase httpContext = HttpContextFactory.GetHttpContext();
    httpContext.Response.Write("Write test!");
    httpContext.Response.Write("Write Some More!");

    //assert what was written
    Assert.AreEqual("Write test!Write Some More!", output);
}

Not too insanely difficult, but not easy either. We are creating the mocks, then setting some expectations on what will be called and what we return from those calls. The second expectation line has a Callback which simply concatenates what is passed to "Response.Write" into a local variable called "output". Then we just set our mock context in the factory.

Next there are three lines where we pull the HttpContext out and call "Response.Write" and then we can check what was written out. Normally we would not be calling these lines directly, instead they would be inside of a component that we are testing. Next we just assert our output against what the component should have written.

There is a lot of overhead in what we are doing here, but we could easily abstract away a good amount of this into helper classes:

[Test]
public void FakeTest()
{
    Mock<HttpResponseBase> mockHttpResponse = GetMockHttpResponse();
    string output = "";
    mockHttpResponse.Expect(mhr => mhr.Write(It.IsAny<string>())).Callback<string>(s => output += s);

    var testComponent = new TestComponent();
    testComponent.Render();
    
    //assert what was written
    Assert.AreEqual("Test component output!", output);
}

So there! Our "GetMockHttpResponse" method would look like this:

public Mock<HttpResponseBase> GetMockHttpResponse()
{
    // create our mocks
    var mockHttpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
    var mockHttpResponse = new Mock<HttpResponseBase>();

    //set our expectations            
    mockHttpContext.Expect(mhc => mhc.Response).Returns(mockHttpResponse.Object);
    
    //set the mock context
    HttpContextFactory.SetHttpContext(mockHttpContext.Object);

    return mockHttpResponse;
}

I hope this can help you get started down the road of testing custom components in asp.net web applications by leveraging the System.Web.Abstractions assembly. Thanks!