generator-jhipster 7.7.0 → 7.9.0

package/generators/server/templates/src/test/java/package/config/MongoDbTestContainer.java.ejs

@@ -0,0 +1,67 @@
+<%#
+ Copyright 2013-2022 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+import java.util.Collections;
+
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.MongoDBContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+
+public class MongoDbTestContainer implements InitializingBean, DisposableBean {
+    /* private final long memoryInBytes = Math.round(1024 * 1024 * 1024 * 0.6);
+    private final long memorySwapInBytes = Math.round(1024 * 1024 * 1024 * 0.8);
+    private final long nanoCpu = Math.round(1_000_000_000L * 0.1); */
+    private static final Logger log = LoggerFactory.getLogger(MongoDbTestContainer.class);
+
+    private MongoDBContainer mongodbContainer;
+
+    @Override
+    public void destroy() {
+        if (null != mongodbContainer && mongodbContainer.isRunning()) {
+           mongodbContainer.stop();
+        }
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        if (null == mongodbContainer) {
+            mongodbContainer = new MongoDBContainer("<%= DOCKER_MONGODB %>")
+                .withTmpFs(Collections.singletonMap("/testtmpfs", "rw"))
+                /* .withCommand(
+                    "--nojournal --wiredTigerCacheSizeGB 0.25 --wiredTigerCollectionBlockCompressor none --slowOpSampleRate 0 --setParameter ttlMonitorEnabled=false --setParameter diagnosticDataCollectionEnabled=false --setParameter logicalSessionRefreshMillis=6000000 --setParameter enableFlowControl=false --setParameter oplogFetcherUsesExhaust=false --setParameter disableResumableRangeDeleter=true --setParameter enableShardedIndexConsistencyCheck=false --setParameter enableFinerGrainedCatalogCacheRefresh=false --setParameter readHedgingMode=off --setParameter loadRoutingTableOnStartup=false --setParameter rangeDeleterBatchDelayMS=2000000 --setParameter skipShardingConfigurationChecks=true --setParameter syncdelay=3600"
+                )
+                .withCreateContainerCmdModifier(cmd ->
+                    cmd.getHostConfig().withMemory(memoryInBytes).withMemorySwap(memorySwapInBytes).withNanoCPUs(nanoCpu)
+                ) */
+                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withReuse(true);
+        }
+        if (!mongodbContainer.isRunning()) {
+            mongodbContainer.start();
+        }
+    }
+
+    public MongoDBContainer getMongoDBContainer() {
+        return mongodbContainer;
+    }
+}

package/generators/server/templates/src/test/java/package/config/Neo4jTestContainer.java.ejs

@@ -0,0 +1,66 @@
+<%#
+    Copyright 2013-2022 the original author or authors from the JHipster project.
+
+    This file is part of the JHipster project, see https://www.jhipster.tech/
+    for more information.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.testcontainers.containers.Neo4jContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.testcontainers.utility.DockerImageName;
+
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+
+/**
+ * Base class for starting/stopping Neo4j during tests.
+ */
+public class Neo4jTestContainer implements InitializingBean, DisposableBean {
+
+    private static final Logger log = LoggerFactory.getLogger(Neo4jTestContainer.class);
+    private static final Integer CONTAINER_STARTUP_TIMEOUT_MINUTES = 10;
+    private Neo4jContainer neo4jContainer;
+
+    @Override
+    public void destroy() {
+        if (null != neo4jContainer && neo4jContainer.isRunning()) {
+            neo4jContainer.close();
+        }
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        if (null == neo4jContainer) {
+            neo4jContainer =
+                (Neo4jContainer) new Neo4jContainer(DockerImageName.parse("<%= DOCKER_NEO4J %>"))
+                    .withoutAuthentication()
+                    .withStartupTimeout(Duration.of(CONTAINER_STARTUP_TIMEOUT_MINUTES, ChronoUnit.MINUTES))
+                    .withLogConsumer(new Slf4jLogConsumer(log))
+                    .withReuse(true);
+        }
+        if (!neo4jContainer.isRunning()) {
+            neo4jContainer.start();
+        }
+    }
+
+    public Neo4jContainer getNeo4jContainer() {
+        return neo4jContainer;
+    }
+}

package/generators/server/templates/src/test/java/package/config/RedisTestContainer.java.ejs

