Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 7bf035f

Browse files
committed
Allow @EnabledOnRedisDriver usage with @ParameterizedRedisTest.
We now enable tests without an instance in EnabledOnRedisDriverCondition assuming that we only use DriverQualifier on instance fields and not static ones. Closes #2734 Original pull request: #2717 
1 parent efc9ecf commit 7bf035f

File tree

3 files changed

+37
-43
lines changed

3 files changed

+37
-43
lines changed

‎src/test/java/org/springframework/data/redis/cache/DefaultRedisCacheWriterTests.java‎

Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,6 @@
1616
package org.springframework.data.redis.cache;
1717

1818
import static org.assertj.core.api.Assertions.*;
19-
import static org.assertj.core.api.Assumptions.*;
2019
import static org.springframework.data.redis.cache.RedisCacheWriter.*;
2120

2221
import java.nio.charset.Charset;
@@ -33,8 +32,10 @@
3332
import org.springframework.data.redis.connection.RedisConnection;
3433
import org.springframework.data.redis.connection.RedisConnectionFactory;
3534
import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
36-
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
3735
import org.springframework.data.redis.core.types.Expiration;
36+
import org.springframework.data.redis.test.condition.EnabledOnRedisDriver;
37+
import org.springframework.data.redis.test.condition.EnabledOnRedisDriver.DriverQualifier;
38+
import org.springframework.data.redis.test.condition.RedisDriver;
3839
import org.springframework.data.redis.test.extension.parametrized.MethodSource;
3940
import org.springframework.data.redis.test.extension.parametrized.ParameterizedRedisTest;
4041

