Since it was found that the integration test can be automated by using Maven Failsafe Plugin, it is described as a memorandum.
--Send a request to the application that creates response information with Servlet and filter, and confirm that the expected response is returned.
--Create a Maven project with the Maven archetype below
--Define dependencies in the form below
pom.xml
<dependencies>
<!-- Servlet API -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
<scope>provided</scope>
</dependency>
<!--client-->
<dependency>
<groupId>org.glassfish.jersey.core</groupId>
<artifactId>jersey-client</artifactId>
<version>2.28</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.glassfish.jersey.inject</groupId>
<artifactId>jersey-hk2</artifactId>
<version>2.28</version>
<scope>test</scope>
</dependency>
<!-- JUnit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
--Prepare the following source code
DemoServlet.java
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/demo")
public class DemoServlet extends HttpServlet {
private static final long serialVersionUID = 2564544155028547344L;
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.getWriter().println("body");
}
}
DemoFilter.java
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
@WebFilter("/demo")
public class DemoFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper((HttpServletResponse) response);
wrapper.setHeader("Header-Name", "value");
chain.doFilter(request, wrapper);
}
@Override
public void destroy() {
}
}
--Prepare the following test code
DemoIT.java
import static org.junit.Assert.assertEquals;
import javax.ws.rs.client.ClientBuilder;
import javax.ws.rs.core.Response;
import org.junit.Test;
public class DemoIT {
@Test
public void test() {
//Send request to server
Response response = ClientBuilder.newClient().target("http://localhost:8080/sample-it/demo").request().get();
//Make sure the filter is working as expected
assertEquals("value", response.getHeaderString("Header-Name"));
//Make sure the Servlet is working as expected
assertEquals("body", response.readEntity(String.class).trim());
}
}
later,
--Start application server --Deploy the application to the server --Run test class --Stop the application server
Make the process automatically executed according to the flow of.
For that, use the Failsafe plugin. (The Failsafe plugin is a plugin that can control the test execution. You can define the pre-processing and post-processing of the test execution as described above.) Since you cannot start the server or deploy the application with the Failsafe plugin, Use Apache Tomcat Maven plugin. The following is set.
pom.xml
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>3.0.0-M3</version>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
</execution>
</executions>
</plugin>
<!--Plugin for operating Tomcat-->
<plugin>
<groupId>org.apache.tomcat.maven</groupId>
<artifactId>tomcat7-maven-plugin</artifactId>
<version>2.2</version>
<executions>
<!--Test execution pre-processing-->
<execution>
<id>run</id>
<phase>pre-integration-test</phase>
<goals>
<!--Start Tomcat / Deploy application-->
<goal>run</goal>
</goals>
<!--Settings to enable execution of goals after run-->
<configuration>
<fork>true</fork>
</configuration>
</execution>
<!--Post-test processing-->
<execution>
<id>shutdown</id>
<phase>post-integration-test</phase>
<goals>
<!--Tomcat stopped-->
<goal>shutdown</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
The test can be performed by executing the following command.
mvn clean verify
Spring Boot system may not be worth using Failsafe plugin because it seems that integration test can be automated by using SprintBootTest. However, for applications such as Spring MVC that must be deployed on a server, this plugin can be used to automate it. It seems to be usable when there are many specification changes such as agile.
Recommended Posts