Take Control of your Integration Testing with TestContainers

Take Control of your
Integration Testing with
TestContainers
Naresha K
@naresha_k

https://blog.nareshak.com/

About me
Developer, Architect &
Tech Excellence Coach
Founder & Organiser
Bangalore Groovy User
Group

Infrastructure as Code
Immutable Infrastructure

testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.2'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.2'
runtimeOnly 'mysql:mysql-connector-java:8.0.22'
testImplementation "org.testcontainers:junit-jupiter:1.15.1"
testCompile "org.testcontainers:mysql:1.15.1"
build.gradle dependencies

@Testcontainers
public class SampleMySqlTest {
@Container
private MySQLContainer mySQLContainer = new
MySQLContainer(DockerImageName.parse("mysql:8"))
.withDatabaseName("foo")
.withUsername("foo")
.withPassword("secret");
@Test
void test1() {
// invoke SUT && assert
assertTrue(mySQLContainer.isRunning());
}
@Test
void test2() {
}
}

@Testcontainers
@Container
private MySQLContainer mySQLContainer = new
@Test
void test1() {
}
@Test
void test2() {
}
}
@Testcontainers
@Container

@Testcontainers
@Container
private static MySQLContainer mySQLContainer = new
@Test
void test1() {
}
@Test
void test2() {
}
}

@Testcontainers
public class MySqlTest {
@Container
protected static final MySQLContainer mySQLContainer;
static {
mySQLContainer = new
mySQLContainer.start();
}
}

@Testcontainers
public class MySqlTestSuite1 extends MySqlTest {
@Test
void test1() {
}
@Test
void test2() {
}
}

@Transactional
class ConferenceService {
def getConferencesInCities(List<String> cities) {
Conference.where {
city in cities
}.list()
}
}

select
this_.id as id1_0_0_,

this_.version as version2_0_0_,

this_.name as name3_0_0_,

this_.city as city4_0_0_
from conference this_
where this_.city in ()

hibernate:
cache:
queries: false
use_second_level_cache: false
use_query_cache: false
dataSource:
pooled: true
jmxExport: true
driverClassName: org.h2.Driver
username: sa
password: ''
logSql: true
environments:
development:
dataSource:
dbCreate: create-drop
url: jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
test:
dataSource:
dbCreate: update
url: jdbc:h2:mem:testDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
Application.yml (Test with H2)

dataSource:
pooled: true
jmxExport: true
driverClassName: com.mysql.jdbc.Driver
username: root
password: secret
logSql: true
environments:
development:
dataSource:
dbCreate: create-drop
url: jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000;DB_CLOSE_ON_EXIT=FALSE
test:
dataSource:
dbCreate: update
url: jdbc:mysql://localhost:3306/testapp
Application.yml (Test with MySQL)

testCompile platform('org.testcontainers:testcontainers-bom:1.12.5')
testCompile 'org.testcontainers:spock'
testCompile 'org.testcontainers:mysql'
build.gradle

dataSource:
pooled: true
jmxExport: true
driverClassName: org.testcontainers.jdbc.ContainerDatabaseDriver
logSql: true
environments:
test:
dataSource:
dbCreate: update
url: jdbc:tc:mysql:8://somehostname:someport/databasename
Application.yml (Test with TestContainers)

