chore: refactor integration tests removing usage of deprecated connection methods from command APIs

Signed-off-by: The-East-Wind <[email protected]>

Author: The-East-Wind

src/test/java/biz/paluch/redis/extensibility/MyExtendedRedisClientIntegrationTests.java

@@ -50,7 +50,7 @@ void testPubsub() throws Exception {
         StatefulRedisPubSubConnection<String, String> connection = client.connectPubSub();
         RedisPubSubAsyncCommands<String, String> commands = connection.async();
         assertThat(commands).isInstanceOf(RedisPubSubAsyncCommandsImpl.class);
-        assertThat(commands.getStatefulConnection()).isInstanceOf(MyPubSubConnection.class);
+        assertThat(connection).isInstanceOf(MyPubSubConnection.class);
         commands.set("key", "value").get();
         connection.close();
     }

src/test/java/io/lettuce/core/AsyncConnectionIntegrationTests.java

@@ -44,23 +44,21 @@
 /**
  * @author Will Glozer
  * @author Mark Paluch
+ * @author Hari Mani
  */
 @Tag(INTEGRATION_TEST)
 @ExtendWith(LettuceExtension.class)
 class AsyncConnectionIntegrationTests extends TestSupport {
 
     private final RedisClient client;
 
-    private final StatefulRedisConnection<String, String> connection;
-
     private final RedisAsyncCommands<String, String> async;
 
     @Inject
     AsyncConnectionIntegrationTests(RedisClient client, StatefulRedisConnection<String, String> connection) {
         this.client = client;
-        this.connection = connection;
         this.async = connection.async();
-        this.connection.sync().flushall();
+        connection.sync().flushall();
     }
 
     @Test
@@ -121,23 +119,14 @@ void futureListener() {
         Delay.delay(Duration.ofMillis(100));
 
         assertThat(run).hasSize(1);
-
-        connection.getStatefulConnection().close();
     }
 
     @Test
     void futureListenerCompleted() {
 
         final List<Object> run = new ArrayList<>();
 
-        Runnable listener = new Runnable() {
-
-            @Override
-            public void run() {
-                run.add(new Object());
-            }
-
-        };
+        Runnable listener = () -> run.add(new Object());
 
         RedisAsyncCommands<String, String> connection = client.connect().async();
 
@@ -147,8 +136,6 @@ public void run() {
         set.thenRun(listener);
 
         assertThat(run).hasSize(1);
-
-        connection.getStatefulConnection().close();
     }
 
     @Test

src/test/java/io/lettuce/core/ClientOptionsIntegrationTests.java

@@ -118,88 +118,77 @@ void requestQueueSize() {
 
     @Test
     void requestQueueSizeAppliedForReconnect() {
-
         client.setOptions(ClientOptions.builder().requestQueueSize(10)
                 .timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
-
-        RedisAsyncCommands<String, String> connection = client.connect().async();
-        testHitRequestQueueLimit(connection);
+        final StatefulRedisConnection<String, String> connection = client.connect();
+        final RedisAsyncCommands<String, String> commands = connection.async();
+        testHitRequestQueueLimit(commands, connection);
     }
 
     @Test
     void testHitRequestQueueLimitReconnectWithAuthCommand() {
-
         WithPassword.run(client, () -> {
-
             client.setOptions(ClientOptions.builder().protocolVersion(ProtocolVersion.RESP2).pingBeforeActivateConnection(false)
                     .requestQueueSize(10).timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
-
-            RedisAsyncCommands<String, String> connection = client.connect().async();
-            connection.auth(passwd);
-            testHitRequestQueueLimit(connection);
+            final StatefulRedisConnection<String, String> connection = client.connect();
+            final RedisAsyncCommands<String, String> commands = connection.async();
+            commands.auth(passwd);
+            testHitRequestQueueLimit(commands, connection);
         });
     }
 
     @Test
     @EnabledOnCommand("ACL")
     void testHitRequestQueueLimitReconnectWithAuthUsernamePasswordCommand() {
-
         WithPassword.run(client, () -> {
-
             client.setOptions(ClientOptions.builder().protocolVersion(ProtocolVersion.RESP2).pingBeforeActivateConnection(false)
                     .requestQueueSize(10).timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
-
-            RedisAsyncCommands<String, String> connection = client.connect().async();
-            connection.auth(username, passwd);
-            testHitRequestQueueLimit(connection);
+            final StatefulRedisConnection<String, String> connection = client.connect();
+            final RedisAsyncCommands<String, String> commands = connection.async();
+            commands.auth(username, passwd);
+            testHitRequestQueueLimit(commands, connection);
         });
     }
 
     @Test
     void testHitRequestQueueLimitReconnectWithUriAuth() {
-
         WithPassword.run(client, () -> {
             client.setOptions(ClientOptions.builder().requestQueueSize(10)
                     .timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
-            ;
-
-            RedisURI redisURI = RedisURI.create(host, port);
+            final RedisURI redisURI = RedisURI.create(host, port);
             redisURI.setPassword(passwd);
-
-            RedisAsyncCommands<String, String> connection = client.connect(redisURI).async();
-            testHitRequestQueueLimit(connection);
+            final StatefulRedisConnection<String, String> connection = client.connect(redisURI);
+            final RedisAsyncCommands<String, String> commands = connection.async();
+            testHitRequestQueueLimit(commands, connection);
         });
     }
 
     @Test
     void testHitRequestQueueLimitReconnectWithUriAuthPingCommand() {
-
         WithPassword.run(client, () -> {
-
             client.setOptions(ClientOptions.builder().requestQueueSize(10)
                     .timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
-
-            RedisURI redisURI = RedisURI.create(host, port);
+            final RedisURI redisURI = RedisURI.create(host, port);
             redisURI.setPassword(passwd);
-
-            RedisAsyncCommands<String, String> connection = client.connect(redisURI).async();
-            testHitRequestQueueLimit(connection);
+            final StatefulRedisConnection<String, String> connection = client.connect(redisURI);
+            RedisAsyncCommands<String, String> commands = connection.async();
+            testHitRequestQueueLimit(commands, connection);
         });
     }
 
-    private void testHitRequestQueueLimit(RedisAsyncCommands<String, String> connection) {
-
-        ConnectionWatchdog watchdog = getConnectionWatchdog(connection.getStatefulConnection());
+    private void testHitRequestQueueLimit(final RedisAsyncCommands<String, String> commands,
+            final StatefulRedisConnection<String, String> connection) {
+        ConnectionWatchdog watchdog = getConnectionWatchdog(connection);
 
         watchdog.setListenOnChannelInactive(false);
 
-        connection.quit();
+        commands.quit();
 
-        Wait.untilTrue(() -> !connection.getStatefulConnection().isOpen()).waitOrTimeout();
+        Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
 
         List<RedisFuture<String>> pings = new ArrayList<>();
         for (int i = 0; i < 10; i++) {
-            pings.add(connection.ping());
+            pings.add(commands.ping());
         }
 
         watchdog.setListenOnChannelInactive(true);
@@ -208,8 +197,7 @@ private void testHitRequestQueueLimit(RedisAsyncCommands<String, String> connect
         for (RedisFuture<String> ping : pings) {
             assertThat(TestFutures.getOrTimeout(ping)).isEqualTo("PONG");
         }
-
-        connection.getStatefulConnection().close();
+        connection.close();
     }
 
     @Test
@@ -252,68 +240,52 @@ void requestQueueSizeOvercommittedReconnect() {
 
     @Test
     void disconnectedWithoutReconnect() {
-
         client.setOptions(ClientOptions.builder().autoReconnect(false).build());
-
-        RedisAsyncCommands<String, String> connection = client.connect().async();
-
-        connection.quit();
-        Wait.untilTrue(() -> !connection.getStatefulConnection().isOpen()).waitOrTimeout();
-        try {
-            connection.get(key);
+        try (final StatefulRedisConnection<String, String> connection = client.connect()) {
+            RedisAsyncCommands<String, String> commands = connection.async();
+            commands.quit();
+            Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
+            commands.get(key);
         } catch (Exception e) {
             assertThat(e).isInstanceOf(RedisException.class).hasMessageContaining("not connected");
-        } finally {
-            connection.getStatefulConnection().close();
         }
     }
 
     @Test
     void disconnectedRejectCommands() {
-
         client.setOptions(ClientOptions.builder().disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
                 .timeoutOptions(TimeoutOptions.builder().timeoutCommands(false).build()).build());
-
-        RedisAsyncCommands<String, String> connection = client.connect().async();
-
-        getConnectionWatchdog(connection.getStatefulConnection()).setListenOnChannelInactive(false);
-        connection.quit();
-        Wait.untilTrue(() -> !connection.getStatefulConnection().isOpen()).waitOrTimeout();
-        try {
-            connection.get(key);
+        try (final StatefulRedisConnection<String, String> connection = client.connect()) {
+            RedisAsyncCommands<String, String> commands = connection.async();
+            getConnectionWatchdog(connection).setListenOnChannelInactive(false);
+            commands.quit();
+            Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
+            commands.get(key);
         } catch (Exception e) {
             assertThat(e).isInstanceOf(RedisException.class).hasMessageContaining("not connected");
-        } finally {
-            connection.getStatefulConnection().close();
         }
     }
 
     @Test
     void disconnectedAcceptCommands() {
-
         client.setOptions(ClientOptions.builder().autoReconnect(false)
                 .disconnectedBehavior(ClientOptions.DisconnectedBehavior.ACCEPT_COMMANDS).build());
-
-        RedisAsyncCommands<String, String> connection = client.connect().async();
-
-        connection.quit();
-        Wait.untilTrue(() -> !connection.getStatefulConnection().isOpen()).waitOrTimeout();
-        connection.get(key);
-        connection.getStatefulConnection().close();
+        try (final StatefulRedisConnection<String, String> connection = client.connect()) {
+            RedisAsyncCommands<String, String> commands = connection.async();
+            commands.quit();
+            Wait.untilTrue(() -> !connection.isOpen()).waitOrTimeout();
+            commands.get(key);
+        }
     }
 
     @Test
     @Inject
     void pingBeforeConnect(StatefulRedisConnection<String, String> sharedConnection) {
-
         sharedConnection.sync().set(key, value);
-        RedisCommands<String, String> connection = client.connect().sync();
-
-        try {
-            String result = connection.get(key);
+        try (final StatefulRedisConnection<String, String> connection = client.connect()) {
+            RedisCommands<String, String> commands = connection.sync();
+            String result = commands.get(key);
             assertThat(result).isEqualTo(value);
-        } finally {
-            connection.getStatefulConnection().close();
         }
     }
 
@@ -337,17 +309,12 @@ void connectTimeout() throws Exception {
 
     @Test
     void connectWithAuthentication() {
-
         WithPassword.run(client, () -> {
             RedisURI redisURI = RedisURI.Builder.redis(host, port).withPassword(passwd).build();
-
-            RedisCommands<String, String> connection = client.connect(redisURI).sync();
-
-            try {
-                String result = connection.info();
+            try (final StatefulRedisConnection<String, String> connection = client.connect(redisURI)) {
+                final RedisCommands<String, String> commands = connection.sync();
+                String result = commands.info();
                 assertThat(result).contains("memory");
-            } finally {
-                connection.getStatefulConnection().close();
             }
         });
     }
@@ -375,21 +342,14 @@ void authenticationTimeout() {
 
     @Test
     void sslAndAuthentication() {
-
         WithPassword.run(client, () -> {
-
             RedisURI redisURI = RedisURI.Builder.redis(host, 6443).withPassword(passwd).withVerifyPeer(false).withSsl(true)
                     .build();
-
-            RedisCommands<String, String> connection = client.connect(redisURI).sync();
-
-            try {
-                String result = connection.info();
+            try (final StatefulRedisConnection<String, String> connection = client.connect(redisURI)) {
+                final RedisCommands<String, String> commands = connection.sync();
+                String result = commands.info();
                 assertThat(result).contains("memory");
-            } finally {
-                connection.getStatefulConnection().close();
             }
-
         });
     }