odd-box 0.1.10

a dead simple reverse proxy server and web server
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297

#[allow(unused)]
use crate::configuration::OddBoxConfiguration;

#[test] pub fn legacy_upgrade_to_latest() {
    let legacy_config = crate::configuration::legacy::OddBoxLegacyConfig::example();
    let cfg = crate::configuration::AnyOddBoxConfig::Legacy(legacy_config);
    cfg.try_upgrade_to_latest_version().unwrap();
} 

#[test] pub fn v1_upgrade_to_latest() {
    let v1_config = crate::configuration::v1::OddBoxV1Config::example();
    let cfg = crate::configuration::AnyOddBoxConfig::V1(v1_config);
    cfg.try_upgrade_to_latest_version().unwrap();
}


#[test] pub fn v2_upgrade_to_latest() {
    let v2_config = crate::configuration::v2::OddBoxV2Config::example();
    let cfg = crate::configuration::AnyOddBoxConfig::V2(v2_config);
    cfg.try_upgrade_to_latest_version().unwrap();
}

#[test] pub fn v3_upgrade_to_latest() {
    let v3_config = crate::configuration::v3::OddBoxV3Config::example();
    let cfg = crate::configuration::AnyOddBoxConfig::V3(v3_config);
    cfg.try_upgrade_to_latest_version().unwrap();
}


#[test] pub fn default_to_port_80_for_backends_with_unspecified_scheme() {

    let mut v1_config = crate::configuration::v1::OddBoxV1Config::example();
    
    let test_site = crate::configuration::v1::RemoteSiteConfig {
        port: None,
        capture_subdomains: None,
        disable_tcp_tunnel_mode: None, 
        h2_hint: None,
        host_name: "test".into(),
        forward_subdomains: None,
        https: None,
        target_hostname: "test-domain.com".into(),
    };

    if let Some(ref mut v) = v1_config.remote_target {
        *v = vec![test_site];
    }

    let v2 : crate::configuration::v2::OddBoxV2Config = v1_config.to_owned().try_into().unwrap();
    let v3 : crate::configuration::v3::OddBoxV3Config = v2.to_owned().try_into().unwrap();

    let v2_remote_sites = v2.remote_target.expect("v2 should have remote sites");
    let v3_remote_sites = v3.remote_target.expect("v3 should have remote sites");
    
    
    assert_eq!(v2_remote_sites.len(),1);
    assert_eq!(v3_remote_sites.len(),1);
    
    let v2_test_site = v2_remote_sites.get(0).expect("v2 should have test site");
    let v3_test_site = v3_remote_sites.get(0).expect("v3 should have test site");

    assert_eq!(v2_test_site.backends.len(),1);
    assert_eq!(v3_test_site.backends.len(),1);
    

    let v2_backend = v2_test_site.backends.get(0).expect("v2 should have backend");
    let v3_backend = v3_test_site.backends.get(0).expect("v3 should have backend");

    assert_eq!(v2_backend.port,80);
    assert_eq!(v2_backend.address,"test-domain.com");
    assert_eq!(v2_backend.https,None);
    assert_eq!(v3_backend.port,80);
    assert_eq!(v3_backend.address,"test-domain.com");
    assert_eq!(v3_backend.https,None);

    
}




