apisdk 0.0.6

An easy-to-use API toolkit for writing HTTP API Clients 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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use apisdk::{
    send, AccessTokenSignature, ApiResult, ApiSignature, Carrier, CodeDataMessage,
    HashedTokenSignature, SignatureTrait, TokenProvider,
};
use async_trait::async_trait;
use base64::{engine::general_purpose, Engine};
use reqwest::{header::AUTHORIZATION, Request};

use crate::common::{init_logger, start_server, Payload, TheApi};

mod common;

impl TheApi {
    async fn touch(&self) -> ApiResult<Payload> {
        let req = self.get("/path/json").await?;
        send!(req, CodeDataMessage).await
    }
}

#[tokio::test]
async fn test_access_token_auth_fixed() -> ApiResult<()> {
    init_logger();
    start_server().await;

    let api = TheApi::builder()
        .with_signature(AccessTokenSignature::new("fixed"))
        .build();

    let res = api.touch().await?;
    log::debug!("res = {:?}", res);
    let auth = res.headers.get("authorization").unwrap();
    assert_eq!("Bearer fixed", auth);

    Ok(())
}

#[tokio::test]
async fn test_access_token_auth_dynamic() -> ApiResult<()> {
    init_logger();
    start_server().await;

    let api = TheApi::builder()
        .with_signature(AccessTokenSignature::new_dynamic(|| Ok("dynamic")))
        .build();

    let res = api.touch().await?;
    log::debug!("res = {:?}", res);
    let auth = res.headers.get(AUTHORIZATION.as_str()).unwrap();
    assert_eq!("Bearer dynamic", auth);

    Ok(())
}

#[tokio::test]
async fn test_access_token_auth_in_header() -> ApiResult<()> {
    init_logger();
    start_server().await;

    let api = TheApi::builder()
        .with_signature(AccessTokenSignature::new("fixed").with_header_name("x-auth"))
        .build();

    let res = api.touch().await?;
    log::debug!("res = {:?}", res);
    let auth = res.headers.get("x-auth").unwrap();
    assert_eq!("fixed", auth);

    Ok(())
}

#[tokio::test]
async fn test_access_token_auth_schemeless() -> ApiResult<()> {
    init_logger();
    start_server().await;

    struct Schemeless {}

    #[async_trait]
    impl TokenProvider for Schemeless {
        async fn generate_token(
            &self,
            _req: &Request,
        ) -> Result<String, reqwest_middleware::Error> {
            Ok("token".to_string())
        }
    }
    #[async_trait]
    impl ApiSignature for Schemeless {
        fn get_carrier(&self) -> &Carrier {
            &Carrier::SchemelessAuth
        }
    }

    let api = TheApi::builder().with_signature(Schemeless {}).build();

    let res = api.touch().await?;
    log::debug!("res = {:?}", res);
    let auth = res.headers.get(AUTHORIZATION.as_str()).unwrap();
    assert_eq!("token", auth);

    Ok(())
}

#[tokio::test]
async fn test_access_token_auth_in_query() -> ApiResult<()> {
    init_logger();
    start_server().await;

    let api = TheApi::builder()
        .with_signature(AccessTokenSignature::new("fixed").with_query_param("x-auth"))
        .build();

    let res = api.touch().await?;
    log::debug!("res = {:?}", res);
    let auth = res.query.get("x-auth").unwrap();
    assert_eq!("fixed", auth);

    Ok(())
}

#[tokio::test]
async fn test_hashed_token_auth() -> ApiResult<()> {
    init_logger();
    start_server().await;

    let api = TheApi::builder()
        .with_signature(HashedTokenSignature::new("app_id", "app_secret"))
        .build();

    let res = api.touch().await?;
    log::debug!("res = {:?}", res);
    let auth = res.headers.get("authorization").unwrap();
    assert!(auth.starts_with("Bearer "));
    let token = auth.trim_start_matches("Bearer ");
    let decoded = general_purpose::STANDARD.decode(token).unwrap();
    let decoded = String::from_utf8(decoded).unwrap();
    log::debug!("decoded = {}", decoded);
    assert!(decoded.starts_with("app_id,"));

    Ok(())
}