gette 0.0.2

A Rust library for getting "things"
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

pub struct S3;

impl crate::Detector for S3 {
    fn detect(&self, path: &str) -> Result<Option<String>, crate::Error> {
        if path.contains("amazonaws.com/") {
            return self.detect_http(path);
        }

        Ok(None)
    }
}

impl S3 {
    fn detect_http(&self, path: &str) -> Result<Option<String>, crate::Error> {
        let parts: Vec<&str> = path.split('/').collect();
        if parts.len() < 2 {
            return Err(crate::Error::InvalidUrl(
                path.to_string(),
                "not a valid s3 url".to_string(),
            ));
        }

        let host: Vec<&str> = parts[0].split('.').collect();
        match host.len() {
            3 => self.region_path_style(host[0], parts[1..].to_vec()),
            4 => self.vhost_path_style(host[1], host[0], parts[1..].to_vec()),
            5 if host[1] == "s3" => {
                self.new_vhost_path_style(host[2], host[0], parts[1..].to_vec())
            }
            _ => Err(crate::Error::InvalidUrl(
                path.to_string(),
                "not a valid s3 url".to_string(),
            )),
        }
    }

    fn region_path_style(
        &self,
        region: &str,
        parts: Vec<&str>,
    ) -> Result<Option<String>, crate::Error> {
        let url_string = format!("https://{}.amazonaws.com/{}", region, parts.join("/"));
        let url_parsed = url::Url::parse(url_string.as_str())?;
        Ok(Some(format!("s3+{}", url_parsed)))
    }

    fn vhost_path_style(
        &self,
        region: &str,
        bucket: &str,
        parts: Vec<&str>,
    ) -> Result<Option<String>, crate::Error> {
        let url_string = format!(
            "https://{}.amazonaws.com/{}/{}",
            region,
            bucket,
            parts.join("/")
        );
        let url_parsed = url::Url::parse(url_string.as_str())?;
        Ok(Some(format!("s3+{}", url_parsed)))
    }

    fn new_vhost_path_style(
        &self,
        region: &str,
        bucket: &str,
        parts: Vec<&str>,
    ) -> Result<Option<String>, crate::Error> {
        let url_string = format!(
            "https://s3.{}.amazonaws.com/{}/{}",
            region,
            bucket,
            parts.join("/")
        );
        let url_parsed = url::Url::parse(url_string.as_str())?;
        Ok(Some(format!("s3+{}", url_parsed)))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::Detector;

    #[test]
    fn it_should_decode_all_valid_variants_of_s3_urls() {
        let d = S3;
        let tests = vec![
            (
                "test.us-east-2.amazonaws.com/test.txt",
                "s3+https://us-east-2.amazonaws.com/test/test.txt",
            ),
            (
                "test.s3.us-east-2.amazonaws.com/test.txt",
                "s3+https://s3.us-east-2.amazonaws.com/test/test.txt",
            ),
            (
                "us-east-2.amazonaws.com/test/test.txt",
                "s3+https://us-east-2.amazonaws.com/test/test.txt",
            ),
        ];

        for test in tests {
            let res = d.detect(test.0).unwrap();
            assert!(res.is_some());
            assert_eq!(res, Some(test.1.to_string()));
        }
    }

    #[test]
    fn it_should_fail_on_invalid_s3_urls() {
        let d = S3;
        let tests = vec![
            "wrong.test.us-east-2.amazonaws.com/test.txt",
            "amazonaws.com/test.txt",
        ];

        for test in tests {
            let res = d.detect(test);
            println!("test: ({}) => {:#?}", test, res);
            assert!(res.is_err());
        }
    }
}