braid_http_rs 0.1.5

Unified Braid Protocol implementation in Rust, including Braid-HTTP, Antimatter CRDT, and BraidFS.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Configuration for the Braid HTTP client.

/// Configuration for the Braid HTTP client.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ClientConfig {
    /// Maximum retries for failed requests.
    pub max_retries: u32,
    /// Base retry delay in milliseconds.
    pub retry_delay_ms: u64,
    /// Connection timeout in seconds.
    pub connection_timeout_secs: u64,
    /// Enable request logging.
    pub enable_logging: bool,
    /// Maximum concurrent subscriptions.
    pub max_subscriptions: usize,
    /// Threshold for auto-multiplexing.
    pub auto_multiplex_threshold: usize,
    /// Enable multiplexing for subscription requests.
    pub enable_multiplex: bool,
    /// Proxy URL (optional).
    pub proxy_url: String,
    /// Request timeout in milliseconds.
    pub request_timeout_ms: u64,
    /// Maximum total connections in the pool.
    pub max_total_connections: u32,
}

impl Default for ClientConfig {
    fn default() -> Self {
        ClientConfig {
            max_retries: 3,
            retry_delay_ms: 1000,
            connection_timeout_secs: 30,
            enable_logging: false,
            max_subscriptions: 100,
            auto_multiplex_threshold: 3,
            enable_multiplex: true,
            proxy_url: String::new(),
            request_timeout_ms: 30000,
            max_total_connections: 100,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_config() {
        let config = ClientConfig::default();
        assert_eq!(config.max_retries, 3);
        assert_eq!(config.retry_delay_ms, 1000);
        assert_eq!(config.connection_timeout_secs, 30);
        assert!(!config.enable_logging);
        assert_eq!(config.max_subscriptions, 100);
        assert_eq!(config.auto_multiplex_threshold, 3);
        assert!(config.enable_multiplex);
        assert_eq!(config.proxy_url, "");
        assert_eq!(config.request_timeout_ms, 30000);
        assert_eq!(config.max_total_connections, 100);
    }

    #[test]
    fn test_custom_config() {
        let config = ClientConfig {
            max_retries: 5,
            retry_delay_ms: 2000,
            connection_timeout_secs: 60,
            enable_logging: true,
            max_subscriptions: 50,
            auto_multiplex_threshold: 5,
            enable_multiplex: false,
            proxy_url: "http://proxy".to_string(),
            request_timeout_ms: 1000,
            max_total_connections: 40,
        };
        assert_eq!(config.max_retries, 5);
        assert_eq!(config.retry_delay_ms, 2000);
        assert_eq!(config.connection_timeout_secs, 60);
        assert!(config.enable_logging);
        assert_eq!(config.max_subscriptions, 50);
        assert_eq!(config.auto_multiplex_threshold, 5);
        assert!(!config.enable_multiplex);
        assert_eq!(config.proxy_url, "http://proxy");
        assert_eq!(config.request_timeout_ms, 1000);
        assert_eq!(config.max_total_connections, 40);
    }

    #[test]
    fn test_partial_override() {
        let config = ClientConfig {
            max_retries: 10,
            ..Default::default()
        };
        assert_eq!(config.max_retries, 10);
        assert_eq!(config.retry_delay_ms, 1000);
    }

    #[test]
    fn test_clone() {
        let config = ClientConfig::default();
        let cloned = config.clone();
        assert_eq!(config, cloned);
    }

    #[test]
    fn test_debug() {
        let config = ClientConfig::default();
        let debug = format!("{:?}", config);
        assert!(debug.contains("ClientConfig"));
        assert!(debug.contains("max_retries"));
    }
}