pretend 0.4.0

pretend is a modular, Feign-inspired, HTTP client based on macros.
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

mod runtimes;
mod server;

use pretend::{pretend, Json, Pretend, Result, Url};
use pretend_reqwest::Client;
use std::collections::HashMap;

#[pretend]
trait TestApi {
    #[request(method = "GET", path = "/method")]
    async fn get(&self) -> Result<String>;
    #[request(method = "POST", path = "/method")]
    async fn post(&self) -> Result<String>;
    #[request(method = "PUT", path = "/method")]
    async fn put(&self) -> Result<String>;
    #[request(method = "PATCH", path = "/method")]
    async fn patch(&self) -> Result<String>;
    #[request(method = "DELETE", path = "/method")]
    async fn delete(&self) -> Result<String>;
    #[request(method = "GET", path = "/query")]
    async fn query(&self, query: &server::TestData) -> Result<Json<HashMap<String, String>>>;
    #[request(method = "GET", path = "/headers")]
    #[header(name = "X-Test-Header-1", value = "abc")]
    #[header(name = "X-Test-Header-2", value = "{value}")]
    #[header(name = "X-{custom}", value = "custom")]
    async fn headers(&self, value: i32, custom: &str) -> Result<Json<HashMap<String, String>>>;
    #[request(method = "POST", path = "/post/string")]
    #[header(name = "Content-Type", value = "text/plain")]
    async fn post_string(&self, body: &'static str) -> Result<String>;
    #[request(method = "POST", path = "/post/json")]
    async fn post_json(&self, json: &server::TestData) -> Result<Json<server::TestData>>;
    #[request(method = "POST", path = "/post/form")]
    async fn post_form(&self, form: &server::TestData) -> Result<Json<server::TestData>>;
}

fn new_pretend() -> impl TestApi {
    let url = Url::parse(server::URL).unwrap();
    let client = Client::default();
    Pretend::for_client(client).with_url(url)
}

#[test]
fn test_pretend() {
    server::test(|| {
        runtimes::block_on(async {
            test_get().await;
            test_post().await;
            test_put().await;
            test_patch().await;
            test_delete().await;

            test_query().await;
            test_headers().await;
            test_post_string().await;
            test_post_json().await;
            test_post_form().await;
        })
    });
}

async fn test_get() {
    let result = new_pretend().get().await;
    assert!(result.is_ok());
}

async fn test_post() {
    let result = new_pretend().post().await;
    assert!(result.is_ok());
}

async fn test_put() {
    let result = new_pretend().put().await;
    assert!(result.is_ok());
}

async fn test_patch() {
    let result = new_pretend().patch().await;
    assert!(result.is_ok());
}

async fn test_delete() {
    let result = new_pretend().delete().await;
    assert!(result.is_ok());
}

async fn test_query() {
    let query = server::TestData {
        first: "Hello".to_string(),
        second: 123,
    };

    let expected_args = [("first", "Hello"), ("second", "123")]
        .iter()
        .map(|(key, value)| (key.to_string(), value.to_string()))
        .collect::<HashMap<_, _>>();

    let result = new_pretend().query(&query).await.unwrap();
    assert_eq!(result.value(), expected_args);
}

async fn test_headers() {
    let result = new_pretend().headers(123, "test").await.unwrap();
    let headers = result.value();
    assert_eq!(headers.get("x-test-header-1").unwrap(), "abc");
    assert_eq!(headers.get("x-test-header-2").unwrap(), "123");
    assert_eq!(headers.get("x-test").unwrap(), "custom");
}

async fn test_post_string() {
    let expected = "Hello";
    let result = new_pretend().post_string(expected).await.unwrap();
    assert_eq!(expected, result);
}

async fn test_post_json() {
    let json = server::TestData {
        first: "Hello".to_string(),
        second: 123,
    };
    let result = new_pretend().post_json(&json).await.unwrap();
    assert_eq!(result.value(), json);
}

async fn test_post_form() {
    let json = server::TestData {
        first: "Hello".to_string(),
        second: 123,
    };
    let result = new_pretend().post_form(&json).await.unwrap();
    assert_eq!(result.value(), json);
}