This post will focus on basic principles and mechanics of writing Java integration tests for a RESTful API (with a JSON payload). The goal is to provide an introduction to the technologies and to write some tests for basic correctness. The examples will consume the latest version of the GitHub REST API.
For an internal application, this kind of testing will usually run as a late step in a Continuous Integration process, consuming the REST API after it has already been deployed.
When testing a REST resource, there are usually a few orthogonal responsibilities the tests should focus on:
- the HTTP response code
- other HTTP headers in the response
- the payload (JSON, XML)
Each test should only focus on a single responsibility and include a single assertion. Focusing on a clear separation always has benefits, but when doing this kind of black box testing it’s even more important, as the general tendency is to write complex test scenarios in the very beginning.
Another important aspect of the integration tests is adherence to the Single Level of Abstraction Principle – the logic within a test should be written at a high level. Details such as creating the request, sending the HTTP request to the server, dealing with IO, etc should not be done inline but via utility methods.
Testing the HTTP response code
This is a rather simple test, which verifies that a basic happy path is working, without adding to much complexity to the test suite. If, for whatever reason it fails, then there is no need to look at any other test for this URL until this is fixed. Because verifying the response code is one of the most common assertions of the integration testing suite, a custom assertion is used.
Testing other headers of the HTTP response
This ensures that the response when requesting the details of the user is actually JSON. There is a logical progression of the functionality under test – first the response code, to ensure that the request was OK, then the mime type of the request, and only then the verification that the actual JSON is correct.
Testing the JSON payload of the HTTP response
In this case, I know the default representation of GitHub resources is JSON, but usually the
The Utilities for testing
Here are the utilities that enable the tests to remain at a higher level of abstraction:
- decorate the HTTP request with the JSON payload (or directly with the POJO):
- retrieve the JSON payload (or directly the POJO) from the HTTP response:
- conversion utilities to and from java object (POJO) to JSON:
Dependencies
The utilities and tests make use of of the following libraries, all available in Maven central:
Conclusion
This is only one part of what the complete integration testing suite should be. The tests focus on ensuring basic correctness for the REST API, without going into more complex scenarios, discoverability of the API, consumption of different representations for the same resource or other more advanced areas. I will address these in a further post, in the meantime checkout the full project on github.
If you read this far, you should follow me on twitter here.
