camel-api 0.8.0

Core traits and interfaces for rust-camel
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use std::sync::Arc;
use std::time::Duration;

use crate::Exchange;

pub type RouterExpression = Arc<dyn Fn(&Exchange) -> Option<String> + Send + Sync>;

#[derive(Clone)]
pub struct DynamicRouterConfig {
    pub expression: RouterExpression,
    pub uri_delimiter: String,
    pub cache_size: i32,
    pub ignore_invalid_endpoints: bool,
    pub max_iterations: usize,
    pub timeout: Option<Duration>,
}

impl DynamicRouterConfig {
    pub fn new(expression: RouterExpression) -> Self {
        Self {
            expression,
            uri_delimiter: ",".to_string(),
            cache_size: 1000,
            ignore_invalid_endpoints: false,
            max_iterations: 1000,
            timeout: Some(Duration::from_secs(60)),
        }
    }

    pub fn uri_delimiter(mut self, d: impl Into<String>) -> Self {
        self.uri_delimiter = d.into();
        self
    }

    pub fn cache_size(mut self, n: i32) -> Self {
        self.cache_size = n;
        self
    }

    pub fn ignore_invalid_endpoints(mut self, ignore: bool) -> Self {
        self.ignore_invalid_endpoints = ignore;
        self
    }

    pub fn max_iterations(mut self, n: usize) -> Self {
        self.max_iterations = n;
        self
    }

    pub fn timeout(mut self, d: Duration) -> Self {
        self.timeout = Some(d);
        self
    }

    pub fn no_timeout(mut self) -> Self {
        self.timeout = None;
        self
    }
}

impl std::fmt::Debug for DynamicRouterConfig {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("DynamicRouterConfig")
            .field("uri_delimiter", &self.uri_delimiter)
            .field("cache_size", &self.cache_size)
            .field("ignore_invalid_endpoints", &self.ignore_invalid_endpoints)
            .field("max_iterations", &self.max_iterations)
            .field("timeout", &self.timeout)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;
    use std::time::Duration;

    use super::*;

    fn noop_expr() -> RouterExpression {
        Arc::new(|_| None)
    }

    #[test]
    fn new_has_defaults() {
        let cfg = DynamicRouterConfig::new(noop_expr());
        assert_eq!(cfg.uri_delimiter, ",");
        assert_eq!(cfg.cache_size, 1000);
        assert!(!cfg.ignore_invalid_endpoints);
        assert_eq!(cfg.max_iterations, 1000);
        assert_eq!(cfg.timeout, Some(Duration::from_secs(60)));
    }

    #[test]
    fn builder_chaining() {
        let cfg = DynamicRouterConfig::new(noop_expr())
            .uri_delimiter(";")
            .cache_size(100)
            .ignore_invalid_endpoints(true)
            .max_iterations(50)
            .timeout(Duration::from_secs(10));
        assert_eq!(cfg.uri_delimiter, ";");
        assert_eq!(cfg.cache_size, 100);
        assert!(cfg.ignore_invalid_endpoints);
        assert_eq!(cfg.max_iterations, 50);
        assert_eq!(cfg.timeout, Some(Duration::from_secs(10)));
    }

    #[test]
    fn no_timeout_clears() {
        let cfg = DynamicRouterConfig::new(noop_expr()).no_timeout();
        assert!(cfg.timeout.is_none());
    }

    #[test]
    fn debug_format_contains_fields() {
        let cfg = DynamicRouterConfig::new(noop_expr());
        let debug = format!("{cfg:?}");
        assert!(debug.contains("DynamicRouterConfig"));
        assert!(debug.contains("uri_delimiter"));
        assert!(debug.contains("cache_size"));
    }

    #[test]
    fn clone_preserves_values() {
        let cfg = DynamicRouterConfig::new(noop_expr())
            .uri_delimiter("|")
            .cache_size(42);
        let cloned = cfg.clone();
        assert_eq!(cloned.uri_delimiter, "|");
        assert_eq!(cloned.cache_size, 42);
    }
}