In this release of the Atbash Integration testing framework, we continued improving the support for creating customised Docker images that run your application under test but also added 2 major features, support for databases and Jakarta EE 10.
Depending on the target version of your application, you can use version 1.2.0 if you are building a Jakarta EE 8 application, or 2.2.0 if your application depends on Jakarta EE 10. More on that later in this blog.
In previous blogs, we covered the basics of using the Integration testing framework. You can have a look at this blog for the introduction and the functionality that was provided in version 1.0.
With the second release, we added the option to use a custom Docker build file that will be used for the container with the application. And we added support for using Wiremock to mock the response of remote services. More details can be found in this blog.
Update : Presentation at Jakarta Tech Talks which can be viewed on YouTube channel.
Customised Build file
In this release, we continued adding support for customising the container that runs your application and that you want to test. You had already the option to supply a custom Docker Build file where the framework only adds the appropriate Docker ADD command to add the WAR file. Now you also can customise the build file just before it will be sent to the Docker engine for processing.
There is a DockerImageAdapter interface that can be implemented by the developer to adjust a few lines of the build file, including the default build file provided by the framework.
This allows for simple additions that are future-compatible with possible changes that will be made to the default build file in future versions.
Implementations of the interface are picked up by the ServiceLoader mechanism within Java. So don’t forget to define your class name in the appropriate service file.
Since there might be more than one implementation within the classpath, you can order them by adding a @Priority annotation. The implementations with a low value are called first. If no priority value is specified, a default value of 100 is taken. And of course, when multiple implementations have the same value, the exact order is undefined for the matching priority values.
When you only need to add some environment variables to the container, there is no need anymore to define a custom build file. You can make use of the AdditionalEnvParameters class. Within an implementation of the DockerImageAdapter you can access this class as follows
public String adapt(String dockerFileContent, TestContext testContext) {
AdditionalEnvParameters envParameters = testContext.getInstance(AdditionalEnvParameters.class);
if (envParameters == null) {
AdditionalEnvParameters envParameters = new AdditionalEnvParameters();
testContext.addInstance(envParameters);
}
envParameters.add(key, value);
}
The TestContext is an object that is added in this release and can be consulted for various information about the test that is running.
It holds for example the ContainerAdapterMetaData instance that holds all data about the test that is currently running.
And with the AdditionalEnvParameters.add(), you can add key-value pairs to the environment variable for the container.
Support for a database
In this version, it is now possible to define a database container and provide the configuration as a data source for the JPA functionality of your application.
To have this functionality, make sure you perform the following steps.
- Add the Atbash Integration testing Database artefact to your project.
- Add the
@DatabaseContainerIntegrationTestannotation to the test class. The class must also extend fromAbstractDatabaseContainerIntegrationTest. - Add the Database test container of your choice as a project dependency. This determines the database that will be started alongside the container with your application.
- Add the JDBC Driver as the test scope. This must be a driver that works with the selected database. The driver is used for 2 purposes, it is added to the container with the application to provide access to the database and it allows during the setup of the test to prepare the database in a known state for the test. You can also access the database tables during the test through this Driver and DBUnit which is proved automatically.
Once these things are in place, a test execution performs the following tasks.
- Determine the Database container to start by looking at which JDBC database container is on the classpath.
- Determinate JDBC driver
- Add the JDBC Driver to the application container in a runtime-specific way.
- Start the database container
- Provide the connection settings as environment variables to the application container
- Create the tables required for the test by executing a SQL script that the developer provided
- Add the data to the tables by reading the Excel file.
A variable is prepared that allows you to access the database tables during the execution of your test. For this, the functionality of the DBUnit library is used. This allows you to check that a call to an application endpoint resulted in the expected database changes.
Have a look at the examples https://github.com/atbashEE/jakarta-integration-testing/tree/main/example/database to get started with this new exciting feature.
Jakarta EE 10
Until now, The Jakarta EE testing framework supported only Jakarta EE 8. There is now also an artifact available specifically for Jakarta EE 10. version 2.x is now based on Jakarta EE 10 dependencies and thus can be added as a test dependency to your project.
All functionality that is available for Jakarta EE 8, is also available for this EE 10 version.
Conclusion
With this new release of the testing framework, more options are available to customise the container image that runs your application during the test. For example, you have now the possibility to specify those environment variables and values that need to the added without using a custom docker build script.
The two major features that are added to this version are of course the integration with a database container that makes it much easier when your application uses a database to test its functionality and the support for Jakarta EE 10.
Enjoy
Training and Support
Do you need a specific training session on Jakarta or MicroProfile? Or do you need some help in getting up and running with your next project? Have a look at the training support that I provide on the page https://www.atbash.be/training/ and contact me for more information.