Demo
In this demo, we're going to test a simple application which only has
one endpoint : "/sum". The Route Handler
associated with this endpoint is going to receive two numbers, will
add them up, and will return the result as a
Json object. Here's the response we would be expecting from the "/sum" endpoint when sending the
parameters "first" = "1" and "second" = "2" :
{
"result": "3"
}
You can download that Sum application [.zip]
if you want to try it by yourself or look at its code directly.
First, let's have a quick look at how the demo application is bootstrapped :
public class App {
public static void main(String[] args) {
Spincast.configure()
.module(new AppModule())
.init(args);
}
@Inject
protected void init(DefaultRouter router,
AppController ctrl,
Server server) {
router.POST("/sum").save(ctrl::sumRoute);
server.start();
}
}
The interesting lines to note here are 4-6 : we
use the standard Bootstrapper to start
everything! We'll see that, without modifying
this bootstrapping process, we'll still be able to tweak the Guice context, to mock
some components.
Let's write a first test class :
public class SumTest extends IntegrationTestAppDefaultContextsBase {
@Override
protected void initApp() {
App.main(null);
}
@Override
protected AppTestingConfigInfo getAppTestingConfigInfo() {
return new AppTestingConfigInfo() {
@Override
public Class<? extends SpincastConfig> getSpincastConfigTestingImplementationClass() {
return SpincastConfigTestingDefault.class;
}
@Override
public Class<?> getAppConfigTestingImplementationClass() {
return null;
}
@Override
public Class<?> getAppConfigInterface() {
return null;
}
};
}
@Inject
private JsonManager jsonManager;
@Test
public void validRequest() throws Exception {
// TODO...
}
}
Explanation :
- 2 : Our test class extends IntegrationTestAppDefaultContextsBase. This class is a child of SpincastTestBase and therefore allows us to use all the tools Spincast testing provides. Note there are other base classes you can extend, we're going to look at them soon.
-
4-7 : The base class we are using requires that we implement the
initApp()method. In this method we have to start the application to test. This is easily done by calling itsmain(...)method. -
9-28 : We also have to implement the
getAppTestingConfigInfo()method. This is to provide Spincast informations about the configurations we want to use when running this test class. Have a look at the Testing configurations section for more information! - 30-31 : Here we can see Spincast testing in action! Our test class has now full access to the Guice context of the application. Therefore, we can inject any component we need. In this test class, we are going to use the JsonManager.
- 33-36 : a first test to implement.
As you can see, simply by extending IntegrationTestAppDefaultContextsBase, and by starting our
application using its main(...) method, we can write integration tests targeting
our running application, and we can use any components from its Guice context. There is some boilerplate
code to write though (to implement the getAppTestingConfigInfo() method, for example), and this why
you would in general create a base class to serve as a parent for all your test classes!
Let's implement our first test. We're going to validate that the "/sum" endpoint
of the application works properly :
@Test
public void validRequest() throws Exception {
HttpResponse response = POST("/sum").addEntityFormDataValue("first", "1")
.addEntityFormDataValue("second", "2")
.addJsonAcceptHeader()
.send();
assertEquals(HttpStatus.SC_OK, response.getStatus());
assertEquals(ContentTypeDefaults.JSON.getMainVariationWithUtf8Charset(),
response.getContentType());
String content = response.getContentAsString();
assertNotNull(content);
JsonObject resultObj = this.jsonManager.fromString(content);
assertNotNull(resultObj);
assertEquals(new Integer(3), resultObj.getInteger("result"));
assertNull(resultObj.getString("error", null));
}
Explanation :
- 4-7 : the Spincast HTTP Client plugin is fully integrated into Spincast testing utilities. This allows us to very easily send requests to test our application. We don't even have to configure the host and port to use : Spincast will automatically find and use those of our application.
-
9-11 : we validate that the response is a success
(
"200") and that the content-type is the expected"application/json". -
13-14 : we get the content of the response as a String and we validate that
it is not
null. -
16-17 : we use the
JsonManager(injected previously) to convert the content to a JsonObject. - 19-20 : we finally validate the result of the sum and that no error occured.
Note that we could also have retrieved the content of the response as a JsonObject
directly, by using response.getContentAsJsonObject() instead of
response.getContentAsString(). But we wanted to demonstrate the use of
an injected component, so bear with us!
If you look at the source
of this demo, you'll see two more tests in that first test class : one that
tests the endpoint when a parameter is missing, and one that tests the endpoint when the sum overflows
the maximum Integer value.
Let's now write a second test class. In this one, we are going to show how
easy it is to replace a binding, to mock a component.
Let's say we simply want to test that the responses returned by our application
are gzipped. We may not care about the actual result of calling the
"/sum" endpoint, so we are going to "mock" it. This is a simple
example, but the process involved is similar if you need to mock a
data source, for example.
Our second test class will look like this :
public class ResponseIsGzippedTest extends IntegrationTestAppDefaultContextsBase {
@Override
protected void initApp() {
App.main(null);
}
public static class AppControllerTesting extends AppControllerDefault {
@Override
public void sumRoute(DefaultRequestContext context) {
context.response().sendPlainText("42");
}
}
@Override
protected SpincastPluginThreadLocal createGuiceTweaker() {
SpincastPluginThreadLocal guiceTweaker = super.createGuiceTweaker();
guiceTweaker.module(new SpincastGuiceModuleBase() {
@Override
protected void configure() {
bind(AppController.class).to(AppControllerTesting.class).in(Scopes.SINGLETON);
}
});
return guiceTweaker;
}
@Test
public void isGzipped() throws Exception {
// TODO...
}
}
Explanation :
- 2 : this test class also extends IntegrationTestAppDefaultContextsBase.
- 4-7 : we start our application.
-
9-15 : we create a mock controller by extending
the original one and replacing the
sumRoute(...)Route Handlerso it always returns "42". -
17-31 : we override the
createGuiceTweaker()method to add a custom Guice module to the Guice Tweaker . As we will see in the next section, the Guice Tweaker allows us to modify the Guice context of our application, without touching its code directly. Here, we change theAppControllerbinding so it uses our mock controller implementation instead of the default one.
And let's write the test itself :
@Test
public void isGzipped() throws Exception {
HttpResponse response = POST("/sum").addEntityFormDataValue("toto", "titi")
.addJsonAcceptHeader()
.send();
assertTrue(response.isGzipped());
assertEquals(HttpStatus.SC_OK, response.getStatus());
assertEquals(ContentTypeDefaults.TEXT.getMainVariationWithUtf8Charset(),
response.getContentType());
assertEquals("42", response.getContentAsString());
}
Explanation :
- 4-6 : We can send pretty much anything here as the parameters since the controller is mocked : they won't be validated.
- 8 : We validate that the response was gzipped.
- 10-13 : just to make sure our tweaking is working properly.
Being able to change bindings like this is very powerful : you are testing your real application,
as it is bootstrapped, without even changing its code. All is done indirectly, using
the Guice Tweaker.