Applications get data from lots
of different sources.
The most common is to get data from a database or a web service. Typically, we encapsulate calls to a database in a Repository object and we create some sort
of IRepository interface as an abstraction to decouple between layers and enable easier unit testing by leveraging faking and mocking. This works great for database interaction. However, when consuming a RESTful web service, this is is not always
the best approach.
The WCF Web APIs that are available on CodePlex (current drop is Preview 3) provide a variety
of features to make building HTTP REST services more robust. When you download
the latest bits, you’ll also find a new HttpClient which has been updated for .NET 4.0 as compared to
the one that shipped for 3.5 in
the original REST Starter Kit.
The HttpClient currently provides
the best API for consuming REST services on
the .NET platform and
the WCF Web APIs provide a number
of extension methods which extend HttpClient and make it even easier to use. Let’s say you have a client application that is consuming an HTTP service – this could be Silverlight, WPF, or any UI technology but for my example I’ll use an MVC application: 1: using System;
2: using System.Net.Http;
3: using System.Web.Mvc;
4: using FakeChannelExample.Models;
5: using Microsoft.Runtime.Serialization;
6:
7: namespace FakeChannelExample.Controllers
8: {
9: public class HomeController : Controller
10: {
11: private readonly HttpClient httpClient;
12:
13: public HomeController(HttpClient httpClient)
14: {
15: this.httpClient = httpClient;
16: }
17:
18: public ActionResult Index()
19: {
20: var response = httpClient.Get("Person(1)");
21: var person = response.Content.ReadAsDataContract<Person>();
22:
23: this.ViewBag.Message = person.FirstName + " " + person.LastName;
24:
25: return View();
26: }
27: }
28: }
On line #20
of the code above you can see I’m performing an HTTP GET request to a Person resource exposed by an HTTP service. On line #21, I use
the ReadAsDataContract()
extension method provided by
the WCF Web APIs to serialize to a Person object. In this example,
the HttpClient is being passed into
the constructor by MVC’s dependency resolver – in this case, I’m using StructureMap as an IoC and my StructureMap initialization code looks like this:
1: using StructureMap;
2: using System.Net.Http;
3:
4: namespace FakeChannelExample
5: {
6: public static class IoC
7: {
8: public static IContainer Initialize()
9: {
10: ObjectFactory.Initialize(x =>
11: {
12: x.For<HttpClient>().Use(() => new HttpClient("http://localhost:31614/"));
13: });
14: return ObjectFactory.Container;
15: }
16: }
17: }
My controller code currently depends on a concrete instance
of the HttpClient. Now I *could* create some sort
of interface and wrap
the HttpClient in this interface and use that object inside my controller instead – however, there are a few why reasons that is not desirable:
For one thing,
the API provided by
the HttpClient provides nice features for dealing with HTTP services. I don’t really *want* these to look like C# RPC method calls – when HTTP services have REST features, I may want to inspect HTTP response headers and hypermedia contained within
the message so that I can make intelligent decisions as to what to do next in my workflow (although I don’t happen to be doing these things in my example above) – this type
of workflow is common in hypermedia REST scenarios. If I just encapsulate HttpClient behind some IRepository interface and make it look like a C# RPC method call, it will become difficult to take advantage
of these types
of things.
Second, it could get pretty mind-numbing to have to create interfaces all over
the place just to wrap
the HttpClient. Then you’re probably going to have to hard-code HTTP knowledge into your code to formulate requests rather than just “following
the links” that
the hypermedia in a message might provide.
Third, at first glance it might appear that we need to create an interface to facilitate unit testing, but actually it’s unnecessary. Even though
the code above is dependent on a concrete type, it’s actually very easy to fake
the data in a unit test.
The HttpClient provides a Channel property (of type HttpMessageChannel) which allows you to create a fake message channel which can be leveraged in unit testing. In this case, what I want is to be able to write a unit test that just returns fake data. I also want this to be as re-usable as possible for my unit testing. I want to be able to write a unit test that looks like this:
1: [TestClass]
2: public class HomeControllerTest
3: {
4: [TestMethod]
5: public void Index()
6: {
7: // Arrange
8: var httpClient = new HttpClient("http://foo.com");
9: httpClient.Channel = new FakeHttpChannel<Person>(new Person { FirstName = "Joe", LastName = "Blow" });
10:
11: HomeController controller = new HomeController(httpClient);
12:
13: // Act
14: ViewResult result = controller.Index() as ViewResult;
15:
16: // Assert
17: Assert.AreEqual("Joe Blow", result.ViewBag.Message);
18: }
19: }
Notice on line #9, I’m setting
the Channel property
of the HttpClient to be a fake channel. I’m also specifying
the fake object that I want to be in
the response on my “fake” Http request. I don’t need to rely on any mocking frameworks to do this. All I need is my FakeHttpChannel.
The code to do this is not complex:
1: using System;
2: using System.IO;
3: using System.Net.Http;
4: using System.Runtime.Serialization;
5: using System.Threading;
6: using FakeChannelExample.Models;
7:
8: namespace FakeChannelExample.Tests
9: {
10: public class FakeHttpChannel<T> : HttpClientChannel
11: {
12: private T responseObject;
13:
14: public FakeHttpChannel(T responseObject)
15: {
16: this.responseObject = responseObject;
17: }
18:
19: protected override HttpResponseMessage Send(HttpRequestMessage request, CancellationToken cancellationToken)
20: {
21: return new HttpResponseMessage()
22: {
23: RequestMessage = request,
24: Content = new StreamContent(this.GetContentStream())
25: };
26: }
27:
28: private Stream GetContentStream()
29: {
30: var serializer = new DataContractSerializer(typeof(T));
31: Stream stream = new MemoryStream();
32: serializer.WriteObject(stream, this.responseObject);
33: stream.Position = 0;
34: return stream;
35: }
36: }
37: }
The HttpClientChannel provides a Send() method which you can override to return any HttpResponseMessage that you want. You can see I’m using
the DataContractSerializer to serialize
the object and write it to a stream. That’s all you need to do.
In
the example above,
the only thing I’ve chosen to do is to provide a way to return different response objects. But there are many more features you could add to your own re-usable FakeHttpChannel. For example, you might want to provide
the ability to add HTTP headers to
the message. You might want to use a different serializer other than
the DataContractSerializer. You might want to provide custom hypermedia in
the response as well as just an object or set HTTP response codes. This list goes on.
This is
the just one example
of the really cool features being added to
the next version
of WCF to enable various HTTP scenarios.
The code sample for this post can be downloaded here.
