Spring Boot With Cucumber Integration - spring

Question

I have been working on a spring boot application I would like to test with cucumber (for business driven development). I can successfully run the cucumber tests with my code, or I can boot the spring context, but I cannot seem to figure out a way to do both at once. I have looked around, and found a few tutorials (such as https://medium.com/#bcarunmail/set-up-and-run-cucumber-tests-in-spring-boot-application-d0c149d26220) that all seem to have this working. I followed the same premise as them, that is, (1) having one class that loads the spring context, (2) having another class be the entry point for discovering the cucumber tests, and finally, (3) a class containing the step definitions that extends the class with the context referenced in number one.
Here are my classes
import org.junit.ClassRule;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.util.TestPropertyValues;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;
import org.testcontainers.containers.MySQLContainer;
import com.connor.Application;
/**
* This class should take care of initializing the test container (for the database) and populating it using the
* sql files that run against the actual db, in the actual order they execute. This guarantees these will run
* before we even use a staging region. Once the database is created, it boots the spring context the spring context
* and configures the environment with the db-related info from the test container.
*
* When ran alone, this test successfully performs the above steps and can be used for integration tests.
* However, when this class is extended by other classes (the glue code classes), it does not boot the spring context
* and hence do not work for integration tests.
* #author connor
*
*/
#RunWith(SpringRunner.class)
#SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, classes = Application.class)
#ContextConfiguration(initializers = SpringContextConfigForCukeUsage.Initializer.class)
//#Ignore //even with this, still need a test method to compile
public /* abstract */ class SpringContextConfigForCukeUsage { //with or without abstract, this doesn't seem to work . . .
/**
* Use with String.format to build the base url string when testing locally.
*/
private static final String LOCAL_BASE_URL_FORMAT_STR = "%s:%d";
/**
* Create the mysql test container as a class rule.
*/
#ClassRule
public static MySQLContainer<?> mysqlDb = new MySQLContainer<>("mysql:latest") //TODO may not want the latest version . . .
.withInitScript("schema.sql");
/**
* The base url for the tests. By passing in here, we allow for testing actual environments, as well as integration tests with the same code.
* If no value is passed, defaults to localhost, and will be combined with port to build base url
*/
#Value("${BASE_URL:locahost}")
private String baseUrl;
/**
* For getting access to the port the spring boot context is running on in subclasses
*/
#LocalServerPort
protected int serverPort;
//Decide whether to use rest template or test res template here
/**
* Used in subclasses to get access to the base url for testing.
* #return
*/
protected String getBaseUrl() {
String baseUrlToReturn;
//if it is local, append the port
if(baseUrl != null && baseUrl.contains("localhost")){
baseUrlToReturn = String.format(LOCAL_BASE_URL_FORMAT_STR, baseUrl, serverPort);
}
//otherwise, return the environment variable, which will always be available on standard http(s) port
else {
baseUrlToReturn = baseUrl;
}
return baseUrlToReturn;
}
/**
* This initalizer class takes care of setting the properties from the test container into environment variables.
* This allows integration tests to be as close to real testing as possible.
* #author connor
*
*/
public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
#Override
public void initialize(ConfigurableApplicationContext applicationContext) {
//add the url, username, and password to the test context before it starts
TestPropertyValues.of(String.format("spring.datasource.url=%s", mysqlDb.getJdbcUrl()),
String.format("spring.datasource.username=%s", mysqlDb.getUsername()),
String.format("spring.datasource.password=%s", mysqlDb.getPassword()))
.applyTo(applicationContext.getEnvironment());
}
}
/**
* This method is only here to test when running alone for debugging . . .
*/
#Test
public void test() {
//just here for compilation when testing this class by itself-- will not execute if no test here
}
}
Here is the second class, the one with the entry point for the cucumber tests
import org.junit.runner.RunWith;
import cucumber.api.CucumberOptions;
import cucumber.api.junit.Cucumber;
/**
* This is the entry point for running the cucumber tests.
* #author connor
*
*/
#RunWith(Cucumber.class)
#CucumberOptions(features = "src/it/resources/AddingAssessment.feature")
public class RunCukesIT {
//intentionally blank -- annotations do all the work
}
Finally, here is my third class containing my step definitions:
import cucumber.api.java8.En;
/**
* This class contains the glue code for the "given when then" step definitions.
* This extends the class that bots the spring context, but it does not boot the
* context
* #author connor
*
*/
//even with these annotations, it does not load spring boot context
//#RunWith(SpringRunner.class)
//#SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT, classes = Application.class)
//#ContextConfiguration(initializers = SpringContextConfigForCukeUsage.Initializer.class)
public class CukeGWT extends SpringContextConfigForCukeUsage implements En {
public CukeGWT() {
Given("we are attempting to add a test for a book", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
System.out.println("\n\n\n\n\n\n\n\n\n\n\n\n" + serverPort); //always 0 (because context doesn't load)
//
System.out.println("Env property is " + System.getenv("local.server.port")); //this also indicates server doesn't start
});
Given("the book has isbn {int}", (Integer int1) -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the author of the book has first name conn", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the author of the book has last name b", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the book has {int} questions", (Integer int1) -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("one of the questions has incorrect answers a hen, a cat", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the question has correct answer a dog", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
When("the api is called", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the api will return a valid response", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the isbn will match", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the author's first name will match", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the author's last name will match", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the question added above will exist", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the book will be unverified", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the author of the book has first name test", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the author of the book has last name testing", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("one of the questions has incorrect answers true", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("the question has correct answer false", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Given("an assessment with valid data is generated", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the api will return an error response", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the http status code will be {int}", (Integer int1) -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
Then("the error message will contain A test already exists for this book", () -> {
// Write code here that turns the phrase above into concrete actions
//throw new cucumber.api.PendingException();
});
}
}
Here is my pom for reference of the dependencies/versions
<?xml version="1.0" encoding="UTF-8"?>
https://maven.apache.org/xsd/maven-4.0.0.xsd">
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.1.3.RELEASE
com.connor
reading-comprehension-api
0.0.1-SNAPSHOT
reading-comprehension-api
This is the containerized webservice for reading
comprehension
<properties>
<!-- miscellaneous properties -->
<docker.image.prefix>connordocker</docker.image.prefix>
<java.version>1.8</java.version>
<!-- get as much info as we can locally for development -->
<downloadSources>true</downloadSources>
<downloadJavadocs>true</downloadJavadocs>
<!-- versions, please keep in alphabetical order -->
<cucumber.version>4.2.5</cucumber.version>
<testcontainer.version>1.12.4</testcontainer.version>
</properties>
<dependencies>
<!-- bring this in once database is integrated and defined in properties
file -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
</dependency>
<!-- lets us connect to mysql db -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
<!-- lets us use test containers; must use same version as mysql test container
below -->
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>testcontainers</artifactId>
<version>${testcontainer.version}</version>
<scope>test</scope>
</dependency>
<!-- mysql specific test container; must use same version as testcontainers -->
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>mysql</artifactId>
<version>${testcontainer.version}</version>
<scope>test</scope>
</dependency>
<!-- the below three dependencies are required for cucumber tests -->
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-java8</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-java</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>io.cucumber</groupId>
<artifactId>cucumber-junit</artifactId>
<version>${cucumber.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<!-- create different profiles for each ci/cd stage -->
<profiles>
<!-- this is ran for every commit -->
<profile>
<id>commit-profile</id>
<activation>
<!-- if we make this active by default, it runs, even when we explicitly
mention another profile -->
<!-- active by default -->
<!-- <activeByDefault>true</activeByDefault> -->
</activation>
<build>
<!-- TODO add compile plugin, surefire plugin here -->
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
</plugin>
<!-- inherit surefire plugin for running unit tests. Overwrite and add
additional configuration to ignore our integration tests -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<configuration>
<!-- ignore the integration tests (named *IT) which come from src/it/java,
but are placed on classpath by the build helper plugin (IT must be on test
classpath to run, but we don't want them running here) -->
<excludes>
<exclude>**/*IT.java</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</profile>
<!-- this is ran on the merge to master -->
<profile>
<id>merge-to-base-branch-profile</id>
<!-- active when stage is merge -Dstage=merge -->
<activation>
<property>
<name>stage</name>
<value>merge</value>
</property>
</activation>
<!-- TODO add enforcer plugin, failsafe plugin, codehaus plugin -->
</profile>
<!-- this is ran and triggered by a tag -->
<profile>
<id>deploy-profile</id>
<!-- active when stage is deploy -Dstage=deploy, should be triggered by
tag from pipeline -->
<activation>
<property>
<name>stage</name>
<value>deploy</value>
</property>
</activation>
<!-- not sure if we want to (or can) trigger deployment to cloud from
maven, or if we can -->
</profile>
<!-- this profile is triggered for running integration tests -->
<profile>
<id>integration-test-profile</id>
<!-- make to skip unit tests so we don't get confused -->
<properties>
<skipTests>true</skipTests>
</properties>
<build>
<plugins>
<!-- this plugin adds folders to the classpath. As of right now, it
takes care of adding the integration tests (and feature files) to test classpath. -->
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<executions>
<!-- this execution adds the src/it/java to test classpath -->
<execution>
<id>add-integration-test-source</id>
<phase>generate-test-sources</phase>
<goals>
<goal>add-test-source</goal>
</goals>
<configuration>
<sources>
<source>src/it/java</source>
</sources>
</configuration>
</execution>
<!-- this execution adds the src/it/resources to test classpath -->
<execution>
<id>add-integration-test-resource</id>
<phase>generate-test-sources</phase>
<goals>
<goal>add-test-resource</goal>
</goals>
<configuration>
<resources>
<resource>
<directory>src/it/resources</directory>
</resource>
</resources>
</configuration>
</execution>
</executions>
</plugin>
<!-- this runs the integration tests -->
<!-- NOTE: I have been considering using this for e2e tests once deployment
is done to staging region. This would allow us to reuse code, with the only
change being the base url system property passed in. However, we still have
to deal with populating the region database, and the fact we want our integration
tests to be much more extensive than our e2e tests, which should be very
brief -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<executions>
<execution>
<id>integration-tests</id>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
<configuration>
<!-- this is needed so we can skip unit tests here, but not integration tests (as both default to skip tests property, which we set to true to ignore unit tests) -->
<skipTests>false</skipTests> <!-- NOTE: In future here, could configure with ${skip.failsafe.tests} or any other variable but skip tests -->
<!-- only run integration tests, which should end in IT -->
<includes>
<include>**/*IT.java</include>
</includes>
<excludes>
<exclude>**/*Test.java</exclude>
</excludes>
<!-- set the environment variable from what is passed in as a system
variable. This allows use with spring boot property injection NOTE: there
is no need to set the jdbc related info here, this comes from test container -->
<environmentVariables>
<!-- set the base url; if not set defaults to localhost for int
testing -->
<BASE_URL>${BASE_URL}</BASE_URL>
</environmentVariables>
</configuration>
</execution>
</executions>
</plugin>
<!-- this plugin builds a pretty(ier) html report from the results of
cucumber tests. This should only be active in this profile, after int tests
have ran -->
<plugin>
<groupId>net.masterthought</groupId>
<artifactId>maven-cucumber-reporting</artifactId>
<version>2.8.0</version>
<!-- we have one execution tag per functionality exposed by the api -->
<executions>
<!-- for the add integration tests -->
<execution>
<id>addCucumberReport</id>
<phase>verify</phase>
<goals>
<goal>generate</goal>
</goals>
<configuration>
<projectName>CucumberWebGui</projectName>
<outputDirectory>${project.build.directory}/cucumber-report-html/add</outputDirectory>
<cucumberOutput>${project.build.directory}/cucumber-report/addCucumber.json</cucumberOutput>
</configuration>
</execution>
<!-- for get integration tests -->
<execution>
<id>getCucumberReport</id>
<phase>verify</phase>
<goals>
<goal>generate</goal>
</goals>
<configuration>
<projectName>CucumberWebGui</projectName>
<outputDirectory>${project.build.directory}/cucumber-report-html/get</outputDirectory>
<cucumberOutput>${project.build.directory}/cucumber-report/getCucumber.json</cucumberOutput>
</configuration>
</execution>
<!-- for the verify/udpate reports -->
<execution>
<id>updateCucumberReport</id>
<phase>verify</phase>
<goals>
<goal>generate</goal>
</goals>
<configuration>
<projectName>CucumberWebGui</projectName>
<outputDirectory>${project.build.directory}/cucumber-report-html/update</outputDirectory>
<cucumberOutput>${project.build.directory}/cucumber-report/verifyCucumber.json</cucumberOutput>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<!-- NOTE: this is the build tag. Every plugin specified here will always
run, regardless of if a profile is selected, or if there are multiple profiles
selected. -->
<build>
<plugins>
<!-- This is the default spring boot plugin that wraps as jar and allows
running with embedded instance -->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>unpack</id>
<phase>package</phase>
<goals>
<goal>unpack</goal>
</goals>
<configuration>
<artifactItems>
<artifactItem>
<groupId>${project.groupId}</groupId>
<artifactId>${project.artifactId}</artifactId>
<version>${project.version}</version>
</artifactItem>
</artifactItems>
</configuration>
</execution>
</executions>
</plugin>
<!-- display active profile in compile phase -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-help-plugin</artifactId>
<executions>
<execution>
<id>show-profiles</id>
<phase>compile</phase>
<goals>
<goal>active-profiles</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
The source code for this can be found at: https://gitlab.com/connorbutch/reading-comprehension-api