{"id":31540,"date":"2023-10-18T15:36:37","date_gmt":"2023-10-18T14:36:37","guid":{"rendered":"https:\/\/www.baeldung.com\/?p=167305"},"modified":"2023-10-18T15:36:37","modified_gmt":"2023-10-18T14:36:37","slug":"how-to-reuse-testcontainers-in-java","status":"publish","type":"post","link":"https:\/\/gamefootballmobileanimeiphone.com\/index.php\/2023\/10\/18\/how-to-reuse-testcontainers-in-java\/","title":{"rendered":"How to Reuse Testcontainers in Java"},"content":{"rendered":"

\"\"<\/p>\n

1. Overview<\/h2>\n
<\/div>\n

In this tutorial, we’ll learn how to reuse Testcontainers<\/a> when setting up the environment for local development and testing.<\/p>\n

Firstly, we’ll have to make sure we’re not shutting down the container when the application is stopped or when the test suite finishes. After that, we’ll talk about the Testcontainer–<\/i>specific configuration and we’ll discuss the benefits of using the Testcontainers Desktop application. Lastly, we need to keep in mind that reusing Testcontainers<\/a> is an experimental feature and it’s not yet ready to be used in CI pipelines.<\/p>\n

2. Ensure the Testcontainer Isn’t Stopped<\/h2>\n
<\/div>\n

A straightforward way of enabling Testcontainers for our unit tests is to leverage their dedicated JUnit 5 extension<\/a> through the @Testcontainers<\/em> and @Container<\/em> annotations.<\/p>\n

Let’s write a test that starts a Spring Boot application and allows it to connect to a MongoDB database running in a Docker<\/a> container:<\/p>\n

@Testcontainers\r\n@SpringBootTest\r\nclass ReusableContainersLiveTest {\r\n    @Container\r\n    static MongoDBContainer mongoDBContainer = new MongoDBContainer(DockerImageName.parse("mongo:4.0.10"));\r\n  \r\n    \/\/ dynamic properties and test cases\r\n}<\/code><\/pre>\n
However, the Testcontainer’s JUnit5 Extension that automatically spins up MongoDBContainer<\/em> will also shuts it down after the tests. Therefore, let’s remove the @Testcontainers<\/em> and @Container<\/em> annotations, and manually start the container instead:<\/strong><\/p>\n
@SpringBootTest\r\nclass ReusableContainersLiveTest {\r\n   static MongoDBContainer mongoDBContainer = new MongoDBContainer(DockerImageName.parse("mongo:4.0.10"));\r\n    @BeforeAll\r\n    static void beforeAll() {\r\n        mongoDBContainer.start();\r\n    }\r\n    \r\n    \/\/ dynamic properties and test cases\r\n}<\/code><\/pre>\n
On the other hand, we might be using Spring Boot’s built-in support for Testcontainers<\/a> during local development. In this context, we won’t use the JUnit 5 extension and this step is unnecessary.<\/p>\n
3. Manage the Testcontainer Lifecycle<\/h2>\n
<\/div>\n
Now, we can be in full control of the container’s lifecycle. We can configure the application to reuse an existing Testcontainer\u00a0and we can manually stop it from the terminal.<\/p>\n
3.1. The withReuse()<\/em> Method<\/h3>\n
<\/div>\n
We can mark a Testcontainer as reusable\u00a0by using the withReuse()<\/em> method of its fluent API:<\/strong><\/p>\n
static MongoDBContainer mongoDBContainer = new MongoDBContainer(DockerImageName.parse("mongo:4.0.10"))\r\n  .withReuse(true);<\/code><\/pre>\n
When we run the test for the first time, we’ll see the usual Testcontainers logs about starting the MongoDBContainer. <\/em>This usually takes a few seconds:<\/p>\n
23:56:42.383 [main] INFO tc.mongo:4.0.10 - Creating container for image: mongo:4.0.10\r\n23:56:42.892 [main] INFO tc.mongo:4.0.10 - Container mongo:4.0.10 is starting: d5fa298bf6...\r\n23:56:45.470 [main] INFO tc.mongo:4.0.10 - Container mongo:4.0.10 started in PT3.11239S<\/code><\/pre>\n
After the test finishes, we should be able to see the container still running. For example, we can check from the terminal using the docker ps<\/em>\u00a0command:<\/p>\n
\"\"<\/a><\/p>\n
 <\/p>\n
Furthermore, when we re-run the test, the container will be reused as long as the configuration isn’t changed. As a result, the container set-up time noticeably decreases:<\/p>\n
00:12:23.859 [main] INFO tc.mongo:4.0.10 - Creating container for image: mongo:4.0.10\r\n00:12:24.190 [main] INFO tc.mongo:4.0.10 - Reusing container with ID: d5fa298b... and hash: 0702144b...\r\n00:12:24.191 [main] INFO tc.mongo:4.0.10 - Reusing existing container (d5fa298b...) and not creating a new one\r\n00:12:24.398 [main] INFO tc.mongo:4.0.10 - Container mongo:4.0.10 started in PT0.5555088S<\/code><\/pre>\n
Lastly, the reused database contains previously inserted documents. Although this might be useful for local development, it may be harmful for testing. If we need to start fresh, we can simply clear the collection before each test.<\/p>\n
3.2. Testcontainers Configuration<\/h3>\n
<\/div>\n
In some cases, a warning may occur, stating that “Reuse was requested but the environment doesn’t support the reuse of containers”. <\/em><\/strong>This happens when the reuse\u00a0is disabled on our local Testcontainers configuration:<\/strong><\/p>\n
00:23:09.461 [main] INFO tc.mongo:4.0.10 - Creating container for image: mongo:4.0.10\r\n00:23:09.463 [main] WARN tc.mongo:4.0.10 - Reuse was requested but the environment does not support the reuse of containers\r\nTo enable reuse of containers, you must set 'testcontainers.reuse.enable=true' in a file located at C:\\Users\\Emanuel Trandafir\\.testcontainers.properties\r\n00:23:09.544 [main] INFO tc.mongo:4.0.10 - Container mongo:4.0.10 is starting: 903dd52d7...\r\n<\/code><\/pre>\n
To fix it, we can simply edit the .testcontainers.properties<\/em> file and set reuse<\/em> as enabled<\/em>:<\/p>\n
 <\/p>\n
\"\"<\/a><\/p>\n
3.3. Stopping the Container<\/h3>\n
<\/div>\n
We can manually stop the Docker container whenever we want, from the terminal. To do so, we only need to run the docker stop<\/em><\/a> command, followed by the container ID. Future executions of the application spin up a new Docker container.<\/p>\n
4. Testcontainers Desktop<\/h2>\n
<\/div>\n
We can install the Testcontainer Desktop<\/a> application to easily manage the lifecycle and configuration of our Testcontainers. <\/strong><\/p>\n
The application requires authentication, but we can easily log in using a GitHub account. After signing in, we’ll see the Testcontainers\u00a0icon in the toolbar. If we click on it, we’ll have a few options to choose from:<\/p>\n
 <\/p>\n
\"\"<\/a><\/p>\n
Now, executing the previously demonstrated steps is as effortless as the click of a button. For instance, we can enable or disable reusable containers with ease via Preferences > Enable reusable containers<\/em>. Furthermore, we have the capability to terminate the containers or freeze them before the shutdown, if more debugging is needed.<\/p>\n
5. Conclusion<\/h2>\n
<\/div>\n
In this article, we’ve learned how to reuse Testcontainers\u00a0<\/em>in Java. We discovered that JUnit 5 might try to shut down the container before finishing the execution. We avoided this by manually starting the containers instead of relying on the Testcontainers’ JUnit 5 extension.<\/p>\n
After that, we discussed the withReuse() <\/em>method and other Testcontainer-specific configurations. Finally, we installed the Testcontainers Desktop application, and we saw how it can be a valuable asset for double-checking configurations when it comes to managing the Testcontainers’ lifecycle.<\/p>\n
As always, the complete code used in this article is available\u00a0over on GitHub<\/a>.<\/p>\n
\"\"<\/p>\n
<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/p>\n
<\/p>\n
Comments<\/h3>\n
<\/a><\/p>\n