Creating A Simple Java Database Integration Test with Openshift 4 and Jenkins Pipeline
During testing phase, there are time when we want to do an automated testing against a real temporary database. For example, if my database in production environment is MySql means i need to have the exact same MySql for testing, with the same version and structure. And one of the most important thing is the test database lifespan is only as long as the test case lifespan which means that once test is done, either success or failed, the temporary database shall be destroyed.
There are multiple ways of achieving this, we can use database sidecar pattern, install a MySql service on our jenkins slave base image, or create a temporary MySql pod on our Openshift cluster specifically for testing purpose. The last approach is the one i choose and i will share how to achieve it on this blog.
Lets start by creating a very simple java web apps with Spring Boot and JUnit, it is basically a simple java apps but the only difference is the database url for testing is not hardcoded, but parameterized.
spring.datasource.url=jdbc:mysql://${MYSQL_URL}:3306/db_test
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=user1
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto=update
and a simple integration test,
package com.edw.controller;
import com.edw.entity.Account;
import com.edw.repository.AccountRepository;
import io.restassured.RestAssured;
import org.apache.http.HttpStatus;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import static io.restassured.RestAssured.given;
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@DirtiesContext
public class AccountControllerIT {
@LocalServerPort
private int port;
@Autowired
private AccountRepository accountRepository;
@Before
public void setup() {
RestAssured.port = this.port;
accountRepository.delete(new Account(10));
Account account = new Account();
account.setId(10);
account.setAccountNumber("ten ten");
accountRepository.save(account);
}
@Test
public void getSuccess() throws Exception {
given()
.when()
.get("/10")
.then()
.assertThat()
.statusCode(HttpStatus.SC_OK);
}
@Test
public void getFailed() throws Exception {
given()
.when()
.get("/7")
.then()
.assertThat()
.statusCode(HttpStatus.SC_INTERNAL_SERVER_ERROR);
}
}
Once created, next step is to create a Jenkins setup for code build and deployment pipeline. Im using a simple a simple maven image which comes with OCP,
Next step is to create a pipeline to spawn database, do integration testing, build apps and destroy database once everything is completed. One think that i need to do is to create a unique database service between build, it will prevent database overlapping between different build and maintain a testing isolation. That is the reason why im appending build number on every temporary database services. And i will inject the database url thru maven build parameter in order to make sure that testing database are pointing to my newly created database.
node('maven') {
try {
stage ('pull code') {
sh "git clone https://github.com/edwin/springboot-integration-test.git source"
}
stage('spawn db') {
sh "oc new-app mysql-ephemeral --name mysql -p MYSQL_USER=user1 -p MYSQL_PASSWORD=password -p MYSQL_DATABASE=db_test -p DATABASE_SERVICE_NAME=mysql${env.BUILD_NUMBER}"
// wait until db is ready
sh """
sleep 10
while oc get po --field-selector=status.phase=Running | grep mysql${env.BUILD_NUMBER}-1-deploy; do
sleep 2
done
"""
}
stage ('test') {
dir("source") {
sh "mvn verify -DMYSQL_URL=mysql${env.BUILD_NUMBER}"
}
}
stage ('build') {
dir("source") {
sh "mvn clean package -DskipTests=true"
}
}
} catch (error) {
throw error
} finally {
stage('destroy db') {
sh "oc delete dc mysql${env.BUILD_NUMBER}"
sh "oc delete svc mysql${env.BUILD_NUMBER}"
sh "oc delete secret mysql${env.BUILD_NUMBER}"
}
}
}
It will generates this output on Jenkins dashboard,
If we check the content of our database while testing is happen, we can see that a table is created and a data is automatically inserted there for testing purpose.
And after test and build is done, we can see that database is deleted automatically from our Openshift cluster.
So basically it is very simple to do an integration test on Openshift 4 and Jenkins, and the code for testing is available on my github repository.
https://github.com/edwin/springboot-integration-test
