Black Box Testing of Spring Boot Microservice is so Easy
When I needed to do prototyping, proof of concept or play with some new technology in free time, starting new project was always a little annoying barrier with Maven. Have to say that setting up Maven project is not hard and you can use Maven Archetypes. But Archetypes are often out of date. Who wants to play with old technologies? So I always end up wiring in dependencies I wanted to play with. Not very productive spent time.
But than Spring Boot came to my way. I fell in love. In last few months I created at least 50 small playground projects, prototypes with Spring Boot. Also incorporated it at work. It’s just perfect for prototyping, learning, microservices, web, batch, enterprise, message flow or command line applications. You have to be dinosaur or be blind not to evaluate Spring Boot for your next Spring project. And when you finish evaluate it, you will go for it. I promise.
I feel a need to highlight how easy is Black Box Testing of Spring Boot microservice. Black Box Testing refers to testing without any poking with application artifact. Such testing can be called also integration testing. You can also perform performance or stress testing way I am going to demonstrate.
Spring Boot Microservice is usually web application with embedded Tomcat. So it is executed as JAR from command line. There is possibility to convert Spring Boot project into WAR artifact, that can be hosted on shared Servlet container. But we don’t want that now. It’s better when microservice has its own little embedded container.
I used existing Spring’s REST service guide as testing target. Focus is mostly on testing project, so it is handy to use this “Hello World” REST application as example. I expect these two common tools are set up and installed on your machine:
- Maven 3
- Git
So we’ll need to download source code and install JAR artifact into our local repository. I am going to use command line to download and install the microservice. Let’s go to some directory where we download source code. Use these commands:
git clone git@github.com:spring-guides/gs-rest-service.git cd gs-rest-service/complete mvn clean install
If everything went OK, Spring Boot microservice JAR artifact is now installed in our local Maven repository. In serious Java development, it would be rather installed into shared repository (e.g. Artifactory, Nexus,… ). When our microservice is installed, we can focus on testing project. It is also Maven and Spring Boot based.
Black box testing will be achieved by downloading the artifact from Maven repository (doesn’t matter if it is local or remote). Maven-dependency-plugin can help us this way:
<plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-dependency-plugin</artifactId> <executions> <execution> <id>copy-dependencies</id> <phase>compile</phase> <goals> <goal>copy-dependencies</goal> </goals> <configuration> <includeArtifactIds>gs-rest-service</includeArtifactIds> <stripVersion>true</stripVersion> </configuration> </execution> </executions> </plugin>
It downloads microservice artifact into target/dependency directory by default. As you can see, it’s hooked to compile phase of Maven lifecycle, so that downloaded artifact is available during test phase. Artifact version is stripped from version information. We use latest version. It makes usage of JAR artifact easier during testing.
Readers skilled with Maven may notice missing plugin version. Spring Boot driven project is inherited from parent Maven project called spring-boot-starter-parent. It contains versions of main Maven plugins. This is one of the Spring Boot’s opinionated aspects. I like it, because it provides stable dependencies matrix. You can change the version if you need.
When we have artifact in our file system, we can start testing. We need to be able to execute JAR file from command line. I used standard JavaProcessBuilder this way:
public class ProcessExecutor {
public Process execute(String jarName) throws IOException {
Process p = null;
ProcessBuilder pb = new ProcessBuilder("java", "-jar", jarName);
pb.directory(new File("target/dependency"));
File log = new File("log");
pb.redirectErrorStream(true);
pb.redirectOutput(Redirect.appendTo(log));
p = pb.start();
return p;
}
}
This class executes given process JAR based on given file name. Location is hard-coded to target/dependency directory, where maven-dependency-plugin located our artifact. Standard and error outputs are redirected to file. Next class needed for testing is DTO (Data transfer object). It is simple POJO that will be used for deserialization from JSON. I use Lombok project to reduce boilerplate code needed for getters, setters, hashCode and equals.
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Greeting {
private long id;
private String content;
}
Test itself looks like this:
public class BlackBoxTest {
private static final String RESOURCE_URL = "http://localhost:8080/greeting";
@Test
public void contextLoads() throws InterruptedException, IOException {
Process process = null;
Greeting actualGreeting = null;
try {
process = new ProcessExecutor().execute("gs-rest-service.jar");
RestTemplate restTemplate = new RestTemplate();
waitForStart(restTemplate);
actualGreeting = restTemplate.getForObject(RESOURCE_URL, Greeting.class);
} finally {
process.destroyForcibly();
}
Assert.assertEquals(new Greeting(2L, "Hello, World!"), actualGreeting);
}
private void waitForStart(RestTemplate restTemplate) {
while (true) {
try {
Thread.sleep(500);
restTemplate.getForObject(RESOURCE_URL, String.class);
return;
} catch (Throwable throwable) {
// ignoring errors
}
}
}
}
It executes Spring Boot microservice process first and wait unit it starts. To verify if microservice is started, it sends HTTP request to URL where it’s expected. The service is ready for testing after first successful response. Microservice should send simple greeting JSON response for HTTP GET request. Deserialization from JSON into our Greeting DTO is verified at the end of the test.
Source code is shared on Github.
