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
+562 -562
View File
File diff suppressed because it is too large Load Diff
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
+28 -28
View File
@@ -1,40 +1,40 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<!-- Console Appender für Test-Ausgaben -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<!-- Console Appender für Test-Ausgaben -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
</encoder>
</appender>
<!-- Cache-spezifische Logger -->
<logger name="at.mocode.infrastructure.cache" level="DEBUG" />
<!-- Cache-spezifische Logger -->
<logger name="at.mocode.infrastructure.cache" level="DEBUG"/>
<!-- Performance Test Logger -->
<logger name="ValkeyDistributedCachePerformanceTest" level="INFO" />
<!-- Performance Test Logger -->
<logger name="ValkeyDistributedCachePerformanceTest" level="INFO"/>
<!-- Edge Cases Test Logger -->
<logger name="ValkeyDistributedCacheEdgeCasesTest" level="INFO" />
<!-- Edge Cases Test Logger -->
<logger name="ValkeyDistributedCacheEdgeCasesTest" level="INFO"/>
<!-- Resilience Test Logger -->
<logger name="ValkeyDistributedCacheResilienceTest" level="INFO" />
<!-- Resilience Test Logger -->
<logger name="ValkeyDistributedCacheResilienceTest" level="INFO"/>
<!-- Configuration Test Logger -->
<logger name="ValkeyDistributedCacheConfigurationTest" level="INFO" />
<!-- Configuration Test Logger -->
<logger name="ValkeyDistributedCacheConfigurationTest" level="INFO"/>
<!-- Integration Test Logger -->
<logger name="ValkeyDistributedCacheIntegrationTest" level="INFO" />
<!-- Integration Test Logger -->
<logger name="ValkeyDistributedCacheIntegrationTest" level="INFO"/>
<!-- Testcontainers Logger (reduziert Verbosity) -->
<logger name="org.testcontainers" level="WARN" />
<logger name="com.github.dockerjava" level="WARN" />
<!-- Testcontainers Logger (reduziert Verbosity) -->
<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" />
<!-- Valkey/Lettuce Logger (reduziert Verbosity) -->
<logger name="io.lettuce" level="WARN"/>
<logger name="io.valkey.springframework.data" level="WARN"/>
<!-- Root Logger -->
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
<!-- Root Logger -->
<root level="INFO">
<appender-ref ref="STDOUT"/>
</root>
</configuration>