#[test] pub fn default_to_port_80_for_backends_with_http() {

    let mut v1_config = crate::configuration::v1::OddBoxV1Config::example();
    
    let test_site = crate::configuration::v1::RemoteSiteConfig {
        port: None,
        capture_subdomains: None,
        disable_tcp_tunnel_mode: None, 
        h2_hint: None,
        host_name: "test".into(),
        forward_subdomains: None,
        https: Some(false),
        target_hostname: "test-domain.com".into(),
    };

    if let Some(ref mut v) = v1_config.remote_target {
        *v = vec![test_site];
    }

    let v2 : crate::configuration::v2::OddBoxV2Config = v1_config.to_owned().try_into().unwrap();
    let v3 : crate::configuration::v3::OddBoxV3Config = v2.to_owned().try_into().unwrap();

    let v2_remote_sites = v2.remote_target.expect("should have remote sites");
    assert_eq!(v2_remote_sites.len(),1);

    let v2_test_site = v2_remote_sites.get(0).expect("should have test site");
    assert_eq!(v2_test_site.backends.len(),1);

    let v2_backend = v2_test_site.backends.get(0).expect("should have backend");
    assert_eq!(v2_backend.port,80);
    assert_eq!(v2_backend.address,"test-domain.com");
    assert_eq!(v2_backend.https,Some(false));

  

    let v3_remote_sites = v3.remote_target.expect("should have remote sites");
    assert_eq!(v3_remote_sites.len(),1);

    let v3_test_site = v3_remote_sites.get(0).expect("should have test site");
    assert_eq!(v3_test_site.backends.len(),1);

    let v3_backend = v3_test_site.backends.get(0).expect("should have backend");
    assert_eq!(v3_backend.port,80);
    assert_eq!(v3_backend.address,"test-domain.com");
    assert_eq!(v3_backend.https,Some(false));

    
}


#[test] pub fn default_to_port_443_for_backends_with_https() {

    let mut v1_config = crate::configuration::v1::OddBoxV1Config::example();
    
    let test_site = crate::configuration::v1::RemoteSiteConfig {
        port: None,
        capture_subdomains: None,
        disable_tcp_tunnel_mode: None, 
        h2_hint: None,
        host_name: "test".into(),
        forward_subdomains: None,
        https: Some(true),
        target_hostname: "test-domain.com".into(),
    };

    if let Some(ref mut v) = v1_config.remote_target {
        *v = vec![test_site];
    }

    let v2 : crate::configuration::v2::OddBoxV2Config = v1_config.to_owned().try_into().unwrap();
    let v3 : crate::configuration::v3::OddBoxV3Config = v2.to_owned().try_into().unwrap();
    

    let remote_sites = v2.remote_target.expect("should have remote sites");
    assert_eq!(remote_sites.len(),1);

    let test_site = remote_sites.get(0).expect("should have test site");
    assert_eq!(test_site.backends.len(),1);

    let backend = test_site.backends.get(0).expect("should have backend");
    assert_eq!(backend.port,443);
    assert_eq!(backend.address,"test-domain.com");
    assert_eq!(backend.https,Some(true));

    let remote_sites = v3.remote_target.expect("should have remote sites");
    assert_eq!(remote_sites.len(),1);

    let test_site = remote_sites.get(0).expect("should have test site");
    assert_eq!(test_site.backends.len(),1);

    let backend = test_site.backends.get(0).expect("should have backend");
    assert_eq!(backend.port,443);
    assert_eq!(backend.address,"test-domain.com");
    assert_eq!(backend.https,Some(true));
    
    
}

#[test] pub fn v2_reserialize_is_lossless() -> Result<(),String> {
    let v2_config_example = crate::configuration::v2::OddBoxV2Config::example();
    let serialized = v2_config_example.to_string().expect("should be able to serialize v2 configurations");
    let deserialized = crate::configuration::AnyOddBoxConfig::parse(&serialized).expect("should be able to deserialize v2 configurations");
    match deserialized {
        crate::configuration::AnyOddBoxConfig::Legacy(_) => Err("expected v2 config".to_string()),
        crate::configuration::AnyOddBoxConfig::V1(_) => Err("expected v2 config".to_string()),
        crate::configuration::AnyOddBoxConfig::V2(v2_after_se_de) => {
            // make sure that the deserialized version is the same as the original so we 
            // can be sure that the serialization and deserialization process is lossless
            if v2_config_example.remote_target.eq(&v2_after_se_de.remote_target) == false {

                panic!("deserialized version of v2 config is not the same as the original: {:?}\n\n{:?}",v2_config_example,v2_after_se_de);
            };
            Ok(())
        },
        _ => Err("unexpected config version".to_string())
    }

}