@@ -0,0 +1,57 @@
+<%#
+ Copyright 2013-2022 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.GenericContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+import org.testcontainers.utility.DockerImageName;
+
+public class RedisTestContainer implements InitializingBean, DisposableBean {
+
+    private GenericContainer redisContainer;
+    private static final Logger log = LoggerFactory.getLogger(RedisTestContainer.class);
+
+    @Override
+    public void destroy() {
+        if (null != redisContainer && redisContainer.isRunning()) {
+            redisContainer.close();
+        }
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        if (null == redisContainer) {
+            redisContainer = new GenericContainer("<%= DOCKER_REDIS %>")
+                .withExposedPorts(6379)
+                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withReuse(true);
+        }
+        if (!redisContainer.isRunning()) {
+            redisContainer.start();
+        }
+    }
+
+    public GenericContainer getRedisContainer() {
+        return redisContainer;
+    }
+}

package/generators/server/templates/src/test/java/package/config/{NoOpMailConfiguration.java.ejs → SpringBootTestClassOrderer.java.ejs}

@@ -16,27 +16,27 @@
  See the License for the specific language governing permissions and
  limitations under the License.
 -%>
-package <%=packageName%>.config;
+package <%= packageName %>.config;
 
-import <%=packageName%>.service.MailService;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
 
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.mock;
+import org.junit.jupiter.api.ClassDescriptor;
+import org.junit.jupiter.api.ClassOrderer;
+import org.junit.jupiter.api.ClassOrdererContext;
+import <%= packageName %>.IntegrationTest;
 
