vicarian 0.2.6

Vicarian is a reverse proxy server with ACME support
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

use anyhow::Result;
use http::{uri::Builder, Uri};
use test_log::test;

use crate::{
    config::Backend,
    proxy::{rewrite_port, router::Router, strip_port}
};

#[test]
fn test_uri_rewrite() -> Result<()> {
    let uri = Uri::from_static("http://example.com/a/path?param=value");
    let changed = Builder::from(uri)
        .scheme("https")
        .build()?;
    assert_eq!("https://example.com/a/path?param=value", changed.to_string());
    Ok(())
}

#[test]
fn test_host_port_rewrite() -> Result<()> {
    let replaced = rewrite_port("example.com:8080", "8443");
    assert_eq!("example.com:8443", replaced);
    let replaced = rewrite_port("example.com", "8443");
    assert_eq!("example.com", replaced);
    Ok(())
}

#[test]
fn test_port_strip() -> Result<()> {
    let host_header = "example.com:8443";
    let host = strip_port(host_header);
    assert_eq!("example.com", host);

    Ok(())
}

#[test]
fn test_no_port_strip() -> Result<()> {
    let host_header = "example.com";
    let host = strip_port(host_header);
    assert_eq!("example.com", host);

    Ok(())
}


#[test]
fn test_strip_port_ipv6() -> Result<()> {
    let host = strip_port("[::1]:8080");
    assert_eq!("[::1]", host);

    let host = strip_port("[::1]");
    assert_eq!("[::1]", host);

    Ok(())
}

#[test]
fn test_router() -> Result<()> {
    let backends = vec![
        Backend {
            context: None,
            url: Uri::from_static("http://localhost:1010"),
            trust: false,
            auth_key: None,
        },
        Backend {
            context: Some("/service".to_string()),
            url: Uri::from_static("http://localhost:2020"),
            trust: false,
            auth_key: None,
        },
        Backend {
            context: Some("/service/subservice/".to_string()),
            url: Uri::from_static("http://localhost:3030"),
            trust: false,
            auth_key: None,
        },
        Backend {
            context: Some("/other_service/".to_string()),
            url: Uri::from_static("http://localhost:4040"),
            trust: false,
            auth_key: None,
        },
    ];

    let router = Router::new(&backends);

    let matched = router.lookup("/").unwrap();
    assert_eq!(Uri::from_static("http://localhost:1010"), matched.backend.url);
    assert_eq!("", matched._path);

    let matched = router.lookup("/base/path").unwrap();
    assert_eq!(Uri::from_static("http://localhost:1010"), matched.backend.url);
    assert_eq!("base/path", matched._path);

    let matched = router.lookup("/service").unwrap();
    assert_eq!(Uri::from_static("http://localhost:2020"), matched.backend.url);
    assert_eq!("", matched._path);

    let matched = router.lookup("/service/").unwrap();
    assert_eq!(Uri::from_static("http://localhost:2020"), matched.backend.url);
    assert_eq!("/", matched._path);

    let matched = router.lookup("/service/some/path").unwrap();
    assert_eq!(Uri::from_static("http://localhost:2020"), matched.backend.url);
    assert_eq!("/some/path", matched._path);

    let matched = router.lookup("/service/subservice").unwrap();
    assert_eq!(Uri::from_static("http://localhost:3030"), matched.backend.url);
    assert_eq!("", matched._path);

    let matched = router.lookup("/service/subservice/").unwrap();
    assert_eq!(Uri::from_static("http://localhost:3030"), matched.backend.url);
    assert_eq!("/", matched._path);

    let matched = router.lookup("/service/subservice/ss/path").unwrap();
    assert_eq!(Uri::from_static("http://localhost:3030"), matched.backend.url);
    assert_eq!("/ss/path", matched._path);

    let matched = router.lookup("/other_service/some/path").unwrap();
    assert_eq!(Uri::from_static("http://localhost:4040"), matched.backend.url);
    assert_eq!("/some/path", matched._path);

    Ok(())
}