Today’s applications don’t live in isolation: we usually need to connect to various external components such as PostgreSQL, Apache Kafka, Cassandra, Redis, and other external APIs.<\/p>\n
In this tutorial, we’re going to see how Spring Framework 5.2.5 facilitates testing such applications with the introduction of dynamic properties<\/a>.<\/p>\n First, we’ll start by defining the problem and seeing how we used to solve the problem in a less than ideal way. Then, we’ll introduce the @DynamicPropertySource<\/a>\u00a0<\/em>annotation and see how it offers a better solution to the same problem. In the end, we’ll also take a look at another solution from test frameworks that can be superior compared to pure Spring solutions.<\/p>\n Let’s suppose we’re developing a typical application that uses PostgreSQL as its database. We’ll begin with a simple JPA entity<\/a>:<\/p>\n To make sure this entity works as expected, we should write a test for it to verify its database interactions. Since this test needs to talk to a real database, we should set up a PostgreSQL instance beforehand.<\/p>\n There are different approaches to set up such infrastructural tools during test executions<\/strong>. As a matter of fact, there are three main categories of such solutions:<\/p>\n As we shouldn’t differentiate between our test and production environments, there are better alternatives compared to using test doubles such as H2<\/a>. The third option, in addition to working with a real database, offers better isolation for tests<\/strong>. Moreover, with technologies like Docker and Testcontainers<\/a>, it’s easy to implement the third option.<\/p>\n Here’s what our test workflow will look like if we use technologies like Testcontainers:<\/p>\n If our PostgreSQL container is going to listen to a random port every time, then we should somehow set and change the spring.datasource.url <\/em>configuration property dynamically<\/strong>. Basically, each test should have its own version of that configuration property.<\/p>\n When the configurations are static, we can easily manage them using Spring Boot’s configuration management<\/a> facility. However, when we’re facing dynamic configurations, the same task can be challenging.<\/p>\n Now that we know the problem, let’s see a traditional solution for it.<\/p>\n The first approach to implement dynamic properties is to use a custom ApplicationContextInitializer<\/em><\/a><\/strong>. Basically, we set up our infrastructure first and use the information from the first step to customize the\u00a0ApplicationContext<\/em><\/a>:<\/p>\n Let’s walk through this somewhat complex setup. JUnit will create and start the container before anything else. After the container is ready, the Spring extension will call the initializer to apply the dynamic configuration to the Spring Environment<\/em><\/a>. Clearly, this approach is a bit verbose and complicated.<\/strong><\/p>\n Only after these steps can we write our test:<\/p>\n Spring Framework 5.2.5 introduced the\u00a0@DynamicPropertySource\u00a0<\/em>annotation to facilitate adding properties with dynamic values<\/strong>. All we have to do is to create a static method annotated with @DynamicPropertySource<\/em> and having just a single DynamicPropertyRegistry<\/a>\u00a0<\/em>instance as the input:<\/p>\n As shown above, we’re using the add(String, Supplier<Object>) <\/em><\/a>method on\u00a0the given\u00a0DynamicPropertyRegistry\u00a0<\/em>to add some properties to the Spring\u00a0Environment<\/em>. This approach is much cleaner compared to the initializer one we saw earlier. Please note that methods annotated with\u00a0@DynamicPropertySource\u00a0<\/em>must be declared as static<\/em> and must accept only one argument of type\u00a0DynamicPropertyRegistry<\/em>.\u00a0<\/strong><\/p>\n Basically, the main motivation behind the\u00a0@DynmicPropertySource\u00a0<\/em>annotation is to more easily facilitate something that was already possible. Although it was initially designed to work with Testcontainers, it’s possible to use it wherever we need to work with dynamic configurations.<\/p>\n So far, in both approaches, the fixture setup and the test code are tightly intertwined<\/strong>. Sometimes, this tight coupling of two concerns complicates the test code, especially when we have multiple things to set up. Imagine what the infrastructure setup would look like if we were using PostgreSQL and Apache Kafka in a single test.<\/p>\n In addition to that, the infrastructure setup and applying dynamic configurations will be duplicated in all tests that need them<\/strong>.<\/p>\n To avoid these drawbacks, we can use test fixtures facilities that most testing frameworks provide<\/strong>. For instance, in JUnit 5, we can define an extension<\/a> that starts a PostgreSQL instance before all tests, configures Spring Boot, and stops the PostgreSQL instance after running tests:<\/p>\n Here, we’re implementing AfterAllCallback<\/a>\u00a0<\/em>and\u00a0BeforeAllCallback<\/a>\u00a0<\/em>to create a JUnit 5 extension. This way, JUnit 5 will execute the beforeAll()\u00a0<\/em>logic before running all the tests, and the logic in the afterAll()\u00a0<\/em>method after running the tests. With this approach, our test code will be as clean as:<\/p>\n In addition to being more readable, we can easily reuse the same functionality just by adding the\u00a0@ExtendWith(PostgreSQLExtension.class)<\/em> annotation. There’s no need to copy-paste the whole PostgreSQL setup everywhere we need it, as we did in the other two approaches.<\/p>\n In this tutorial, we first saw how hard can it be to test a Spring component that depends on something like a database. Then, we introduced three solutions for this problem, each improving upon what the previous solution had to offer.<\/p>\n As usual, all the examples are available over on GitHub<\/a>.<\/p>\n The post Guide to @DynamicPropertySource in Spring<\/a> first appeared on Baeldung<\/a>.<\/p>\n Learn how to leverage @DynamicPropertySource to manage testing with external applications.<\/p>\n The post Guide to @DynamicPropertySource in Spring<\/a> first appeared on Baeldung<\/a>.<\/p>\n2. The Problem: Dynamic Properties<\/h2>\n
@Entity\r\n@Table(name = \"articles\")\r\npublic class Article {\r\n @Id\r\n @GeneratedValue(strategy = IDENTITY)\r\n private Long id;\r\n private String title;\r\n private String content;\r\n \/\/ getters and setters\r\n}<\/code><\/pre>\n\n
\n
3. Traditional Solution<\/h2>\n
@SpringBootTest\r\n@Testcontainers\r\n@ContextConfiguration(initializers = ArticleTraditionalLiveTest.EnvInitializer.class)\r\nclass ArticleTraditionalLiveTest {\r\n @Container\r\n static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>(\"postgres:11\")\r\n .withDatabaseName(\"prop\")\r\n .withUsername(\"postgres\")\r\n .withPassword(\"pass\")\r\n .withExposedPorts(5432);\r\n static class EnvInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {\r\n @Override\r\n public void initialize(ConfigurableApplicationContext applicationContext) {\r\n TestPropertyValues.of(\r\n String.format(\"spring.datasource.url=jdbc:postgresql:\/\/localhost:%d\/prop\", postgres.getFirstMappedPort()),\r\n \"spring.datasource.username=postgres\",\r\n \"spring.datasource.password=pass\"\r\n ).applyTo(applicationContext);\r\n }\r\n }\r\n \/\/ omitted \r\n}<\/code><\/pre>\n@Autowired\r\nprivate ArticleRepository articleRepository;\r\n@Test\r\nvoid givenAnArticle_whenPersisted_thenShouldBeAbleToReadIt() {\r\n Article article = new Article();\r\n article.setTitle(\"A Guide to @DynamicPropertySource in Spring\");\r\n article.setContent(\"Today's applications...\");\r\n articleRepository.save(article);\r\n Article persisted = articleRepository.findAll().get(0);\r\n assertThat(persisted.getId()).isNotNull();\r\n assertThat(persisted.getTitle()).isEqualTo(\"A Guide to @DynamicPropertySource in Spring\");\r\n assertThat(persisted.getContent()).isEqualTo(\"Today's applications...\");\r\n}<\/code><\/pre>\n4. The\u00a0@DynamicPropertySource<\/em><\/h2>\n
@SpringBootTest\r\n@Testcontainers\r\npublic class ArticleLiveTest {\r\n @Container\r\n static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>(\"postgres:11\")\r\n .withDatabaseName(\"prop\")\r\n .withUsername(\"postgres\")\r\n .withPassword(\"pass\")\r\n .withExposedPorts(5432);\r\n @DynamicPropertySource\r\n static void registerPgProperties(DynamicPropertyRegistry registry) {\r\n registry.add(\"spring.datasource.url\", \r\n () -> String.format(\"jdbc:postgresql:\/\/localhost:%d\/prop\", postgres.getFirstMappedPort()));\r\n registry.add(\"spring.datasource.username\", () -> \"postgres\");\r\n registry.add(\"spring.datasource.password\", () -> \"pass\");\r\n }\r\n \r\n \/\/ tests are same as before\r\n}<\/code><\/pre>\n5. An Alternative: Test Fixtures<\/h2>\n
public class PostgreSQLExtension implements BeforeAllCallback, AfterAllCallback {\r\n private PostgreSQLContainer<?> postgres;\r\n @Override\r\n public void beforeAll(ExtensionContext context) {\r\n postgres = new PostgreSQLContainer<>(\"postgres:11\")\r\n .withDatabaseName(\"prop\")\r\n .withUsername(\"postgres\")\r\n .withPassword(\"pass\")\r\n .withExposedPorts(5432);\r\n postgres.start();\r\n String jdbcUrl = String.format(\"jdbc:postgresql:\/\/localhost:%d\/prop\", postgres.getFirstMappedPort());\r\n System.setProperty(\"spring.datasource.url\", jdbcUrl);\r\n System.setProperty(\"spring.datasource.username\", \"postgres\");\r\n System.setProperty(\"spring.datasource.password\", \"pass\");\r\n }\r\n @Override\r\n public void afterAll(ExtensionContext context) {\r\n postgres.stop();\r\n }\r\n}\r\n<\/code><\/pre>\n@SpringBootTest\r\n@ExtendWith(PostgreSQLExtension.class)\r\npublic class ArticleTestFixtureLiveTest {\r\n \/\/ just the test code\r\n}<\/code><\/pre>\n6. Conclusion<\/h2>\n
<\/p>\n
![](\"https:\/\/assets.feedblitz.com\/i\/fblike20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/googleplus20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/pinterest20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/twitter20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/email20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/rss20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/comments20.png\")
<\/a> ![](\"https:\/\/assets.feedblitz.com\/i\/commentsrss20.png\")
<\/a> <\/div>\n\n![\\\"IT\u96fb\u8166\u88dc\u7fd2](\\\"http:\/\/itteacheritfreelance.hk\/test\/wordpress\/wp-content\/uploads\/2016\/05\/logo2-2.png\\\"){kind=logo}
\r\nwww.itsec.hk<\/a>
\r\nwww.itsec.vip<\/a>
\r\nwww.itseceu.uk<\/a>
<\/p>","protected":false},"excerpt":{"rendered":"<\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/a> <\/div>\n<\/div>","protected":false},"author":760,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"slim_seo":{"title":"Guide to @DynamicPropertySource in Spring - ITTeacherITFreelance.hk","description":"Learn how to leverage @DynamicPropertySource to manage testing with external applications. The post Guide to @DynamicPropertySource in Spring first appeared on"},"footnotes":""},"categories":[6],"tags":[],"_links":{"self":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/65404"}],"collection":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/users\/760"}],"replies":[{"embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/comments?post=65404"}],"version-history":[{"count":10,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/65404\/revisions"}],"predecessor-version":[{"id":70343,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/posts\/65404\/revisions\/70343"}],"wp:attachment":[{"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/media?parent=65404"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/categories?post=65404"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/itteacheritfreelance.hk\/wordpress\/index.php\/wp-json\/wp\/v2\/tags?post=65404"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}