-@Configuration
-public class NoOpMailConfiguration {
-    private final MailService mockMailService;
+import java.util.Comparator;
 
-    public NoOpMailConfiguration() {
-        mockMailService = mock(MailService.class);
-        doNothing().when(mockMailService).sendActivationEmail(any());
+public class SpringBootTestClassOrderer implements ClassOrderer {
+
+    @Override
+    public void orderClasses(ClassOrdererContext context) {
+        context.getClassDescriptors().sort(Comparator.comparingInt(SpringBootTestClassOrderer::getOrder));
     }
 
-    @Bean
-    public MailService mailService() {
-        return mockMailService;
+    private static int getOrder(ClassDescriptor classDescriptor) {
+        if (classDescriptor.findAnnotation(IntegrationTest.class).isPresent()) {
+            return 2;
+        }
+        return 1;
     }
 }

package/generators/server/templates/src/test/java/package/config/TestContainersSpringContextCustomizerFactory.java.ejs

@@ -0,0 +1,250 @@
+<%#
+ Copyright 2013-2022 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= packageName %>.config;
+
+import java.util.List;
+
+<%_ if (databaseTypeCassandra) { _%>
+import org.cassandraunit.CQLDataLoader;
+<%_ } _%>
+<%_ if (databaseTypeSql) { _%>
+import java.util.Arrays;
+import tech.jhipster.config.JHipsterConstants;
+<%_ } _%>
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
+import org.springframework.beans.factory.support.DefaultSingletonBeanRegistry;
+import org.springframework.core.annotation.AnnotatedElementUtils;
+
+import org.springframework.test.context.ContextConfigurationAttributes;
+import org.springframework.test.context.ContextCustomizer;
+import org.springframework.test.context.ContextCustomizerFactory;
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.boot.test.util.TestPropertyValues;
+<%_ if (databaseTypeCassandra) { _%>
+import org.testcontainers.containers.CassandraContainer;
+<%_ } _%>
+<%_ if (messageBrokerKafka) { _%>
+import org.testcontainers.containers.KafkaContainer;
+<%_ } _%>
+
+public class TestContainersSpringContextCustomizerFactory implements ContextCustomizerFactory {
+
+    private Logger log = LoggerFactory.getLogger(TestContainersSpringContextCustomizerFactory.class);
+
+<%_ if (cacheProviderRedis) { _%>
+    private static RedisTestContainer redisBean;
+<%_ } _%>
+<%_ if (messageBrokerKafka) { _%>
+    private static KafkaTestContainer kafkaBean;
+<%_ } _%>
+<%_ if (databaseTypeMongodb) { _%>
+    private static MongoDbTestContainer mongoDbBean;
+<%_ } _%>
+<%_ if (databaseTypeCassandra) { _%>
+    private static CassandraTestContainer cassandraBean;
+<%_ } _%>
+<%_ if (searchEngineElasticsearch) { _%>
+    private static ElasticsearchTestContainer elasticsearchBean;
+<%_ } _%>
+<%_ if (databaseTypeCouchbase || searchEngineCouchbase) { _%>
+    private static CouchbaseTestContainer couchbaseBean;
+<%_ } _%>
+<%_ if (databaseTypeNeo4j) { _%>
+    private static Neo4jTestContainer neo4jBean;
+<%_ } _%>
+<%_ if (devDatabaseTypeMysql || devDatabaseTypeMariadb || devDatabaseTypeMssql || devDatabaseTypePostgres) { _%>
+    private static SqlTestContainer devTestContainer;
+<%_ } _%>
+<%_ if (prodDatabaseTypeMysql || prodDatabaseTypeMariadb || prodDatabaseTypeMssql || prodDatabaseTypePostgres) { _%>
+    private static SqlTestContainer prodTestContainer;
+<%_ } _%>
+
+    @Override
+    public ContextCustomizer createContextCustomizer(Class<?> testClass, List<ContextConfigurationAttributes> configAttributes) {
+
+        return (context, mergedConfig) -> {
+            ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
+            TestPropertyValues testValues = TestPropertyValues.empty();
+<%_ if (databaseTypeCouchbase || searchEngineCouchbase) { _%>
+            EmbeddedCouchbase couchbaseAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedCouchbase.class);
+            if (null != couchbaseAnnotation) {
+                log.debug("detected the EmbeddedCouchbase annotation on class {}", testClass.getName());
+                log.info("Warming up the Couchbase database");
+                if (null == couchbaseBean) {
+                    couchbaseBean = beanFactory.createBean(CouchbaseTestContainer.class);
+                    beanFactory.registerSingleton(CouchbaseTestContainer.class.getName(), couchbaseBean);
+                    // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(CouchbaseTestContainer.class.getName(), couchbaseBean);
+                }
+                testValues = testValues.and("spring.couchbase.connection-string=" + couchbaseBean.getCouchbaseContainer().getConnectionString());
+                testValues = testValues.and("spring.couchbase.username=" + couchbaseBean.getCouchbaseContainer().getUsername());
+                testValues = testValues.and("spring.couchbase.password=" + couchbaseBean.getCouchbaseContainer().getPassword());
+                testValues = testValues.and("jhipster.database.couchbase.bucket-name=" + couchbaseBean.getBucketName());
+                testValues = testValues.and("jhipster.database.couchbase.scope-name=testScope");
+            }
+<%_ } _%>
+<%_ if (databaseTypeMongodb) { _%>
+                EmbeddedMongo mongoAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedMongo.class);
+                if (null != mongoAnnotation) {
+                    log.debug("detected the EmbeddedMongo annotation on class {}", testClass.getName());
+                    log.info("Warming up the mongo database");
+                    if (null == mongoDbBean) {
+                        mongoDbBean = beanFactory.createBean(MongoDbTestContainer.class);
+                        beanFactory.registerSingleton(MongoDbTestContainer.class.getName(), mongoDbBean);
+                        // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(MongoDbTestContainer.class.getName(), mongoDbBean);
+                    }
+                    testValues = testValues.and("spring.data.mongodb.uri=" + mongoDbBean.getMongoDBContainer().getReplicaSetUrl());
+                }
+<%_ } _%>
+<%_ if (cacheProviderRedis) { _%>
+                EmbeddedRedis redisAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedRedis.class);
+                if (null != redisAnnotation) {
+                    log.debug("detected the EmbeddedRedis annotation on class {}", testClass.getName());
+                    log.info("Warming up the redis database");
+                    if (null == redisBean) {
+                        redisBean = beanFactory.createBean(RedisTestContainer.class);
+                        beanFactory.registerSingleton(RedisTestContainer.class.getName(), redisBean);
+                        // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(RedisTestContainer.class.getName(), redisBean);
+                    }
+                    testValues = testValues.and("jhipster.cache.redis.server=redis://" + redisBean.getRedisContainer().getContainerIpAddress() + ":" + redisBean.getRedisContainer().getMappedPort(6379));
+                }
+<%_ } _%>
+<%_ if (databaseTypeSql) { _%>
+            EmbeddedSQL sqlAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedSQL.class);
+            if (null != sqlAnnotation) {
+                log.debug("detected the EmbeddedSQL annotation on class {}", testClass.getName());
+                log.info("Warming up the sql database");
+  <%_ if (devDatabaseTypeMysql || devDatabaseTypeMariadb || devDatabaseTypeMssql || devDatabaseTypePostgres) { _%>
+                if (Arrays.asList(context.getEnvironment().getActiveProfiles()).contains("test" + JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)) {
+                    if (null == devTestContainer) {
+                        try {
+                            Class<? extends SqlTestContainer> containerClass = (Class<? extends SqlTestContainer>) Class.forName(this.getClass().getPackageName() + ".<% if (devDatabaseTypeMysql) { %>Mysql<% } else if (devDatabaseTypeMariadb) { %>Mariadb<% } else if (devDatabaseTypeMssql) { %>MsSql<% } else if (devDatabaseTypePostgres) { %>PostgreSql<% } %>TestContainer");
+                            devTestContainer = beanFactory.createBean(containerClass);
+                            beanFactory.registerSingleton(containerClass.getName(), devTestContainer);
+                            // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(containerClass.getName(), devTestContainer);
+                        } catch (ClassNotFoundException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }
+    <%_ if (reactive) { _%>
+                    testValues = testValues.and("spring.r2dbc.url=" + devTestContainer.getTestContainer().getJdbcUrl().replace("jdbc", "r2dbc")<% if (devDatabaseTypeMysql) { %>.replace("mysql", "mariadb")<% } %> + "<%- getDBCExtraOption(devDatabaseType) %>");
+                    testValues = testValues.and("spring.r2dbc.username=" + devTestContainer.getTestContainer().getUsername());
+                    testValues = testValues.and("spring.r2dbc.password=" + devTestContainer.getTestContainer().getPassword());
+                    testValues = testValues.and("spring.liquibase.url=" + devTestContainer.getTestContainer().getJdbcUrl() + "<%- getDBCExtraOption(devDatabaseType) %>" );
+    <%_ } else { _%>
+                    testValues = testValues.and("spring.datasource.url=" + devTestContainer.getTestContainer().getJdbcUrl() + "<%- getDBCExtraOption(devDatabaseType) %>");
+                    testValues = testValues.and("spring.datasource.username=" + devTestContainer.getTestContainer().getUsername());
+                    testValues = testValues.and("spring.datasource.password=" + devTestContainer.getTestContainer().getPassword());
+    <%_ } _%>
+                }
+  <%_ } _%>
+  <%_ if (prodDatabaseTypeMysql || prodDatabaseTypeMariadb || prodDatabaseTypeMssql || prodDatabaseTypePostgres) { _%>
+                if (Arrays.asList(context.getEnvironment().getActiveProfiles()).contains("test" + JHipsterConstants.SPRING_PROFILE_PRODUCTION)) {
+                    if (null == prodTestContainer) {
+                        try {
+                            Class<? extends SqlTestContainer> containerClass = (Class<? extends SqlTestContainer>) Class.forName(this.getClass().getPackageName() + ".<% if (prodDatabaseTypeMysql) { %>Mysql<% } else if (prodDatabaseTypeMariadb) { %>Mariadb<% } else if (prodDatabaseTypeMssql) { %>MsSql<% } else if (prodDatabaseTypePostgres) { %>PostgreSql<% } %>TestContainer");
+                            prodTestContainer = beanFactory.createBean(containerClass);
+                            beanFactory.registerSingleton(containerClass.getName(), prodTestContainer);
+                            // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(containerClass.getName(), prodTestContainer);
+                        } catch (ClassNotFoundException e) {
+                            throw new RuntimeException(e);
+                        }
+                    }
+    <%_ if (reactive) { _%>
+                    testValues = testValues.and("spring.r2dbc.url=" + prodTestContainer.getTestContainer().getJdbcUrl().replace("jdbc", "r2dbc")<% if (prodDatabaseTypeMysql) { %>.replace("mysql", "mariadb")<% } %> + "<%- getDBCExtraOption(prodDatabaseType) %>");
+                    testValues = testValues.and("spring.r2dbc.username=" + prodTestContainer.getTestContainer().getUsername());
+                    testValues = testValues.and("spring.r2dbc.password=" + prodTestContainer.getTestContainer().getPassword());
+                    testValues = testValues.and("spring.liquibase.url=" + prodTestContainer.getTestContainer().getJdbcUrl()  + "<%- getDBCExtraOption(prodDatabaseType) %>");
+    <%_ } else { _%>
+                    testValues = testValues.and("spring.datasource.url=" + prodTestContainer.getTestContainer().getJdbcUrl() + "<%- getDBCExtraOption(prodDatabaseType) %>");
+                    testValues = testValues.and("spring.datasource.username=" + prodTestContainer.getTestContainer().getUsername());
+                    testValues = testValues.and("spring.datasource.password=" + prodTestContainer.getTestContainer().getPassword());
+    <%_ } _%>
+                }
+  <%_ } _%>
+            }
+<%_ } _%>
+<%_ if (databaseTypeCassandra) { _%>
+            EmbeddedCassandra cassandraAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedCassandra.class);
+            if (null != cassandraAnnotation) {
+                log.debug("detected the EmbeddedCassandra annotation on class {}", testClass.getName());
+                log.info("Warming up the cassandra database");
+                if (null == cassandraBean) {
+                    cassandraBean = beanFactory.createBean(CassandraTestContainer.class);
+                    beanFactory.registerSingleton(CassandraTestContainer.class.getName(), cassandraBean);
+                    // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(CassandraTestContainer.class.getName(), cassandraBean);
+                }
+                testValues = testValues.and("spring.data.cassandra.port=" +  cassandraBean.getCassandraContainer().getMappedPort(CassandraContainer.CQL_PORT))
+                    .and("spring.data.cassandra.contact-points=" +  cassandraBean.getCassandraContainer().getHost())
+                    .and("spring.data.cassandra.keyspace-name=" + CQLDataLoader.DEFAULT_KEYSPACE_NAME)
+                    .and("spring.data.cassandra.local-datacenter=" + cassandraBean.getCassandraContainer().getCluster().getMetadata().getAllHosts().iterator().next().getDatacenter())
+                    .and("spring.data.cassandra.cluster-name=" + cassandraBean.getCassandraContainer().getCluster().getMetadata().getClusterName());
+            }
+<%_ } _%>
+<%_ if (databaseTypeNeo4j) { _%>
+            EmbeddedNeo4j neo4jAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedNeo4j.class);
+            if (null != neo4jAnnotation) {
+                log.debug("detected the EmbeddedNeo4j annotation on class {}", testClass.getName());
+                log.info("Warming up the neo4j database");
+                if (null == neo4jBean) {
+                    neo4jBean = beanFactory.createBean(Neo4jTestContainer.class);
+                    beanFactory.registerSingleton(Neo4jTestContainer.class.getName(), neo4jBean);
+                    // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(Neo4jTestContainer.class.getName(), neo4jBean);
+                }
+                testValues =
+                    testValues.and(
+                        "spring.neo4j.uri=" + neo4jBean.getNeo4jContainer().getBoltUrl()
+                    );
+            }
+<%_ } _%>
+<%_ if (messageBrokerKafka) { _%>
+            EmbeddedKafka kafkaAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedKafka.class);
+            if (null != kafkaAnnotation) {
+                log.debug("detected the EmbeddedKafka annotation on class {}", testClass.getName());
+                log.info("Warming up the kafka broker");
+                if (null == kafkaBean) {
+                    kafkaBean = beanFactory.createBean(KafkaTestContainer.class);
+                    beanFactory.registerSingleton(KafkaTestContainer.class.getName(), kafkaBean);
+                    // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(KafkaTestContainer.class.getName(), kafkaBean);
+                }
+                testValues = testValues.and("spring.cloud.stream.kafka.binder.brokers=" + kafkaBean.getKafkaContainer().getHost() + ':' + kafkaBean.getKafkaContainer().getMappedPort(KafkaContainer.KAFKA_PORT));
+            }
+<%_ } _%>
+<%_ if (searchEngineElasticsearch) { _%>
+            EmbeddedElasticsearch elasticsearchAnnotation = AnnotatedElementUtils.findMergedAnnotation(testClass, EmbeddedElasticsearch.class);
+            if (null != elasticsearchAnnotation) {
+                log.debug("detected the EmbeddedElasticsearch annotation on class {}", testClass.getName());
+                log.info("Warming up the elastic database");
+                if (null == elasticsearchBean) {
+                    elasticsearchBean = beanFactory.createBean(ElasticsearchTestContainer.class);
+                    beanFactory.registerSingleton(ElasticsearchTestContainer.class.getName(), elasticsearchBean);
+                    // ((DefaultListableBeanFactory)beanFactory).registerDisposableBean(ElasticsearchTestContainer.class.getName(), elasticsearchBean);
+                }
+                testValues =
+                    testValues.and(
+                        "spring.elasticsearch.uris=http://" + elasticsearchBean.getElasticsearchContainer().getHttpHostAddress()
+                    );
+            }
+<%_ } _%>
+            testValues.applyTo(context);
+        };
+    }
+}

