feat(cassandra): modernize test infrastructure with Spring Boot Testcontainers

generators/spring-boot/generators/data-cassandra/cleanup.ts

@@ -37,4 +37,8 @@ export default asWritingTask(function cleanupCassandraFilesTask({ application, c
   if (control.isJhipsterVersionLessThan('7.10.0')) {
     this.removeFile(`${application.javaPackageTestDir}config/TestContainersSpringContextCustomizerFactory.java`);
   }
+  if (control.isJhipsterVersionLessThan('9.1.0')) {
+    this.removeFile(`${application.javaPackageTestDir}config/CassandraTestContainersSpringContextCustomizerFactory.java`);
+    this.removeFile(`${application.javaPackageTestDir}config/EmbeddedCassandra.java`);
+  }
 });

generators/spring-boot/generators/data-cassandra/files.ts

@@ -55,12 +55,7 @@ export const cassandraFiles = asWriteFilesSection<JavaApplication>({
     {
       path: `${SERVER_TEST_SRC_DIR}_package_/`,
       renameTo: moveToJavaPackageTestDir,
-      templates: [
-        'CassandraKeyspaceIT.java',
-        'config/CassandraTestContainer.java',
-        'config/CassandraTestContainersSpringContextCustomizerFactory.java',
-        'config/EmbeddedCassandra.java',
-      ],
+      templates: ['CassandraKeyspaceIT.java', 'config/CassandraTestContainer.java'],
     },
   ],
 });

generators/spring-boot/generators/data-cassandra/generator.spec.ts

