generator-jhipster 7.7.0 → 7.8.0

package/generators/server/templates/src/main/java/package/repository/EntityManager.java.ejs

@@ -192,11 +192,11 @@ public class EntityManager {
      * @param referencedIds the id of the referred entities.
      * @return the number of inserted rows.
      */
-    public Mono<Integer> updateLinkTable(LinkTable table, Long entityId, Stream<Long> referencedIds) {
+    public Mono<Integer> updateLinkTable(LinkTable table, Object entityId, Stream<?> referencedIds) {
         return deleteFromLinkTable(table, entityId)
                 .then(
                     Flux.fromStream(referencedIds)
-                        .flatMap((Long referenceId) -> {
+                        .flatMap((Object referenceId) -> {
                             StatementMapper.InsertSpec insert = r2dbcEntityTemplate
                                 .getDataAccessStrategy()
                                 .getStatementMapper()
@@ -214,7 +214,7 @@ public class EntityManager {
                         .map((List<Integer> updates) -> updates.stream().reduce(Integer::sum).orElse(0)));
     }
 
-    public Mono<Void> deleteFromLinkTable(LinkTable table, Long entityId) {
+    public Mono<Void> deleteFromLinkTable(LinkTable table, Object entityId) {
         Assert.notNull(entityId, "entityId is null");
         StatementMapper.DeleteSpec deleteSpec = r2dbcEntityTemplate.getDataAccessStrategy().getStatementMapper()
             .createDelete(table.tableName)

package/generators/server/templates/src/main/java/package/security/jwt/JWTFilter.java.ejs

@@ -75,7 +75,7 @@ public class JWTFilter <% if (reactive) { %>implements WebFilter<% } else { %>ex
         if (StringUtils.hasText(jwt) && this.tokenProvider.validateToken(jwt)) {
             Authentication authentication = this.tokenProvider.getAuthentication(jwt);
 <%_ if (reactive) { _%>
-            return chain.filter(exchange).subscriberContext(ReactiveSecurityContextHolder.withAuthentication(authentication));
+            return chain.filter(exchange).contextWrite(ReactiveSecurityContextHolder.withAuthentication(authentication));
         }
         return chain.filter(exchange);
 <%_ } else { _%>

package/generators/server/templates/src/main/java/package/security/jwt/TokenProvider.java.ejs

@@ -106,7 +106,7 @@ public class TokenProvider {
             .signWith(key, SignatureAlgorithm.HS512)
             .setExpiration(validity)
 <%_ if (reactive) { _%>
-            .serializeToJsonWith(new JacksonSerializer())
+            .serializeToJsonWith(new JacksonSerializer<>())
 <%_ } _%>
             .compact();
     }

package/generators/server/templates/src/main/java/package/web/rest/KafkaResource.java.ejs

@@ -18,133 +18,85 @@
 -%>
 package <%= packageName %>.web.rest;
 
-import <%= packageName %>.config.KafkaProperties;
-import org.apache.kafka.clients.consumer.ConsumerRecord;
-<%_ if (!reactive) { _%>
-import org.apache.kafka.clients.consumer.ConsumerRecords;
-import org.apache.kafka.clients.consumer.KafkaConsumer;
-import org.apache.kafka.clients.producer.KafkaProducer;
-import org.apache.kafka.clients.producer.ProducerRecord;
-import org.apache.kafka.clients.producer.RecordMetadata;
-<%_ }  _%>
+import static org.springframework.web.servlet.mvc.method.annotation.SseEmitter.event;
+
+import java.io.IOException;
+import java.security.Principal;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.cloud.stream.annotation.StreamListener;
+import org.springframework.http.MediaType;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.GenericMessage;
+import org.springframework.util.MimeTypeUtils;
+
 import org.springframework.web.bind.annotation.*;
-<%_ if (reactive) { _%>
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
-import reactor.kafka.receiver.KafkaReceiver;
-import reactor.kafka.receiver.ReceiverOptions;
-import reactor.kafka.sender.KafkaSender;
-import reactor.kafka.sender.SenderOptions;
-import reactor.kafka.sender.SenderRecord;
-import reactor.kafka.sender.SenderResult;
-<%_ }  _%>
-<%_ if (!reactive) { _%>
+import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyEmitter;
 import org.springframework.web.servlet.mvc.method.annotation.SseEmitter;
-<%_ }  _%>
 
-<%_ if (!reactive) { _%>
-import java.time.Duration;
-<%_ }  _%>
-import java.time.Instant;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-<%_ if (!reactive) { _%>
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-<%_ }  _%>
+import <%= packageName %>.config.KafkaSseConsumer;
+import <%= packageName %>.config.KafkaSseProducer;
 
 @RestController
 @RequestMapping("/api/<%= dasherizedBaseName %>-kafka")
 public class <%= upperFirstCamelCase(baseName) %>KafkaResource {
 
     private final Logger log = LoggerFactory.getLogger(<%= upperFirstCamelCase(baseName) %>KafkaResource.class);
+    private final MessageChannel output;
+
+    // TODO implement state of the art emitter repository to become 12 factor
+    private Map<String, SseEmitter> emitters = new HashMap<>();
 
-    private final KafkaProperties kafkaProperties;
-<%_ if (reactive) { _%>
-    private KafkaSender<String, String> sender;
-<%_ } else { _%>
-    private KafkaProducer<String, String> producer;
-    private ExecutorService sseExecutorService = Executors.newCachedThreadPool();
-<%_ }  _%>
-
-    public <%= upperFirstCamelCase(baseName) %>KafkaResource(KafkaProperties kafkaProperties) {
-        this.kafkaProperties = kafkaProperties;
-<%_ if (reactive) { _%>
-        this.sender = KafkaSender.create(SenderOptions.create(kafkaProperties.getProducerProps()));
-<%_ } else { _%>
-        this.producer = new KafkaProducer<>(kafkaProperties.getProducerProps());
-<%_ }  _%>
+    public <%= upperFirstCamelCase(baseName) %>KafkaResource(@Qualifier(KafkaSseProducer.CHANNELNAME) MessageChannel output) {
+        this.output = output;
     }
 
-    @PostMapping("/publish/{topic}")
-    public <% if (reactive) { %>Mono<PublishResult><% } else { %>PublishResult<% }  %> publish(@PathVariable String topic, @RequestParam String message, @RequestParam(required = false) String key)<% if (!reactive) { %> throws ExecutionException, InterruptedException<% } %> {
-        log.debug("REST request to send to Kafka topic {} with key {} the message : {}", topic, key, message);
-<%_ if (reactive) { _%>
-        return Mono.just(SenderRecord.create(topic, null, null, key, message, null))
-            .as(sender::send)
-            .next()
-            .map(SenderResult::recordMetadata)
-            .map(metadata -> new PublishResult(metadata.topic(), metadata.partition(), metadata.offset(), Instant.ofEpochMilli(metadata.timestamp())));
-<%_ } else { _%>
-        RecordMetadata metadata = producer.send(new ProducerRecord<>(topic, key, message)).get();
-        return new PublishResult(metadata.topic(), metadata.partition(), metadata.offset(), Instant.ofEpochMilli(metadata.timestamp()));
-<%_ }  _%>
+    @PostMapping("/publish")
+    public void publish(@RequestParam String message) {
+        log.debug("REST request the message : {} to send to Kafka topic ", message);
+        Map<String, Object> map = new HashMap<>();
+        map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN_VALUE);
+        MessageHeaders headers = new MessageHeaders(map);
+        output.send(new GenericMessage<>(message, headers));
     }
 
-    @GetMapping("/consume")
-    public <% if (reactive) { %>Flux<String><% } else { %>SseEmitter<% }  %> consume(@RequestParam("topic") List<String> topics, @RequestParam Map<String, String> consumerParams) {
-        log.debug("REST request to consume records from Kafka topics {}", topics);
-        Map<String, Object> consumerProps = kafkaProperties.getConsumerProps();
-        consumerProps.putAll(consumerParams);
-        consumerProps.remove("topic");
-
-<%_ if (reactive) { _%>
-        ReceiverOptions<String, String> receiverOptions = ReceiverOptions.<String, String>create(consumerProps)
-            .subscription(topics);
-        return KafkaReceiver.create(receiverOptions)
-            .receive()
-            .map(ConsumerRecord::value);
-<%_ } else { _%>
-        SseEmitter emitter = new SseEmitter(0L);
-        sseExecutorService.execute(() -> {
-            KafkaConsumer<String, String> consumer = new KafkaConsumer<>(consumerProps);
-            emitter.onCompletion(consumer::close);
-            consumer.subscribe(topics);
-            boolean exitLoop = false;
-            while(!exitLoop) {
+    @GetMapping("/register")
+    public ResponseBodyEmitter register(Principal principal) {
+        log.debug("Registering sse client for {}", principal.getName());
+        SseEmitter emitter = new SseEmitter();
+        emitter.onCompletion(() -> emitters.remove(emitter));
+        emitters.put(principal.getName(), emitter);
+        return emitter;
+    }
+
+    @GetMapping("/unregister")
+    public void unregister(Principal principal) {
+        String user = principal.getName();
+        log.debug("Unregistering sse emitter for user: {}", user);
+        Optional.ofNullable(emitters.get(user))
+            .ifPresent(ResponseBodyEmitter::complete);
+    }
+
+    @StreamListener(value = KafkaSseConsumer.CHANNELNAME, copyHeaders = "false")
+    public void consume(Message<String> message) {
+        log.debug("Got message from kafka stream: {}", message.getPayload());
+        emitters.entrySet().stream().map(Map.Entry::getValue)
+            .forEach((SseEmitter emitter) -> {
                 try {
-                    ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(5));
-                    for (ConsumerRecord<String, String> record : records) {
-                        emitter.send(record.value());
-                    }
-                    emitter.send(SseEmitter.event().comment(""));
-                } catch (Exception ex) {
-                    log.trace("Complete with error {}", ex.getMessage(), ex);
-                    emitter.completeWithError(ex);
-                    exitLoop = true;
-                }
+                    emitter.send(event().data(message.getPayload(), MediaType.TEXT_PLAIN));
+                } catch (IOException e) {
+                log.debug("error sending sse message, {}", message.getPayload());
             }
-            consumer.close();
-            emitter.complete();
         });
-        return emitter;
-<%_ }  _%>
     }
 
-    private static class PublishResult {
-        public final String topic;
-        public final int partition;
-        public final long offset;
-        public final Instant timestamp;
-
-        private PublishResult(String topic, int partition, long offset, Instant timestamp) {
-            this.topic = topic;
-            this.partition = partition;
-            this.offset = offset;
-            this.timestamp = timestamp;
-        }
-    }
+
 }
+

package/generators/server/templates/src/main/java/package/web/rest/KafkaResource_reactive.java.ejs

@@ -0,0 +1,74 @@
+<%#
+ 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 %>.web.rest;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.cloud.stream.annotation.StreamListener;
+import org.springframework.http.ResponseEntity;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageChannel;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.messaging.support.GenericMessage;
+import org.springframework.util.MimeTypeUtils;
+import org.springframework.web.bind.annotation.*;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.publisher.Sinks;
+import <%= packageName %>.config.KafkaSseConsumer;
+import <%= packageName %>.config.KafkaSseProducer;
+
+@RestController
+@RequestMapping("/api/<%= dasherizedBaseName %>-kafka")
+public class <%= upperFirstCamelCase(baseName) %>KafkaResource {
+
+    private final Logger log = LoggerFactory.getLogger(<%= upperFirstCamelCase(baseName) %>KafkaResource.class);
+
+    private final MessageChannel output;
+    private Sinks.Many<Message<String>> sink = Sinks.many().unicast().onBackpressureBuffer();
+
+    public <%= upperFirstCamelCase(baseName) %>KafkaResource(@Qualifier(KafkaSseProducer.CHANNELNAME) MessageChannel output) {
+        this.output = output;
+    }
+
+    @PostMapping("/publish")
+    public Mono<ResponseEntity<Void>> publish(@RequestParam String message) {
+        log.debug("REST request the message : {} to send to Kafka topic", message);
+        Map<String, Object> map = new HashMap<>();
+        map.put(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.TEXT_PLAIN_VALUE);
+        MessageHeaders headers = new MessageHeaders(map);
+        output.send(new GenericMessage<>(message, headers));
+        return Mono.just(ResponseEntity.noContent().build());
+    }
+
+    @GetMapping("/consume")
+    public Flux<String> consume() {
+        log.debug("REST request to consume records from Kafka topics");
+        return sink.asFlux().map(m -> m.getPayload());
+    }
+
+    @StreamListener(value = KafkaSseConsumer.CHANNELNAME, copyHeaders = "false")
+    public void consume(Message<String> message) {
+        log.debug("Got message from kafka stream: {}", message.getPayload());
+        sink.emitNext(message, Sinks.EmitFailureHandler.FAIL_FAST);
+    }
+}

package/generators/server/templates/src/main/resources/config/application.yml.ejs

@@ -156,7 +156,7 @@ spring:
 <%_ } _%>
   application:
     name: <%= baseName %>
-<%_ if (serviceDiscoveryConsul || (applicationTypeGateway && reactive)) { _%>
+<%_ if (serviceDiscoveryConsul || (applicationTypeGateway && reactive) || messageBrokerKafka) { _%>
   cloud:
   <%_ if (serviceDiscoveryConsul) { _%>
     consul:
@@ -189,6 +189,23 @@ spring:
         pool:
           max-connections: 1000
   <%_ } _%>
+  <%_ if (messageBrokerKafka) { _%>
+    stream:
+      kafka:
+        binder:
+          replicationFactor: 1
+          auto-create-topics: true
+          brokers: localhost:9092
+      bindings:
+        binding-in-sse:
+          destination: sse-topic
+          content-type: text/plain
+          group: <%= dasherizedBaseName %>
+        binding-out-sse:
+          destination: sse-topic
+          content-type: text/plain
+          group: <%= dasherizedBaseName %>
+  <%_ } _%>
 <%_ } _%>
   profiles:
     # The commented value for `active` can be replaced with valid Spring profiles to load.
@@ -252,7 +269,6 @@ spring:
     basename: i18n/messages
   main:
     allow-bean-definition-overriding: true
-    allow-circular-references: true
 <%_ if (!reactive) { _%>
   mvc:
     pathmatch:
@@ -299,7 +315,7 @@ spring:
             client-id: web_app
             client-secret: web_app
   <%_ } _%>
-            scope: openid,profile,email
+            scope: openid, profile, email, offline_access # last one for refresh tokens
 <%_ } _%>
 
 server:
@@ -330,11 +346,11 @@ jhipster:
   #   allowed-origins: "http://localhost:8100,http://localhost:9000"
   #   allowed-methods: "*"
   #   allowed-headers: "*"
-  <%_ if (authenticationType === 'session') { _%>
+<%_ if (authenticationTypeSession) { _%>
   #   exposed-headers: "Link,X-Total-Count,X-${jhipster.clientApp.name}-alert,X-${jhipster.clientApp.name}-error,X-${jhipster.clientApp.name}-params"
-  <%_ } else { _%>
+<%_ } else { _%>
   #   exposed-headers: "Authorization,Link,X-Total-Count,X-${jhipster.clientApp.name}-alert,X-${jhipster.clientApp.name}-error,X-${jhipster.clientApp.name}-params"
-  <%_ } _%>
+<%_ } _%>
   #   allow-credentials: true
   #   max-age: 1800
   mail:
@@ -352,28 +368,16 @@ jhipster:
     license: unlicensed
     license-url:
   security:
-    <%_ if (clientTheme !== 'none') { _%>
+<%_ if (clientTheme !== 'none') { _%>
     content-security-policy: "default-src 'self'; frame-src 'self' data:; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://storage.googleapis.com; style-src 'self' https://fonts.googleapis.com 'unsafe-inline'; img-src 'self' data:; font-src 'self' https://fonts.gstatic.com data:"
-    <%_ } else { _%>
+<%_ } else { _%>
     content-security-policy: "default-src 'self'; frame-src 'self' data:; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://storage.googleapis.com; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:"
-    <%_ } _%>
-    <%_ if (authenticationType === 'oauth2') { _%>
+<%_ } _%>
+<%_ if (authenticationTypeOauth2) { _%>
     oauth2:
       audience:
         - account
         - api://default
-  <%_ } _%>
-<%_ if (messageBroker === 'kafka') { _%>
-kafka:
-  bootstrap-servers: localhost:9092
-  consumer:
-    key.deserializer: org.apache.kafka.common.serialization.StringDeserializer
-    value.deserializer: org.apache.kafka.common.serialization.StringDeserializer
-    group.id: <%= dasherizedBaseName %>
-    auto.offset.reset: earliest
-  producer:
-    key.serializer: org.apache.kafka.common.serialization.StringSerializer
-    value.serializer: org.apache.kafka.common.serialization.StringSerializer
 <%_ } _%>
 
 # ===================================================================

package/generators/server/templates/src/test/java/package/CassandraKeyspaceIT.java.ejs

@@ -18,17 +18,16 @@
 -%>
 package <%= packageName %>;
 
-import <%= packageName %>.IntegrationTest;
 import com.datastax.oss.driver.api.core.CqlSession;
 import com.datastax.oss.driver.api.core.metadata.Metadata;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
+import org.cassandraunit.CQLDataLoader;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
 @IntegrationTest
-public class CassandraKeyspaceIT extends AbstractCassandraTest {
+public class CassandraKeyspaceIT {
 
     @Autowired
     private CqlSession session;
@@ -36,6 +35,6 @@ public class CassandraKeyspaceIT extends AbstractCassandraTest {
     @Test
     void shouldListCassandraUnitKeyspace() {
         Metadata metadata = session.getMetadata();
-        assertThat(metadata.getKeyspace(CASSANDRA_UNIT_KEYSPACE)).isNotNull();
+        assertThat(metadata.getKeyspace(CQLDataLoader.DEFAULT_KEYSPACE_NAME)).isNotNull();
     }
 }

package/generators/server/templates/src/test/java/package/IntegrationTest.java.ejs

@@ -27,7 +27,10 @@ import tech.jhipster.config.JHipsterConstants;
 import <%= packageName %>.AbstractNeo4jIT;
 <%_ } _%>
 <%_ if (databaseTypeMongodb) { _%>
-    import <%= packageName %>.MongoDbTestContainerExtension;
+import <%= packageName %>.config.EmbeddedMongo;
+<%_ } _%>
+<%_ if (databaseTypeCassandra) { _%>
+import <%= packageName %>.config.EmbeddedCassandra;
 <%_ } _%>
 <%_ if (reactiveSqlTestContainers) { _%>
 import <%= packageName %>.ReactiveSqlTestContainerExtension;
@@ -38,7 +41,7 @@ import <%= packageName %>.RedisTestContainerExtension;
 <%_ if (authenticationTypeOauth2) { _%>
 import <%= packageName %>.config.TestSecurityConfiguration;
 <%_ } _%>
-<%_ if (cacheProviderRedis || databaseTypeNeo4j || databaseTypeCouchbase || reactiveSqlTestContainers || databaseTypeMongodb) { _%>
+<%_ if (cacheProviderRedis || databaseTypeNeo4j || databaseTypeCouchbase || reactiveSqlTestContainers) { _%>
 import org.junit.jupiter.api.extension.ExtendWith;
 <%_ } _%>
 
@@ -67,7 +70,10 @@ import java.lang.annotation.Target;
 @ActiveProfiles(JHipsterConstants.SPRING_PROFILE_TEST)
 <%_ } _%>
 <%_ if (databaseTypeMongodb) { _%>
-@ExtendWith(MongoDbTestContainerExtension.class)
+@EmbeddedMongo
+<%_ } _%>
+<%_ if (databaseTypeCassandra) { _%>
+@EmbeddedCassandra
 <%_ } _%>
 <%_ if (databaseTypeNeo4j) { _%>
 @ExtendWith(AbstractNeo4jIT.class)

package/generators/server/templates/src/test/java/package/TechnicalStructureTest.java.ejs

@@ -66,9 +66,6 @@ class TechnicalStructureTest {
         .ignoreDependency(alwaysTrue(), belongToAnyOf(
 <%_ if (hasConstants) { _%>
             <%= packageName %>.config.Constants.class,
-<%_ } _%>
-<%_ if (messageBrokerKafka) { _%>
-            <%= packageName %>.config.KafkaProperties.class,
 <%_ } _%>
             <%= packageName %>.config.ApplicationProperties.class
         ));

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

@@ -0,0 +1,122 @@
+package <%= packageName %>.config;
+
+import static java.nio.file.Files.newDirectoryStream;
+import static java.nio.file.Paths.get;
+import static java.util.Spliterator.SORTED;
+import static java.util.Spliterators.spliteratorUnknownSize;
+import static java.util.stream.StreamSupport.stream;
+
+import com.datastax.driver.core.Cluster;
+import com.datastax.driver.core.Session;
+import com.datastax.oss.driver.api.core.CqlSession;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.util.Iterator;
+import java.util.Spliterator;
+
+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 org.cassandraunit.CQLDataLoader;
+import org.cassandraunit.dataset.cql.ClassPathCQLDataSet;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.testcontainers.containers.CassandraContainer;
+import org.testcontainers.containers.output.Slf4jLogConsumer;
+
+/**
+ * Base class for starting/stopping Cassandra during tests.
+ */
+public class CassandraTestContainer implements InitializingBean, DisposableBean {
+
+    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;
+    private CassandraContainer cassandraContainer;
+
+    @Override
+    public void destroy() {
+        if (null != cassandraContainer && cassandraContainer.isRunning()) {
+            cassandraContainer.stop();
+        }
+    }
+
+    @Override
+    public void afterPropertiesSet() {
+        if (null == cassandraContainer) {
+            cassandraContainer = (CassandraContainer) new CassandraContainer("<%= DOCKER_CASSANDRA %>")
+                .withStartupTimeout(Duration.of(CONTAINER_STARTUP_TIMEOUT_MINUTES, ChronoUnit.MINUTES))
+                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withReuse(true);
+        }
+        if (!cassandraContainer.isRunning()) {
+            cassandraContainer.start();
+            Cluster cluster = cassandraContainer.getCluster();
+
+            try(Session session = cluster.connect()) {
+                createTestKeyspace(session);
+            }
+            CqlSession cqlSession = new CqlSessionBuilder()
+                .addContactPoint(
+                    new InetSocketAddress(
+                        cassandraContainer.getHost(),
+                        cassandraContainer.getMappedPort(CassandraContainer.CQL_PORT))
+                ).withLocalDatacenter(cluster.getMetadata().getAllHosts().iterator().next().getDatacenter())
+                .withKeyspace(CQLDataLoader.DEFAULT_KEYSPACE_NAME)
+                .withConfigLoader(getConfigLoader())
+                .build();
+            CQLDataLoader dataLoader = new CQLDataLoader(cqlSession);
+            applyScripts(dataLoader, "config/cql/changelog/", "*.cql");
+            cqlSession.close();
+        }
+    }
+
+    public CassandraContainer getCassandraContainer() {
+        return cassandraContainer;
+    }
+
+    private DriverConfigLoader getConfigLoader() {
+        return  DriverConfigLoader.programmaticBuilder()
+            .withDuration(DefaultDriverOption.REQUEST_TIMEOUT, Duration.ofSeconds(DATABASE_REQUEST_TIMEOUT))
+            .build();
+    }
+
+    private void createTestKeyspace(Session session) {
+        String createQuery =
+            "CREATE KEYSPACE " + CQLDataLoader.DEFAULT_KEYSPACE_NAME + " WITH replication={'class' : 'SimpleStrategy', 'replication_factor':1}";
+        session.execute(createQuery);
+    }
+
+    private void applyScripts(CQLDataLoader dataLoader, String cqlDir, String pattern) {
+        URL dirUrl = ClassLoader.getSystemResource(cqlDir);
+        if (dirUrl == null) { // protect for empty directory
+            return;
+        }
+
+        Iterator<Path> pathIterator = null;
+        try {
+            pathIterator = newDirectoryStream(get(dirUrl.toURI()), pattern).iterator();
+        } catch (IOException e) {
+            log.error("error trying to reading CQL chagelog", e);
+        } catch (URISyntaxException e) {
+            log.error("error trying to get CQL chagelog uri", e);
+        }
+
+        Spliterator<Path> pathSpliterator = spliteratorUnknownSize(pathIterator, SORTED);
+        stream(pathSpliterator, false)
+            .map(Path::getFileName)
+            .map(Path::toString)
+            .sorted()
+            .map(file -> cqlDir + file)
+            .map(dataSetLocation -> new ClassPathCQLDataSet(dataSetLocation, false, false, dataLoader.getSession().getKeyspace().get().toString()))
+            .forEach(dataLoader::load);
+    }
+}

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

@@ -0,0 +1,11 @@
+package <%= packageName %>.config;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface EmbeddedCassandra {
+}

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

@@ -0,0 +1,11 @@
+package <%= packageName %>.config;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface EmbeddedKafka {
+}

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

@@ -0,0 +1,11 @@
+package <%= packageName %>.config;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface EmbeddedMongo {
+}