Skip to content

Commit df37dc8

Browse files
mp911demp911de
committed
DATAREDIS-729 - Polishing.
Tweak assertion messages and consistently use constants. Reformat code. Join assertions in tests. Original pull request: #566.
1 parent da81275 commit df37dc8

File tree

5 files changed

+36
-77
lines changed

5 files changed

+36
-77
lines changed

‎src/main/java/org/springframework/data/redis/connection/RedisZSetCommands.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1046,8 +1046,8 @@ default Set<byte[]> zRevRangeByLex(byte[] key, Range range) {
10461046
}
10471047

10481048
/**
1049-
* Get all the elements in {@link Range} from the sorted set at {@literal key} in reversed lexicographical ordering. Result is
1050-
* limited via {@link Limit}.
1049+
* Get all the elements in {@link Range} from the sorted set at {@literal key} in reversed lexicographical ordering.
1050+
* Result is limited via {@link Limit}.
10511051
*
10521052
* @param key must not be {@literal null}.
10531053
* @param range must not be {@literal null}.

‎src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterZSetCommands.java‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -309,11 +309,11 @@ public Set<byte[]> zRangeByScore(byte[] key, Range range, Limit limit) {
309309
public Set<byte[]> zRangeByLex(byte[] key, Range range, Limit limit) {
310310

311311
Assert.notNull(key, "Key must not be null!");
312-
Assert.notNull(range, "Range cannot be null for ZRANGEBYLEX.");
312+
Assert.notNull(range, "Range must not be null for ZRANGEBYLEX!");
313313
Assert.notNull(limit, "Limit must not be null!");
314314

315-
byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.toBytes("-"));
316-
byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.toBytes("+"));
315+
byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES);
316+
byte[] max = JedisConverters.boundaryToBytesForZRangeByLex(range.getMax(), JedisConverters.PLUS_BYTES);
317317

318318
try {
319319
if (limit.isUnlimited()) {
@@ -333,7 +333,7 @@ public Set<byte[]> zRangeByLex(byte[] key, Range range, Limit limit) {
333333
public Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit) {
334334

335335
Assert.notNull(key, "Key must not be null!");
336-
Assert.notNull(range, "Range cannot be null for ZREVRANGEBYLEX.");
336+
Assert.notNull(range, "Range must not be null for ZREVRANGEBYLEX!");
337337
Assert.notNull(limit, "Limit must not be null!");
338338

339339
byte[] min = JedisConverters.boundaryToBytesForZRangeByLex(range.getMin(), JedisConverters.MINUS_BYTES);

‎src/main/java/org/springframework/data/redis/connection/jedis/JedisZSetCommands.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -933,7 +933,8 @@ public Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit) {
933933
}
934934

935935
if (!limit.isUnlimited()) {
936-
return new LinkedHashSet<>(connection.getJedis().zrevrangeByLex(key, max, min, limit.getOffset(), limit.getCount()));
936+
return new LinkedHashSet<>(
937+
connection.getJedis().zrevrangeByLex(key, max, min, limit.getOffset(), limit.getCount()));
937938
}
938939
return new LinkedHashSet<>(connection.getJedis().zrevrangeByLex(key, max, min));
939940
} catch (Exception ex) {

‎src/main/java/org/springframework/data/redis/connection/lettuce/LettuceZSetCommands.java‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -892,25 +892,25 @@ public Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit) {
892892
try {
893893
if (isPipelined()) {
894894
if (limit.isUnlimited()) {
895-
pipeline(
896-
connection.newLettuceResult(getAsyncConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true)),
897-
LettuceConverters.bytesListToBytesSet()));
895+
pipeline(connection.newLettuceResult(
896+
getAsyncConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true)),
897+
LettuceConverters.bytesListToBytesSet()));
898898
} else {
899-
pipeline(
900-
connection.newLettuceResult(getAsyncConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true),
901-
LettuceConverters.toLimit(limit)), LettuceConverters.bytesListToBytesSet()));
899+
pipeline(connection.newLettuceResult(getAsyncConnection().zrevrangebylex(key,
900+
LettuceConverters.toRange(range, true), LettuceConverters.toLimit(limit)),
901+
LettuceConverters.bytesListToBytesSet()));
902902
}
903903
return null;
904904
}
905905
if (isQueueing()) {
906906
if (limit.isUnlimited()) {
907-
transaction(
908-
connection.newLettuceResult(getAsyncConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true)),
909-
LettuceConverters.bytesListToBytesSet()));
907+
transaction(connection.newLettuceResult(
908+
getAsyncConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true)),
909+
LettuceConverters.bytesListToBytesSet()));
910910
} else {
911-
transaction(
912-
connection.newLettuceResult(getAsyncConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true),
913-
LettuceConverters.toLimit(limit)), LettuceConverters.bytesListToBytesSet()));
911+
transaction(connection.newLettuceResult(getAsyncConnection().zrevrangebylex(key,
912+
LettuceConverters.toRange(range, true), LettuceConverters.toLimit(limit)),
913+
LettuceConverters.bytesListToBytesSet()));
914914
}
915915
return null;
916916
}
@@ -919,8 +919,8 @@ public Set<byte[]> zRevRangeByLex(byte[] key, Range range, Limit limit) {
919919
return LettuceConverters.bytesListToBytesSet()
920920
.convert(getConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true)));
921921
}
922-
return LettuceConverters.bytesListToBytesSet().convert(
923-
getConnection().zrevrangebylex(key, LettuceConverters.toRange(range, true), LettuceConverters.toLimit(limit)));
922+
return LettuceConverters.bytesListToBytesSet().convert(getConnection().zrevrangebylex(key,
923+
LettuceConverters.toRange(range, true), LettuceConverters.toLimit(limit)));
924924

925925
} catch (Exception ex) {
926926
throw convertLettuceAccessException(ex);

‎src/test/java/org/springframework/data/redis/connection/AbstractConnectionIntegrationTests.java‎

Lines changed: 14 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -2411,34 +2411,13 @@ public void zRangeByLexTest() {
24112411

24122412
List<Object> results = getResults();
24132413

2414-
Set<String> values = (Set<String>) results.get(7);
2415-
2416-
assertThat(values).containsExactly("a", "b", "c");
2417-
assertThat(values).doesNotContain("d", "e", "f", "g");
2418-
2419-
values = (Set<String>) results.get(8);
2420-
assertThat(values).containsExactly("a", "b");
2421-
assertThat(values).doesNotContain("c");
2422-
2423-
values = (Set<String>) results.get(9);
2424-
assertThat(values).containsExactly("b", "c", "d", "e", "f");
2425-
assertThat(values).doesNotContain("a", "g");
2426-
2427-
values = (Set<String>) results.get(10);
2428-
assertThat(values).containsExactly("e", "f", "g");
2429-
assertThat(values).doesNotContain("a", "b", "c", "d");
2430-
2431-
values = (Set<String>) results.get(11);
2432-
assertThat(values).containsExactly("a", "b", "c");
2433-
assertThat(values).doesNotContain("d", "e", "f", "g");
2434-
2435-
values = (Set<String>) results.get(12);
2436-
assertThat(values).contains("a");
2437-
assertThat(values).doesNotContain("b", "c", "d", "e", "f", "g");
2438-
2439-
values = (Set<String>) results.get(13);
2440-
assertThat(values).contains("b");
2441-
assertThat(values).doesNotContain("a", "c", "d", "e", "f", "g");
2414+
assertThat((Set<String>) results.get(7)).containsExactly("a", "b", "c").doesNotContain("d", "e", "f", "g");
2415+
assertThat((Set<String>) results.get(8)).containsExactly("a", "b").doesNotContain("c");
2416+
assertThat((Set<String>) results.get(9)).containsExactly("b", "c", "d", "e", "f").doesNotContain("a", "g");
2417+
assertThat((Set<String>) results.get(10)).containsExactly("e", "f", "g").doesNotContain("a", "b", "c", "d");
2418+
assertThat((Set<String>) results.get(11)).containsExactly("a", "b", "c").doesNotContain("d", "e", "f", "g");
2419+
assertThat((Set<String>) results.get(12)).contains("a").doesNotContain("b", "c", "d", "e", "f", "g");
2420+
assertThat((Set<String>) results.get(13)).contains("b").doesNotContain("a", "c", "d", "e", "f", "g");
24422421
}
24432422

24442423
@SuppressWarnings("unchecked")
@@ -2466,34 +2445,13 @@ public void zRevRangeByLexTest() {
24662445

24672446
List<Object> results = getResults();
24682447

2469-
Set<String> values = (Set<String>) results.get(7);
2470-
2471-
assertThat(values).containsExactly("c", "b", "a");
2472-
assertThat(values).doesNotContain("d", "e", "f", "g");
2473-
2474-
values = (Set<String>) results.get(8);
2475-
assertThat(values).containsExactly("b", "a");
2476-
assertThat(values).doesNotContain("c");
2477-
2478-
values = (Set<String>) results.get(9);
2479-
assertThat(values).containsExactly("f", "e", "d", "c", "b");
2480-
assertThat(values).doesNotContain("a", "g");
2481-
2482-
values = (Set<String>) results.get(10);
2483-
assertThat(values).containsExactly("g", "f", "e");
2484-
assertThat(values).doesNotContain("a", "b", "c", "d");
2485-
2486-
values = (Set<String>) results.get(11);
2487-
assertThat(values).containsExactly("c", "b", "a");
2488-
assertThat(values).doesNotContain("d", "e", "f", "g");
2489-
2490-
values = (Set<String>) results.get(12);
2491-
assertThat(values).contains("d", "c");
2492-
assertThat(values).doesNotContain("a", "b", "e", "f", "g");
2493-
2494-
values = (Set<String>) results.get(13);
2495-
assertThat(values).contains("c", "b");
2496-
assertThat(values).doesNotContain("a", "d", "e", "f", "g");
2448+
assertThat((Set<String>) results.get(7)).containsExactly("c", "b", "a").doesNotContain("d", "e", "f", "g");
2449+
assertThat((Set<String>) results.get(8)).containsExactly("b", "a").doesNotContain("c");
2450+
assertThat((Set<String>) results.get(9)).containsExactly("f", "e", "d", "c", "b").doesNotContain("a", "g");
2451+
assertThat((Set<String>) results.get(10)).containsExactly("g", "f", "e").doesNotContain("a", "b", "c", "d");
2452+
assertThat((Set<String>) results.get(11)).containsExactly("c", "b", "a").doesNotContain("d", "e", "f", "g");
2453+
assertThat((Set<String>) results.get(12)).contains("d", "c").doesNotContain("a", "b", "e", "f", "g");
2454+
assertThat((Set<String>) results.get(13)).contains("c", "b").doesNotContain("a", "d", "e", "f", "g");
24972455
}
24982456

24992457
@Test(expected = IllegalArgumentException.class) // DATAREDIS-316, DATAREDIS-692

0 commit comments

Comments
 (0)