Java: Add PING command

java/client/src/main/java/glide/api/BaseClient.java

@@ -2,8 +2,11 @@
 package glide.api;
 
 import static glide.ffi.resolvers.SocketListenerResolver.getSocket;
+import static redis_request.RedisRequestOuterClass.RequestType.Ping;
 
+import glide.api.commands.ConnectionManagementCommands;
 import glide.api.models.configuration.BaseClientConfiguration;
+import glide.api.models.exceptions.RedisException;
 import glide.connectors.handlers.CallbackDispatcher;
 import glide.connectors.handlers.ChannelHandler;
 import glide.connectors.resources.Platform;
@@ -17,12 +20,12 @@
 import java.util.concurrent.ExecutionException;
 import java.util.function.BiFunction;
 import lombok.AllArgsConstructor;
+import lombok.NonNull;
 import response.ResponseOuterClass.Response;
 
 /** Base Client class for Redis */
 @AllArgsConstructor
-public abstract class BaseClient implements AutoCloseable {
-
+public abstract class BaseClient implements AutoCloseable, ConnectionManagementCommands {
     protected final ConnectionManager connectionManager;
     protected final CommandManager commandManager;
 
@@ -100,4 +103,33 @@ protected Object handleObjectResponse(Response response) {
         // convert protobuf response into Object
         return new BaseCommandResponseResolver(RedisValueResolver::valueFromPointer).apply(response);
     }
+
+    /**
+     * Extracts the response value from the Redis response and either throws an exception or returns
+     * the value as a <code>String</code>.
+     *
+     * @param response Redis protobuf message
+     * @return Response as a <code>String</code>
+     * @throws RedisException if there's a type mismatch
+     */
+    protected String handleStringResponse(Response response) {
+        Object value = handleObjectResponse(response);
+        if (value instanceof String || value == null) {
+            return (String) value;
+        }
+        throw new RedisException(
+                "Unexpected return type from Redis: got "
+                        + value.getClass().getSimpleName()
+                        + " expected String");
+    }
+
+    @Override
+    public CompletableFuture<String> ping() {
+        return commandManager.submitNewCommand(Ping, new String[0], this::handleStringResponse);
+    }
+
+    @Override
+    public CompletableFuture<String> ping(@NonNull String str) {
+        return commandManager.submitNewCommand(Ping, new String[] {str}, this::handleStringResponse);
+    }
 }

java/client/src/main/java/glide/api/RedisClient.java

@@ -8,6 +8,7 @@
 import glide.managers.CommandManager;
 import glide.managers.ConnectionManager;
 import java.util.concurrent.CompletableFuture;
+import lombok.NonNull;
 
 /**
  * Async (non-blocking) client for Redis in Standalone mode. Use {@link #CreateClient} to request a
@@ -25,12 +26,13 @@ protected RedisClient(ConnectionManager connectionManager, CommandManager comman
      * @param config Redis client Configuration
      * @return A Future to connect and return a RedisClient
      */
-    public static CompletableFuture<RedisClient> CreateClient(RedisClientConfiguration config) {
+    public static CompletableFuture<RedisClient> CreateClient(
+            @NonNull RedisClientConfiguration config) {
         return CreateClient(config, RedisClient::new);
     }
 
     @Override
-    public CompletableFuture<Object> customCommand(String[] args) {
+    public CompletableFuture<Object> customCommand(@NonNull String[] args) {
         return commandManager.submitNewCommand(CustomCommand, args, this::handleObjectResponse);
     }
 }

java/client/src/main/java/glide/api/RedisClusterClient.java

@@ -2,7 +2,9 @@
 package glide.api;
 
 import static redis_request.RedisRequestOuterClass.RequestType.CustomCommand;
+import static redis_request.RedisRequestOuterClass.RequestType.Ping;
 
+import glide.api.commands.ConnectionManagementClusterCommands;
 import glide.api.commands.GenericClusterCommands;
 import glide.api.models.ClusterValue;
 import glide.api.models.configuration.RedisClusterClientConfiguration;
@@ -11,12 +13,14 @@
 import glide.managers.ConnectionManager;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import lombok.NonNull;
 
 /**
  * Async (non-blocking) client for Redis in Cluster mode. Use {@link #CreateClient} to request a
  * client to Redis.
  */
-public class RedisClusterClient extends BaseClient implements GenericClusterCommands {
+public class RedisClusterClient extends BaseClient
+        implements ConnectionManagementClusterCommands, GenericClusterCommands {
 
     protected RedisClusterClient(ConnectionManager connectionManager, CommandManager commandManager) {
         super(connectionManager, commandManager);
@@ -29,20 +33,21 @@ protected RedisClusterClient(ConnectionManager connectionManager, CommandManager
      * @return A Future to connect and return a RedisClusterClient
      */
     public static CompletableFuture<RedisClusterClient> CreateClient(
-            RedisClusterClientConfiguration config) {
+            @NonNull RedisClusterClientConfiguration config) {
         return CreateClient(config, RedisClusterClient::new);
     }
 
     @Override
-    public CompletableFuture<ClusterValue<Object>> customCommand(String[] args) {
+    public CompletableFuture<ClusterValue<Object>> customCommand(@NonNull String[] args) {
         // TODO if a command returns a map as a single value, ClusterValue misleads user
         return commandManager.submitNewCommand(
                 CustomCommand, args, response -> ClusterValue.of(handleObjectResponse(response)));
     }
 
     @Override
     @SuppressWarnings("unchecked")
-    public CompletableFuture<ClusterValue<Object>> customCommand(String[] args, Route route) {
+    public CompletableFuture<ClusterValue<Object>> customCommand(
+            @NonNull String[] args, @NonNull Route route) {
         return commandManager.submitNewCommand(
                 CustomCommand,
                 args,
@@ -52,4 +57,15 @@ public CompletableFuture<ClusterValue<Object>> customCommand(String[] args, Rout
                                 ? ClusterValue.ofSingleValue(handleObjectResponse(response))
                                 : ClusterValue.ofMultiValue((Map<String, Object>) handleObjectResponse(response)));
     }
+
+    @Override
+    public CompletableFuture<String> ping(@NonNull Route route) {
+        return commandManager.submitNewCommand(Ping, new String[0], route, this::handleStringResponse);
+    }
+
+    @Override
+    public CompletableFuture<String> ping(@NonNull String str, @NonNull Route route) {
+        return commandManager.submitNewCommand(
+                Ping, new String[] {str}, route, this::handleStringResponse);
+    }
 }

java/client/src/main/java/glide/api/commands/ConnectionManagementClusterCommands.java

@@ -0,0 +1,35 @@
+/** Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0 */
+package glide.api.commands;
+
+import glide.api.models.configuration.RequestRoutingConfiguration.Route;
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Connection Management Commands interface.
+ *
+ * @see: <a href="https://redis.io/commands/?group=connection">Connection Management Commands</a>
+ */
+public interface ConnectionManagementClusterCommands {
+
+    /**
+     * Ping the Redis server.
+     *
+     * @see <a href="https://redis.io/commands/ping/">redis.io</a> for details.
+     * @param route Routing configuration for the command. Client will route the command to the nodes
+     *     defined.
+     * @return Response from Redis containing a <code>String</code> with "PONG".
+     */
+    CompletableFuture<String> ping(Route route);
+
+    /**
+     * Ping the Redis server.
+     *
+     * @see <a href="https://redis.io/commands/ping/">redis.io</a> for details.
+     * @param str The ping argument that will be returned.
+     * @param route Routing configuration for the command. Client will route the command to the nodes
+     *     defined.
+     * @return Response from Redis containing a <code>String</code> with a copy of the argument <code>
+     *     str</code>.
+     */
+    CompletableFuture<String> ping(String str, Route route);
+}

java/client/src/main/java/glide/api/commands/ConnectionManagementCommands.java

@@ -0,0 +1,30 @@
+/** Copyright GLIDE-for-Redis Project Contributors - SPDX Identifier: Apache-2.0 */
+package glide.api.commands;
+
+import java.util.concurrent.CompletableFuture;
+
+/**
+ * Connection Management Commands interface.
+ *
+ * @see: <a href="https://redis.io/commands/?group=connection">Connection Management Commands</a>
+ */
+public interface ConnectionManagementCommands {
+
+    /**
+     * Ping the Redis server.
+     *
+     * @see <a href="https://redis.io/commands/ping/">redis.io</a> for details.
+     * @return Response from Redis containing a <code>String</code> with "PONG".
+     */
+    CompletableFuture<String> ping();
+
+    /**
+     * Ping the Redis server.
+     *
+     * @see <a href="https://redis.io/commands/ping/">redis.io</a> for details.
+     * @param str The ping argument that will be returned.
+     * @return Response from Redis containing a <code>String</code> with a copy of the argument <code>
+     *     str</code>.
+     */
+    CompletableFuture<String> ping(String str);
+}

java/client/src/main/java/glide/managers/CommandManager.java

@@ -39,7 +39,7 @@ public class CommandManager {
      * @return A result promise of type T
      */
     public <T> CompletableFuture<T> submitNewCommand(
-            RedisRequestOuterClass.RequestType requestType,
+            RequestType requestType,
             String[] arguments,
             RedisExceptionCheckedFunction<Response, T> responseHandler) {
 

java/client/src/test/java/glide/api/RedisClientTest.java

@@ -7,6 +7,7 @@
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 import static redis_request.RedisRequestOuterClass.RequestType.CustomCommand;
+import static redis_request.RedisRequestOuterClass.RequestType.Ping;
 
 import glide.managers.CommandManager;
 import glide.managers.ConnectionManager;
@@ -53,4 +54,46 @@ public void customCommand_returns_success() {
         assertEquals(testResponse, response);
         assertEquals(value, payload);
     }
+
+    @SneakyThrows
+    @Test
+    public void ping_returns_success() {
+        // setup
+        CompletableFuture<String> testResponse = mock(CompletableFuture.class);
+        when(testResponse.get()).thenReturn("PONG");
+
+        // match on protobuf request
+        when(commandManager.<String>submitNewCommand(eq(Ping), eq(new String[0]), any()))
+                .thenReturn(testResponse);
+
+        // exercise
+        CompletableFuture<String> response = service.ping();
+        String payload = response.get();
+
+        // verify
+        assertEquals(testResponse, response);
+        assertEquals("PONG", payload);
+    }
+
+    @SneakyThrows
+    @Test
+    public void ping_with_message_returns_success() {
+        // setup
+        String message = "RETURN OF THE PONG";
+        String[] arguments = new String[] {message};
+        CompletableFuture<String> testResponse = new CompletableFuture();
+        testResponse.complete(message);
+
+        // match on protobuf request
+        when(commandManager.<String>submitNewCommand(eq(Ping), eq(arguments), any()))
+                .thenReturn(testResponse);
+
+        // exercise
+        CompletableFuture<String> response = service.ping(message);
+        String pong = response.get();
+
+        // verify
+        assertEquals(testResponse, response);
+        assertEquals(message, pong);
+    }
 }

java/client/src/test/java/glide/api/RedisClusterClientTest.java

@@ -2,24 +2,46 @@
 package glide.api;
 
 import static glide.api.models.configuration.RequestRoutingConfiguration.SimpleRoute.ALL_NODES;
+import static glide.api.models.configuration.RequestRoutingConfiguration.SimpleRoute.ALL_PRIMARIES;
 import static glide.api.models.configuration.RequestRoutingConfiguration.SimpleRoute.RANDOM;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static redis_request.RedisRequestOuterClass.RequestType.Ping;
 
+import glide.api.models.configuration.RequestRoutingConfiguration.Route;
 import glide.managers.CommandManager;
+import glide.managers.ConnectionManager;
 import glide.managers.RedisExceptionCheckedFunction;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import lombok.SneakyThrows;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import redis_request.RedisRequestOuterClass.RedisRequest;
 import response.ResponseOuterClass.Response;
 
 public class RedisClusterClientTest {
 
+    RedisClusterClient service;
+
+    ConnectionManager connectionManager;
+
+    CommandManager commandManager;
+
     private final String[] TEST_ARGS = new String[0];
 
+    @BeforeEach
+    public void setUp() {
+        connectionManager = mock(ConnectionManager.class);
+        commandManager = mock(CommandManager.class);
+        service = new RedisClusterClient(connectionManager, commandManager);
+    }
+
     @Test
     @SneakyThrows
     public void custom_command_returns_single_value() {
@@ -103,4 +125,50 @@ public <T> CompletableFuture<T> submitCommandToChannel(
             return CompletableFuture.supplyAsync(() -> responseHandler.apply(response));
         }
     }
+
+    @SneakyThrows
+    @Test
+    public void ping_returns_success() {
+        // setup
+        CompletableFuture<String> testResponse = mock(CompletableFuture.class);
+        when(testResponse.get()).thenReturn("PONG");
+
+        Route route = ALL_NODES;
+
+        // match on protobuf request
+        when(commandManager.<String>submitNewCommand(eq(Ping), eq(new String[0]), eq(route), any()))
+                .thenReturn(testResponse);
+
+        // exercise
+        CompletableFuture<String> response = service.ping(route);
+        String payload = response.get();
+
+        // verify
+        assertEquals(testResponse, response);
+        assertEquals("PONG", payload);
+    }
+
+    @SneakyThrows
+    @Test
+    public void ping_with_message_returns_success() {
+        // setup
+        String message = "RETURN OF THE PONG";
+        String[] arguments = new String[] {message};
+        CompletableFuture<String> testResponse = new CompletableFuture();
+        testResponse.complete(message);
+
+        Route route = ALL_PRIMARIES;
+
+        // match on protobuf request
+        when(commandManager.<String>submitNewCommand(eq(Ping), eq(arguments), eq(route), any()))
+                .thenReturn(testResponse);
+
+        // exercise
+        CompletableFuture<String> response = service.ping(message, route);
+        String pong = response.get();
+
+        // verify
+        assertEquals(testResponse, response);
+        assertEquals(message, pong);
+    }
 }