feignhttp 0.5.2

Declarative HTTP client for rust
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

#![allow(dead_code)]
#![allow(unused_imports)]

use feignhttp::{HttpClient, HttpResponse};

use mockito::{mock, server_address};
use serde::Deserialize;

#[tokio::test]
async fn test_response() {
    let _mock = mock("GET", "/").with_status(200).create();

    let url = format!("http://{}", server_address());
    let method = "GET";
    let request = HttpClient::builder()
        .url(&url)
        .method(method)
        .build()
        .unwrap();
    let response = request.send().await.unwrap();

    assert_eq!(200, response.status().as_u16());
}

#[tokio::test]
async fn test_get_text() {
    let _mock = mock("GET", "/text").with_body("Hello, i' m text").create();

    let url = format!("http://{}/text", server_address());
    let method = "GET";
    let request = HttpClient::builder()
        .url(&url)
        .method(method)
        .build()
        .unwrap();
    let response = request.send().await.unwrap();
    let text = response.text().await.unwrap();

    assert_eq!("Hello, i' m text", text);
}

#[tokio::test]
async fn test_get_json() {
    #[cfg(feature = "json")]
    {
        let _mock = mock("GET", "/json")
            .with_body(r#"{ "code": 200, "message": "success" }"#)
            .create();

        #[derive(Debug, Deserialize)]
        struct User {
            code: u32,
            message: String,
        }

        let url = format!("http://{}/json", server_address());
        let method = "GET";
        let request = HttpClient::builder()
            .url(&url)
            .method(method)
            .build()
            .unwrap();
        let response = request.send().await.unwrap();
        let user: User = response.json().await.unwrap();

        assert_eq!(
            r#"User { code: 200, message: "success" }"#,
            format!("{:?}", user)
        );
    }
}

#[tokio::test]
async fn test_get_vec() {
    let _mock = mock("GET", "/vec")
        .with_header("content-type", "application/octet-stream")
        .with_body(r#"aaa"#)
        .create();

    let url = format!("http://{}/vec", server_address());
    let method = "GET";
    let request = HttpClient::builder()
        .url(&url)
        .method(method)
        .build()
        .unwrap();
    let response = request.send().await.unwrap();
    let vec = response.vec().await.unwrap();

    assert_eq!(vec![97, 97, 97], vec);
}

#[tokio::test]
#[should_panic]
async fn test_client_error() {
    let _mock = mock("GET", "/").with_status(404).create();

    let url = format!("http://{}", server_address());
    let method = "GET";
    let request = HttpClient::builder()
        .url(&url)
        .method(method)
        .build()
        .unwrap();
    let _response = request.send().await.unwrap();
}

#[tokio::test]
#[should_panic]
async fn test_server_error() {
    let _mock = mock("GET", "/").with_status(503).create();

    let url = format!("http://{}", server_address());
    let method = "GET";
    let request = HttpClient::builder()
        .url(&url)
        .method(method)
        .build()
        .unwrap();
    let _response = request.send().await.unwrap();
}