@@ -55,7 +56,7 @@ public class DefaultRedisCacheWriterTests {
5556
private byte[] binaryCacheKey = cacheKey.getBytes(StandardCharsets.UTF_8);
5657
private byte[] binaryCacheValue = "value".getBytes(StandardCharsets.UTF_8);
5758

58-
private RedisConnectionFactory connectionFactory;
59+
private final@DriverQualifierRedisConnectionFactory connectionFactory;
5960

6061
public DefaultRedisCacheWriterTests(RedisConnectionFactory connectionFactory) {
6162
this.connectionFactory = connectionFactory;
@@ -147,10 +148,9 @@ void getShouldReturnNullWhenKeyDoesNotExist() {
147148
}
148149

149150
@ParameterizedRedisTest // GH-2650
151+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
150152
void cacheHitRetrieveShouldIncrementStatistics() throws ExecutionException, InterruptedException {
151153

152-
assumeThat(connectionFactory).isInstanceOf(LettuceConnectionFactory.class);
153-
154154
doWithConnection(connection -> connection.set(binaryCacheKey, binaryCacheValue));
155155

156156
RedisCacheWriter writer = nonLockingRedisCacheWriter(connectionFactory)
@@ -163,10 +163,9 @@ void cacheHitRetrieveShouldIncrementStatistics() throws ExecutionException, Inte
163163
}
164164

165165
@ParameterizedRedisTest // GH-2650
166+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
166167
void storeShouldIncrementStatistics() throws ExecutionException, InterruptedException {
167168

168-
assumeThat(connectionFactory).isInstanceOf(LettuceConnectionFactory.class);
169-
170169
RedisCacheWriter writer = nonLockingRedisCacheWriter(connectionFactory)
171170
.withStatisticsCollector(CacheStatisticsCollector.create());
172171

@@ -176,10 +175,9 @@ void storeShouldIncrementStatistics() throws ExecutionException, InterruptedExce
176175
}
177176

178177
@ParameterizedRedisTest // GH-2650
178+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
179179
void cacheMissRetrieveWithLoaderAsyncShouldIncrementStatistics() throws ExecutionException, InterruptedException {
180180

181-
assumeThat(connectionFactory).isInstanceOf(LettuceConnectionFactory.class);
182-
183181
RedisCacheWriter writer = nonLockingRedisCacheWriter(connectionFactory)
184182
.withStatisticsCollector(CacheStatisticsCollector.create());
185183

‎src/test/java/org/springframework/data/redis/cache/RedisCacheTests.java‎

Lines changed: 12 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,6 @@
1616
package org.springframework.data.redis.cache;
1717

1818
import static org.assertj.core.api.Assertions.*;
19-
import static org.assertj.core.api.Assumptions.*;
2019
import static org.awaitility.Awaitility.*;
2120

2221
import io.netty.util.concurrent.DefaultThreadFactory;
@@ -49,11 +48,12 @@
4948
import org.springframework.cache.support.NullValue;
5049
import org.springframework.data.redis.connection.RedisConnection;
5150
import org.springframework.data.redis.connection.RedisConnectionFactory;
52-
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
53-
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
5451
import org.springframework.data.redis.serializer.RedisSerializationContext.SerializationPair;
5552
import org.springframework.data.redis.serializer.RedisSerializer;
5653
import org.springframework.data.redis.test.condition.EnabledOnCommand;
54+
import org.springframework.data.redis.test.condition.EnabledOnRedisDriver;
55+
import org.springframework.data.redis.test.condition.EnabledOnRedisDriver.DriverQualifier;
56+
import org.springframework.data.redis.test.condition.RedisDriver;
5757
import org.springframework.data.redis.test.extension.parametrized.MethodSource;
5858
import org.springframework.data.redis.test.extension.parametrized.ParameterizedRedisTest;
5959
import org.springframework.lang.Nullable;
@@ -80,7 +80,7 @@ public class RedisCacheTests {
8080

8181
private byte[] binaryNullValue = RedisSerializer.java().serialize(NullValue.INSTANCE);
8282

83-
private RedisConnectionFactory connectionFactory;
83+
private final@DriverQualifierRedisConnectionFactory connectionFactory;
8484
private RedisSerializer serializer;
8585
private RedisCache cache;
8686

@@ -284,13 +284,9 @@ void clearShouldClearCache() {
284284
}
285285

286286
@ParameterizedRedisTest // GH-1721
287+
@EnabledOnRedisDriver(RedisDriver.LETTUCE) // SCAN not supported via Jedis Cluster.
287288
void clearWithScanShouldClearCache() {
288289

289-
// SCAN not supported via Jedis Cluster.
290-
if (connectionFactory instanceof JedisConnectionFactory) {
291-
assumeThat(((JedisConnectionFactory) connectionFactory).isRedisClusterAware()).isFalse();
292-
}
293-
294290
RedisCache cache = new RedisCache("cache",
295291
RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory, BatchStrategies.scan(25)),
296292
RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(SerializationPair.fromSerializer(serializer)));
@@ -573,11 +569,9 @@ void cacheGetWithTimeToIdleExpirationAfterEntryExpiresShouldReturnNull() {
573569
}
574570

575571
@ParameterizedRedisTest // GH-2650
572+
@EnabledOnRedisDriver(RedisDriver.JEDIS)
576573
void retrieveCacheValueUsingJedis() {
577574

578-
// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.JEDIS) does not work!
579-
assumeThat(this.connectionFactory instanceof JedisConnectionFactory).isTrue();
580-
581575
assertThatExceptionOfType(UnsupportedOperationException.class)
582576
.isThrownBy(() -> this.cache.retrieve(this.binaryCacheKey)).withMessageContaining("RedisCache");
583577

@@ -587,12 +581,10 @@ void retrieveCacheValueUsingJedis() {
587581
}
588582

589583
@ParameterizedRedisTest // GH-2650
584+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
590585
@SuppressWarnings("unchecked")
591586
void retrieveReturnsCachedValue() throws Exception {
592587

593-
// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
594-
assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
595-
596588
doWithConnection(connection -> connection.stringCommands().set(this.binaryCacheKey, this.binarySample));
597589

598590
RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());
@@ -605,13 +597,10 @@ void retrieveReturnsCachedValue() throws Exception {
605597
}
606598

607599
@ParameterizedRedisTest // GH-2650
600+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
608601
@SuppressWarnings("unchecked")
609602
void retrieveReturnsCachedValueWhenLockIsReleased() throws Exception {
610603

611-
// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
612-
assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
613-
614-
String mockValue = "MockValue";
615604
String testValue = "TestValue";
616605

617606
byte[] binaryCacheValue = this.serializer.serialize(testValue);
@@ -634,11 +623,9 @@ void retrieveReturnsCachedValueWhenLockIsReleased() throws Exception {
634623
}
635624

636625
@ParameterizedRedisTest // GH-2650
626+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
637627
void retrieveReturnsLoadedValue() throws Exception {
638628

639-
// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
640-
assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
641-
642629
RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());
643630
AtomicBoolean loaded = new AtomicBoolean(false);
644631
Person jon = new Person("Jon", Date.from(Instant.now()));
@@ -658,11 +645,9 @@ void retrieveReturnsLoadedValue() throws Exception {
658645
}
659646

660647
@ParameterizedRedisTest // GH-2650
648+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
661649
void retrieveStoresLoadedValue() throws Exception {
662650

663-
// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
664-
assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
665-
666651
RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());
667652
Person jon = new Person("Jon", Date.from(Instant.now()));
668653
Supplier<CompletableFuture<Person>> valueLoaderSupplier = () -> CompletableFuture.completedFuture(jon);
@@ -675,11 +660,9 @@ void retrieveStoresLoadedValue() throws Exception {
675660
}
676661

677662
@ParameterizedRedisTest // GH-2650
663+
@EnabledOnRedisDriver(RedisDriver.LETTUCE)
678664
void retrieveReturnsNull() throws Exception {
679665

680-
// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
681-
assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
682-
683666
doWithConnection(connection -> connection.stringCommands().set(this.binaryCacheKey, this.binaryNullValue));
684667

685668
RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());
@@ -733,11 +716,8 @@ private Function<RedisCacheConfiguration, RedisCacheConfiguration> withTtiExpira
733716
}
734717

735718
void doWithConnection(Consumer<RedisConnection> callback) {
736-
RedisConnection connection = connectionFactory.getConnection();
737-
try {
719+
try (RedisConnection connection = connectionFactory.getConnection()) {
738720
callback.accept(connection);
739-
} finally {
740-
connection.close();
741721
}
742722
}
743723

‎src/test/java/org/springframework/data/redis/test/condition/EnabledOnRedisDriverCondition.java‎

Lines changed: 18 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -59,10 +59,15 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con
5959

6060
if (annotatedFields.isEmpty()) {
6161
throw new IllegalStateException(
62-
"@EnabledOnRedisDriver requires a field of type RedisConnectionFactory annotated with @DriverQualifier");
62+
"@EnabledOnRedisDriver requires a field of type \"RedisConnectionFactory\" annotated with @DriverQualifier");
63+
}
64+
65+
if (context.getTestInstance().isEmpty()) {
66+
return ENABLED_BY_DEFAULT;
6367
}
6468

6569
for (Field field : annotatedFields) {
70+
6671
Try<Object> fieldValue = ReflectionUtils.tryToReadFieldValue(field, context.getRequiredTestInstance());
6772

6873
RedisConnectionFactory value = (RedisConnectionFactory) fieldValue
@@ -76,7 +81,8 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con
7681
}
7782

7883
if (!foundMatch) {
79-
return disabled(String.format("Driver %s not supported; Supported driver(s): %s", value,
84+
return disabled(String.format("Driver %s not supported; Supported driver(s): %s",
85+
formatUnsupportedDriver(value),
8086
Arrays.toString(annotation.value())));
8187
}
8288
}
@@ -85,4 +91,14 @@ public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext con
8591

8692
}
8793

94+
private static String formatUnsupportedDriver(RedisConnectionFactory value) {
95+
96+
for (RedisDriver redisDriver : RedisDriver.values()) {
97+
if (redisDriver.matches(value)) {
98+
return redisDriver.toString();
99+
}
100+
}
101+
102+
return value.toString();
103+
}
88104
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /