fierros-core 1.0.0

Provider-neutral core primitives for Fierros
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

use crate::{FierrosError, FierrosResult};
use async_trait::async_trait;
use reqwest::header::{HeaderName, HeaderValue};
use serde_json::Value;

#[derive(Debug, Clone, PartialEq)]
pub struct JsonHttpRequest {
    pub url: String,
    pub headers: Vec<(String, String)>,
    pub body: Value,
}

#[async_trait]
pub trait JsonHttpClient: Send + Sync {
    async fn post_json(&self, request: JsonHttpRequest) -> FierrosResult<Value>;
}

#[derive(Debug, Clone, Default)]
pub struct ReqwestJsonHttpClient {
    client: reqwest::Client,
}

impl ReqwestJsonHttpClient {
    pub fn new(client: reqwest::Client) -> Self {
        Self { client }
    }
}

#[async_trait]
impl JsonHttpClient for ReqwestJsonHttpClient {
    async fn post_json(&self, request: JsonHttpRequest) -> FierrosResult<Value> {
        let mut builder = self.client.post(&request.url);
        for (name, value) in &request.headers {
            let header_name = HeaderName::from_bytes(name.as_bytes()).map_err(|error| {
                FierrosError::Configuration(format!("invalid HTTP header name '{name}': {error}"))
            })?;
            let header_value = HeaderValue::from_str(value).map_err(|error| {
                FierrosError::Configuration(format!(
                    "invalid HTTP header value for '{name}': {error}"
                ))
            })?;
            builder = builder.header(header_name, header_value);
        }

        let response = builder
            .json(&request.body)
            .send()
            .await
            .map_err(|error| FierrosError::Provider(format!("request failed: {error}")))?;

        let status = response.status();
        let body_text = response.text().await.map_err(|error| {
            FierrosError::Provider(format!("failed to read response body: {error}"))
        })?;
        if !status.is_success() {
            return Err(FierrosError::Provider(format!(
                "HTTP {} from '{}': {body_text}",
                status.as_u16(),
                request.url
            )));
        }

        serde_json::from_str(&body_text).map_err(|error| {
            FierrosError::Provider(format!("response body was not valid JSON: {error}"))
        })
    }
}

#[cfg(test)]
mod tests {
    use super::{JsonHttpClient, JsonHttpRequest, ReqwestJsonHttpClient};
    use crate::FierrosError;
    use serde_json::json;

    #[tokio::test]
    async fn reqwest_client_constructor_accepts_custom_client() {
        let client = ReqwestJsonHttpClient::new(reqwest::Client::new());
        let error = client
            .post_json(JsonHttpRequest {
                url: "http://127.0.0.1:1".into(),
                headers: vec![("invalid header".into(), "token".into())],
                body: json!({}),
            })
            .await
            .unwrap_err();

        assert!(matches!(error, FierrosError::Configuration(_)));
    }

    #[tokio::test]
    async fn post_json_surfaces_request_errors_for_invalid_url() {
        let client = ReqwestJsonHttpClient::default();
        let error = client
            .post_json(JsonHttpRequest {
                url: "::://not-a-valid-url".into(),
                headers: vec![],
                body: json!({ "query": "status" }),
            })
            .await
            .unwrap_err();

        assert!(matches!(error, FierrosError::Provider(_)));
        assert!(error.to_string().contains("request failed"));
    }

    #[tokio::test]
    async fn post_json_rejects_invalid_header_name() {
        let client = ReqwestJsonHttpClient::default();
        let error = client
            .post_json(JsonHttpRequest {
                url: "http://127.0.0.1:1".into(),
                headers: vec![("invalid header".into(), "token".into())],
                body: json!({}),
            })
            .await
            .unwrap_err();

        assert!(matches!(error, FierrosError::Configuration(_)));
        assert!(error.to_string().contains("invalid HTTP header name"));
    }

    #[tokio::test]
    async fn post_json_rejects_invalid_header_value() {
        let client = ReqwestJsonHttpClient::default();
        let error = client
            .post_json(JsonHttpRequest {
                url: "http://127.0.0.1:1".into(),
                headers: vec![("x-auth-token".into(), "bad\nvalue".into())],
                body: json!({ "query": "status" }),
            })
            .await
            .unwrap_err();

        assert!(matches!(error, FierrosError::Configuration(_)));
        assert!(error
            .to_string()
            .contains("invalid HTTP header value for 'x-auth-token'"));
    }
}