cleanup and refactoring of notification

close rabbit and redis connexion on application close
Refactoring of Configuration class
fix notification id increment
Add builder for NotificationPush
Add close to notificationPush to remove listener
Clean tags of tests
purge queue before functional tests

.idea/runConfigurations/Unit_Tests.xml

@@ -15,7 +15,7 @@
       <env name="SEND_GRID_KEY" value="$SEND_GRID_KEY$" />
     </envs>
     <dir value="$PROJECT_DIR$" />
-    <tag value="!functional" />
+    <tag value="unit" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>

.idea/runConfigurations/Unit_Tests__offline_.xml

@@ -1,23 +0,0 @@
-<component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Unit Tests (offline)" type="JUnit" factoryName="JUnit" show_console_on_std_err="true">
-    <output_file path="$PROJECT_DIR$/var/log/test/out.log" is_save="true" />
-    <useClassPathOnly />
-    <option name="PACKAGE_NAME" value="fr.dcproject" />
-    <option name="MAIN_CLASS_NAME" value="" />
-    <option name="METHOD_NAME" value="" />
-    <option name="TEST_OBJECT" value="tags" />
-    <option name="VM_PARAMETERS" value="-ea -Dcucumber.options=&quot;--tags ~@online&quot; -Djdk.attach.allowAttachSelf=true" />
-    <option name="PARAMETERS" value="" />
-    <option name="TEST_SEARCH_SCOPE">
-      <value defaultName="wholeProject" />
-    </option>
-    <envs>
-      <env name="SEND_GRID_KEY" value="$SEND_GRID_KEY$" />
-    </envs>
-    <dir value="$PROJECT_DIR$" />
-    <tag value="!online" />
-    <method v="2">
-      <option name="Make" enabled="true" />
-    </method>
-  </configuration>
-</component>

src/main/kotlin/application/Application.kt

@@ -39,6 +39,7 @@ import fr.dcproject.routes.notificationArticle
 import fr.dcproject.security.AccessDeniedException
 import fr.postgresjson.migration.Migrations
 import io.ktor.application.Application
+import io.ktor.application.ApplicationStopped
 import io.ktor.application.call
 import io.ktor.application.install
 import io.ktor.auth.Authentication
@@ -122,7 +123,12 @@ fun Application.module(env: Env = PROD) {
         masking = false
     }
 
-    NotificationConsumer(get(), get(), get(), get(), get(), Configuration.exchangeNotificationName).config()
+    get<NotificationConsumer>().run {
+        start()
+        environment.monitor.subscribe(ApplicationStopped) {
+            close()
+        }
+    }
 
     install(Authentication, jwtInstallation(get()))
 

src/main/kotlin/application/Configuration.kt

@@ -1,23 +1,39 @@
 package fr.dcproject.application
 
+import com.typesafe.config.Config
 import com.typesafe.config.ConfigFactory
 import java.net.URI
 
