1) TestContainers is a Java library that supports integration testing with real databases, services, and APIs without requiring heavy infrastructure. It uses Docker containers to launch and initialize external dependencies for tests. 2) The document discusses how to use TestContainers to test against databases like MySQL and services like S3 storage. It provides code examples of initializing containers and writing integration tests against them. 3) TestContainers supports various databases and services out of the box. It can also be used to launch generic Docker images and Docker Compose configurations to test against complex environments.

1. Take Control of your
Integration Testing with
TestContainers
Naresha K
@naresha_k
https://blog.nareshak.com/

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

3. Integration Testing?

7. Infrastructure as Code

9. Infrastructure as Code

10. Infrastructure as Code
Immutable Infrastructure

12. TestContainers

14. 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

15. @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() {
// invoke SUT && assert
assertTrue(mySQLContainer.isRunning());
}
}

16. @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() {
// invoke SUT && assert
assertTrue(mySQLContainer.isRunning());
}
}
@Testcontainers
@Container

17. @Testcontainers
public class SampleMySqlTest {
@Container
private static 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() {
// invoke SUT && assert
assertTrue(mySQLContainer.isRunning());
}
}

18. @Testcontainers
public class MySqlTest {
@Container
protected static final MySQLContainer mySQLContainer;
static {
mySQLContainer = new
MySQLContainer(DockerImageName.parse("mysql:8"))
.withDatabaseName("foo")
.withUsername("foo")
.withPassword("secret");
mySQLContainer.start();
}
}

19. @Testcontainers
public class MySqlTestSuite1 extends MySqlTest {
@Test
void test1() {
assertTrue(mySQLContainer.isRunning());
}
@Test
void test2() {
assertTrue(mySQLContainer.isRunning());
}
}

20. Case Study #1

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

22. 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 ()

23. 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)

25. 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)

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

28. 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)

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

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

32. @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

33. Case Study #2

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

35. @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)

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

37. 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
}

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

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

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

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

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

43. @Container
private static GenericContainer<?> tomcat = new
GenericContainer<>(
DockerImageName.parse("tomcat:8.5.8-jre8"))
.withExposedPorts(8080)
.withStartupTimeout(Duration.ofMinutes(2));

44. @Container
private static GenericContainer<?> tomcat = new
GenericContainer<>(
DockerImageName.parse("tomcat:8.5.8-jre8"))
.withExposedPorts(8080)
.waitingFor(Wait.forHttp("/"));

45. @Container
private static GenericContainer<?> tomcat = new
GenericContainer<>(
DockerImageName.parse("tomcat:8.5.8-jre8"))
.withExposedPorts(8080)
.waitingFor(Wait.forHttp("/")
.forStatusCode(200));
https://www.testcontainers.org/features/startup_and_waits/

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

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

48. Integration Tests
are not replacements for
Unit Tests

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

50. Thank You