rrw 0.1.2

A crate to easily build clients for REST-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

//! Authentication of requests
//!
//! The general interface for authenticating requests is the [Authenticator]. One example
//! implementation is the [HeaderAuthenticator] that sets the authentication in the header.
use reqwest::RequestBuilder;

/// Authenticate a request.
pub trait Authenticator {
    /// Modify a [RequestBuilder] to be authenticated.
    fn authenticate(&self, request: RequestBuilder) -> RequestBuilder;
}

/// Authenticate a request by setting a key-value pair in the head of the request.
pub struct HeaderAuthenticator {
    key: String,
    token: String,
}

impl HeaderAuthenticator {
    /// Create a new [HeaderAuthenticator] with the given header key (usually `Authentication`,
    /// `PRIVATE-TOKEN` or similar) and the value as the given token.
    pub fn new<S1: AsRef<str>, S2: AsRef<str>>(key: S1, token: S2) -> Self {
        Self {
            key: key.as_ref().to_owned(),
            token: token.as_ref().to_owned(),
        }
    }
}

impl Authenticator for HeaderAuthenticator {
    fn authenticate(&self, request: RequestBuilder) -> RequestBuilder {
        request.header(&self.key, &self.token)
    }
}

#[cfg(test)]
mod test {
    use crate::{Error, RestConfigBuilder, RestRequest, StandardRestError};

    use super::*;

    use httpmock::prelude::*;
    use serde::{Deserialize, Serialize};

    #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
    struct Json {
        key: String,
    }

    #[tokio::test]
    async fn header_authenticator() -> Result<(), Error<StandardRestError>> {
        let server = MockServer::start();

        let mock = server.mock(|when, then| {
            when.method(GET)
                .path("/test")
                .header("PRIVATE-TOKEN", "123456");
            then.status(200)
                .header("content-type", "application/json; charset=UTF-8")
                .body(r#"{"key":"value"}"#);
        });

        let authenticator = HeaderAuthenticator::new("PRIVATE-TOKEN", "123456");

        let config = RestConfigBuilder::new(server.base_url())
            .authenticator(authenticator)
            .build();
        let query: Json = config
            .execute(&RestRequest::<(), ()>::get("/test").authenticate())
            .await?;

        mock.assert();
        assert_eq!(
            query,
            Json {
                key: "value".to_string()
            }
        );

        Ok(())
    }
}