@Integration
@Rollback
@Testcontainers
class ConferenceTestContainerSpec extends Specification {
@Shared
MySQLContainer mySQLContainer = new MySQLContainer(
DockerImageName.parse("mysql:8"))
.withDatabaseName("testapp")
.withUsername("user")
.withPassword("secret")
ConferenceService conferenceService

void "should return empty list"() {
given:
List<String> cities = []
when:
List<Conference> conferences =
conferenceService.getConferencesInCities(cities)
then:
conferences.size() == 0
}

@Integration
@Rollback
@Testcontainers
class ConferenceTestContainerSpec extends Specification {
@Shared
MySQLContainer mySQLContainer = new MySQLContainer()
.withDatabaseName("testapp")
.withUsername("user")
.withPassword("secret")
ConferenceService conferenceService
void "should return empty list"() {
// test code
}
}
dataSource:
driverClassName: org.testcontainers.jdbc.ContainerDatabaseDriver
environments:
test:
dataSource:
dbCreate: update
url: jdbc:tc:mysql:8://somehostname:someport/databasename

testCompile platform('org.testcontainers:testcontainers-bom:1.15.1')
testCompile 'org.testcontainers:spock'
testCompile 'org.testcontainers:mysql'
testCompile "org.testcontainers:localstack"
build.gradle

@Integration
@Testcontainers
class FileStorageSpec extends Specification {
public static final String TARGET_BUCKET = "testbucket"
AmazonS3Service amazonS3Service
FileStorageService fileStorageService
@Shared
public LocalStackContainer localstack = new LocalStackContainer(
DockerImageName.parse("localstack/localstack:0.11.2"))
.withServices(S3)

void setup() {
AmazonS3 s3 = AmazonS3ClientBuilder
.standard()
.withEndpointConfiguration(
localstack.getEndpointConfiguration(S3))
.withCredentials(
localstack.getDefaultCredentialsProvider())
.build();
amazonS3Service.client = s3
amazonS3Service.createBucket(TARGET_BUCKET)
}

def "file can be stored in s3 storage and read"() {
given:
def filePath = Paths.get("src/test/resources/car.jpg")
InputStream stream = Files.newInputStream(filePath)
when:
fileStorageService.storeFile(TARGET_BUCKET, "vehicles/123.jpg", stream)
then:
amazonS3Service.exists(TARGET_BUCKET, "vehicles/123.jpg")
when:
File file = fileStorageService.readFile(TARGET_BUCKET, "vehicles/123.jpg",
Files.createTempFile(null, null).toAbsolutePath().toString())
then:
file
and:
file.newInputStream().bytes == filePath.bytes
}

https://www.testcontainers.org/modules/databases/

https://www.testcontainers.org/modules/localstack/

@Testcontainers
public class GenericContainerTest {
@Container
private static GenericContainer<?> redis =
new GenericContainer<>(
DockerImageName.parse("redis:6"))
.withExposedPorts(6379);
@Test
void testRedisOps() {
assertTrue(redis.isRunning());
}
}

@Testcontainers
public class GenericContainerTest {
@Container
private static GenericContainer<?> redis =
new GenericContainer<>(
DockerImageName.parse("redis:6"))
@Test
void testRedisOps() {
assertTrue(redis.isRunning());
}
}
//get host port
redis.getMappedPort(6379)

@Container
private static GenericContainer<?> tomcat = new
GenericContainer<>(
DockerImageName.parse("tomcat:8.5.8-jre8"))

@Container
GenericContainer<>(
.withExposedPorts(8080)
.withStartupTimeout(Duration.ofMinutes(2));

@Container
GenericContainer<>(
.waitingFor(Wait.forHttp("/"));

@Container
GenericContainer<>(
.waitingFor(Wait.forHttp("/")
.forStatusCode(200));
https://www.testcontainers.org/features/startup_and_waits/

web:
image: "tomcat:8.5.50-jdk8-adoptopenjdk-hotspot"
ports:
- "8080:8080"
redis:
image: "redis:6"
docker-compose.yml

@Container
private DockerComposeContainer<?> container = new
DockerComposeContainer<>(
new File("src/test/resources/docker-compose.yml"))
.withExposedService("web_1", 8080)
.withExposedService("redis_1", 6379);

Integration Tests
are not replacements for
Unit Tests

References
https://github.com/naresha/java2days2020testcontainers
https://www.testcontainers.org/
https://www2.slideshare.net/nareshak

Take Control of your Integration Testing with TestContainers

Recommended

More Related Content

What's hot (20)

Similar to Take Control of your Integration Testing with TestContainers (20)

More from Naresha K (20)

Recently uploaded (20)

Take Control of your Integration Testing with TestContainers