rh 0.1.14

A user-friendly command-line tool to request HTTP APis
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

use crate::request::Method;

pub fn from_str(keyword: &str) -> Option<Method> {
    if !is_valid(keyword) {
        return None;
    }

    let method = reqwest::Method::from_bytes(keyword.as_bytes());
    match method {
        Ok(m) => Some(m),
        _ => None,
    }
}

fn is_valid(keyword: &str) -> bool {
    for c in keyword.chars() {
        if !c.is_uppercase() {
            return false;
        }
    }
    true
}

// fn is_standard(keyword: &str) -> bool {
//     let length = keyword.len();
//     if length != 3 && length != 4 && length != 5 && length != 6 && length != 7 {
//         return false;
//     }
//     [
//         "GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "CONNECT", "PATCH", "TRACE",
//     ]
//     .contains(&keyword)
// }

// UNIT TESTS /////////////////////////////////////////////////////////////////////////////

#[cfg(test)]
mod tests {
    use super::{from_str, Method};

    macro_rules! assert_standard_method_eq {
        ($method:expr, $expected:expr) => {
            assert_eq!(from_str($method).unwrap(), $expected)
        };
    }

    macro_rules! assert_standard_method_invalid {
        ($method:expr) => {
            assert!(from_str($method).is_none())
        };
    }

    #[test]
    fn standard() {
        assert_standard_method_eq!("GET", Method::GET);
        assert_standard_method_eq!("POST", Method::POST);
        assert_standard_method_eq!("PUT", Method::PUT);
        assert_standard_method_eq!("DELETE", Method::DELETE);
        assert_standard_method_eq!("HEAD", Method::HEAD);
        assert_standard_method_eq!("OPTIONS", Method::OPTIONS);
        assert_standard_method_eq!("CONNECT", Method::CONNECT);
        assert_standard_method_eq!("PATCH", Method::PATCH);
        assert_standard_method_eq!("TRACE", Method::TRACE);
    }

    #[test]
    fn custom() {
        assert_standard_method_eq!("HELLO", Method::from_bytes(b"HELLO").unwrap());
        assert_standard_method_eq!("WORLD", Method::from_bytes(b"WORLD").unwrap());
    }

    #[test]
    fn invalid() {
        assert_standard_method_invalid!("test");

        assert_standard_method_invalid!("get");
        assert_standard_method_invalid!("post");
        assert_standard_method_invalid!("put");
        assert_standard_method_invalid!("delete");
        assert_standard_method_invalid!("head");
        assert_standard_method_invalid!("options");
        assert_standard_method_invalid!("connect");
        assert_standard_method_invalid!("patch");
        assert_standard_method_invalid!("trace");
    }
}