restson 1.5.0

Easy-to-use REST client with automatic serialization and deserialization.
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
125
126
127
128
129
130
131
132
133
134
135
136
137

use restson::{Error, RestClient, RestPath};
use serde_derive::Deserialize;
use std::time::Duration;

#[derive(Deserialize)]
struct HttpBinAnything {
    url: String,
    args: HttpBinAnythingArgs,
}

#[derive(Deserialize)]
struct HttpRelativePath {
    url: String,
}

#[derive(Deserialize)]
struct HttpBinAnythingArgs {
    #[serde(default)]
    a: String,
    #[serde(default)]
    b: String,
}

impl RestPath<()> for HttpBinAnything {
    fn get_path(_: ()) -> Result<String, Error> {
        Ok(String::from("anything"))
    }
}

impl RestPath<u32> for HttpBinAnything {
    fn get_path(param: u32) -> Result<String, Error> {
        Ok(format!("anything/{}", param))
    }
}

impl<'a> RestPath<(u32, &'a str)> for HttpBinAnything {
    fn get_path(param: (u32, &str)) -> Result<String, Error> {
        let (a, b) = param;
        Ok(format!("anything/{}/{}", a, b))
    }
}

impl RestPath<()> for HttpRelativePath {
    fn get_path(_: ()) -> Result<String, Error> {
        Ok(String::from("test"))
    }
}

#[tokio::test]
async fn basic_get_builder() {
    let client = RestClient::builder()
        .timeout(Duration::from_secs(10))
        .send_null_body(false)
        .build("https://httpbin.org")
        .unwrap();

    let data = client.get::<_, HttpBinAnything>(()).await.unwrap();
    assert_eq!(data.url, "https://httpbin.org/anything");
}

#[tokio::test]
async fn basic_get_https() {
    let client = RestClient::new("https://httpbin.org").unwrap();

    let data = client.get::<_, HttpBinAnything>(()).await.unwrap();
    assert_eq!(data.url, "https://httpbin.org/anything");
}

#[tokio::test]
async fn get_path_param() {
    let client = RestClient::new("https://httpbin.org").unwrap();

    let data = client.get::<_, HttpBinAnything>(1234).await.unwrap();
    assert_eq!(data.url, "https://httpbin.org/anything/1234");
}

#[tokio::test]
async fn get_concurrent() {
    let client = RestClient::new("https://httpbin.org").unwrap();

    let (data1, data2, data3) = tokio::try_join!(
        client.get::<_, HttpBinAnything>(1),
        client.get::<_, HttpBinAnything>(2),
        client.get::<_, HttpBinAnything>(3)
    ).unwrap();

    assert_eq!(data1.url, "https://httpbin.org/anything/1");
    assert_eq!(data2.url, "https://httpbin.org/anything/2");
    assert_eq!(data3.url, "https://httpbin.org/anything/3");
}

#[tokio::test]
async fn get_multi_path_param() {
    let client = RestClient::new("https://httpbin.org").unwrap();

    let data = client.get::<_, HttpBinAnything>((1234, "abcd")).await.unwrap();
    assert_eq!(data.url, "https://httpbin.org/anything/1234/abcd");
}

#[tokio::test]
async fn get_query_params() {
    let client = RestClient::new("https://httpbin.org").unwrap();

    let params = vec![("a", "2"), ("b", "abcd")];
    let data = client.get_with::<_, HttpBinAnything>((), &params).await.unwrap();

    assert_eq!(data.url, "https://httpbin.org/anything?a=2&b=abcd");
    assert_eq!(data.args.a, "2");
    assert_eq!(data.args.b, "abcd");
}

#[tokio::test]
async fn relative_path() {
    // When using relative paths, the base path should end with '/'. Otherwise
    // the Url crate join() will replace the last element instead of appending
    // the path returned from get_path().
    let client = RestClient::new("https://httpbin.org/anything/api/").unwrap();

    let data = client.get::<_, HttpRelativePath>(()).await.unwrap();
    assert_eq!(data.url, "https://httpbin.org/anything/api/test");
}


#[tokio::test]
async fn body_wash_fn() {
    let mut client = RestClient::new("https://httpbin.org").unwrap();

    // Ignore the JSON returned by the server and return a static test
    // JSON from the body wash fn so it is easy to detect it was called.
    let body_wash_fn = |_body: String| -> String {
        String::from("{\"url\": \"from body wash fn\", \"args\": {}}")
    };
    client.set_body_wash_fn(body_wash_fn);

    let data = client.get::<_, HttpBinAnything>(()).await.unwrap();
    assert_eq!(data.url, "from body wash fn");
}