feat(rust): test Valkey 9.2 INFO fields

Add an `info_returns_expected_fields` test, run against standalone
servers (RESP2 and RESP3), which replaces `info_non_empty` and
`info_sections`:

- Default INFO contains one field from each default section.
- Valkey 9.2.0+ only: INFO persistence `rdb_current_bgsave_type` and
  `rdb_last_bgsave_type` are one of fork, forkless, or none, and
  `forkless_estimated_seconds_remaining` is at least -1.

The typed INFO, LATENCY DOCTOR/GRAPH, BGSAVE, and BGREWRITEAOF methods
fail on cluster clients (#7362), so the test is standalone only and its
`cluster_info` check is commented out until that is fixed. Mark each
affected method with a TODO.

Add `get_info`, `parse_int`, `INFO_DEFAULT_FIELDS`, and `BGSAVE_TYPES`
test helpers, and allow the `use super::*` import in `resp_test!` and
`matrix_test!` to go unused.

Part of #7199.

Signed-off-by: currantw <taylor.curran@improving.com>

Author: currantw

CHANGELOG.md

@@ -60,6 +60,7 @@
 
 ### Changes
 
+* Go, Java, Node, Python: Add `cluster_info` `INFO` section (Valkey 9.1) ([#7199](https://github.com/valkey-io/valkey-glide/issues/7199))
 * Java: add useMutualTlsFromKeyStore to load mTLS client identity ([#7258](https://github.com/valkey-io/valkey-glide/pull/7258))
 * Java: Add `HGETDEL` command support ([#6145](https://github.com/valkey-io/valkey-glide/issues/6145))
 * Node: Add `HGETDEL` command support ([#6145](https://github.com/valkey-io/valkey-glide/issues/6145))

rust/src/commands/server_management.rs

@@ -16,11 +16,13 @@ use std::collections::HashMap;
 /// Server-management commands (`INFO`, `DBSIZE`, `FLUSHALL`, `CONFIG ...`, `TIME`).
 #[async_trait]
 pub trait ServerManagementCommands: CommandExecutor {
+    // TODO #7362: Return per-node replies for cluster clients.
     /// Get server information and statistics (`INFO`).
     async fn info(&self) -> ValkeyResult<String> {
         String::from_owned_valkey_value(self.execute_command(cmd("INFO"), None).await?)
     }
 
+    // TODO #7362: Return per-node replies for cluster clients.
     /// Get server information for specific sections (`INFO section...`).
     async fn info_sections<S: ToValkeyArgs + Send + Sync>(
         &self,
@@ -99,12 +101,14 @@ pub trait ServerManagementCommands: CommandExecutor {
         String::from_owned_valkey_value(self.execute_command(cmd, None).await?)
     }
 
+    // TODO #7362: Return per-node replies for cluster clients.
     /// Asynchronously rewrite the append-only file (`BGREWRITEAOF`). Returns the
     /// server's status message.
     async fn bgrewriteaof(&self) -> ValkeyResult<String> {
         String::from_owned_valkey_value(self.execute_command(cmd("BGREWRITEAOF"), None).await?)
     }
 
+    // TODO #7362: Return per-node replies for cluster clients.
     /// Asynchronously save the dataset to disk (`BGSAVE`). Set `schedule` to defer
     /// until no other save is running. Returns the server's status message.
     async fn bgsave(&self, schedule: bool) -> ValkeyResult<String> {
@@ -190,12 +194,14 @@ pub trait ServerManagementCommands: CommandExecutor {
         i64::from_owned_valkey_value(self.execute_command(cmd, None).await?)
     }
 
+    // TODO #7362: Return per-node replies for cluster clients.
     /// Get a human-readable latency diagnosis report (`LATENCY DOCTOR`).
     async fn latency_doctor(&self) -> ValkeyResult<String> {
         let cmd = cmd("LATENCY").with_arg("DOCTOR");
         String::from_owned_valkey_value(self.execute_command(cmd, None).await?)
     }
 
+    // TODO #7362: Return per-node replies for cluster clients.
     /// Get a latency graph for an event (`LATENCY GRAPH`).
     async fn latency_graph<E: ToValkeyArgs + Send>(&self, event: E) -> ValkeyResult<String> {
         let cmd = cmd("LATENCY").with_arg("GRAPH").with_arg(event);

rust/tests/common/helpers.rs

@@ -30,6 +30,53 @@ pub fn tkey(tag: &str, name: &str) -> String {
     format!("{{{tag}}}:{name}:{t}:{n}")
 }
 
+/// One field from each default INFO section.
+pub const INFO_DEFAULT_FIELDS: [&str; 8] = [
+    "redis_version",               // server
+    "connected_clients",           // clients
+    "used_memory",                 // memory
+    "rdb_changes_since_last_save", // persistence
+    "total_commands_processed",    // stats
+    "role",                        // replication
+    "used_cpu_sys",                // cpu
+    "cluster_enabled",             // cluster
+];
+
+/// Expected server responses for the `rdb_*_bgsave_type` INFO persistence fields.
+///
+/// Since Valkey 9.2.0.
+pub const BGSAVE_TYPES: [&str; 3] = ["fork", "forkless", "none"];
+
+/// Assert that `value` is an integer and return it.
+/// `name` identifies the value in the failure message.
+pub fn parse_int(value: Option<&String>, name: &str) -> i64 {
+    match value.map(|v| v.parse::<i64>()) {
+        Some(Ok(result)) => result,
+        _ => panic!("{name} is not an integer: {value:?}"),
+    }
+}
+
+/// Return the fields and values from the given `INFO` sections.
+// TODO #7362: Support cluster clients once the typed `INFO` methods return per-node replies.
+pub async fn get_info<C>(c: &C, sections: &[&str]) -> std::collections::HashMap<String, String>
+where
+    C: glide::ServerManagementCommands + Sync,
+{
+    let info = if sections.is_empty() {
+        c.info().await
+    } else {
+        c.info_sections(sections).await
+    };
+
+    info.unwrap()
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#'))
+        .filter_map(|line| line.split_once(':'))
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect()
+}
+
 /// Parse a `"major.minor.patch"` version string into a tuple.
 fn parse_version(s: &str) -> Option<(u32, u32, u32)> {
     let mut it = s.trim().split('.');

rust/tests/common/macros.rs

@@ -59,6 +59,9 @@ macro_rules! retry_transient {
 macro_rules! resp_test {
     ($name:ident, $client:ident, $body:block) => {
         mod $name {
+            // The test body is placed in this module, so it imports everything that the test file imports.
+            // Some tests don't need any of them, so allow the import to go unused.
+            #[allow(unused_imports)]
             use super::*;
             #[allow(unused_imports)]
             use $crate::common;
@@ -108,6 +111,11 @@ macro_rules! resp_test {
 macro_rules! matrix_test {
     ($name:ident, $client:ident, $body:block) => {
         mod $name {
+            // The test body is placed in this module, so it imports everything that the test
+            // file imports (e.g. command traits such as `ServerManagementCommands`). Some test
+            // bodies don't need any of them (e.g. a body that only calls `common::` helpers),
+            // so allow the import to go unused rather than fail `clippy -D warnings`.
+            #[allow(unused_imports)]
             use super::*;
             #[allow(unused_imports)]
             use $crate::common;

rust/tests/common/mod.rs

@@ -26,8 +26,18 @@ mod pubsub;
 mod server;
 mod timeout;
 
-pub use cluster::{ClusterHarness, is_transient_cluster_error};
-pub use helpers::{key, server_version, tkey, version_below};
-pub use pubsub::{wait_for_numpat, wait_for_numsub};
+pub use cluster::ClusterHarness;
+pub use cluster::is_transient_cluster_error;
+pub use helpers::BGSAVE_TYPES;
+pub use helpers::INFO_DEFAULT_FIELDS;
+pub use helpers::get_info;
+pub use helpers::key;
+pub use helpers::parse_int;
+pub use helpers::server_version;
+pub use helpers::tkey;
+pub use helpers::version_below;
+pub use pubsub::wait_for_numpat;
+pub use pubsub::wait_for_numsub;
 pub use server::TestServer;
-pub use timeout::{test_timeout, with_test_timeout};
+pub use timeout::test_timeout;
+pub use timeout::with_test_timeout;

rust/tests/it_server.rs

@@ -7,21 +7,41 @@ use glide::FlushAllOptions;
 use glide::FlushDbOptions;
 use glide::{AsyncTypedCommands, ServerManagementCommands};
 
-resp_test!(info_non_empty, c, {
-    let info = c.info().await.unwrap();
-
-    // INFO always contains the server section header.
-    assert!(!info.is_empty());
-    assert!(
-        info.contains("redis_version")
-            || info.contains("valkey_version")
-            || info.contains("# Server")
-    );
-});
+// TODO #7362: Change to `matrix_test!` once the typed `INFO` methods return per-node replies.
+resp_test!(info_returns_expected_fields, c, {
+    // Default fields
+    let info = common::get_info(&c, &[]).await;
+    for field in common::INFO_DEFAULT_FIELDS {
+        assert!(info.contains_key(field));
+    }
+
+    // Valkey 9.2+ fields
+    // ------------------
+
+    if common::version_below(&c, (9, 2, 0)).await {
+        return;
+    }
+
+    // Persistence fields
+    let persistence = common::get_info(&c, &["persistence"]).await;
+
+    assert!(common::BGSAVE_TYPES.contains(&persistence["rdb_current_bgsave_type"].as_str()));
+    assert!(common::BGSAVE_TYPES.contains(&persistence["rdb_last_bgsave_type"].as_str()));
+
+    let remaining_name = "forkless_estimated_seconds_remaining";
+    let remaining_value = common::parse_int(persistence.get(remaining_name), remaining_name);
+    assert!(remaining_value >= -1);
 
-resp_test!(info_sections, c, {
-    let info = c.info_sections(&["server"]).await.unwrap();
-    assert!(!info.is_empty());
+    // Cluster info fields
+    // TODO #7362: Uncomment once the typed `INFO` methods return per-node replies.
+    // let is_cluster = (&c as &dyn std::any::Any).is::<glide::GlideClusterClient>();
+    // if is_cluster {
+    //     let cluster_info = common::get_info(&c, &["cluster_info"]).await;
+    //
+    //     let fallbacks_name = "cluster_io_main_thread_fallbacks";
+    //     let fallbacks_value = common::parse_int(cluster_info.get(fallbacks_name), fallbacks_name);
+    //     assert!(fallbacks_value >= 0);
+    // }
 });
 
 resp_test!(dbsize, c, {