camel_api/
load_balancer.rs

1#[derive(Debug, Clone, Default, PartialEq, Eq)]
2pub enum LoadBalanceStrategy {
3    #[default]
4    RoundRobin,
5    Random,
6    Weighted(Vec<(String, u32)>),
7    Failover,
8}
9
10#[derive(Debug, Clone)]
11pub struct LoadBalancerConfig {
12    pub strategy: LoadBalanceStrategy,
13    pub parallel: bool,
14}
15
16impl LoadBalancerConfig {
17    pub fn round_robin() -> Self {
18        Self {
19            strategy: LoadBalanceStrategy::RoundRobin,
20            parallel: false,
21        }
22    }
23
24    pub fn random() -> Self {
25        Self {
26            strategy: LoadBalanceStrategy::Random,
27            parallel: false,
28        }
29    }
30
31    pub fn weighted(weights: Vec<(String, u32)>) -> Self {
32        Self {
33            strategy: LoadBalanceStrategy::Weighted(weights),
34            parallel: false,
35        }
36    }
37
38    pub fn failover() -> Self {
39        Self {
40            strategy: LoadBalanceStrategy::Failover,
41            parallel: false,
42        }
43    }
44
45    pub fn parallel(mut self, p: bool) -> Self {
46        self.parallel = p;
47        self
48    }
49}
50
51#[cfg(test)]
52mod tests {
53    use super::*;
54
55    #[test]
56    fn round_robin_factory() {
57        let cfg = LoadBalancerConfig::round_robin();
58        assert_eq!(cfg.strategy, LoadBalanceStrategy::RoundRobin);
59        assert!(!cfg.parallel);
60    }
61
62    #[test]
63    fn random_factory() {
64        let cfg = LoadBalancerConfig::random();
65        assert_eq!(cfg.strategy, LoadBalanceStrategy::Random);
66    }
67
68    #[test]
69    fn weighted_factory() {
70        let weights = vec![("a".to_string(), 3), ("b".to_string(), 1)];
71        let cfg = LoadBalancerConfig::weighted(weights.clone());
72        assert_eq!(cfg.strategy, LoadBalanceStrategy::Weighted(weights));
73    }
74
75    #[test]
76    fn failover_factory() {
77        let cfg = LoadBalancerConfig::failover();
78        assert_eq!(cfg.strategy, LoadBalanceStrategy::Failover);
79    }
80
81    #[test]
82    fn parallel_builder() {
83        let cfg = LoadBalancerConfig::round_robin().parallel(true);
84        assert!(cfg.parallel);
85    }
86
87    #[test]
88    fn default_strategy_is_round_robin() {
89        assert_eq!(
90            LoadBalanceStrategy::default(),
91            LoadBalanceStrategy::RoundRobin
92        );
93    }
94
95    #[test]
96    fn strategy_equality() {
97        assert_eq!(
98            LoadBalanceStrategy::RoundRobin,
99            LoadBalanceStrategy::RoundRobin
100        );
101        assert_ne!(LoadBalanceStrategy::RoundRobin, LoadBalanceStrategy::Random);
102    }
103
104    #[test]
105    fn clone_preserves_strategy() {
106        let cfg = LoadBalancerConfig::failover().parallel(true);
107        let cloned = cfg.clone();
108        assert_eq!(cloned.strategy, LoadBalanceStrategy::Failover);
109        assert!(cloned.parallel);
110    }
111}
camel_api/load_balancer.rs

camel_api/
load_balancer.rs
