Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

32.9 KB
Raw Blame
use async_trait::async_trait;
use std::sync::Arc;
use std::time::Duration;
use tracing::warn;

use crate::pipeline::{PipelineCommand, PipelineResult};
use crate::{Client, CompressionConfig, CustomRedisError, RedisClient, RedisValueFormat};

/// Configuration for creating a ReadWriteClient with separate primary and replica URLs.
///
/// This configuration allows you to specify different Redis endpoints for read and write
/// operations (primary for writes, replica for reads), while using the same
/// compression and serialization settings for both.
///
/// # Examples
///
/// ```no_run
/// use common_redis::{ReadWriteClientConfig, CompressionConfig, RedisValueFormat};
///
/// # async fn example() {
/// let config = ReadWriteClientConfig::new(
///     "redis://primary:6379".to_string(),
///     "redis://replica:6379".to_string(),
///     CompressionConfig::default(),
///     RedisValueFormat::Pickle,
///     None, // No response timeout
///     None, // No connection timeout
/// );
///
/// let client = config.build().await.unwrap();
/// # }
/// ```
#[derive(Debug, Clone)]
pub struct ReadWriteClientConfig {
    pub primary_url: String,
    pub replica_url: String,
    pub compression: CompressionConfig,
    pub format: RedisValueFormat,
    pub response_timeout: Option<Duration>,
    pub connection_timeout: Option<Duration>,
}

impl ReadWriteClientConfig {
    /// Create a new ReadWriteClientConfig.
    ///
    /// # Arguments
    /// * `primary_url` - Redis connection string for writes (primary instance)
    /// * `replica_url` - Redis connection string for reads (replica instance)
    /// * `compression` - Compression configuration applied to both connections
    /// * `format` - Serialization format applied to both connections
    /// * `response_timeout` - Optional timeout for Redis command responses. `None` means no timeout.
    /// * `connection_timeout` - Optional timeout for establishing connections. `None` means no timeout.
    pub fn new(
        primary_url: String,
        replica_url: String,
        compression: CompressionConfig,
        format: RedisValueFormat,
        response_timeout: Option<Duration>,
        connection_timeout: Option<Duration>,
    ) -> Self {
        Self {
            primary_url,
            replica_url,
            compression,
            format,
            response_timeout,
            connection_timeout,
        }
    }

    /// Build a ReadWriteClient from this configuration.
    ///
    /// Creates Redis connections for both primary and replica URLs using the
    /// shared compression and format settings.
    pub async fn build(self) -> Result<ReadWriteClient, CustomRedisError> {
        ReadWriteClient::with_config(self).await
    }
}

/// A Redis client that automatically routes read and write operations to separate connections.
///
/// This client wraps two underlying Redis clients:
/// - A reader for read operations (GET, HGET, etc.)
/// - A writer for write operations (SET, DEL, HINCRBY, etc.)
///
/// Read operations automatically fall back to the writer if the reader fails,
/// providing resilience against reader replica failures.
///
/// **Pipeline Routing:** All pipeline commands are routed to the primary (writer) since
/// pipelines can contain a mix of read and write operations. This ensures consistency
/// and simplifies routing logic.
///
/// # Examples
///
/// ```no_run
/// use common_redis::{Client, ReadWriteClient, ReadWriteClientConfig, CompressionConfig, RedisValueFormat};
///
/// # async fn example() {
/// // Create a ReadWriteClient from config
/// let config = ReadWriteClientConfig::new(
///     "redis://primary:6379".to_string(),
///     "redis://replica:6379".to_string(),
///     CompressionConfig::default(),
///     RedisValueFormat::Pickle,
///     None, // No response timeout
///     None, // No connection timeout
/// );
///
/// let client = ReadWriteClient::with_config(config).await.unwrap();
///
/// // Or use the builder pattern:
/// let client = ReadWriteClientConfig::new(
///     "redis://primary:6379".to_string(),
///     "redis://replica:6379".to_string(),
///     CompressionConfig::default(),
///     RedisValueFormat::Pickle,
///     None, // No response timeout
///     None, // No connection timeout
/// )
/// .build()
/// .await
/// .unwrap();
///
/// // Use it like a normal client - routing happens automatically
/// client.set("key".to_string(), "value".to_string()).await.unwrap();  // → primary
/// let value = client.get("key".to_string()).await.unwrap();  // → replica (falls back to primary on error)
/// # }
/// ```
pub struct ReadWriteClient {
    reader: Arc<dyn Client + Send + Sync>,
    writer: Arc<dyn Client + Send + Sync>,
}

