There are times when you’re unit testing code that is making HTTP calls to a remote server. You could be using a library such as Apache’sHttpClient or Spring’s RestTemplate to do so.
Of course, you don’t want to rely on a remote service for your unit tests. Besides the overhead involved (remember that unit test are supposed to be fast) you simply cannot rely on remote services being available during execution of your tests. You probably are also not able to completely control the response for all of your test scenarios.
Consider the following simplified example.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class ExampleHttpCall { private String serviceUrl; public ExampleHttpCall(String url) { serviceUrl = url; } public String doGet() { RestTemplate restTemplate = new RestTemplate(); ResponseEntity<String> responseEntity = restTemplate.getForEntity(serviceUrl, String.class); String response = responseEntity.getBody(); return response; } } |
How would you go about writing a unit test for the ExampleHttpCall?
You could of course redesign the class in such a manner that an instance of the RestTemplate gets injected into the class:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
@Component public class ExampleHttpCallAlternateVersion { @Resource private RestTemplate restTemplate; private String serviceUrl; public ExampleHttpCallAlternateVersion(String url) { serviceUrl = url; } public String doGet() { ResponseEntity<String> responseEntity = restTemplate.getForEntity(serviceUrl, String.class); String response = responseEntity.getBody(); return response; } } |
The dependency can now be mocked giving you great control. However, this approach also incurs increased complexity due to additional configuration. Furthermore, you could end up with a lot of tedious mocking.
For this simple example using a mock probably is the way to go. But this may not always be the case. If so, another possible approach employs the use of a local test server. As it happens, the Apache HttpClient project provides a LocalTestServer in its tests artifact. If you’re using Maven you can include it by adding the following dependency:
|
1 2 3 4 5 6 7 |
<dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.3.6</version> <classifier>tests</classifier> <scope>test</scope> </dependency> |
Now you can set up the server in your unit test:
|
1 2 3 4 5 6 7 8 9 10 11 |
private LocalTestServer server = new LocalTestServer(null, null); @Before public void setUp() throws Exception { server.start(); } @After public void tearDown() throws Exception { server.stop(); } |
Only starting and stopping a server doesn’t get you very far, of course. So there is one more ingredient that you’ll be needing. You’ll be wanting to register one or more handlers that implement the interface org.apache.http.protocol.HttpRequestHandler, e.g.:
|
1 |
server.register("/foo/*", myHttpRequestHandler); |
The HttpRequestHanlder interface will have you implement the method void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException;
This will method will give you full control over the HTTP response.
So for our original example a minimal unit test could look something like the following code:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 |
public class ExampleHttpCallTest { private ExampleHttpCall exampleHttpCall; private LocalTestServer server = new LocalTestServer(null, null); private HttpRequestHandler myHttpRequestHandler = new HttpRequestHandler() { @Override public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException { response.setEntity(new StringEntity("foobar")); } }; @Before public void setUp() throws Exception { server.start(); server.register("/foo/*", myHttpRequestHandler); String serverUrl = "http:/" + server.getServiceAddress(); exampleHttpCall = new ExampleHttpCall(serverUrl +"/foo/bar"); } @After public void tearDown() throws Exception { server.stop(); } @Test public void test() { String result = exampleHttpCall.doGet(); assertEquals("foobar", result); } } |
That’s all that it takes to get started. From here on you can elaborate by adding test cases for every possible scenario.