mocode-software/meldestelle
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

refactor: replace Redis references with Valkey in tests and cache modules

Browse Source 
Updated test cases in `ValkeyEventStoreTest` and cache implementation in `ValkeyDistributedCache` to fully transition from Redis to Valkey. Adjusted configurations, templates, connection handling, and exception management to reflect Valkey-specific behavior and APIs.
This commit is contained in:
Stefan Mogeritsch
2026-02-12 20:13:35 +01:00
parent 7757684b6e
commit 59f608b553
25 changed files with 1131 additions and 1101 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/infrastructure/cache/valkey-cache/build.gradle.kts
Vendored
+7
View File
@@ -28,6 +28,13 @@ dependencies {
// OPTIMIERUNG: Verwendung des `valkey-cache`-Bundles aus libs.versions.toml.
// Dieses Bundle enthält Spring Data Valkey, Lettuce und Jackson-Module.
implementation(libs.bundles.valkey.cache)
// Benötigt für Lettuce-basierten Valkey-Client (LettuceConnectionFactory)
implementation(libs.lettuce.core)
// Für Boot-Autoconfiguration-Annotations wie @ConfigurationProperties,
// @EnableConfigurationProperties und @ConditionalOnMissingBean
implementation("org.springframework.boot:spring-boot-autoconfigure")
// Optional, generiert Metadata f. @ConfigurationProperties (zur IDE-Unterstützung)
compileOnly("org.springframework.boot:spring-boot-configuration-processor")
// Stellt alle Test-Abhängigkeiten gebündelt bereit.
testImplementation(projects.platform.platformTesting)
testImplementation(libs.bundles.testing.jvm)
backend/infrastructure/cache/valkey-cache/src/main/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyConfiguration.kt
Vendored
+14 -14
View File
@@ -3,18 +3,18 @@ package at.mocode.infrastructure.cache.valkey
import at.mocode.infrastructure.cache.api.CacheConfiguration
import at.mocode.infrastructure.cache.api.CacheSerializer
import at.mocode.infrastructure.cache.api.DefaultCacheConfiguration
import io.valkey.springframework.data.valkey.connection.ValkeyConnectionFactory
import io.valkey.springframework.data.valkey.connection.ValkeyPassword
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.connection.RedisPassword
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.StringRedisSerializer
/**
* Valkey connection properties.
@@ -46,11 +46,11 @@ class ValkeyConfiguration {
* @return Valkey connection factory
*/
@Bean
fun valkeyConnectionFactory(properties: ValkeyProperties): RedisConnectionFactory {
val config = RedisStandaloneConfiguration().apply {
fun valkeyConnectionFactory(properties: ValkeyProperties): ValkeyConnectionFactory {
val config = ValkeyStandaloneConfiguration().apply {
hostName = properties.host
port = properties.port
properties.password?.let { password = RedisPassword.of(it) }
properties.password?.let { password = ValkeyPassword.of(it) }
database = properties.database
}
@@ -68,11 +68,11 @@ class ValkeyConfiguration {
*/
@Bean
fun valkeyTemplate(
@Qualifier("valkeyConnectionFactory") connectionFactory: RedisConnectionFactory
): RedisTemplate<String, ByteArray> {
return RedisTemplate<String, ByteArray>().apply {
@Qualifier("valkeyConnectionFactory") connectionFactory: ValkeyConnectionFactory
): ValkeyTemplate<String, ByteArray> {
return ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
// Use default serializer for values (byte arrays)
afterPropertiesSet()
}
backend/infrastructure/cache/valkey-cache/src/main/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCache.kt
Vendored
+13 -13
View File
@@ -7,9 +7,9 @@ import at.mocode.infrastructure.cache.api.ConnectionState
import at.mocode.infrastructure.cache.api.ConnectionStateListener
import at.mocode.infrastructure.cache.api.ConnectionStatusTracker
import at.mocode.infrastructure.cache.api.DistributedCache
import io.valkey.springframework.data.valkey.ValkeyConnectionFailureException
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import org.slf4j.LoggerFactory
import org.springframework.data.redis.RedisConnectionFailureException
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.scheduling.annotation.Scheduled
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList
@@ -21,7 +21,7 @@ import kotlin.time.ExperimentalTime
@OptIn(ExperimentalTime::class)
class ValkeyDistributedCache(
private val valkeyTemplate: RedisTemplate<String, ByteArray>,
private val valkeyTemplate: ValkeyTemplate<String, ByteArray>,
private val serializer: CacheSerializer,
private val config: CacheConfiguration
) : DistributedCache, ConnectionStatusTracker {
@@ -86,7 +86,7 @@ class ValkeyDistributedCache(
trackOperation(true)
return entry.value
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
trackOperation(false)
return null
@@ -121,13 +121,13 @@ class ValkeyDistributedCache(
val bytes = serializer.serializeEntry(entry)
val effectiveTtl = ttl ?: config.defaultTtl
if (effectiveTtl != null) {
// KORREKTUR: Konvertierung zu java.time.Duration für RedisTemplate
// KORREKTUR: Konvertierung zu java.time.Duration für ValkeyTemplate
valkeyTemplate.opsForValue().set(prefixedKey, bytes, effectiveTtl.toJavaDuration())
} else {
valkeyTemplate.opsForValue().set(prefixedKey, bytes)
}
trackOperation(true)
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
markDirty(key)
trackOperation(false)
@@ -153,7 +153,7 @@ class ValkeyDistributedCache(
// Try to delete from Valkey
try {
valkeyTemplate.delete(prefixedKey)
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
markDirty(key)
} catch (e: Exception) {
@@ -183,7 +183,7 @@ class ValkeyDistributedCache(
// Check Valkey
try {
return valkeyTemplate.hasKey(prefixedKey) ?: false
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
return false
} catch (e: Exception) {
@@ -243,7 +243,7 @@ class ValkeyDistributedCache(
}
}
}
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
} catch (e: Exception) {
logger.error("Error getting multiple values from Valkey", e)
@@ -286,7 +286,7 @@ class ValkeyDistributedCache(
null
}
}
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
entries.keys.forEach { markDirty(it) }
} catch (e: Exception) {
@@ -310,7 +310,7 @@ class ValkeyDistributedCache(
// Try to delete from Valkey
try {
valkeyTemplate.delete(prefixedKeys)
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
keys.forEach { markDirty(it) }
} catch (e: Exception) {
@@ -402,7 +402,7 @@ class ValkeyDistributedCache(
if (keys != null && keys.isNotEmpty()) {
valkeyTemplate.delete(keys)
}
} catch (e: RedisConnectionFailureException) {
} catch (e: ValkeyConnectionFailureException) {
handleConnectionFailure(e)
} catch (e: Exception) {
logger.error("Error clearing Valkey cache", e)
@@ -565,7 +565,7 @@ class ValkeyDistributedCache(
/**
* Loggt Performance-Metriken (periodisch aufgerufen).
*/
@Scheduled(fixedDelayString = "\${valkey.metrics-log-interval:300000}")
@Scheduled(fixedDelayString = $$"${valkey.metrics-log-interval:300000}")
fun logPerformanceMetrics() {
val metrics = getPerformanceMetrics()
logger.info("Cache performance metrics: $metrics")
backend/infrastructure/cache/valkey-cache/src/test/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCacheConfigurationTest.kt
Vendored
+10 -10
View File
@@ -5,12 +5,12 @@ import at.mocode.infrastructure.cache.api.DefaultCacheConfiguration
import at.mocode.infrastructure.cache.api.get
import at.mocode.infrastructure.cache.api.multiGet
import io.github.oshai.kotlinlogging.KotlinLogging
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -37,14 +37,14 @@ class ValkeyDistributedCacheConfigurationTest {
@Container
val valkeyContainer = GenericContainer<Nothing>(
DockerImageName.parse("valkey/valkey:9-alpine")
.asCompatibleSubstituteFor("valkey")
DockerImageName.parse("valkey/valkey:8.0.2-alpine")
.asCompatibleSubstituteFor("redis")
).apply {
withExposedPorts(6379)
}
}
private lateinit var valkeyTemplate: RedisTemplate<String, ByteArray>
private lateinit var valkeyTemplate: ValkeyTemplate<String, ByteArray>
private lateinit var serializer: CacheSerializer
@BeforeEach
@@ -52,13 +52,13 @@ class ValkeyDistributedCacheConfigurationTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = RedisTemplate<String, ByteArray>().apply {
valkeyTemplate = ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
afterPropertiesSet()
}
backend/infrastructure/cache/valkey-cache/src/test/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCacheEdgeCasesTest.kt
Vendored
+10 -10
View File
@@ -2,12 +2,12 @@ package at.mocode.infrastructure.cache.valkey
import at.mocode.infrastructure.cache.api.*
import io.github.oshai.kotlinlogging.KotlinLogging
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -29,14 +29,14 @@ class ValkeyDistributedCacheEdgeCasesTest {
@Container
val valkeyContainer = GenericContainer<Nothing>(
DockerImageName.parse("valkey/valkey:9-alpine")
.asCompatibleSubstituteFor("valkey")
DockerImageName.parse("valkey/valkey:8.0.2-alpine")
.asCompatibleSubstituteFor("redis")
).apply {
withExposedPorts(6379)
}
}
private lateinit var valkeyTemplate: RedisTemplate<String, ByteArray>
private lateinit var valkeyTemplate: ValkeyTemplate<String, ByteArray>
private lateinit var serializer: CacheSerializer
private lateinit var config: CacheConfiguration
private lateinit var cache: ValkeyDistributedCache
@@ -46,13 +46,13 @@ class ValkeyDistributedCacheEdgeCasesTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = RedisTemplate<String, ByteArray>().apply {
valkeyTemplate = ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
afterPropertiesSet()
}
backend/infrastructure/cache/valkey-cache/src/test/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCacheIntegrationTest.kt
Vendored
+10 -10
View File
@@ -2,14 +2,14 @@ package at.mocode.infrastructure.cache.valkey
import at.mocode.infrastructure.cache.api.*
import io.github.oshai.kotlinlogging.KotlinLogging
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -36,14 +36,14 @@ class ValkeyDistributedCacheIntegrationTest {
@Container
val valkeyContainer = GenericContainer<Nothing>(
DockerImageName.parse("valkey/valkey:9-alpine")
.asCompatibleSubstituteFor("valkey")
DockerImageName.parse("valkey/valkey:8.0.2-alpine")
.asCompatibleSubstituteFor("redis")
).apply {
withExposedPorts(6379)
}
}
private lateinit var valkeyTemplate: RedisTemplate<String, ByteArray>
private lateinit var valkeyTemplate: ValkeyTemplate<String, ByteArray>
private lateinit var serializer: CacheSerializer
private lateinit var config: CacheConfiguration
@@ -52,13 +52,13 @@ class ValkeyDistributedCacheIntegrationTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = RedisTemplate<String, ByteArray>().apply {
valkeyTemplate = ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
afterPropertiesSet()
}
backend/infrastructure/cache/valkey-cache/src/test/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCachePerformanceTest.kt
Vendored
+10 -10
View File
@@ -2,15 +2,15 @@ package at.mocode.infrastructure.cache.valkey
import at.mocode.infrastructure.cache.api.*
import io.github.oshai.kotlinlogging.KotlinLogging
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import kotlinx.coroutines.joinAll
import kotlinx.coroutines.launch
import kotlinx.coroutines.test.runTest
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -32,14 +32,14 @@ class ValkeyDistributedCachePerformanceTest {
@Container
val valkeyContainer = GenericContainer<Nothing>(
DockerImageName.parse("valkey/valkey:9-alpine")
.asCompatibleSubstituteFor("valkey")
DockerImageName.parse("valkey/valkey:8.0.2-alpine")
.asCompatibleSubstituteFor("redis")
).apply {
withExposedPorts(6379)
}
}
private lateinit var valkeyTemplate: RedisTemplate<String, ByteArray>
private lateinit var valkeyTemplate: ValkeyTemplate<String, ByteArray>
private lateinit var serializer: CacheSerializer
private lateinit var config: CacheConfiguration
private lateinit var cache: ValkeyDistributedCache
@@ -49,13 +49,13 @@ class ValkeyDistributedCachePerformanceTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = RedisTemplate<String, ByteArray>().apply {
valkeyTemplate = ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
afterPropertiesSet()
}
backend/infrastructure/cache/valkey-cache/src/test/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCacheResilienceTest.kt
Vendored
+25 -25
View File
@@ -4,16 +4,16 @@ import at.mocode.infrastructure.cache.api.*
import io.github.oshai.kotlinlogging.KotlinLogging
import io.mockk.every
import io.mockk.mockk
import io.valkey.springframework.data.valkey.ValkeyConnectionFailureException
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.core.ValueOperations
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.RedisConnectionFailureException
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.core.ValueOperations
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -38,14 +38,14 @@ class ValkeyDistributedCacheResilienceTest {
@Container
val valkeyContainer = GenericContainer<Nothing>(
DockerImageName.parse("valkey/valkey:9-alpine")
.asCompatibleSubstituteFor("valkey")
DockerImageName.parse("valkey/valkey:8.0.2-alpine")
.asCompatibleSubstituteFor("redis")
).apply {
withExposedPorts(6379)
}
}
private lateinit var valkeyTemplate: RedisTemplate<String, ByteArray>
private lateinit var valkeyTemplate: ValkeyTemplate<String, ByteArray>
private lateinit var serializer: CacheSerializer
private lateinit var config: CacheConfiguration
@@ -54,13 +54,13 @@ class ValkeyDistributedCacheResilienceTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = RedisTemplate<String, ByteArray>().apply {
valkeyTemplate = ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
afterPropertiesSet()
}
@@ -76,7 +76,7 @@ class ValkeyDistributedCacheResilienceTest {
fun `test connection timeout scenarios`() = runBlocking {
logger.info { "Testing connection timeout scenarios" }
val mockTemplate = mockk<RedisTemplate<String, ByteArray>>()
val mockTemplate = mockk<ValkeyTemplate<String, ByteArray>>()
val mockValueOps = mockk<ValueOperations<String, ByteArray>>()
every { mockTemplate.opsForValue() } returns mockValueOps
@@ -117,7 +117,7 @@ class ValkeyDistributedCacheResilienceTest {
fun `test partial valkey failures`() {
logger.info { "Testing partial Valkey failures" }
val mockTemplate = mockk<RedisTemplate<String, ByteArray>>()
val mockTemplate = mockk<ValkeyTemplate<String, ByteArray>>()
val mockValueOps = mockk<ValueOperations<String, ByteArray>>()
every { mockTemplate.opsForValue() } returns mockValueOps
@@ -128,14 +128,14 @@ class ValkeyDistributedCacheResilienceTest {
// Simulate intermittent connection failures (fail every 3rd operation)
every { mockValueOps.get(any()) } answers {
if (failureCounter.incrementAndGet() % 3 == 0) {
throw RedisConnectionFailureException("Intermittent failure")
throw ValkeyConnectionFailureException("Intermittent failure") as Throwable
}
serializer.serializeEntry(CacheEntry("test", "value"))
}
every { mockValueOps.set(any<String>(), any<ByteArray>(), any<JavaDuration>()) } answers {
if (failureCounter.incrementAndGet() % 3 == 0) {
throw RedisConnectionFailureException("Intermittent failure")
throw ValkeyConnectionFailureException("Intermittent failure")
}
}
@@ -197,20 +197,20 @@ class ValkeyDistributedCacheResilienceTest {
// Phase 2: Simulate network partition by creating a new cache with a broken connection
logger.info { "Phase 2: Simulating network partition" }
val mockTemplate = mockk<RedisTemplate<String, ByteArray>>()
val mockTemplate = mockk<ValkeyTemplate<String, ByteArray>>()
val mockValueOps = mockk<ValueOperations<String, ByteArray>>()
every { mockTemplate.opsForValue() } returns mockValueOps
every { mockValueOps.get(any()) } throws RedisConnectionFailureException("Network partition")
every { mockValueOps.get(any()) } throws ValkeyConnectionFailureException("Network partition")
every {
mockValueOps.set(
any<String>(),
any<ByteArray>(),
any<JavaDuration>()
)
} throws RedisConnectionFailureException("Network partition")
every { mockTemplate.delete(any<String>()) } throws RedisConnectionFailureException("Network partition")
every { mockTemplate.hasKey(any()) } throws RedisConnectionFailureException("Network partition")
} throws ValkeyConnectionFailureException("Network partition")
every { mockTemplate.delete(any<String>()) } throws ValkeyConnectionFailureException("Network partition")
every { mockTemplate.hasKey(any()) } throws ValkeyConnectionFailureException("Network partition")
val partitionedCache = ValkeyDistributedCache(mockTemplate, serializer, config)
@@ -235,7 +235,7 @@ class ValkeyDistributedCacheResilienceTest {
fun `test reconnection and synchronization after network issues`() {
logger.info { "Testing reconnection and synchronization" }
val mockTemplate = mockk<RedisTemplate<String, ByteArray>>()
val mockTemplate = mockk<ValkeyTemplate<String, ByteArray>>()
val mockValueOps = mockk<ValueOperations<String, ByteArray>>()
every { mockTemplate.opsForValue() } returns mockValueOps
@@ -243,15 +243,15 @@ class ValkeyDistributedCacheResilienceTest {
val reconnectingCache = ValkeyDistributedCache(mockTemplate, serializer, config)
// Phase 1: Simulate disconnection
every { mockValueOps.get(any()) } throws RedisConnectionFailureException("Disconnected")
every { mockValueOps.get(any()) } throws ValkeyConnectionFailureException("Disconnected")
every {
mockValueOps.set(
any<String>(),
any<ByteArray>(),
any<JavaDuration>()
)
} throws RedisConnectionFailureException("Disconnected")
every { mockTemplate.hasKey(any()) } throws RedisConnectionFailureException("Disconnected")
} throws ValkeyConnectionFailureException("Disconnected")
every { mockTemplate.hasKey(any()) } throws ValkeyConnectionFailureException("Disconnected")
reconnectingCache.set("reconnect-test-1", "value-1")
reconnectingCache.set("reconnect-test-2", "value-2")
backend/infrastructure/cache/valkey-cache/src/test/kotlin/at/mocode/infrastructure/cache/valkey/ValkeyDistributedCacheTest.kt
Vendored
+24 -19
View File
@@ -5,15 +5,15 @@ import io.github.oshai.kotlinlogging.KotlinLogging
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import io.valkey.springframework.data.valkey.ValkeyConnectionFailureException
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import io.valkey.springframework.data.valkey.core.ValueOperations
import io.valkey.springframework.data.valkey.serializer.StringValkeySerializer
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.RedisConnectionFailureException
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.data.redis.core.ValueOperations
import org.springframework.data.redis.serializer.StringRedisSerializer
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -31,14 +31,14 @@ class ValkeyDistributedCacheTest {
@Container
val valkeyContainer = GenericContainer<Nothing>(
DockerImageName.parse("valkey/valkey:9-alpine")
.asCompatibleSubstituteFor("valkey")
DockerImageName.parse("valkey/valkey:8.0.2-alpine")
.asCompatibleSubstituteFor("redis")
).apply {
withExposedPorts(6379)
}
}
private lateinit var valkeyTemplate: RedisTemplate<String, ByteArray>
private lateinit var valkeyTemplate: ValkeyTemplate<String, ByteArray>
private lateinit var serializer: CacheSerializer
private lateinit var config: CacheConfiguration
private lateinit var cache: ValkeyDistributedCache
@@ -48,13 +48,13 @@ class ValkeyDistributedCacheTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = RedisTemplate<String, ByteArray>().apply {
valkeyTemplate = ValkeyTemplate<String, ByteArray>().apply {
setConnectionFactory(connectionFactory)
keySerializer = StringRedisSerializer()
keySerializer = StringValkeySerializer()
afterPropertiesSet()
}
@@ -131,7 +131,7 @@ class ValkeyDistributedCacheTest {
@Test
fun `should handle offline mode and synchronize correctly`() {
// Arrange
val mockTemplate = mockk<RedisTemplate<String, ByteArray>>(relaxed = true)
val mockTemplate = mockk<ValkeyTemplate<String, ByteArray>>(relaxed = true)
val mockValueOps = mockk<ValueOperations<String, ByteArray>>(relaxed = true)
every { mockTemplate.opsForValue() } returns mockValueOps
@@ -157,10 +157,15 @@ class ValkeyDistributedCacheTest {
any<ByteArray>(),
any<JavaDuration>()
)
} throws RedisConnectionFailureException("Valkey is down")
every { mockValueOps.set(any<String>(), any<ByteArray>()) } throws RedisConnectionFailureException("Valkey is down")
} throws ValkeyConnectionFailureException("Valkey is down")
every {
mockValueOps.set(
any<String>(),
any<ByteArray>()
)
} throws ValkeyConnectionFailureException("Valkey is down")
every { mockTemplate.delete(any<String>()) } throws RedisConnectionFailureException("Valkey is down")
every { mockTemplate.delete(any<String>()) } throws ValkeyConnectionFailureException("Valkey is down")
offlineCache.set("key2", "offline-value")
offlineCache.delete("key1")
@@ -246,13 +251,13 @@ class ValkeyDistributedCacheTest {
@Test
fun `test handling valkey connection failures`() {
// Create a mock ValkeyTemplate and ValueOperations
val mockTemplate = mockk<RedisTemplate<String, ByteArray>>()
val mockTemplate = mockk<ValkeyTemplate<String, ByteArray>>()
val mockValueOps = mockk<ValueOperations<String, ByteArray>>()
// Configure the mock to throw connection failure
every { mockTemplate.opsForValue() } returns mockValueOps
every { mockValueOps.get(any()) } throws RedisConnectionFailureException("Test connection failure")
every { mockTemplate.hasKey(any()) } throws RedisConnectionFailureException("Test connection failure")
every { mockValueOps.get(any()) } throws ValkeyConnectionFailureException("Test connection failure")
every { mockTemplate.hasKey(any()) } throws ValkeyConnectionFailureException("Test connection failure")
// Create a cache with the mock
val mockCache = ValkeyDistributedCache(mockTemplate, serializer, config)
backend/infrastructure/cache/valkey-cache/src/test/resources/logback-test.xml
Vendored
+11 -11
View File
@@ -8,33 +8,33 @@
</appender>
<!-- Cache-spezifische Logger -->
<logger name="at.mocode.infrastructure.cache" level="DEBUG" />
<logger name="at.mocode.infrastructure.cache" level="DEBUG"/>
<!-- Performance Test Logger -->
<logger name="ValkeyDistributedCachePerformanceTest" level="INFO" />
<logger name="ValkeyDistributedCachePerformanceTest" level="INFO"/>
<!-- Edge Cases Test Logger -->
<logger name="ValkeyDistributedCacheEdgeCasesTest" level="INFO" />
<logger name="ValkeyDistributedCacheEdgeCasesTest" level="INFO"/>
<!-- Resilience Test Logger -->
<logger name="ValkeyDistributedCacheResilienceTest" level="INFO" />
<logger name="ValkeyDistributedCacheResilienceTest" level="INFO"/>
<!-- Configuration Test Logger -->
<logger name="ValkeyDistributedCacheConfigurationTest" level="INFO" />
<logger name="ValkeyDistributedCacheConfigurationTest" level="INFO"/>
<!-- Integration Test Logger -->
<logger name="ValkeyDistributedCacheIntegrationTest" level="INFO" />
<logger name="ValkeyDistributedCacheIntegrationTest" level="INFO"/>
<!-- Testcontainers Logger (reduziert Verbosity) -->
<logger name="org.testcontainers" level="WARN" />
<logger name="com.github.dockerjava" level="WARN" />
<logger name="org.testcontainers" level="WARN"/>
<logger name="com.github.dockerjava" level="WARN"/>
<!-- Valkey/Lettuce Logger (reduziert Verbosity) -->
<logger name="io.lettuce" level="WARN" />
<logger name="org.springframework.data.redis" level="WARN" />
<logger name="io.lettuce" level="WARN"/>
<logger name="io.valkey.springframework.data" level="WARN"/>
<!-- Root Logger -->
<root level="INFO">
<appender-ref ref="STDOUT" />
<appender-ref ref="STDOUT"/>
</root>
</configuration>
backend/infrastructure/event-store/valkey-event-store/build.gradle.kts
+5
View File
@@ -30,6 +30,11 @@ dependencies {
// OPTIMIERUNG: Wiederverwendung des `valkey-cache`-Bundles, da es die
// gleichen Technologien (Spring Data Valkey, Lettuce, Jackson) verwendet
implementation(libs.bundles.valkey.cache)
// Benötigt für Lettuce-basierten Valkey-Client (LettuceConnectionFactory)
implementation(libs.lettuce.core)
// Für Boot-Autoconfiguration-Annotations (z. B. @ConditionalOnMissingBean,
// @ConfigurationProperties, @EnableConfigurationProperties)
implementation("org.springframework.boot:spring-boot-autoconfigure")
// Stellt Jakarta Annotations bereit (z. B. @PostConstruct), die von Spring verwendet werden
implementation(libs.jakarta.annotation.api)
// Für Kotlin-spezifische Coroutines-Integration mit Spring
backend/infrastructure/event-store/valkey-event-store/src/main/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventConsumer.kt
+8 -4
View File
@@ -2,12 +2,16 @@ package at.mocode.infrastructure.eventstore.valkey
import at.mocode.core.domain.event.DomainEvent
import at.mocode.infrastructure.eventstore.api.EventSerializer
import io.valkey.springframework.data.valkey.connection.stream.Consumer
import io.valkey.springframework.data.valkey.connection.stream.MapRecord
import io.valkey.springframework.data.valkey.connection.stream.ReadOffset
import io.valkey.springframework.data.valkey.connection.stream.StreamOffset
import io.valkey.springframework.data.valkey.connection.stream.StreamReadOptions
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import jakarta.annotation.PostConstruct
import jakarta.annotation.PreDestroy
import org.slf4j.LoggerFactory
import org.springframework.data.domain.Range
import org.springframework.data.redis.connection.stream.*
import org.springframework.data.redis.core.StringRedisTemplate
import org.springframework.scheduling.annotation.Scheduled
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.CopyOnWriteArrayList
@@ -16,7 +20,7 @@ import java.util.concurrent.CopyOnWriteArrayList
* Consumer for Valkey Streams that processes events using consumer groups.
*/
class ValkeyEventConsumer(
private val valkeyTemplate: StringRedisTemplate,
private val valkeyTemplate: StringValkeyTemplate,
private val serializer: EventSerializer,
private val properties: ValkeyEventStoreProperties
) {
@@ -143,7 +147,7 @@ class ValkeyEventConsumer(
/**
* Periodic polls for new events from all streams.
*/
@Scheduled(fixedDelayString = $$"${valkey.event-store.poll-interval:100}")
@Scheduled(fixedDelayString = "\${valkey.event-store.poll-interval:100}")
fun pollEvents() {
if (!running) {
running = true
backend/infrastructure/event-store/valkey-event-store/src/main/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStore.kt
+8 -7
View File
@@ -8,16 +8,17 @@ import at.mocode.infrastructure.eventstore.api.ConcurrencyException
import at.mocode.infrastructure.eventstore.api.EventSerializer
import at.mocode.infrastructure.eventstore.api.EventStore
import at.mocode.infrastructure.eventstore.api.Subscription
import io.valkey.springframework.data.valkey.core.SessionCallback
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import io.valkey.springframework.data.valkey.core.ValkeyOperations
import org.slf4j.LoggerFactory
import org.springframework.dao.DataAccessException
import org.springframework.data.domain.Range
import org.springframework.data.redis.core.SessionCallback
import org.springframework.data.redis.core.StringRedisTemplate
import java.util.concurrent.ConcurrentHashMap
import kotlin.uuid.Uuid
class ValkeyEventStore(
private val valkeyTemplate: StringRedisTemplate,
private val valkeyTemplate: StringValkeyTemplate,
private val serializer: EventSerializer,
private val properties: ValkeyEventStoreProperties
) : EventStore {
@@ -131,8 +132,8 @@ class ValkeyEventStore(
try {
valkeyTemplate.execute(object : SessionCallback<List<Any>> {
@Throws(DataAccessException::class)
override fun <K, V> execute(operations: org.springframework.data.redis.core.RedisOperations<K, V>): List<Any> {
val streamOps = (operations as StringRedisTemplate).opsForStream<String, String>()
override fun <K, V> execute(operations: ValkeyOperations<K, V>): List<Any> {
val streamOps = (operations as StringValkeyTemplate).opsForStream<String, String>()
operations.multi()
@@ -178,8 +179,8 @@ class ValkeyEventStore(
try {
valkeyTemplate.execute(object : SessionCallback<List<Any>> {
@Throws(DataAccessException::class)
override fun <K, V> execute(operations: org.springframework.data.redis.core.RedisOperations<K, V>): List<Any> {
val streamOps = (operations as StringRedisTemplate).opsForStream<String, String>()
override fun <K, V> execute(operations: ValkeyOperations<K, V>): List<Any> {
val streamOps = (operations as StringValkeyTemplate).opsForStream<String, String>()
operations.multi()
streamOps.add(streamKey, eventData)
backend/infrastructure/event-store/valkey-event-store/src/main/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStoreConfiguration.kt
+18 -17
View File
@@ -2,16 +2,17 @@ package at.mocode.infrastructure.eventstore.valkey
import at.mocode.infrastructure.eventstore.api.EventSerializer
import at.mocode.infrastructure.eventstore.api.EventStore
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import io.valkey.springframework.data.valkey.connection.ValkeyConnectionFactory
import io.valkey.springframework.data.valkey.connection.ValkeyPassword
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import org.springframework.beans.factory.annotation.Qualifier
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.connection.RedisPassword
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import java.time.Duration
/**
@@ -53,11 +54,11 @@ class ValkeyEventStoreConfiguration {
*/
@Bean
@ConditionalOnMissingBean(name = ["eventStoreValkeyConnectionFactory"])
fun eventStoreValkeyConnectionFactory(properties: ValkeyEventStoreProperties): RedisConnectionFactory {
val config = RedisStandaloneConfiguration().apply {
fun eventStoreValkeyConnectionFactory(properties: ValkeyEventStoreProperties): ValkeyConnectionFactory {
val config = ValkeyStandaloneConfiguration().apply {
hostName = properties.host
port = properties.port
properties.password?.let { password = RedisPassword.of(it) }
properties.password?.let { password = ValkeyPassword.of(it) }
database = properties.database
}
@@ -76,10 +77,10 @@ class ValkeyEventStoreConfiguration {
@Bean
@ConditionalOnMissingBean(name = ["eventStoreValkeyTemplate"])
fun eventStoreValkeyTemplate(
@org.springframework.beans.factory.annotation.Qualifier("eventStoreValkeyConnectionFactory")
connectionFactory: RedisConnectionFactory
): StringRedisTemplate {
return StringRedisTemplate().apply {
@Qualifier("eventStoreValkeyConnectionFactory")
connectionFactory: ValkeyConnectionFactory
): StringValkeyTemplate {
return StringValkeyTemplate().apply {
setConnectionFactory(connectionFactory)
afterPropertiesSet()
}
@@ -107,8 +108,8 @@ class ValkeyEventStoreConfiguration {
@Bean
@ConditionalOnMissingBean
fun eventStore(
@org.springframework.beans.factory.annotation.Qualifier("eventStoreValkeyTemplate")
valkeyTemplate: StringRedisTemplate,
@Qualifier("eventStoreValkeyTemplate")
valkeyTemplate: StringValkeyTemplate,
eventSerializer: EventSerializer,
properties: ValkeyEventStoreProperties
): EventStore {
@@ -126,8 +127,8 @@ class ValkeyEventStoreConfiguration {
@Bean
@ConditionalOnMissingBean
fun eventConsumer(
@org.springframework.beans.factory.annotation.Qualifier("eventStoreValkeyTemplate")
valkeyTemplate: StringRedisTemplate,
@Qualifier("eventStoreValkeyTemplate")
valkeyTemplate: StringValkeyTemplate,
eventSerializer: EventSerializer,
properties: ValkeyEventStoreProperties
): ValkeyEventConsumer {
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyCacheAndEventStoreIntegrationTest.kt
+5 -5
View File
@@ -8,6 +8,8 @@ import at.mocode.infrastructure.cache.valkey.JacksonCacheSerializer
import at.mocode.infrastructure.cache.valkey.ValkeyConfiguration
import at.mocode.infrastructure.cache.valkey.ValkeyDistributedCache
import at.mocode.infrastructure.eventstore.api.EventStore
import io.valkey.springframework.data.valkey.connection.ValkeyConnectionFactory
import io.valkey.springframework.data.valkey.core.ValkeyTemplate
import kotlinx.coroutines.runBlocking
import org.junit.jupiter.api.AfterAll
import org.junit.jupiter.api.Assertions.assertEquals
@@ -20,8 +22,6 @@ import org.springframework.boot.test.context.SpringBootTest
import org.springframework.context.annotation.Bean
import org.springframework.context.annotation.Configuration
import org.springframework.context.annotation.Import
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.core.RedisTemplate
import org.springframework.test.context.DynamicPropertyRegistry
import org.springframework.test.context.DynamicPropertySource
import org.testcontainers.containers.GenericContainer
@@ -96,7 +96,7 @@ class ValkeyCacheAndEventStoreIntegrationTest {
class TestConfig {
@Bean
fun distributedCache(
@Qualifier("valkeyTemplate") valkeyTemplate: RedisTemplate<String, ByteArray>,
@Qualifier("valkeyTemplate") valkeyTemplate: ValkeyTemplate<String, ByteArray>,
cacheConfiguration: CacheConfiguration
): DistributedCache {
return ValkeyDistributedCache(
@@ -116,11 +116,11 @@ class ValkeyCacheAndEventStoreIntegrationTest {
// Verify separate ConnectionFactories
@Autowired
@Qualifier("valkeyConnectionFactory")
private lateinit var cacheConnectionFactory: RedisConnectionFactory
private lateinit var cacheConnectionFactory: ValkeyConnectionFactory
@Autowired
@Qualifier("eventStoreValkeyConnectionFactory")
private lateinit var eventStoreConnectionFactory: RedisConnectionFactory
private lateinit var eventStoreConnectionFactory: ValkeyConnectionFactory
@Test
fun `test both modules can be used simultaneously without conflicts`(): Unit = runBlocking {
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventConsumerResilienceTest.kt
+7 -7
View File
@@ -6,6 +6,9 @@ import at.mocode.core.domain.model.AggregateId
import at.mocode.core.domain.model.EventType
import at.mocode.core.domain.model.EventVersion
import at.mocode.infrastructure.eventstore.api.EventSerializer
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import org.junit.jupiter.api.AfterEach
@@ -14,9 +17,6 @@ import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.slf4j.LoggerFactory
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -35,11 +35,11 @@ class ValkeyEventConsumerResilienceTest {
companion object {
@Container
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:9-alpine"))
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:8.0.2-alpine"))
.withExposedPorts(6379)
}
private lateinit var valkeyTemplate: StringRedisTemplate
private lateinit var valkeyTemplate: StringValkeyTemplate
private lateinit var serializer: EventSerializer
private lateinit var properties: ValkeyEventStoreProperties
private lateinit var eventStore: ValkeyEventStore
@@ -51,11 +51,11 @@ class ValkeyEventConsumerResilienceTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = StringRedisTemplate(connectionFactory)
valkeyTemplate = StringValkeyTemplate(connectionFactory)
serializer = JacksonEventSerializer().apply {
registerEventType(ResilienceTestEvent::class.java, "ResilienceTestEvent")
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStoreConfigurationTest.kt
+8 -8
View File
@@ -2,6 +2,8 @@ package at.mocode.infrastructure.eventstore.valkey
import at.mocode.infrastructure.eventstore.api.EventSerializer
import at.mocode.infrastructure.eventstore.api.EventStore
import io.valkey.springframework.data.valkey.connection.ValkeyConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.DisplayName
import org.junit.jupiter.api.Test
@@ -11,8 +13,6 @@ import org.springframework.boot.autoconfigure.AutoConfigurations
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.boot.test.context.runner.ApplicationContextRunner
import org.springframework.context.annotation.Configuration
import org.springframework.data.redis.connection.RedisConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import java.time.Duration
/**
@@ -71,8 +71,8 @@ class ValkeyEventStoreConfigurationTest {
assertTrue(context.containsBean("eventConsumer"))
// Verify bean types
assertNotNull(context.getBean<RedisConnectionFactory>("eventStoreValkeyConnectionFactory"))
assertNotNull(context.getBean<StringRedisTemplate>("eventStoreValkeyTemplate"))
assertNotNull(context.getBean<ValkeyConnectionFactory>("eventStoreValkeyConnectionFactory"))
assertNotNull(context.getBean<StringValkeyTemplate>("eventStoreValkeyTemplate"))
assertNotNull(context.getBean<EventSerializer>("eventSerializer"))
assertNotNull(context.getBean<EventStore>("eventStore"))
assertNotNull(context.getBean<ValkeyEventConsumer>("eventConsumer"))
@@ -160,7 +160,7 @@ class ValkeyEventStoreConfigurationTest {
"valkey.event-store.database=1"
)
.run { context ->
val connectionFactory = context.getBean<RedisConnectionFactory>("eventStoreValkeyConnectionFactory")
val connectionFactory = context.getBean<ValkeyConnectionFactory>("eventStoreValkeyConnectionFactory")
assertNotNull(connectionFactory)
// Verify the connection factory is properly configured
@@ -176,7 +176,7 @@ class ValkeyEventStoreConfigurationTest {
fun `should handle Valkey template creation correctly`() {
contextRunner
.run { context ->
val valkeyTemplate = context.getBean<StringRedisTemplate>("eventStoreValkeyTemplate")
val valkeyTemplate = context.getBean<StringValkeyTemplate>("eventStoreValkeyTemplate")
assertNotNull(valkeyTemplate)
// Verify the template is properly set up
@@ -211,7 +211,7 @@ class ValkeyEventStoreConfigurationTest {
assertTrue(eventStore is ValkeyEventStore)
// Verify dependencies are wired correctly
val valkeyTemplate = context.getBean<StringRedisTemplate>("eventStoreValkeyTemplate")
val valkeyTemplate = context.getBean<StringValkeyTemplate>("eventStoreValkeyTemplate")
val eventSerializer = context.getBean<EventSerializer>("eventSerializer")
val properties = context.getBean<ValkeyEventStoreProperties>()
@@ -231,7 +231,7 @@ class ValkeyEventStoreConfigurationTest {
assertNotNull(eventConsumer)
// Verify dependencies are available
val valkeyTemplate = context.getBean<StringRedisTemplate>("eventStoreValkeyTemplate")
val valkeyTemplate = context.getBean<StringValkeyTemplate>("eventStoreValkeyTemplate")
val eventSerializer = context.getBean<EventSerializer>("eventSerializer")
val properties = context.getBean<ValkeyEventStoreProperties>()
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStoreErrorHandlingTest.kt
+7 -7
View File
@@ -6,6 +6,9 @@ import at.mocode.core.domain.model.EventType
import at.mocode.core.domain.model.EventVersion
import at.mocode.infrastructure.eventstore.api.ConcurrencyException
import at.mocode.infrastructure.eventstore.api.EventSerializer
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import org.junit.jupiter.api.AfterEach
@@ -13,9 +16,6 @@ import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -32,11 +32,11 @@ class ValkeyEventStoreErrorHandlingTest {
companion object {
@Container
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:9-alpine"))
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:8.0.2-alpine"))
.withExposedPorts(6379)
}
private lateinit var valkeyTemplate: StringRedisTemplate
private lateinit var valkeyTemplate: StringValkeyTemplate
private lateinit var serializer: EventSerializer
private lateinit var properties: ValkeyEventStoreProperties
private lateinit var eventStore: ValkeyEventStore
@@ -46,11 +46,11 @@ class ValkeyEventStoreErrorHandlingTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = StringRedisTemplate(connectionFactory)
valkeyTemplate = StringValkeyTemplate(connectionFactory)
serializer = JacksonEventSerializer().apply {
registerEventType(TestErrorEvent::class.java, "TestErrorEvent")
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStoreIntegrationTest.kt
+7 -7
View File
@@ -7,14 +7,14 @@ import at.mocode.core.domain.event.DomainEvent
import at.mocode.core.domain.model.*
import at.mocode.infrastructure.eventstore.api.EventSerializer
import at.mocode.infrastructure.eventstore.api.EventStore
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -30,11 +30,11 @@ class ValkeyEventStoreIntegrationTest {
companion object {
@Container
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:9-alpine"))
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:8.0.2-alpine"))
.withExposedPorts(6379)
}
private lateinit var valkeyTemplate: StringRedisTemplate
private lateinit var valkeyTemplate: StringValkeyTemplate
private lateinit var serializer: EventSerializer
private lateinit var properties: ValkeyEventStoreProperties
private lateinit var eventStore: EventStore
@@ -45,11 +45,11 @@ class ValkeyEventStoreIntegrationTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = StringRedisTemplate(connectionFactory)
valkeyTemplate = StringValkeyTemplate(connectionFactory)
serializer = JacksonEventSerializer().apply {
registerEventType(TestCreatedEvent::class.java, "TestCreated")
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStoreStreamTest.kt
+7 -7
View File
@@ -5,6 +5,9 @@ import at.mocode.core.domain.model.AggregateId
import at.mocode.core.domain.model.EventType
import at.mocode.core.domain.model.EventVersion
import at.mocode.infrastructure.eventstore.api.EventSerializer
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import org.junit.jupiter.api.AfterEach
@@ -12,9 +15,6 @@ import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.slf4j.LoggerFactory
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -31,11 +31,11 @@ class ValkeyEventStoreStreamTest {
companion object {
@Container
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:9-alpine"))
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:8.0.2-alpine"))
.withExposedPorts(6379)
}
private lateinit var valkeyTemplate: StringRedisTemplate
private lateinit var valkeyTemplate: StringValkeyTemplate
private lateinit var serializer: EventSerializer
private lateinit var properties: ValkeyEventStoreProperties
private lateinit var eventStore: ValkeyEventStore
@@ -45,11 +45,11 @@ class ValkeyEventStoreStreamTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = StringRedisTemplate(connectionFactory)
valkeyTemplate = StringValkeyTemplate(connectionFactory)
serializer = JacksonEventSerializer().apply {
registerEventType(StreamTestEvent::class.java, "StreamTestEvent")
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyEventStoreTest.kt
+7 -7
View File
@@ -6,6 +6,9 @@ import at.mocode.core.domain.model.EventType
import at.mocode.core.domain.model.EventVersion
import at.mocode.infrastructure.eventstore.api.ConcurrencyException
import at.mocode.infrastructure.eventstore.api.EventSerializer
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import org.junit.jupiter.api.AfterEach
@@ -13,9 +16,6 @@ import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.assertThrows
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -27,11 +27,11 @@ class ValkeyEventStoreTest {
companion object {
@Container
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:9-alpine"))
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:8.0.2-alpine"))
.withExposedPorts(6379)
}
private lateinit var valkeyTemplate: StringRedisTemplate
private lateinit var valkeyTemplate: StringValkeyTemplate
private lateinit var serializer: EventSerializer
private lateinit var properties: ValkeyEventStoreProperties
private lateinit var eventStore: ValkeyEventStore
@@ -41,11 +41,11 @@ class ValkeyEventStoreTest {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = StringRedisTemplate(connectionFactory)
valkeyTemplate = StringValkeyTemplate(connectionFactory)
serializer = JacksonEventSerializer().apply {
registerEventType(TestCreatedEvent::class.java, "TestCreated")
backend/infrastructure/event-store/valkey-event-store/src/test/kotlin/at/mocode/infrastructure/eventstore/valkey/ValkeyIntegrationTest.kt
+7 -7
View File
@@ -9,15 +9,15 @@ import at.mocode.core.domain.model.EventType
import at.mocode.core.domain.model.EventVersion
import at.mocode.infrastructure.eventstore.api.EventSerializer
import at.mocode.infrastructure.eventstore.api.EventStore
import io.valkey.springframework.data.valkey.connection.ValkeyStandaloneConfiguration
import io.valkey.springframework.data.valkey.connection.lettuce.LettuceConnectionFactory
import io.valkey.springframework.data.valkey.core.StringValkeyTemplate
import kotlinx.serialization.Serializable
import kotlinx.serialization.Transient
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.data.redis.connection.RedisStandaloneConfiguration
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory
import org.springframework.data.redis.core.StringRedisTemplate
import org.testcontainers.containers.GenericContainer
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
@@ -29,11 +29,11 @@ class ValkeyIntegrationTest {
companion object {
@Container
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:9-alpine"))
val valkeyContainer: GenericContainer<*> = GenericContainer(DockerImageName.parse("valkey/valkey:8.0.2-alpine"))
.withExposedPorts(6379)
}
private lateinit var valkeyTemplate: StringRedisTemplate
private lateinit var valkeyTemplate: StringValkeyTemplate
private lateinit var serializer: EventSerializer
private lateinit var properties: ValkeyEventStoreProperties
private lateinit var eventStore: EventStore
@@ -43,10 +43,10 @@ class ValkeyIntegrationTest {
fun setUp() {
val valkeyPort = valkeyContainer.getMappedPort(6379)
val valkeyHost = valkeyContainer.host
val valkeyConfig = RedisStandaloneConfiguration(valkeyHost, valkeyPort)
val valkeyConfig = ValkeyStandaloneConfiguration(valkeyHost, valkeyPort)
val connectionFactory = LettuceConnectionFactory(valkeyConfig)
connectionFactory.afterPropertiesSet()
valkeyTemplate = StringRedisTemplate(connectionFactory)
valkeyTemplate = StringValkeyTemplate(connectionFactory)
serializer = JacksonEventSerializer().apply {
registerEventType(TestCreatedEvent::class.java, "TestCreated")
registerEventType(TestUpdatedEvent::class.java, "TestUpdated")
backend/infrastructure/gateway/build.gradle.kts
+1 -1
View File
@@ -31,7 +31,7 @@ dependencies {
// Resilience (Reactive) - WICHTIG: Reactor-Variante für WebFlux!
implementation(libs.spring.cloud.starter.circuitbreaker.reactor.resilience4j)
implementation(libs.spring.boot.starter.data.redis)
implementation(libs.spring.data.valkey)
implementation(libs.micrometer.tracing.bridge.brave)
testImplementation(projects.platform.platformTesting)
backend/infrastructure/messaging/messaging-client/build.gradle.kts
+6
View File
@@ -41,3 +41,9 @@ dependencies {
// Stellt alle Test-Abhängigkeiten gebündelt bereit.
testImplementation(projects.platform.platformTesting)
}
// JVM Native Access (JDK 22+): Unterdrückt Warnung/Blockade für Snappy (org.xerial.snappy)
tasks.withType<Test>().configureEach {
// Erfordert JDK 21+; ab zukünftigen Versionen sonst Fehler statt Warnung
jvmArgs("--enable-native-access=ALL-UNNAMED")
}
gradle/libs.versions.toml
+3 -2
View File
@@ -59,6 +59,7 @@ flyway = "11.19.1"
redisson = "4.0.0"
# Spring Boot 3.5.x manages Lettuce 6.6.x; keep aligned to avoid binary/API mismatches.
lettuce = "6.6.0.RELEASE"
springDataValkey = "0.2.0"
# Observability
micrometer = "1.16.1"
@@ -229,6 +230,7 @@ flyway-postgresql = { module = "org.flywaydb:flyway-database-postgresql", versio
redisson = { module = "org.redisson:redisson", version.ref = "redisson" }
lettuce-core = { module = "io.lettuce:lettuce-core", version.ref = "lettuce" }
spring-data-valkey = { module = "io.valkey.springframework.data:spring-data-valkey", version.ref = "springDataValkey" }
micrometer-prometheus = { module = "io.micrometer:micrometer-registry-prometheus", version.ref = "micrometer" }
micrometer-tracing-bridge-brave = { module = "io.micrometer:micrometer-tracing-bridge-brave", version.ref = "micrometerTracing" }
@@ -342,8 +344,7 @@ database-complete = [
"flyway-postgresql"
]
valkey-cache = [
"spring-boot-starter-data-redis",
"lettuce-core",
"spring-data-valkey",
"jackson-module-kotlin",
"jackson-datatype-jsr310"
]