Containers are an amazing technology that are revolutionising how we deploy and create applications. Docker and Kubernetes are helping developers and organisations realise the magical potential that container technology and orchestration offer. Enter MicroShed and the Testcontainers framework enabling local test automation that leverages that magical portability containers offer. In this session we'll explore how Testcontainers can help you run and test with true-to-production environments in development with minimal re-writing of your test code.

1. © 2021 IBM Corporation
Replicating production on
your laptop using the
magic of containers
Grace Jansen
Developer Advocate
@gracejansen27

2. Why do we write automated
tests?

3. To have confidence that our applications
work the way we want them to!

4. System/
UI testing
Integration testing
UnitTesting
Types of testing

5. ManualTesting if I have
time and remember
Integration
testing
UnitTesting
What we have
time to do

6. Problem with just using Unit tests
Tap turns on
Tap turns off
Drain works
Sink does not overflow

7. Testing with
Containers

8. The Magic of Containers
• Virtualization from OS level
• Lightweight
• Faster start-up
• Portable with images and config files such as a Dockerfile
• Run Anywhere
• Isolation
• Complexity!

9. The Magic of Kubernetes
• Automated rollouts and rollbacks
• Automatic scaling of services (containers)
• Health monitoring
• Declarative management
• Deploy anywhere (Hybrid deployments)

10. What Magic can Developers use?
• Isolated development environments
• Portable
• Preconfigured images available
• Fast start-up of applications
• No need to have so many pre-reqs installed
• Version control of dependencies
• Can develop easily in the cloud
• True-to production testing!

11. What Magic can Developers use?
• Isolated development environments
• Portable
• Preconfigured images available
• Fast start-up of applications
• No need to have so many pre-reqs installed
• Version control of dependencies
• Can develop easily in the cloud
• True-to production testing!

12. 1. Codebase
2. Dependencies
3. Config
4. Backing Services
5. Build, Release, Run
6. Stateless Processes
7. Port Binding
8. Concurrency
9. Disposability
10. Dev-Prod Parity
11. Logs
12. Admin processes

13. Dev-Prod Parity
Keep development, staging, and production as similar as possible
Comprised of three common issues:
• The time gap
• The personnel gap
• The tools gap
“The twelve-factor developer resists the urge to use different backing services
between development and production, even when adapters theoretically
abstract away any differences in backing services.”

14. IT WORKS
ON MY
MACHINE

15. Testing Problems that Containers can solve
• Data access such access to databases
• Integration testing
• Automatic updating and version control
• Complex setup on local machines
• Portable testing environments (So others can run the
same test easily)
• …

16. Testcontainers
https://www.testcontainers.org/

17. my-
app:latest
(app container)
mongo:4.0
(DB container)
Dev/Test env
Production env
integration
tests
end users
my-
app:latest
(app container)
mongo:4.0
(DB container)
Testcontainers
• Integration tests that are easy
to setup, write, and run
• Test your apps the same way
they run in production
• Tests are portable to any
compatible implementation:
• Liberty
• Wildfly
• Payara
• TomEE
• etc…

18. AvailableTestcontainer Modules:
Database Modules:
• CouchBase
• DB2
• MongoDB
• MySQL
• Postgress etc
Other Modules:
• Docker Compose
• Elasticsearch
• Kafka
• Nginx
• RabbitMQ

19. MicroShed Testing
http://microshed.org/microshed-testing/

20. What is MicroShedTesting?
The MicroshedTesting framework allows for true-to-production
integration tests on your local machine.This enables you as a
developer to minimize the amount of test failures due to differences in
dev/test and production environments. Using the magic of containers,
you can replicate what you have in your production environment
without much setup at all.

21. MicroShed Example
@MicroShedTest
public class MyTest {
// Search for Dockerfile.
// Start app in Container.
// Wait for Container before running tests.
@Container
public static MicroProfileApplication app
= new MicroProfileApplication()
.withAppContextRoot("/myservice");
// Inject JAX-RS REST Client
@RestClient
public static MyService mySvc;
// A test method like any other
@Test
public void testMyService() {
...
}
}
The @MicroShedTest annotation is required so
that the build knows this is a MicroShed test
The @Container annotation is required for setting
up your container to run your tests inside
The @RESTClient annotation is needed to give us
something to test against
The @Test annotation like you would in a normal
JUnit test.

22. SharableConfiguration
If multiple test classes can share the same container instances, they
can offload their @Container annotated fields to a sperate class like
so:
public class AppContainerConfig implements SharedContainerConfiguration {
@Container
public static ApplicationContainer app = new ApplicationContainer()
.withAppContextRoot("/myservice");
}
@MicroShedTest
@SharedContainerConfig(AppContainerConfig.class)
public class MySimpleTestA {
// ...
}
@MicroShedTest
@SharedContainerConfig(AppContainerConfig.class)
public class MySimpleTestB {
// ...
}

23. Different RuntimesAvailable
• Open Liberty
• Payara Micro
• Payara Sever
• Wildfly
• Quarkus

24. True to production
testing with MicroShed
Testing

25. Skills Network Labs

26. Skills Network Labs

27. Interactive Demo
Turning a JUnit test into a MicroShed test
If you would like to follow along at the same time please go to the
following link and select the “Testing a MicroProfile or Jakarta EE
Application” Module
https://openliberty.skillsnetwork.site/cloud-native-java-made-
easy-microprofile-jakarta-ee

28. Summary
• Containers are great!
• They make developers lives easier (portable, configurable,
lightweight…)
• They can help solve some issues with testing such as dev/test prod
parity
• There are some great open source tools available to utilise testing
with containers
• Helps speed up time to production, making everyone happier!

29. Resources:
• Run true-to-production tests on your MicroProfile and JakartaEE applications -
https://developer.ibm.com/languages/java/articles/true-to-production-testing-
microprofile-jakarta-ee/
• Five Java frameworks for improving your automated testing -
https://developer.ibm.com/devpractices/continuous-delivery/blogs/five-frameworks-for-
improving-your-java-automated-tests/
• Open Liberty - https://openliberty.io
• MicroShed - https://microshed.org
• Testcontainers - https://www.testcontainers.org/
• MicroProfile - https://microprofile.io/
• Jakarta EE - https://jakarta.ee/

30. ThankYou
Grace Jansen
@gracejansen27