impl Clone for ReadWriteClient {
    fn clone(&self) -> Self {
        Self {
            reader: Arc::clone(&self.reader),
            writer: Arc::clone(&self.writer),
        }
    }
}

impl std::fmt::Debug for ReadWriteClient {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ReadWriteClient")
            .field("reader", &"<Redis Client>")
            .field("writer", &"<Redis Client>")
            .finish()
    }
}

impl ReadWriteClient {
    /// Create a new ReadWriteClient from existing reader and writer clients.
    ///
    /// This allows for maximum flexibility when you need custom client instances
    /// or want to compose clients in special ways (e.g., dual-write patterns).
    ///
    /// # Arguments
    /// * `reader` - Client for read operations
    /// * `writer` - Client for write operations
    ///
    /// # Examples
    /// ```no_run
    /// use common_redis::{ReadWriteClient, RedisClient, CompressionConfig, RedisValueFormat};
    /// use std::sync::Arc;
    ///
    /// # async fn example() {
    /// let replica = Arc::new(
    ///     RedisClient::with_config(
    ///         "redis://replica:6379".to_string(),
    ///         CompressionConfig::default(),
    ///         RedisValueFormat::Pickle,
    ///         None, // No response timeout
    ///         None, // No connection timeout
    ///     )
    ///     .await
    ///     .unwrap()
    /// );
    ///
    /// let primary = Arc::new(
    ///     RedisClient::with_config(
    ///         "redis://primary:6379".to_string(),
    ///         CompressionConfig::default(),
    ///         RedisValueFormat::Pickle,
    ///         None, // No response timeout
    ///         None, // No connection timeout
    ///     )
    ///     .await
    ///     .unwrap()
    /// );
    ///
    /// let client = ReadWriteClient::new(replica, primary);
    /// # }
    /// ```
    pub fn new(
        reader: Arc<dyn Client + Send + Sync>,
        writer: Arc<dyn Client + Send + Sync>,
    ) -> Self {
        Self { reader, writer }
    }

    /// Create a new ReadWriteClient from configuration.
    ///
    /// This is the recommended way to create a ReadWriteClient. It creates
    /// Redis connections for both primary and replica URLs using shared
    /// compression and format settings.
    ///
    /// # Arguments
    /// * `config` - Configuration specifying primary/replica URLs and shared settings
    ///
    /// # Examples
    /// ```no_run
    /// use common_redis::{ReadWriteClient, ReadWriteClientConfig, CompressionConfig, RedisValueFormat};
    ///
    /// # async fn example() {
    /// let config = ReadWriteClientConfig::new(
    ///     "redis://primary:6379".to_string(),
    ///     "redis://replica:6379".to_string(),
    ///     CompressionConfig::default(),
    ///     RedisValueFormat::Pickle,
    ///     None, // No response timeout
    ///     None, // No connection timeout
    /// );
    ///
    /// let client = ReadWriteClient::with_config(config).await.unwrap();
    /// # }
    /// ```
    pub async fn with_config(config: ReadWriteClientConfig) -> Result<Self, CustomRedisError> {
        let reader = Arc::new(
            RedisClient::with_config(
                config.replica_url,
                config.compression.clone(),
                config.format,
                config.response_timeout,
                config.connection_timeout,
            )
            .await?,
        );
        let writer = Arc::new(
            RedisClient::with_config(
                config.primary_url,
                config.compression,
                config.format,
                config.response_timeout,
                config.connection_timeout,
            )
            .await?,
        );

        Ok(Self::new(reader, writer))
    }
}

#[async_trait]
impl Client for ReadWriteClient {
    async fn heal(&self) {
        self.reader.heal().await;
        self.writer.heal().await;
    }

