Polish "Add missing RedisCommand enum entries for ZSet WithScores methods"

Adds convenience method to verify results in the newly added regression test in the previous commit.

Also removes a few warnings in the regression test by suppressing 'rawtypes' and 'unchecked' usages.

Original Pull Request: #3225
Related tickets: #3187

Signed-off-by: onobc <chris.bono@gmail.com>

Author: onobc

src/test/java/org/springframework/data/redis/core/TransactionalStringRedisTemplateTests.java

@@ -22,11 +22,11 @@
 import java.sql.SQLException;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.Set;
 import java.util.stream.Stream;
 
 import javax.sql.DataSource;
 
+import org.assertj.core.api.InstanceOfAssertFactories;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -68,6 +68,7 @@ class TransactionalStringRedisTemplateTests {
 		}
 	}
 
+	@SuppressWarnings({"rawtypes", "unchecked"})
 	@BeforeEach
 	void beforeEach() {
 
@@ -78,14 +79,14 @@ void beforeEach() {
 		stringTemplate.afterPropertiesSet();
 
 		stringTemplate.execute((RedisCallback) con -> {
-			con.flushDb();
+			con.serverCommands().flushDb();
 			return null;
 		});
 	}
 
 	@AfterEach
 	void afterEach() {
-		redisConnectionFactory.getConnection().flushAll();
+		redisConnectionFactory.getConnection().serverCommands().flushAll();
 	}
 
 	@Test // GH-3191
@@ -119,7 +120,6 @@ void visibilityDuringManagedTransaction() throws SQLException {
 				.containsEntry("isMember(inside)", false);
 	}
 
-	@SuppressWarnings("unchecked")
 	@Test // GH-3187
 	void allRangeWithScoresMethodsShouldExecuteImmediatelyInTransaction() throws SQLException {
 
@@ -138,77 +138,55 @@ void allRangeWithScoresMethodsShouldExecuteImmediatelyInTransaction() throws SQL
 			Map<String, Object> ops = new LinkedHashMap<>();
 
 			// Query data added outside transaction (should execute immediately)
-			ops.put("rangeWithScores_before",
+			ops.put("rangeWithScores_outside",
 				stringTemplate.opsForZSet().rangeWithScores("testzset", 0, -1));
-			ops.put("reverseRangeWithScores_before",
+			ops.put("reverseRangeWithScores_outside",
 				stringTemplate.opsForZSet().reverseRangeWithScores("testzset", 0, -1));
-			ops.put("rangeByScoreWithScores_before",
+			ops.put("rangeByScoreWithScores_outside",
 				stringTemplate.opsForZSet().rangeByScoreWithScores("testzset", 1.0, 2.0));
-			ops.put("reverseRangeByScoreWithScores_before",
+			ops.put("reverseRangeByScoreWithScores_outside",
 				stringTemplate.opsForZSet().reverseRangeByScoreWithScores("testzset", 1.0, 2.0));
 
 			// Add inside transaction (goes into multi/exec queue)
-			ops.put("add_result", stringTemplate.opsForZSet().add("testzset", "inside", 3.0));
+			ops.put("add_inside", stringTemplate.opsForZSet().add("testzset", "inside", 3.0));
 
 			// Changes made inside transaction should not be visible yet (read executes immediately)
-			ops.put("rangeWithScores_after",
+			ops.put("rangeWithScores_inside",
 				stringTemplate.opsForZSet().rangeWithScores("testzset", 0, -1));
-			ops.put("reverseRangeWithScores_after",
+			ops.put("reverseRangeWithScores_inside",
 				stringTemplate.opsForZSet().reverseRangeWithScores("testzset", 0, -1));
-			ops.put("rangeByScoreWithScores_after",
+			ops.put("rangeByScoreWithScores_inside",
 				stringTemplate.opsForZSet().rangeByScoreWithScores("testzset", 1.0, 3.0));
-			ops.put("reverseRangeByScoreWithScores_after",
+			ops.put("reverseRangeByScoreWithScores_inside",
 				stringTemplate.opsForZSet().reverseRangeByScoreWithScores("testzset", 1.0, 3.0));
 
 			return ops;
 		});
 
 		// add result is null (no result until exec)
-		assertThat(result).containsEntry("add_result", null);
-
-		// before: only data added outside transaction is visible
-		assertThat((Set<TypedTuple<String>>) result.get("rangeWithScores_before"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside1", "outside2");
-
-		assertThat((Set<TypedTuple<String>>) result.get("reverseRangeWithScores_before"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside2", "outside1");
-
-		assertThat((Set<TypedTuple<String>>) result.get("rangeByScoreWithScores_before"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside1", "outside2");
-
-		assertThat((Set<TypedTuple<String>>) result.get("reverseRangeByScoreWithScores_before"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside2", "outside1");
-
-		// after: changes made inside transaction are still not visible
-		assertThat((Set<TypedTuple<String>>) result.get("rangeWithScores_after"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside1", "outside2");
-
-		assertThat((Set<TypedTuple<String>>) result.get("reverseRangeWithScores_after"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside2", "outside1");
-
-		assertThat((Set<TypedTuple<String>>) result.get("rangeByScoreWithScores_after"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside1", "outside2");
-
-		assertThat((Set<TypedTuple<String>>) result.get("reverseRangeByScoreWithScores_after"))
-			.hasSize(2)
-			.extracting(TypedTuple::getValue)
-			.containsExactly("outside2", "outside1");
+		assertThat(result).containsEntry("add_inside", null);
+
+		// changes made outside transaction are visible
+		assertThatResultForOperationContainsExactly(result, "rangeWithScores_outside", "outside1", "outside2");
+		assertThatResultForOperationContainsExactly(result, "reverseRangeWithScores_outside", "outside2", "outside1");
+		assertThatResultForOperationContainsExactly(result, "rangeByScoreWithScores_outside", "outside1", "outside2");
+		assertThatResultForOperationContainsExactly(result, "reverseRangeByScoreWithScores_outside", "outside2", "outside1");
+		
+		// changes made inside transaction are not visible (i.e. a 3rd element was added but not detected in range op)
+		assertThatResultForOperationContainsExactly(result, "rangeWithScores_inside", "outside1", "outside2");
+		assertThatResultForOperationContainsExactly(result, "reverseRangeWithScores_inside", "outside2", "outside1");
+		assertThatResultForOperationContainsExactly(result, "rangeByScoreWithScores_inside", "outside1", "outside2");
+		assertThatResultForOperationContainsExactly(result, "reverseRangeByScoreWithScores_inside", "outside2", "outside1");
 	}
 
+	private void assertThatResultForOperationContainsExactly(Map<String, Object> result, String operation, String... expectedValues) {
+		assertThat(result.get(operation))
+				.asInstanceOf(InstanceOfAssertFactories.set(TypedTuple.class))
+				.hasSize(expectedValues.length)
+				.extracting(TypedTuple::getValue)
+				.containsExactly(expectedValues);
+	}
+	
 	static Stream<Arguments> argumentsStream() {
 
 		LettuceConnectionFactory lcf = new LettuceConnectionFactory(SettingsUtils.standaloneConfiguration());