#[test] pub fn v3_reserialize_is_lossless() -> Result<(),String> {
    let v3_config_example = crate::configuration::v3::OddBoxV3Config::example();
    let serialized = v3_config_example.to_string().expect("should be able to serialize v3 configurations");
    let deserialized = crate::configuration::AnyOddBoxConfig::parse(&serialized).expect("should be able to deserialize v2 configurations");
    match deserialized {
        crate::configuration::AnyOddBoxConfig::Legacy(_) => Err("expected v3 config - found legacy".to_string()),
        crate::configuration::AnyOddBoxConfig::V1(_) => Err("expected v3 config - found v1".to_string()),
        crate::configuration::AnyOddBoxConfig::V2(_) => Err("expected v3 config - found v2".to_string()),
        crate::configuration::AnyOddBoxConfig::V3(v3_after_se_de) => {
            // make sure that the deserialized version is the same as the original so we 
            // can be sure that the serialization and deserialization process is lossless
            if v3_config_example.remote_target.eq(&v3_after_se_de.remote_target) == false {

                panic!("deserialized version of v3 config is not the same as the original: {:?}\n\n{:?}",v3_config_example,v3_after_se_de);
            };
            Ok(())
        }
    }
}

#[test] pub fn v2_to_next_with_hints_adds_h1() {
    let mut example = crate::configuration::v2::OddBoxV2Config::example();
    example.remote_target = Some(vec![
        crate::configuration::v2::RemoteSiteConfig {
            enable_lets_encrypt: None,
            capture_subdomains: None,
            disable_tcp_tunnel_mode: None,
            host_name: "test".into(),
            forward_subdomains: None,
            keep_original_host_header: None,
            backends: vec![
                crate::configuration::v2::Backend {
                    address: "test-domain.com".into(),
                    port: 443,
                    https: Some(true),
                    hints : Some(vec![
                        crate::configuration::v2::Hint::H2
                    ])
                }
            ]
        }
    ]);
    let v2_config_example = crate::configuration::AnyOddBoxConfig::V2(example);
    match v2_config_example.try_upgrade_to_latest_version() {
        Ok((upgraded_config,_input_version,_)) => {
            let remote_sites = upgraded_config.remote_target.expect("should have remote sites");
            let test_site = remote_sites.get(0).expect("should have test site");
            let backend = test_site.backends.get(0).expect("should have backend");
            let has_h1 = backend.hints.as_ref().expect("should have hints").contains(&crate::configuration::v3::Hint::H1);
            assert!(has_h1);
        },
        _ => panic!("expected v3 config")
    }
}

#[test] pub fn v2_to_next_without_hints_does_not_add_h1() {
    let mut example = crate::configuration::v2::OddBoxV2Config::example();
    example.remote_target = Some(vec![
        crate::configuration::v2::RemoteSiteConfig {
            enable_lets_encrypt: None,
            capture_subdomains: None,
            disable_tcp_tunnel_mode: None,
            host_name: "test".into(),
            forward_subdomains: None,
            keep_original_host_header: None,
            backends: vec![
                crate::configuration::v2::Backend {
                    address: "test-domain.com".into(),
                    port: 443,
                    https: Some(true),
                    hints : Some(vec![])
                }
            ]
        }
    ]);
    let v2_config_example = crate::configuration::AnyOddBoxConfig::V2(example);
    match v2_config_example.try_upgrade_to_latest_version() {
        Ok((upgraded_config,_input_version,_)) => {
            let remote_sites = upgraded_config.remote_target.expect("should have remote sites");
            let test_site = remote_sites.get(0).expect("should have test site");
            let backend = test_site.backends.get(0).expect("should have backend");
            assert!(backend.hints.is_none());
        },
        _ => panic!("expected v3 config")
    }
}


#[test] 
fn init_cfg_is_valid() {
    crate::generate_config(None,false).expect("should be able to create initial config");
}

#[test]
fn init_filled_cfg_is_valid() { 
    crate::generate_config(None,true).expect("should be able to create initial filled config");
}