    async fn get(&self, k: String) -> Result<String, CustomRedisError> {
        match self.reader.get(k.clone()).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica read failed for key '{}', falling back to primary: {}",
                    k, err
                );
                self.writer.get(k).await
            }
            Err(err) => Err(err),
        }
    }

    async fn get_with_format(
        &self,
        k: String,
        format: RedisValueFormat,
    ) -> Result<String, CustomRedisError> {
        match self.reader.get_with_format(k.clone(), format).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica read failed for key '{}', falling back to primary: {}",
                    k, err
                );
                self.writer.get_with_format(k, format).await
            }
            Err(err) => Err(err),
        }
    }

    async fn get_raw_bytes(&self, k: String) -> Result<Vec<u8>, CustomRedisError> {
        match self.reader.get_raw_bytes(k.clone()).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica read failed for key '{}', falling back to primary: {}",
                    k, err
                );
                self.writer.get_raw_bytes(k).await
            }
            Err(err) => Err(err),
        }
    }

    async fn hget(&self, k: String, field: String) -> Result<String, CustomRedisError> {
        match self.reader.hget(k.clone(), field.clone()).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica read failed for key '{}' field '{}', falling back to primary: {}",
                    k, field, err
                );
                self.writer.hget(k, field).await
            }
            Err(err) => Err(err),
        }
    }

    async fn zrangebyscore(
        &self,
        k: String,
        min: String,
        max: String,
    ) -> Result<Vec<String>, CustomRedisError> {
        match self
            .reader
            .zrangebyscore(k.clone(), min.clone(), max.clone())
            .await
        {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica zrangebyscore failed for key '{}', falling back to primary: {}",
                    k, err
                );
                self.writer.zrangebyscore(k, min, max).await
            }
            Err(err) => Err(err),
        }
    }

    async fn zrangebyscore_limit(
        &self,
        k: String,
        min: String,
        max: String,
        offset: isize,
        count: isize,
    ) -> Result<Vec<String>, CustomRedisError> {
        match self
            .reader
            .zrangebyscore_limit(k.clone(), min.clone(), max.clone(), offset, count)
            .await
        {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica zrangebyscore_limit failed for key '{}', falling back to primary: {}",
                    k, err
                );
                self.writer
                    .zrangebyscore_limit(k, min, max, offset, count)
                    .await
            }
            Err(err) => Err(err),
        }
    }

    async fn scard(&self, k: String) -> Result<u64, CustomRedisError> {
        match self.reader.scard(k.clone()).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica scard failed for key '{}', falling back to primary: {}",
                    k, err
                );
                self.writer.scard(k).await
            }
            Err(err) => Err(err),
        }
    }

    async fn set_bytes(
        &self,
        k: String,
        v: Vec<u8>,
        ttl_seconds: Option<u64>,
    ) -> Result<(), CustomRedisError> {
        self.writer.set_bytes(k, v, ttl_seconds).await
    }

    async fn set(&self, k: String, v: String) -> Result<(), CustomRedisError> {
        self.writer.set(k, v).await
    }

    async fn zadd(&self, k: String, member: String, score: i64) -> Result<(), CustomRedisError> {
        self.writer.zadd(k, member, score).await
    }

    async fn zadd_nx(&self, k: String, member: String, score: i64) -> Result<(), CustomRedisError> {
        self.writer.zadd_nx(k, member, score).await
    }

    async fn zrem(&self, k: String, member: String) -> Result<(), CustomRedisError> {
        self.writer.zrem(k, member).await
    }

    async fn set_with_format(
        &self,
        k: String,
        v: String,
        format: RedisValueFormat,
    ) -> Result<(), CustomRedisError> {
        self.writer.set_with_format(k, v, format).await
    }

    async fn setex(&self, k: String, v: String, seconds: u64) -> Result<(), CustomRedisError> {
        self.writer.setex(k, v, seconds).await
    }

    async fn setex_with_format(
        &self,
        k: String,
        v: String,
        seconds: u64,
        format: RedisValueFormat,
    ) -> Result<(), CustomRedisError> {
        self.writer.setex_with_format(k, v, seconds, format).await
    }

    async fn set_nx_ex(
        &self,
        k: String,
        v: String,
        seconds: u64,
    ) -> Result<bool, CustomRedisError> {
        self.writer.set_nx_ex(k, v, seconds).await
    }

    async fn set_nx_ex_with_format(
        &self,
        k: String,
        v: String,
        seconds: u64,
        format: RedisValueFormat,
    ) -> Result<bool, CustomRedisError> {
        self.writer
            .set_nx_ex_with_format(k, v, seconds, format)
            .await
    }

    async fn batch_incr_by_expire_nx(
        &self,
        items: Vec<(String, i64)>,
        ttl_seconds: usize,
    ) -> Result<(), CustomRedisError> {
        self.writer
            .batch_incr_by_expire_nx(items, ttl_seconds)
            .await
    }

    async fn batch_incr_by_expire(
        &self,
        items: Vec<(String, i64)>,
        ttl_seconds: usize,
    ) -> Result<(), CustomRedisError> {
        self.writer.batch_incr_by_expire(items, ttl_seconds).await
    }

    async fn batch_incr_by_expire_at(
        &self,
        items: Vec<(String, i64, i64)>,
    ) -> Result<(), CustomRedisError> {
        self.writer.batch_incr_by_expire_at(items).await
    }

    async fn del(&self, k: String) -> Result<(), CustomRedisError> {
        self.writer.del(k).await
    }

    async fn hincrby(&self, k: String, v: String, count: i64) -> Result<(), CustomRedisError> {
        self.writer.hincrby(k, v, count).await
    }

    async fn mget(&self, keys: Vec<String>) -> Result<Vec<Option<Vec<u8>>>, CustomRedisError> {
        match self.reader.mget(keys.clone()).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica mget failed for {} keys, falling back to primary: {}",
                    keys.len(),
                    err
                );
                self.writer.mget(keys).await
            }
            Err(err) => Err(err),
        }
    }

    async fn scard_multiple(&self, keys: Vec<String>) -> Result<Vec<u64>, CustomRedisError> {
        match self.reader.scard_multiple(keys.clone()).await {
            Ok(value) => Ok(value),
            Err(err) if !err.is_unrecoverable_error() => {
                warn!(
                    "Replica scard_multiple failed for {} keys, falling back to primary: {}",
                    keys.len(),
                    err
                );
                self.writer.scard_multiple(keys).await
            }
            Err(err) => Err(err),
        }
    }

    async fn batch_sadd_expire(
        &self,
        items: Vec<(String, String)>,
        ttl_seconds: usize,
    ) -> Result<(), CustomRedisError> {
        self.writer.batch_sadd_expire(items, ttl_seconds).await
    }

    async fn batch_set_nx_ex(
        &self,
        items: Vec<(String, String, usize)>,
    ) -> Result<Vec<bool>, CustomRedisError> {
        self.writer.batch_set_nx_ex(items).await
    }

    async fn batch_del(&self, keys: Vec<String>) -> Result<(), CustomRedisError> {
        self.writer.batch_del(keys).await
    }

    /// Execute a pipeline of commands.
    ///
    /// All pipeline commands are routed to the primary (writer) since pipelines
    /// can contain a mix of read and write operations. This ensures consistency
    /// and avoids complex routing logic for mixed pipelines.
    async fn execute_pipeline(
        &self,
        commands: Vec<PipelineCommand>,
    ) -> Result<Vec<Result<PipelineResult, CustomRedisError>>, CustomRedisError> {
        self.writer.execute_pipeline(commands).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{ClientPipelineExt, MockRedisClient, PipelineResult};

    fn create_test_client(
        reader_setup: impl FnOnce(&mut MockRedisClient),
        writer_setup: impl FnOnce(&mut MockRedisClient),
    ) -> ReadWriteClient {
        let mut reader = MockRedisClient::new();
        reader_setup(&mut reader);

        let mut writer = MockRedisClient::new();
        writer_setup(&mut writer);

        ReadWriteClient::new(Arc::new(reader), Arc::new(writer))
    }

    #[tokio::test]
    async fn test_read_operations_use_reader() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Ok("reader_value".to_string()));
                reader.get_raw_bytes_ret("raw_key", Ok(vec![1, 2, 3]));
                reader.hget_ret("hash_key", Ok("field_value".to_string()));
                reader.zrangebyscore_ret("zset_key", vec!["item1".to_string()]);
                reader.scard_ret("set_key", Ok(5));
            },
            |_writer| {},
        );

        let result = client.get("test_key".to_string()).await;
        assert_eq!(result.unwrap(), "reader_value");

        let result = client.get_raw_bytes("raw_key".to_string()).await;
        assert_eq!(result.unwrap(), vec![1, 2, 3]);

        let result = client
            .hget("hash_key".to_string(), "field".to_string())
            .await;
        assert_eq!(result.unwrap(), "field_value");

        let result = client
            .zrangebyscore("zset_key".to_string(), "0".to_string(), "10".to_string())
            .await;
        assert_eq!(result.unwrap(), vec!["item1".to_string()]);

        let result = client.scard("set_key".to_string()).await;
        assert_eq!(result.unwrap(), 5);
    }

    #[tokio::test]
    async fn test_write_operations_use_writer() {
        let client = create_test_client(
            |_reader| {},
            |writer| {
                writer.set_ret("test_key", Ok(()));
                writer.set_ret("test_key_format", Ok(()));
                writer.set_ret("test_key_ex", Ok(()));
                writer.set_nx_ex_ret("test_key_nx", Ok(true));
                writer.set_nx_ex_ret("test_key_nx_format", Ok(false));
                writer.del_ret("del_key", Ok(()));
                writer.hincrby_ret("counter", Ok(()));
            },
        );

        let result = client
            .set("test_key".to_string(), "value".to_string())
            .await;
        assert!(result.is_ok());

        let result = client
            .set_with_format(
                "test_key_format".to_string(),
                "value".to_string(),
                RedisValueFormat::Utf8,
            )
            .await;
        assert!(result.is_ok());

        let result = client
            .setex("test_key_ex".to_string(), "value".to_string(), 60)
            .await;
        assert!(result.is_ok());

        let result = client
            .set_nx_ex("test_key_nx".to_string(), "value".to_string(), 60)
            .await;
        assert!(result.unwrap());

        let result = client
            .set_nx_ex_with_format(
                "test_key_nx_format".to_string(),
                "value".to_string(),
                60,
                RedisValueFormat::Utf8,
            )
            .await;
        assert!(!result.unwrap());

        let result = client.del("del_key".to_string()).await;
        assert!(result.is_ok());

        let result = client
            .hincrby("counter".to_string(), "field".to_string(), 5)
            .await;
        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_fallback_on_transient_error() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Err(CustomRedisError::Timeout));
            },
            |writer| {
                writer.get_ret("test_key", Ok("writer_value".to_string()));
            },
        );

        let result = client.get("test_key".to_string()).await;
        assert_eq!(result.unwrap(), "writer_value");
    }

    #[tokio::test]
    async fn test_fallback_on_io_error() {
        let client = create_test_client(
            |reader| {
                reader.get_ret(
                    "test_key",
                    Err(CustomRedisError::from_redis_kind(
                        crate::RedisErrorKind::IoError,
                        "Connection refused",
                    )),
                );
            },
            |writer| {
                writer.get_ret("test_key", Ok("writer_value".to_string()));
            },
        );

        let result = client.get("test_key".to_string()).await;
        assert_eq!(result.unwrap(), "writer_value");
    }

    #[tokio::test]
    async fn test_no_fallback_on_unrecoverable_error() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Err(CustomRedisError::NotFound));
            },
            |writer| {
                writer.get_ret("test_key", Ok("writer_value".to_string()));
            },
        );

        let result = client.get("test_key".to_string()).await;
        assert!(matches!(result, Err(CustomRedisError::NotFound)));
    }

    #[tokio::test]
    async fn test_no_fallback_on_parse_error() {
        let client = create_test_client(
            |reader| {
                reader.get_ret(
                    "test_key",
                    Err(CustomRedisError::ParseError("bad data".to_string())),
                );
            },
            |writer| {
                writer.get_ret("test_key", Ok("writer_value".to_string()));
            },
        );

        let result = client.get("test_key".to_string()).await;
        assert!(matches!(result, Err(CustomRedisError::ParseError(_))));
    }

    #[tokio::test]
    async fn test_fallback_works_for_all_read_operations() {
        // MockRedisClient's zrangebyscore_ret doesn't support error returns
        let client = create_test_client(
            |reader| {
                reader.get_ret("get_key", Err(CustomRedisError::Timeout));
                reader.get_raw_bytes_ret("raw_key", Err(CustomRedisError::Timeout));
                reader.hget_ret("hash_key", Err(CustomRedisError::Timeout));
                reader.scard_ret("set_key", Err(CustomRedisError::Timeout));
            },
            |writer| {
                writer.get_ret("get_key", Ok("fallback".to_string()));
                writer.get_raw_bytes_ret("raw_key", Ok(vec![4, 5, 6]));
                writer.hget_ret("hash_key", Ok("fallback_field".to_string()));
                writer.scard_ret("set_key", Ok(10));
            },
        );

        assert_eq!(client.get("get_key".to_string()).await.unwrap(), "fallback");
        assert_eq!(
            client.get_raw_bytes("raw_key".to_string()).await.unwrap(),
            vec![4, 5, 6]
        );
        assert_eq!(
            client
                .hget("hash_key".to_string(), "field".to_string())
                .await
                .unwrap(),
            "fallback_field"
        );
        assert_eq!(client.scard("set_key".to_string()).await.unwrap(), 10);
    }

    #[tokio::test]
    async fn test_zrangebyscore_routing() {
        let client = create_test_client(
            |reader| {
                reader.zrangebyscore_ret("zset_key", vec!["reader_item".to_string()]);
            },
            |_writer| {},
        );

        let result = client
            .zrangebyscore("zset_key".to_string(), "0".to_string(), "10".to_string())
            .await;
        assert_eq!(result.unwrap(), vec!["reader_item".to_string()]);
    }

    #[tokio::test]
    async fn test_reader_success_writer_never_called() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Ok("reader_value".to_string()));
            },
            |writer| {
                // Writer error ensures test fails if writer is called
                writer.get_ret("test_key", Err(CustomRedisError::NotFound));
            },
        );

        let result = client.get("test_key".to_string()).await;
        assert_eq!(result.unwrap(), "reader_value");
    }

    #[tokio::test]
    async fn test_get_with_format_routing() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Ok("reader_value".to_string()));
            },
            |_writer| {},
        );

        let result = client
            .get_with_format("test_key".to_string(), RedisValueFormat::Utf8)
            .await;
        assert_eq!(result.unwrap(), "reader_value");
    }

    #[tokio::test]
    async fn test_get_with_format_fallback() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Err(CustomRedisError::Timeout));
            },
            |writer| {
                writer.get_ret("test_key", Ok("writer_fallback".to_string()));
            },
        );

        let result = client
            .get_with_format("test_key".to_string(), RedisValueFormat::Utf8)
            .await;
        assert_eq!(result.unwrap(), "writer_fallback");
    }

    #[test]
    fn test_clone_implementation() {
        let client = create_test_client(
            |reader| {
                reader.get_ret("test_key", Ok("value".to_string()));
            },
            |_writer| {},
        );

        let cloned = client.clone();

        // Arc cloning doesn't deep copy - both references point to same clients
        drop(client);
        assert!(format!("{cloned:?}").contains("ReadWriteClient"));
    }

    #[test]
    fn test_debug_implementation() {
        let client = create_test_client(|_reader| {}, |_writer| {});

        let debug_output = format!("{client:?}");
        assert!(debug_output.contains("ReadWriteClient"));
        assert!(debug_output.contains("reader"));
        assert!(debug_output.contains("writer"));
        assert!(debug_output.contains("<Redis Client>"));
    }

    #[tokio::test]
    async fn test_mget_uses_reader() {
        let client = create_test_client(
            |reader| {
                reader.mget_ret("key1", Some(b"value1".to_vec()));
                reader.mget_ret("key2", Some(b"value2".to_vec()));
            },
            |_writer| {},
        );

        let result = client
            .mget(vec!["key1".to_string(), "key2".to_string()])
            .await;
        assert_eq!(
            result.unwrap(),
            vec![Some(b"value1".to_vec()), Some(b"value2".to_vec())]
        );
    }

    #[tokio::test]
    async fn test_mget_fallback_on_transient_error() {
        let client = create_test_client(
            |reader| {
                reader.mget_error(CustomRedisError::Timeout);
            },
            |writer| {
                writer.mget_ret("key1", Some(b"fallback1".to_vec()));
                writer.mget_ret("key2", Some(b"fallback2".to_vec()));
            },
        );

        let result = client
            .mget(vec!["key1".to_string(), "key2".to_string()])
            .await;
        assert_eq!(
            result.unwrap(),
            vec![Some(b"fallback1".to_vec()), Some(b"fallback2".to_vec())]
        );
    }

    #[tokio::test]
    async fn test_mget_no_fallback_on_unrecoverable_error() {
        let client = create_test_client(
            |reader| {
                reader.mget_error(CustomRedisError::ParseError("bad data".to_string()));
            },
            |writer| {
                writer.mget_ret("key1", Some(b"fallback".to_vec()));
            },
        );

        let result = client.mget(vec!["key1".to_string()]).await;
        assert!(matches!(result, Err(CustomRedisError::ParseError(_))));
    }

    // Pipeline routing tests - verify all pipeline commands go to writer (primary)

    #[tokio::test]
    async fn test_pipeline_routes_all_commands_to_writer() {
        // Clone mocks before wrapping so we can inspect calls after test
        // (MockRedisClient uses Arc<Mutex<Vec<_>>> internally, so clones share state)
        let reader_mock = MockRedisClient::new();
        let reader_inspector = reader_mock.clone();

        let mut writer_mock = MockRedisClient::new();
        writer_mock.get_ret("key1", Ok("writer_value".to_string()));
        writer_mock.set_ret("key2", Ok(()));
        let writer_inspector = writer_mock.clone();

        // Coerce to trait objects
        let reader: Arc<dyn Client + Send + Sync> = Arc::new(reader_mock);
        let writer: Arc<dyn Client + Send + Sync> = Arc::new(writer_mock);

        let client = ReadWriteClient::new(reader, writer);

        // Execute mixed read/write pipeline
        let results = client
            .pipeline()
            .get("key1") // Read operation
            .set("key2", "value2") // Write operation
            .execute()
            .await
            .unwrap();

        assert_eq!(results.len(), 2);
        assert!(matches!(
            &results[0],
            Ok(PipelineResult::String(s)) if s == "writer_value"
        ));
        assert!(matches!(results[1], Ok(PipelineResult::Ok)));

        // Verify ALL commands went to writer, not reader
        let writer_calls = writer_inspector.get_calls();
        assert_eq!(
            writer_calls.len(),
            2,
            "Writer should handle all pipeline commands"
        );
        assert_eq!(writer_calls[0].op, "pipeline_get");
        assert_eq!(writer_calls[0].key, "key1");
        assert_eq!(writer_calls[1].op, "pipeline_set");
        assert_eq!(writer_calls[1].key, "key2");

        // Verify reader was NOT called
        let reader_calls = reader_inspector.get_calls();
        assert_eq!(
            reader_calls.len(),
            0,
            "Reader should never be called for pipelines"
        );
    }

    #[tokio::test]
    async fn test_pipeline_does_not_fallback_to_reader_on_error() {
        // Configure reader with good data but writer returns error
        let mut reader_mock = MockRedisClient::new();
        reader_mock.get_ret("key1", Ok("reader_value".to_string()));
        let reader_inspector = reader_mock.clone();

        // Writer has no configured response, will return NotFound
        let writer_mock = MockRedisClient::new();

        let reader: Arc<dyn Client + Send + Sync> = Arc::new(reader_mock);
        let writer: Arc<dyn Client + Send + Sync> = Arc::new(writer_mock);

        let client = ReadWriteClient::new(reader, writer);

        // Pipeline should use writer and return its error, NOT fallback to reader
        let results = client.pipeline().get("key1").execute().await.unwrap();

        assert_eq!(results.len(), 1);
        // Should get writer's NotFound error, not reader's success
        assert!(
            matches!(&results[0], Err(CustomRedisError::NotFound)),
            "Pipeline should return writer's error, not fallback to reader"
        );

        // Verify reader was never consulted
        let reader_calls = reader_inspector.get_calls();
        assert_eq!(
            reader_calls.len(),
            0,
            "Reader should never be called for pipeline operations"
        );
    }

    #[tokio::test]
    async fn test_pipeline_empty_does_not_call_either_client() {
        let reader_mock = MockRedisClient::new();
        let reader_inspector = reader_mock.clone();

        let writer_mock = MockRedisClient::new();
        let writer_inspector = writer_mock.clone();

        let reader: Arc<dyn Client + Send + Sync> = Arc::new(reader_mock);
        let writer: Arc<dyn Client + Send + Sync> = Arc::new(writer_mock);

        let client = ReadWriteClient::new(reader, writer);

        let results = client.pipeline().execute().await.unwrap();

        assert!(results.is_empty());

        // Neither client should be called for empty pipeline
        assert_eq!(reader_inspector.get_calls().len(), 0);
        assert_eq!(writer_inspector.get_calls().len(), 0);
    }
}