markdown_harvest/
http_config.rs

1#[derive(Default, Clone, Copy)]
2pub struct HttpConfig {
3    timeout: Option<u64>,
4    max_redirect: Option<usize>,
5    cookie_store: bool,
6}
7
8#[derive(Default)]
9pub struct HttpConfigBuilder {
10    timeout: Option<u64>,
11    max_redirect: Option<usize>,
12    cookie_store: bool,
13}
14
15impl HttpConfigBuilder {
16    pub fn new() -> Self {
17        Self {
18            timeout: None,
19            max_redirect: None,
20            cookie_store: false,
21        }
22    }
23
24    pub fn timeout(mut self, ms: u64) -> Self {
25        self.timeout = Some(ms);
26        self
27    }
28
29    pub fn max_redirect(mut self, max_redirect: usize) -> Self {
30        self.max_redirect = Some(max_redirect);
31        self
32    }
33
34    pub fn cookie_store(mut self, cookie_store: bool) -> Self {
35        self.cookie_store = cookie_store;
36        self
37    }
38
39    pub fn build(self) -> HttpConfig {
40        HttpConfig {
41            timeout: self.timeout,
42            max_redirect: self.max_redirect,
43            cookie_store: self.cookie_store,
44        }
45    }
46}
47
48impl HttpConfig {
49    #[allow(dead_code)]
50    fn new(timeout: Option<u64>, max_redirect: Option<usize>, cookie_store: bool) -> Self {
51        Self {
52            timeout,
53            max_redirect,
54            cookie_store,
55        }
56    }
57
58    pub fn builder() -> HttpConfigBuilder {
59        HttpConfigBuilder::new()
60    }
61
62    pub fn timeout(&self) -> Option<u64> {
63        self.timeout
64    }
65
66    pub fn max_redirect(&self) -> Option<usize> {
67        self.max_redirect
68    }
69
70    pub fn cookie_store(&self) -> bool {
71        self.cookie_store
72    }
73}
74
75#[cfg(test)]
76mod tests {
77    use super::*;
78
79    #[test]
80    fn test_http_config_builder_new() {
81        let builder = HttpConfigBuilder::new();
82        assert_eq!(builder.timeout, None);
83        assert_eq!(builder.max_redirect, None);
84        assert_eq!(builder.cookie_store, false);
85    }
86
87    #[test]
88    fn test_http_config_builder_default() {
89        let builder = HttpConfigBuilder::default();
90        assert_eq!(builder.timeout, None);
91        assert_eq!(builder.max_redirect, None);
92        assert_eq!(builder.cookie_store, false);
93    }
94
95    #[test]
96    fn test_http_config_builder_timeout() {
97        let builder = HttpConfigBuilder::new().timeout(5000);
98        assert_eq!(builder.timeout, Some(5000));
99        assert_eq!(builder.max_redirect, None);
100        assert_eq!(builder.cookie_store, false);
101    }
102
103    #[test]
104    fn test_http_config_builder_max_redirect() {
105        let builder = HttpConfigBuilder::new().max_redirect(10);
106        assert_eq!(builder.timeout, None);
107        assert_eq!(builder.max_redirect, Some(10));
108        assert_eq!(builder.cookie_store, false);
109    }
110
111    #[test]
112    fn test_http_config_builder_cookie_store() {
113        let builder = HttpConfigBuilder::new().cookie_store(true);
114        assert_eq!(builder.timeout, None);
115        assert_eq!(builder.max_redirect, None);
116        assert_eq!(builder.cookie_store, true);
117    }
118
119    #[test]
120    fn test_http_config_builder_fluent_api() {
121        let builder = HttpConfigBuilder::new()
122            .timeout(3000)
123            .max_redirect(5)
124            .cookie_store(true);
125
126        assert_eq!(builder.timeout, Some(3000));
127        assert_eq!(builder.max_redirect, Some(5));
128        assert_eq!(builder.cookie_store, true);
129    }
130
131    #[test]
132    fn test_http_config_builder_build() {
133        let config = HttpConfigBuilder::new()
134            .timeout(2500)
135            .max_redirect(8)
136            .cookie_store(false)
137            .build();
138
139        assert_eq!(config.timeout(), Some(2500));
140        assert_eq!(config.max_redirect(), Some(8));
141        assert_eq!(config.cookie_store(), false);
142    }
143
144    #[test]
145    fn test_http_config_builder_build_empty() {
146        let config = HttpConfigBuilder::new().build();
147
148        assert_eq!(config.timeout(), None);
149        assert_eq!(config.max_redirect(), None);
150        assert_eq!(config.cookie_store(), false);
151    }
152
153    #[test]
154    fn test_http_config_default() {
155        let config = HttpConfig::default();
156
157        assert_eq!(config.timeout(), None);
158        assert_eq!(config.max_redirect(), None);
159        assert_eq!(config.cookie_store(), false);
160    }
161
162    #[test]
163    fn test_http_config_builder_static_method() {
164        let config = HttpConfig::builder()
165            .timeout(1000)
166            .max_redirect(3)
167            .cookie_store(true)
168            .build();
169
170        assert_eq!(config.timeout(), Some(1000));
171        assert_eq!(config.max_redirect(), Some(3));
172        assert_eq!(config.cookie_store(), true);
173    }
174
175    #[test]
176    fn test_http_config_getters() {
177        let config = HttpConfig {
178            timeout: Some(4000),
179            max_redirect: Some(7),
180            cookie_store: true,
181        };
182
183        assert_eq!(config.timeout(), Some(4000));
184        assert_eq!(config.max_redirect(), Some(7));
185        assert_eq!(config.cookie_store(), true);
186    }
187
188    #[test]
189    fn test_http_config_clone() {
190        let original = HttpConfig::builder()
191            .timeout(1500)
192            .max_redirect(4)
193            .cookie_store(true)
194            .build();
195
196        let cloned = original.clone();
197
198        assert_eq!(original.timeout(), cloned.timeout());
199        assert_eq!(original.max_redirect(), cloned.max_redirect());
200        assert_eq!(original.cookie_store(), cloned.cookie_store());
201    }
202
203    #[test]
204    fn test_http_config_copy() {
205        let original = HttpConfig::builder()
206            .timeout(2000)
207            .max_redirect(6)
208            .cookie_store(false)
209            .build();
210
211        let copied = original;
212
213        assert_eq!(original.timeout(), copied.timeout());
214        assert_eq!(original.max_redirect(), copied.max_redirect());
215        assert_eq!(original.cookie_store(), copied.cookie_store());
216    }
217
218    #[test]
219    fn test_http_config_builder_chaining_order() {
220        // Test different chaining orders produce same result
221        let config1 = HttpConfig::builder()
222            .timeout(1000)
223            .max_redirect(5)
224            .cookie_store(true)
225            .build();
226
227        let config2 = HttpConfig::builder()
228            .cookie_store(true)
229            .timeout(1000)
230            .max_redirect(5)
231            .build();
232
233        assert_eq!(config1.timeout(), config2.timeout());
234        assert_eq!(config1.max_redirect(), config2.max_redirect());
235        assert_eq!(config1.cookie_store(), config2.cookie_store());
236    }
237
238    #[test]
239    fn test_http_config_builder_overwrite() {
240        // Test that later values overwrite earlier ones
241        let config = HttpConfig::builder()
242            .timeout(1000)
243            .timeout(2000) // This should overwrite the previous timeout
244            .max_redirect(3)
245            .max_redirect(6) // This should overwrite the previous max_redirect
246            .cookie_store(false)
247            .cookie_store(true) // This should overwrite the previous cookie_store
248            .build();
249
250        assert_eq!(config.timeout(), Some(2000));
251        assert_eq!(config.max_redirect(), Some(6));
252        assert_eq!(config.cookie_store(), true);
253    }
254
255    #[test]
256    fn test_http_config_edge_values() {
257        // Test edge values
258        let config = HttpConfig::builder()
259            .timeout(0) // Minimum timeout
260            .max_redirect(0) // Minimum redirects
261            .cookie_store(false)
262            .build();
263
264        assert_eq!(config.timeout(), Some(0));
265        assert_eq!(config.max_redirect(), Some(0));
266        assert_eq!(config.cookie_store(), false);
267
268        let config2 = HttpConfig::builder()
269            .timeout(u64::MAX) // Maximum timeout
270            .max_redirect(usize::MAX) // Maximum redirects
271            .cookie_store(true)
272            .build();
273
274        assert_eq!(config2.timeout(), Some(u64::MAX));
275        assert_eq!(config2.max_redirect(), Some(usize::MAX));
276        assert_eq!(config2.cookie_store(), true);
277    }
278
279    #[test]
280    fn test_http_config_partial_configuration() {
281        // Test partial configurations
282        let config1 = HttpConfig::builder().timeout(1000).build();
283        assert_eq!(config1.timeout(), Some(1000));
284        assert_eq!(config1.max_redirect(), None);
285        assert_eq!(config1.cookie_store(), false);
286
287        let config2 = HttpConfig::builder().max_redirect(5).build();
288        assert_eq!(config2.timeout(), None);
289        assert_eq!(config2.max_redirect(), Some(5));
290        assert_eq!(config2.cookie_store(), false);
291
292        let config3 = HttpConfig::builder().cookie_store(true).build();
293        assert_eq!(config3.timeout(), None);
294        assert_eq!(config3.max_redirect(), None);
295        assert_eq!(config3.cookie_store(), true);
296    }
297}
markdown_harvest/http_config.rs

markdown_harvest/
http_config.rs
