roadster 0.8.1

A "Batteries Included" web framework for rust designed to get you moving fast.
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

use crate::error::RoadsterResult;
use serde_derive::{Deserialize, Serialize};
use std::net::SocketAddr;
use validator::Validate;

#[serde_with::skip_serializing_none]
#[derive(Debug, Clone, Validate, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
#[non_exhaustive]
pub struct Address {
    pub scheme: String,
    pub host: String,
    pub port: u32,
}

impl Address {
    pub fn url(&self) -> String {
        format!("{}:{}", self.host, self.port)
    }

    pub fn url_with_scheme(&self) -> String {
        format!("{}://{}:{}", self.scheme, self.host, self.port)
    }

    pub fn socket_addr(&self) -> RoadsterResult<SocketAddr> {
        let addr = self.url().parse()?;
        Ok(addr)
    }
}

#[cfg(test)]
mod tests {
    use crate::config::service::common::address::Address;
    use crate::testing::snapshot::TestCase;
    use insta::assert_debug_snapshot;
    use rstest::{fixture, rstest};
    use url::Url;

    #[fixture]
    #[cfg_attr(coverage_nightly, coverage(off))]
    fn case() -> TestCase {
        Default::default()
    }

    #[rstest]
    #[case(
        r#"
        scheme = "https"
        host = "example.com"
        port = 3000
        "#
    )]
    #[case(
        r#"
        scheme = "https"
        host = "localhost"
        port = 3000
        "#
    )]
    #[cfg_attr(coverage_nightly, coverage(off))]
    fn url_str(_case: TestCase, #[case] address: &str) {
        let addr: Address = toml::from_str(address).unwrap();

        let url_str = addr.url();

        assert_debug_snapshot!(url_str);
    }

    #[rstest]
    #[case(
        r#"
        scheme = "http"
        host = "localhost"
        port = 1234
        "#
    )]
    #[case(
        r#"
        scheme = "https"
        host = "[::]"
        port = 3000
        "#
    )]
    #[cfg_attr(coverage_nightly, coverage(off))]
    fn url_with_scheme(_case: TestCase, #[case] address: &str) {
        let addr: Address = toml::from_str(address).unwrap();

        let url: Result<Url, _> = addr.url_with_scheme().parse();

        assert_debug_snapshot!(url);
    }

    #[rstest]
    #[case(
        r#"
        scheme = "http"
        host = "localhost"
        port = 1234
        "#
    )]
    #[case(
        r#"
        scheme = "https"
        host = "[::]"
        port = 3000
        "#
    )]
    #[cfg_attr(coverage_nightly, coverage(off))]
    fn socket_addr(_case: TestCase, #[case] address: &str) {
        let addr: Address = toml::from_str(address).unwrap();

        let addr = addr.socket_addr();

        assert_debug_snapshot!(addr);
    }
}