package/generators/server/templates/src/test/java/package/config/WebConfigurerTest.java.ejs

@@ -20,9 +20,6 @@ package <%= packageName %>.config;
 
 import tech.jhipster.config.JHipsterConstants;
 import tech.jhipster.config.JHipsterProperties;
-<%_ if (devDatabaseTypeH2Any) { _%>
-import org.h2.server.web.WebServlet;
-<%_ } _%>
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 <%_ if (!skipClient) { _%>
@@ -79,26 +76,6 @@ class WebConfigurerTest {
         webConfigurer = new WebConfigurer(env, props);
     }
 
-    @Test
-    void shouldStartUpProdServletContext() throws ServletException {
-        env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION);
-
-        assertThatCode(() -> webConfigurer.onStartup(servletContext)).doesNotThrowAnyException();
-<%_ if (devDatabaseTypeH2Any) { _%>
-        verify(servletContext, never()).addServlet(eq("H2Console"), any(WebServlet.class));
-<%_ } _%>
-    }
-
-    @Test
-    void shouldStartUpDevServletContext() throws ServletException {
-        env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT);
-
-        assertThatCode(() -> webConfigurer.onStartup(servletContext)).doesNotThrowAnyException();
-<%_ if (devDatabaseTypeH2Any) { _%>
-        verify(servletContext).addServlet(eq("H2Console"), any(WebServlet.class));
-<%_ } _%>
-    }
-
 <%_ if (!skipClient) { _%>
     @Test
     void shouldCustomizeServletContainer() {

package/generators/server/templates/src/test/java/package/cucumber/CucumberIT.java.ejs

@@ -18,18 +18,11 @@
 -%>
 package <%= packageName %>.cucumber;
 
-<%_ if (databaseTypeCassandra) { _%>
-import <%= packageName %>.AbstractCassandraTest;
-<%_ } _%>
-<%_ if (databaseTypeNeo4j) { _%>
-import <%= packageName %>.AbstractNeo4jIT;
-<%_ } _%>
+import <%= packageName %>.IntegrationTest;
 import io.cucumber.junit.platform.engine.Cucumber;
 
 @Cucumber
-<%_ if (databaseTypeNeo4j) { _%>
-@ExtendWith(AbstractNeo4jIT)
-<%_ } _%>
-class CucumberIT <% if (databaseTypeCassandra) { %>extends AbstractCassandraTest<% } %> {
+@IntegrationTest
+class CucumberIT {
 
 }

package/generators/server/templates/src/test/java/package/security/DomainUserDetailsServiceIT.java.ejs

@@ -18,9 +18,6 @@
 -%>
 package <%= packageName %>.security;
 
-<%_ if (databaseTypeCassandra) { _%>
-import <%= packageName %>.AbstractCassandraTest;
-<%_ } _%>
 import <%= packageName %>.IntegrationTest;
 <%_ if (databaseTypeSql && reactive) { _%>
 import <%= packageName %>.config.Constants;
@@ -32,6 +29,7 @@ import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
 <%_ if (reactive) { _%>
 import org.springframework.security.core.userdetails.ReactiveUserDetailsService;
 <%_ } _%>
@@ -64,7 +62,7 @@ import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 @WithMockUser("test-user-one")
 <%_ } _%>
 @IntegrationTest
-class DomainUserDetailsServiceIT <% if (databaseTypeCassandra) { %>extends AbstractCassandraTest <% } %>{
+class DomainUserDetailsServiceIT {
 
     private static final String USER_ONE_LOGIN = "test-user-one";
     private static final String USER_ONE_EMAIL = "test-user-one@localhost";
@@ -77,6 +75,7 @@ class DomainUserDetailsServiceIT <% if (databaseTypeCassandra) { %>extends Abstr
     private UserRepository userRepository;
 
     @Autowired
+    @Qualifier("userDetailsService")
     private <% if (reactive) { %>Reactive<% } %>UserDetailsService domainUserDetailsService;
 
     @BeforeEach
@@ -93,7 +92,7 @@ class DomainUserDetailsServiceIT <% if (databaseTypeCassandra) { %>extends Abstr
         userOne.setId(UUID.randomUUID().toString());
 <%_ } _%>
         userOne.setLogin(USER_ONE_LOGIN);
-        userOne.setPassword(RandomStringUtils.random(60));
+        userOne.setPassword(RandomStringUtils.randomAlphanumeric(60));
         userOne.setActivated(true);
         userOne.setEmail(USER_ONE_EMAIL);
         userOne.setFirstName("userOne");
@@ -109,7 +108,7 @@ class DomainUserDetailsServiceIT <% if (databaseTypeCassandra) { %>extends Abstr
         userTwo.setId(UUID.randomUUID().toString());
 <%_ } _%>
         userTwo.setLogin(USER_TWO_LOGIN);
-        userTwo.setPassword(RandomStringUtils.random(60));
+        userTwo.setPassword(RandomStringUtils.randomAlphanumeric(60));
         userTwo.setActivated(true);
         userTwo.setEmail(USER_TWO_EMAIL);
         userTwo.setFirstName("userTwo");
@@ -125,7 +124,7 @@ class DomainUserDetailsServiceIT <% if (databaseTypeCassandra) { %>extends Abstr
         userThree.setId(UUID.randomUUID().toString());
 <%_ } _%>
         userThree.setLogin(USER_THREE_LOGIN);
-        userThree.setPassword(RandomStringUtils.random(60));
+        userThree.setPassword(RandomStringUtils.randomAlphanumeric(60));
         userThree.setActivated(false);
         userThree.setEmail(USER_THREE_EMAIL);
         userThree.setFirstName("userThree");

package/generators/server/templates/src/test/java/package/security/jwt/JWTFilterTest.java.ejs

@@ -93,7 +93,7 @@ class JWTFilterTest {
         MockServerWebExchange exchange = MockServerWebExchange.from(request);
         jwtFilter.filter(
             exchange,
-            it -> Mono.subscriberContext()
+            it -> Mono.deferContextual(Mono::just)
                 .flatMap(c -> ReactiveSecurityContextHolder.getContext())
                 .map(SecurityContext::getAuthentication)
                 .doOnSuccess(auth -> assertThat(auth.getName()).isEqualTo("test-user"))
@@ -123,7 +123,7 @@ class JWTFilterTest {
         MockServerWebExchange exchange = MockServerWebExchange.from(request);
         jwtFilter.filter(
             exchange,
-            it -> Mono.subscriberContext()
+            it -> Mono.deferContextual(Mono::just)
                 .flatMap(c -> ReactiveSecurityContextHolder.getContext())
                 .map(SecurityContext::getAuthentication)
                 .doOnSuccess(auth -> assertThat(auth).isNull())
@@ -149,7 +149,7 @@ class JWTFilterTest {
         MockServerWebExchange exchange = MockServerWebExchange.from(request);
         jwtFilter.filter(
             exchange,
-            it -> Mono.subscriberContext()
+            it -> Mono.deferContextual(Mono::just)
                 .flatMap(c -> ReactiveSecurityContextHolder.getContext())
                 .map(SecurityContext::getAuthentication)
                 .doOnSuccess(auth -> assertThat(auth).isNull())
@@ -175,7 +175,7 @@ class JWTFilterTest {
         MockServerWebExchange exchange = MockServerWebExchange.from(request);
         jwtFilter.filter(
             exchange,
-            it -> Mono.subscriberContext()
+            it -> Mono.deferContextual(Mono::just)
                 .flatMap(c -> ReactiveSecurityContextHolder.getContext())
                 .map(SecurityContext::getAuthentication)
                 .doOnSuccess(auth -> assertThat(auth).isNull())
@@ -208,7 +208,7 @@ class JWTFilterTest {
         MockServerWebExchange exchange = MockServerWebExchange.from(request);
         jwtFilter.filter(
             exchange,
-            it -> Mono.subscriberContext()
+            it -> Mono.deferContextual(Mono::just)
                 .flatMap(c -> ReactiveSecurityContextHolder.getContext())
                 .map(SecurityContext::getAuthentication)
                 .doOnSuccess(auth -> assertThat(auth).isNull())