-object Configuration {
+class Configuration(val config: Config) {
-    private var config = ConfigFactory.load()
+    constructor(resourceBasename: String? = null) : this(if (resourceBasename == null) ConfigFactory.load() else ConfigFactory.load(resourceBasename))
 
-    object Sql {
+    interface Sql {
-        val migrationFiles: URI = this::class.java.getResource("/sql/migrations")?.toURI() ?: error("No migrations found")
+        val migrationFiles: URI
-        val functionFiles: URI = this::class.java.getResource("/sql/functions")?.toURI() ?: error("No sql function found")
+        val functionFiles: URI
-        val fixtureFiles: URI = this::class.java.getResource("/sql/fixtures")?.toURI() ?: error("No sql fixture found")
+        val fixtureFiles: URI
     }
-    object Database {
+    val sql
-        val host: String = config.getString("db.host")
+        get() = object : Sql {
-        val port: Int = config.getInt("db.port")
+            override val migrationFiles: URI = this::class.java.getResource("/sql/migrations")?.toURI() ?: error("No migrations found")
-        var database: String = config.getString("db.database")
+            override val functionFiles: URI = this::class.java.getResource("/sql/functions")?.toURI() ?: error("No sql function found")
-        var username: String = config.getString("db.username")
+            override val fixtureFiles: URI = this::class.java.getResource("/sql/fixtures")?.toURI() ?: error("No sql fixture found")
-        var password: String = config.getString("db.password")
+        }
+
+    interface Database {
+        val host: String
+        val port: Int
+        var database: String
+        var username: String
+        var password: String
     }
+    val database
+        get() = object : Database {
+            override val host: String = config.getString("db.host")
+            override val port: Int = config.getInt("db.port")
+            override var database: String = config.getString("db.database")
+            override var username: String = config.getString("db.username")
+            override var password: String = config.getString("db.password")
+        }
 
     val envName: String = config.getString("app.envName")
     val domain: String = config.getString("app.domain")

src/main/kotlin/application/KoinModule.kt

@@ -8,9 +8,10 @@ import com.fasterxml.jackson.databind.module.SimpleModule
 import com.fasterxml.jackson.datatype.joda.JodaModule
 import com.fasterxml.jackson.module.kotlin.jacksonObjectMapper
 import com.rabbitmq.client.ConnectionFactory
-import fr.dcproject.notification.publisher.Publisher
 import fr.dcproject.messages.Mailer
 import fr.dcproject.messages.NotificationEmailSender
+import fr.dcproject.notification.NotificationConsumer
+import fr.dcproject.notification.publisher.Publisher
 import fr.postgresjson.connexion.Connection
 import fr.postgresjson.connexion.Requester
 import fr.postgresjson.migration.Migrations
@@ -18,36 +19,52 @@ import io.ktor.client.HttpClient
 import io.ktor.client.features.websocket.WebSockets
 import io.ktor.util.KtorExperimentalAPI
 import io.lettuce.core.RedisClient
-import io.lettuce.core.api.async.RedisAsyncCommands
+import notification.NotificationsPush
 import org.koin.core.qualifier.named
 import org.koin.dsl.module
+import org.koin.ktor.ext.get
 
 @KtorExperimentalAPI
 val KoinModule = module {
+    single { Configuration() }
+
     // SQL connection
     single {
+        val config: Configuration = get()
         Connection(
-            host = Configuration.Database.host,
+            host = config.database.host,
-            port = Configuration.Database.port,
+            port = config.database.port,
-            database = Configuration.Database.database,
+            database = config.database.database,
-            username = Configuration.Database.username,
+            username = config.database.username,
-            password = Configuration.Database.password
+            password = config.database.password
         )
     }
 
     // Launch Database migration
-    single { Migrations(get(), Configuration.Sql.migrationFiles, Configuration.Sql.functionFiles) }
+    single {
+        val config: Configuration = get()
+        Migrations(get(), config.sql.migrationFiles, config.sql.functionFiles)
+    }
 
     // Redis client
     single<RedisClient> {
-        RedisClient.create(Configuration.redis).apply {
+        val config: Configuration = get()
+        RedisClient.create(config.redis).apply {
             connect().sync().configSet("notify-keyspace-events", "KEA")
         }
     }
 
+    single { NotificationsPush.Builder(get()) }
+
+    single {
+        val config: Configuration = get()
+        NotificationConsumer(get(), get(), get(), get(), get(), config.exchangeNotificationName)
+    }
+
     // RabbitMQ
     single<ConnectionFactory> {
-        ConnectionFactory().apply { setUri(Configuration.rabbitmq) }
+        val config: Configuration = get()
+        ConnectionFactory().apply { setUri(config.rabbitmq) }
     }
 
     // JsonSerializer
@@ -71,16 +88,26 @@ val KoinModule = module {
 
     // SQL Requester (postgresJson)
     single {
+        val config: Configuration = get()
         Requester.RequesterFactory(
             connection = get(),
-            functionsDirectory = Configuration.Sql.functionFiles
+            functionsDirectory = config.sql.functionFiles
         ).createRequester()
     }
 
     // Mailer
-    single { Mailer(Configuration.sendGridKey) }
+    single {
+        val config: Configuration = get()
+        Mailer(config.sendGridKey)
+    }
 
-    single { Publisher(factory = get(), exchangeName = Configuration.exchangeNotificationName) }
+    single {
+        val config: Configuration = get()
+        Publisher(factory = get(), exchangeName = config.exchangeNotificationName)
+    }
 
-    single { NotificationEmailSender(get<Mailer>(), Configuration.domain, get(), get()) }
+    single {
+        val config: Configuration = get()
+        NotificationEmailSender(get<Mailer>(), config.domain, get(), get())
+    }
 }

src/main/kotlin/component/auth/KoinModule.kt

@@ -7,5 +7,8 @@ import org.koin.dsl.module
 val authKoinModule = module {
     single { UserRepository(get()) }
     // Used to send a connexion link by email
-    single { PasswordlessAuth(get<Mailer>(), Configuration.domain, get()) }
+    single {
+        val config: Configuration = get()
+        PasswordlessAuth(get<Mailer>(), config.domain, get())
+    }
 }

src/main/kotlin/component/views/KoinModule.kt

@@ -8,12 +8,15 @@ import org.elasticsearch.client.RestClient
 import org.koin.dsl.module
 
 val viewKoinModule = module {
-    // Elasticsearch Client
-    val esClient = RestClient.builder(
-        HttpHost.create(Configuration.elasticsearch)
-    ).build().apply {
-        createEsIndexForViews()
-    }
 
-    single { ArticleViewManager<ArticleForView>(esClient) }
+    single {
+        val config: Configuration = get()
+        // Elasticsearch Client
+        val esClient = RestClient.builder(
+            HttpHost.create(config.elasticsearch)
+        ).build().apply {
+            createEsIndexForViews()
+        }
+        ArticleViewManager<ArticleForView>(esClient)
+    }
 }

src/main/kotlin/notification/Notification.kt

@@ -10,16 +10,16 @@ import com.fasterxml.jackson.module.kotlin.readValue
 import fr.dcproject.component.article.ArticleForView
 import fr.postgresjson.entity.UuidEntity
 import org.joda.time.DateTime
-import kotlin.random.Random
+import java.util.concurrent.atomic.AtomicInteger
 
 open class Notification(
     val type: String,
     val createdAt: DateTime = DateTime.now()
 ) {
-    val id: Double = randId(createdAt.millis)
+    val id: Double = nextId()
 
-    private fun randId(time: Long): Double {
+    private fun nextId(): Double {
-        return (time.toString() + Random.nextInt(1000, 9999).toString()).toDouble()
+        return (createdAt.millis.toString() + nextInt().toString()).toDouble()
     }
 
     override fun toString(): String = mapper.writeValueAsString(this) ?: error("Unable to serialize notification")
@@ -27,6 +27,12 @@ open class Notification(
     fun toByteArray() = toString().toByteArray()
 
     companion object {
+        private val counter: AtomicInteger = AtomicInteger(1000)
+        fun nextInt(): Int {
+            counter.compareAndSet(9999, 1000)
+            return counter.incrementAndGet()
+        }
+
         val mapper = jacksonObjectMapper().apply {
             registerModule(SimpleModule())
             propertyNamingStrategy = PropertyNamingStrategies.SNAKE_CASE

src/main/kotlin/notification/NotificationConsumer.kt

@@ -29,10 +29,18 @@ class NotificationConsumer(
     private val notificationEmailSender: NotificationEmailSender,
     private val exchangeName: String,
 ) {
-    val redis: RedisAsyncCommands<String, String> = redisClient.connect()?.async() ?: error("Unable to connect to redis")
+    private val redisConnection = redisClient.connect() ?: error("Unable to connect to redis")
+    private val redis: RedisAsyncCommands<String, String> = redisConnection.async() ?: error("Unable to connect to redis")
+    private val rabbitConnection = rabbitFactory.newConnection()
+    private val rabbitChannel = rabbitConnection.createChannel()
     private val logger: Logger = LoggerFactory.getLogger(Publisher::class.qualifiedName)
 
-    fun config() {
+    fun close() {
+        rabbitChannel.close()
+        rabbitConnection.close()
+    }
+
+    fun start() {
         /* Config Rabbit */
         rabbitFactory.newConnection().use { connection ->
             connection.createChannel().use { channel ->
@@ -45,8 +53,6 @@ class NotificationConsumer(
         }
 
         /* Define Consumer */
-        val rabbitChannel = rabbitFactory.newConnection().createChannel()
-
         val consumerPush: Consumer = object : DefaultConsumer(rabbitChannel) {
             @Throws(IOException::class)
             override fun handleDelivery(
@@ -106,4 +112,4 @@ class NotificationConsumer(
         val rawMessage: String,
         val follow: FollowSimple<out TargetRef, CitizenRef>
     )
-}
+}

src/main/kotlin/notification/NotificationsPush.kt

@@ -1,34 +1,80 @@
 package notification
 
 import com.fasterxml.jackson.core.JsonProcessingException
+import fr.dcproject.component.auth.citizen
 import fr.dcproject.component.citizen.CitizenI
 import fr.dcproject.notification.Notification
+import io.ktor.http.cio.websocket.Frame
+import io.ktor.http.cio.websocket.Frame.Text
+import io.ktor.http.cio.websocket.readText
 import io.ktor.routing.Route
+import io.ktor.websocket.DefaultWebSocketServerSession
 import io.lettuce.core.Limit
 import io.lettuce.core.Range
 import io.lettuce.core.Range.Boundary
 import io.lettuce.core.RedisClient
 import io.lettuce.core.api.async.RedisAsyncCommands
 import io.lettuce.core.pubsub.RedisPubSubAdapter
+import io.lettuce.core.pubsub.StatefulRedisPubSubConnection
+import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.coroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.flow.consumeAsFlow
 import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import org.slf4j.LoggerFactory
 
-class NotificationsPush (
+class NotificationsPush private constructor(
-    val redisClient: RedisClient,
+    private val redis: RedisAsyncCommands<String, String>,
+    private val redisConnectionPubSub: StatefulRedisPubSubConnection<String, String>,
     citizen: CitizenI,
     incoming: Flow<Notification>,
     onRecieve: suspend (Notification) -> Unit,
-)
+) {
-{
+    class Builder(val redisClient: RedisClient) {
-    val redis: RedisAsyncCommands<String, String> = redisClient.connect()?.async() ?: error("Unable to connect to redis")
+        private val redisConnection = redisClient.connect() ?: error("Unable to connect to redis")
-    val key = "notification:${citizen.id}"
+        private val redisConnectionPubSub = redisClient.connectPubSub() ?: error("Unable to connect to redis")
+        private val redis: RedisAsyncCommands<String, String> = redisConnection.async() ?: error("Unable to connect to redis")
+
+        fun build(
+            citizen: CitizenI,
+            incoming: Flow<Notification>,
+            onRecieve: suspend (Notification) -> Unit,
+        ): NotificationsPush = NotificationsPush(redis, redisConnectionPubSub, citizen, incoming, onRecieve)
+
+        @ExperimentalCoroutinesApi
+        fun build(ws: DefaultWebSocketServerSession): NotificationsPush {
+            /* Convert channel of string from websocket, to a flow of Notification object */
+            val incomingFlow: Flow<Notification> = ws.incoming.consumeAsFlow()
+                .mapNotNull<Frame, Text> { it as? Frame.Text }
+                .map { it.readText() }
+                .map { Notification.fromString(it) }
+
+            return build(ws.call.citizen, incomingFlow) {
+                ws.outgoing.send(Text(it.toString()))
+            }.apply {
+                ws.outgoing.invokeOnClose { close() }
+            }
+        }
+    }
+
+    private val key = "notification:${citizen.id}"
     private var score: Double = 0.0
+    private val listener = object : RedisPubSubAdapter<String, String>() {
+        /* On new key publish */
+        override fun message(pattern: String?, channel: String?, message: String?) {
+            runBlocking {
+                getNotifications().collect {
+                    onRecieve(it)
+                }
+            }
+        }
+    }
 
     init {
         /* Mark as read all incoming notifications */
@@ -44,21 +90,16 @@ class NotificationsPush (
         }
 
         /* Lisen redis event, and sent the new notification into websocket */
-        redisClient.connectPubSub()?.run {
+        redisConnectionPubSub.run {
-            addListener(object : RedisPubSubAdapter<String, String>() {
+            addListener(listener)
-                /* On new key publish */
-                override fun message(pattern: String?, channel: String?, message: String?) {
-                    runBlocking {
-                        getNotifications().collect {
-                            onRecieve(it)
-                        }
-                    }
-                }
-            })
 
             /* Register to the events */
             async()?.psubscribe("__key*__:$key") ?: error("Unable to connect to redis")
-        } ?: error("PubSub Fail")
+        }
+    }
+
+    fun close() {
+        redisConnectionPubSub.removeListener(listener)
     }
 
     /* Return flow with all new notifications */
@@ -92,4 +133,4 @@ class NotificationsPush (
                 .error("Unable to deserialize notification")
         }
     }
-}
+}

src/main/kotlin/routes/Notification.kt

@@ -1,19 +1,9 @@
 package fr.dcproject.routes
 
-import fr.dcproject.component.auth.citizen
-import fr.dcproject.notification.Notification
-import io.ktor.http.cio.websocket.Frame
-import io.ktor.http.cio.websocket.Frame.Text
-import io.ktor.http.cio.websocket.readText
 import io.ktor.locations.KtorExperimentalLocationsAPI
 import io.ktor.routing.Route
 import io.ktor.websocket.webSocket
-import io.lettuce.core.RedisClient
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.consumeAsFlow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.mapNotNull
 import notification.NotificationsPush
 
 /**
@@ -23,18 +13,8 @@ import notification.NotificationsPush
  */
 @ExperimentalCoroutinesApi
 @KtorExperimentalLocationsAPI
-fun Route.notificationArticle(redisClient: RedisClient) {
+fun Route.notificationArticle(pushBuilder: NotificationsPush.Builder) {
     webSocket("/notifications") {
-        /* Convert channel of string from websocket, to a flow of Notification object */
+        pushBuilder.build(this)
-        val incomingFlow: Flow<Notification> = incoming.consumeAsFlow()
-            .mapNotNull<Frame, Text> { it as? Frame.Text }
-            .map { it.readText() }
-            .map { Notification.fromString(it) }
-
-        /* Read user notifications in redis then sent it to the websocket */
-        NotificationsPush(redisClient, call.citizen, incomingFlow) {
-            outgoing.send(Text(it.toString()))
-        }
     }
 }
-

src/test/kotlin/CucumberTest.kt

@@ -1,3 +1,5 @@
+import com.rabbitmq.client.Channel
+import com.rabbitmq.client.ConnectionFactory
 import fr.dcproject.application.Configuration
 import fr.dcproject.application.Env.CUCUMBER
 import fr.dcproject.application.module
@@ -10,6 +12,8 @@ import io.cucumber.java8.Scenario
 import io.cucumber.junit.Cucumber
 import io.cucumber.junit.CucumberOptions
 import io.ktor.server.testing.withTestApplication
+import io.lettuce.core.RedisClient
+import io.lettuce.core.api.sync.RedisCommands
 import kotlinx.coroutines.InternalCoroutinesApi
 import org.junit.runner.RunWith
 import org.koin.test.KoinTest
@@ -24,6 +28,12 @@ var unitialized: Boolean = false
 @CucumberOptions(plugin = ["pretty"], strict = true)
 class CucumberTest : En, KoinTest {
     private val logger: Logger? by LoggerDelegate()
+    val config = Configuration("application-test.conf")
+    val redis: RedisCommands<String, String> = RedisClient.create(config.redis).connect().sync()
+    val rabbit: Channel = ConnectionFactory()
+        .apply { setUri(config.rabbitmq) }
+        .newConnection()
+        .createChannel()
 
     @InternalCoroutinesApi
     val ktorContext = KtorServerContext {
@@ -47,6 +57,14 @@ class CucumberTest : En, KoinTest {
         After { _: Scenario ->
             //language=PostgreSQL
             get<Connection>().sendQuery("rollback;", listOf())
+
+            redis.flushall()
+            /* Purge rabbit notification queues */
+            rabbit.run {
+                queuePurge("push")
+                queuePurge("email")
+            }
+
             ktorContext.stop()
         }
     }
@@ -75,7 +93,7 @@ class CucumberTest : En, KoinTest {
     private fun getFixturesRequester(): Requester {
         return Requester.RequesterFactory(
             connection = get(),
-            queriesDirectory = Configuration.Sql.fixtureFiles
+            queriesDirectory = config.sql.fixtureFiles
         ).createRequester()
     }
 }

src/test/kotlin/functional/MailerTest.kt

@@ -11,6 +11,7 @@ import io.ktor.server.testing.withTestApplication
 import io.ktor.util.KtorExperimentalAPI
 import kotlinx.coroutines.InternalCoroutinesApi
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.koin.test.AutoCloseKoinTest
@@ -20,10 +21,11 @@ import org.koin.test.get
 @KtorExperimentalLocationsAPI
 @KtorExperimentalAPI
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@Tags(Tag("functional"))
 class MailerTest : KoinTest, AutoCloseKoinTest() {
     @InternalCoroutinesApi
     @Test
-    @Tag("online, functional")
+    @Tags(Tag("online"))
     fun `can be send an email`() {
         withTestApplication({ module(TEST) }) {
             get<Mailer>().sendEmail {

src/test/kotlin/functional/NotificationConsumerTest.kt

@@ -7,10 +7,10 @@ import fr.dcproject.component.article.ArticleRef
 import fr.dcproject.component.citizen.CitizenRef
 import fr.dcproject.component.follow.FollowArticleRepository
 import fr.dcproject.component.follow.FollowSimple
+import fr.dcproject.messages.NotificationEmailSender
 import fr.dcproject.notification.ArticleUpdateNotification
 import fr.dcproject.notification.NotificationConsumer
 import fr.dcproject.notification.publisher.Publisher
-import fr.dcproject.messages.NotificationEmailSender
 import io.ktor.locations.KtorExperimentalLocationsAPI
 import io.ktor.util.KtorExperimentalAPI
 import io.lettuce.core.RedisClient
@@ -22,31 +22,53 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.InternalCoroutinesApi
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 
-@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@TestInstance(TestInstance.Lifecycle.PER_METHOD)
+@Tags(Tag("functional"))
 class NotificationConsumerTest {
+    companion object {
+        @BeforeAll
+        @JvmStatic
+        fun before() {
+            val config: Configuration = Configuration("application-test.conf")
+            RedisClient.create(config.redis).connect().sync().flushall()
+
+            /* Purge rabbit notification queues */
+            ConnectionFactory()
+                .apply { setUri(config.rabbitmq) }
+                .run {
+                    newConnection().createChannel().apply {
+                        queuePurge("push")
+                        queuePurge("email")
+                    }
+                }
+        }
+    }
+
     @InternalCoroutinesApi
     @KtorExperimentalLocationsAPI
     @KtorExperimentalAPI
     @ExperimentalCoroutinesApi
     @Test
-    @Tag("functional")
     fun `can be send notification`() = runBlocking {
+        val config: Configuration = Configuration("application-test.conf")
         /* Create mocks and spy's */
         val emailSender = mockk<NotificationEmailSender>() {
             every { sendEmail(any()) } returns Unit
         }
 
         /* Init Spy on redis client */
-        val redisClient = spyk<RedisClient>(RedisClient.create(Configuration.redis))
+        val redisClient = spyk<RedisClient>(RedisClient.create(config.redis))
         val asyncCommand = spyk(redisClient.connect().async())
         every { redisClient.connect().async() } returns asyncCommand
 
         val rabbitFactory: ConnectionFactory = spyk {
-            ConnectionFactory().apply { setUri(Configuration.rabbitmq) }
+            ConnectionFactory().apply { setUri(config.rabbitmq) }
         }
         val followArticleRepo = mockk<FollowArticleRepository> {
             every { findFollowsByTarget(any()) } returns flow {
@@ -57,21 +79,15 @@ class NotificationConsumerTest {
             }
         }
 
-        /* Purge rabbit notification queues */
-        rabbitFactory.newConnection().createChannel().apply {
-            queuePurge("push")
-            queuePurge("email")
-        }
-
         /* Config consumer */
-        NotificationConsumer(
+        val consumer = NotificationConsumer(
             rabbitFactory = rabbitFactory,
             redisClient = redisClient,
             followArticleRepo = followArticleRepo,
             followConstitutionRepo = mockk(),
             notificationEmailSender = emailSender,
             exchangeName = "notification_test",
-        ).config()
+        ).apply { start() }
         verify { rabbitFactory.newConnection() }
 
         /* Push message */
@@ -93,5 +109,7 @@ class NotificationConsumerTest {
         verify(timeout = 1000) { followArticleRepo.findFollowsByTarget(any()) }
         verify(timeout = 1000) { emailSender.sendEmail(any()) }
         verify(timeout = 1000) { asyncCommand.zadd(any<String>(), any<Double>(), any<String>()) }
+
+//        consumer.close()
     }
 }

src/test/kotlin/functional/NotificationsPushTest.kt

@@ -1,35 +1,54 @@
 package functional
 
+import com.rabbitmq.client.ConnectionFactory
 import fr.dcproject.application.Configuration
 import fr.dcproject.component.article.ArticleForView
 import fr.dcproject.component.citizen.CitizenRef
 import fr.dcproject.notification.ArticleUpdateNotification
 import fr.dcproject.notification.Notification
-import io.lettuce.core.Limit
 import io.lettuce.core.RedisClient
 import io.mockk.every
 import io.mockk.spyk
 import io.mockk.verify
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.runBlocking
 import notification.NotificationsPush
 import org.amshove.kluent.`should be equal to`
-import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.BeforeAll
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
-import org.koin.test.AutoCloseKoinTest
+import kotlin.test.assertEquals
-import org.koin.test.KoinTest
 
+@Tags(Tag("functional"))
 internal class NotificationsPushTest {
+    companion object {
+        @BeforeAll
+        @JvmStatic
+        fun before() {
+            val config: Configuration = Configuration("application-test.conf")
+            RedisClient.create(config.redis).connect().sync().flushall()
+
+            /* Purge rabbit notification queues */
+            ConnectionFactory()
+                .apply { setUri(config.rabbitmq) }
+                .newConnection().createChannel().apply {
+                    queuePurge("push")
+                    queuePurge("email")
+                }
+        }
+    }
+
     @Test
-    @Tag("functional")
     fun `Notification from redis is well catch and return`() = runBlocking {
+        val config: Configuration = Configuration("application-test.conf")
         /* Redis client for test */
-        val redisClientTest = RedisClient.create(Configuration.redis)
+        val redisClientTest = RedisClient.create(config.redis)
 
         /* Init Spy on redis client */
-        val redisClient = spyk<RedisClient>(RedisClient.create(Configuration.redis))
+        val redisClient = spyk<RedisClient>(RedisClient.create(config.redis))
         val asyncCommand = spyk(redisClient.connect().async())
         every { redisClient.connect().async() } returns asyncCommand
 
@@ -44,36 +63,41 @@ internal class NotificationsPushTest {
         )
         /* Init two notification, one called before subscription, and the other after */
         val notifBeforeSubscribe = ArticleUpdateNotification(article)
+        runBlocking {
+            delay(100)
+        }
         val notifAfterSubscribe = ArticleUpdateNotification(article)
 
         /* init event for emulate incomint message from websocket */
         val event = MutableSharedFlow<Notification>()
         val incomingFlow = event.asSharedFlow()
 
-        spyk(object { var counter = 0}).run { /* Counter for count the callback of notification */
+        spyk(object { var counter = 0 }).run { /* Counter for count the callback of notification */
             /* Sent notification */
-            redisClientTest.connect().sync().run {
+            redisClientTest.connect().run {
-                zadd(
+                sync().zadd(
                     "notification:${citizen.id}",
                     notifBeforeSubscribe.id,
                     notifBeforeSubscribe.toString()
                 )
+                close()
             }
 
             /* Init NotificationPush system, and set assertion in callback */
-            NotificationsPush(redisClient, citizen, incomingFlow) {
+            val notificationPush = NotificationsPush.Builder(redisClient).build(citizen, incomingFlow) {
                 counter++
                 if (counter == 1) it.id `should be equal to` notifBeforeSubscribe.id
                 else it.id `should be equal to` notifAfterSubscribe.id
             }
 
             /* Sent the notification */
-            redisClientTest.connect().sync().run {
+            redisClientTest.connect().run {
-                zadd(
+                sync().zadd(
                     "notification:${citizen.id}",
                     notifAfterSubscribe.id,
                     notifAfterSubscribe.toString()
                 )
+                close()
             }
 
             /* Verify if the callback is called 2 times */
@@ -83,7 +107,8 @@ internal class NotificationsPushTest {
             /* Emit an event to delete notification */
             event.emit(notifAfterSubscribe)
             /* Verify the "mark as read" is called */
-            verify(timeout = 300) { asyncCommand.zremrangebyscore(any(), any()) }
+            verify(timeout = 500) { asyncCommand.zremrangebyscore(any(), any()) }
+            notificationPush.close()
         }
     }
-}
+}

src/test/kotlin/functional/ResourcesKtTest.kt

@@ -1,11 +1,14 @@
 package functional
 
 import fr.dcproject.utils.readResource
+import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import kotlin.test.assertEquals
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
+@Tags(Tag("functional"))
 class ResourcesKtTest {
     @Test
     fun readResource() {

src/test/kotlin/functional/ViewTest.kt

@@ -10,6 +10,7 @@ import io.ktor.server.testing.withTestApplication
 import io.ktor.util.KtorExperimentalAPI
 import org.amshove.kluent.`should be equal to`
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.TestInstance.Lifecycle.PER_CLASS
@@ -19,7 +20,7 @@ import java.util.UUID
 @KtorExperimentalLocationsAPI
 @KtorExperimentalAPI
 @TestInstance(PER_CLASS)
-@Tag("functional")
+@Tags(Tag("functional"))
 class ViewTest {
     @Test
     fun `test View Article`() {

src/test/kotlin/unit/security/ArticleAccessControlTest.kt

@@ -14,6 +14,7 @@ import io.mockk.mockk
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -23,7 +24,7 @@ import fr.dcproject.component.article.ArticleRepository as ArticleRepo
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class ArticleAccessControlTest {
     private val tesla = CitizenCart(
         id = UUID.fromString("e6efc288-4283-4729-a268-6debb18de1a0"),

src/test/kotlin/unit/security/CitizenAccessControlTest.kt

@@ -10,6 +10,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -17,7 +18,7 @@ import org.junit.jupiter.api.parallel.ExecutionMode.CONCURRENT
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class CitizenAccessControlTest {
     private val tesla = CitizenBasic(
         user = User(

src/test/kotlin/unit/security/CommentAccessControlTest.kt

@@ -15,6 +15,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -23,7 +24,7 @@ import java.util.UUID
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class CommentAccessControlTest {
     private val tesla = Citizen(
         user = User(

src/test/kotlin/unit/security/FollowAccessControlTest.kt

@@ -14,6 +14,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -22,7 +23,7 @@ import java.util.UUID
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class FollowAccessControlTest {
     private val tesla = CitizenBasic(
         user = User(

src/test/kotlin/unit/security/OpinionAccessControlTest.kt

@@ -14,6 +14,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -22,7 +23,7 @@ import java.util.UUID
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class OpinionAccessControlTest {
     private val tesla = CitizenBasic(
         user = User(

src/test/kotlin/unit/security/OpinionChoiceAccessControlTest.kt

@@ -12,6 +12,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -20,7 +21,7 @@ import java.util.UUID
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class OpinionChoiceAccessControlTest {
     private val tesla = CitizenBasic(
         id = UUID.fromString("e6efc288-4283-4729-a268-6debb18de1a0"),

src/test/kotlin/unit/security/VoteAccessControlTest.kt

@@ -14,6 +14,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -23,7 +24,7 @@ import fr.dcproject.component.vote.entity.Vote as VoteEntity
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class VoteAccessControlTest {
     private val tesla = Citizen(
         id = UUID.fromString("a1e35c99-9d33-4fb4-9201-58d7071243bb"),

src/test/kotlin/unit/security/WorkgroupAccessControlTest.kt

@@ -12,6 +12,7 @@ import fr.dcproject.security.AccessDecision.GRANTED
 import org.amshove.kluent.`should be`
 import org.joda.time.DateTime
 import org.junit.jupiter.api.Tag
+import org.junit.jupiter.api.Tags
 import org.junit.jupiter.api.Test
 import org.junit.jupiter.api.TestInstance
 import org.junit.jupiter.api.parallel.Execution
@@ -21,7 +22,7 @@ import fr.dcproject.component.workgroup.Workgroup as WorkgroupEntity
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 @Execution(CONCURRENT)
-@Tag("security")
+@Tags(Tag("security"), Tag("unit"))
 internal class WorkgroupAccessControlTest {
     private val tesla = CitizenBasic(
         user = User(

src/test/resources/application-test.conf

@@ -9,7 +9,7 @@ ktor {
 }
 
 app {
-    envName = prod
+    envName = test
     domain = dc-project.fr
 }