@@ -59,7 +59,7 @@ describe(`generator - ${databaseType}`, () => {
         await helpers
           .runJHipster('server')
           .withJHipsterConfig(sampleConfig, entities)
-          .withMockedSource({ except: ['addTestSpringFactory'] })
+          .withMockedSource()
           .withMockedJHipsterGenerators({
             except: ['jhipster:spring-boot:data-cassandra'],
             filter: filterBasicServerGenerators,

generators/spring-boot/generators/data-cassandra/generator.ts

@@ -81,16 +81,10 @@ export default class CassandraGenerator extends SpringBootApplicationGenerator {
 
   get postWriting() {
     return this.asPostWritingTaskGroup({
-      addTestSpringFactory({ source, application }) {
-        source.addTestSpringFactory?.({
-          key: 'org.springframework.test.context.ContextCustomizerFactory',
-          value: `${application.packageName}.config.CassandraTestContainersSpringContextCustomizerFactory`,
-        });
-      },
       addDependencies({ application, source }) {
         const { reactive, javaDependencies } = application;
 
-        source.addSpringBootModule?.(`spring-boot-starter-data-cassandra${reactive ? '-reactive' : ''}`);
+        source.addSpringBootModule?.(`spring-boot-starter-data-cassandra${reactive ? '-reactive' : ''}`, 'spring-boot-testcontainers');
         source.addJavaDependencies?.([
           { groupId: 'org.apache.cassandra', artifactId: 'java-driver-mapper-runtime' },
           { groupId: 'commons-codec', artifactId: 'commons-codec' },
@@ -103,7 +97,14 @@ export default class CassandraGenerator extends SpringBootApplicationGenerator {
       },
       integrationTest({ application, source }) {
         source.editJavaFile!(`${application.javaPackageTestDir}IntegrationTest.java`, {
-          annotations: [{ package: `${application.packageName}.config`, annotation: 'EmbeddedCassandra' }],
+          imports: [`${application.packageName}.config.CassandraTestContainer`],
+          annotations: [
+            {
+              package: 'org.springframework.boot.testcontainers.context',
+              annotation: 'ImportTestcontainers',
+              parameters: (_, cb) => cb.addKeyValue('value', 'CassandraTestContainer.class'),
+            },
+          ],
         });
       },
     });

generators/spring-boot/generators/data-cassandra/templates/src/test/java/_package_/config/CassandraTestContainer.java.ejs

@@ -22,76 +22,69 @@ import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.CqlSessionBuilder;
 import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
 import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
-import java.io.IOException;
-import java.net.InetSocketAddress;
 import java.time.Duration;
-import java.time.temporal.ChronoUnit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.InitializingBean;
 import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
 import org.springframework.data.cassandra.core.cql.session.init.ResourceKeyspacePopulator;
-import org.testcontainers.containers.CassandraContainer;
-import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.testcontainers.cassandra.CassandraContainer;
+import org.testcontainers.junit.jupiter.Container;
 
-/**
- * Base class for starting/stopping Cassandra during tests.
- */
-public class CassandraTestContainer implements InitializingBean, DisposableBean {
+public interface CassandraTestContainer {
 
-    public static final String DEFAULT_KEYSPACE_NAME = "cassandratestkeyspace";
+    String DEFAULT_KEYSPACE_NAME = "cassandratestkeyspace";
 
-    private static final Logger LOG = LoggerFactory.getLogger(CassandraTestContainer.class);
-    private static final Integer DATABASE_REQUEST_TIMEOUT = 20;
-    private static final Integer CONTAINER_STARTUP_TIMEOUT_MINUTES = 10;
+    Logger LOG = LoggerFactory.getLogger(CassandraTestContainer.class);
 
-    private CassandraContainer<?> cassandraContainer;
+    @Container
+    CassandraContainer cassandraContainer = new CassandraContainer("<%- dockerContainers.cassandra %>")
+        .withStartupTimeout(Duration.ofMinutes(10))
+        .withLogConsumer(new org.testcontainers.containers.output.Slf4jLogConsumer(LOG))
+        .withReuse(true);
 
-    @Override
-    public void destroy() {
-        if (null != cassandraContainer && cassandraContainer.isRunning()) {
-            cassandraContainer.close();
-        }
-    }
-
-    @Override
-    public void afterPropertiesSet() throws IOException {
-        if (null == cassandraContainer) {
-            cassandraContainer = new CassandraContainer<>("<%- dockerContainers.cassandra %>")
-                    .withStartupTimeout(Duration.of(CONTAINER_STARTUP_TIMEOUT_MINUTES, ChronoUnit.MINUTES))
-                    .withLogConsumer(new Slf4jLogConsumer(LOG))
-                    .withReuse(true);
-        }
+    @DynamicPropertySource
+    static void registerProperties(DynamicPropertyRegistry registry) {
         if (!cassandraContainer.isRunning()) {
             cassandraContainer.start();
-
-            CqlSession cqlSession = new CqlSessionBuilder().addContactPoint(cassandraContainer.getContactPoint()).withLocalDatacenter(cassandraContainer.getLocalDatacenter()).build();
-            cqlSession.execute("CREATE KEYSPACE " + DEFAULT_KEYSPACE_NAME + " WITH replication={'class' : 'SimpleStrategy', 'replication_factor':1}");
-            cqlSession.close();
-
-            cqlSession = new CqlSessionBuilder()
-                .addContactPoint(cassandraContainer.getContactPoint())
-                .withLocalDatacenter(cassandraContainer.getLocalDatacenter())
-                .withKeyspace(DEFAULT_KEYSPACE_NAME)
-                .withConfigLoader(getConfigLoader())
-                .build();
-
-            new ResourceKeyspacePopulator(new PathMatchingResourcePatternResolver().getResources("config/cql/changelog/*.cql"))
-                .populate(cqlSession);
-
-            cqlSession.close();
+            initKeyspace();
         }
+        registry.add("spring.cassandra.port", () -> cassandraContainer.getMappedPort(CassandraContainer.CQL_PORT));
+        registry.add("spring.cassandra.contact-points", cassandraContainer::getHost);
+        registry.add("spring.cassandra.keyspace-name", () -> DEFAULT_KEYSPACE_NAME);
+        registry.add("spring.cassandra.local-datacenter", cassandraContainer::getLocalDatacenter);
     }
 
-    public CassandraContainer<?> getCassandraContainer() {
-        return cassandraContainer;
-    }
+    private static void initKeyspace() {
+        try (CqlSession session = new CqlSessionBuilder()
+            .addContactPoint(cassandraContainer.getContactPoint())
+            .withLocalDatacenter(cassandraContainer.getLocalDatacenter())
+            .build()) {
+            session.execute(
+                "CREATE KEYSPACE IF NOT EXISTS " + DEFAULT_KEYSPACE_NAME +
+                " WITH replication={'class':'SimpleStrategy','replication_factor':1}"
+            );
+        }
 
-    private DriverConfigLoader getConfigLoader() {
-        return DriverConfigLoader
+        DriverConfigLoader configLoader = DriverConfigLoader
             .programmaticBuilder()
-            .withDuration(DefaultDriverOption.REQUEST_TIMEOUT, Duration.ofSeconds(DATABASE_REQUEST_TIMEOUT))
+            .withDuration(DefaultDriverOption.REQUEST_TIMEOUT, Duration.ofSeconds(20))
             .build();
+
+        try (CqlSession session = new CqlSessionBuilder()
+            .addContactPoint(cassandraContainer.getContactPoint())
+            .withLocalDatacenter(cassandraContainer.getLocalDatacenter())
+            .withKeyspace(DEFAULT_KEYSPACE_NAME)
+            .withConfigLoader(configLoader)
+            .build()) {
+            try {
+                new ResourceKeyspacePopulator(
+                    new PathMatchingResourcePatternResolver().getResources("config/cql/changelog/*.cql")
+                ).populate(session);
+            } catch (Exception e) {
+                LOG.warn("Could not populate Cassandra keyspace: {}", e.getMessage());
+            }
+        }
     }
 }