bitwarden_api_key_connector/apis/
user_keys_api.rs

1use std::sync::Arc;
2
3use async_trait::async_trait;
4use bitwarden_api_base::{AuthRequired, Configuration};
5use mockall::automock;
6use reqwest::Method;
7use serde::Serialize;
8
9use crate::{
10    apis::Error,
11    models::{
12        user_key_request_model::UserKeyKeyRequestModel,
13        user_key_response_model::UserKeyResponseModel,
14    },
15};
16
17#[automock]
18#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
19#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
20pub trait UserKeysApi: Send + Sync {
21    /// GET /user-keys
22    async fn get_user_key(&self) -> Result<UserKeyResponseModel, Error>;
23
24    /// POST /user-keys
25    async fn post_user_key(&self, request_model: UserKeyKeyRequestModel) -> Result<(), Error>;
26
27    /// PUT /user-keys
28    async fn put_user_key(&self, request_model: UserKeyKeyRequestModel) -> Result<(), Error>;
29}
30
31pub struct UserKeysApiClient {
32    configuration: Arc<Configuration>,
33}
34
35impl UserKeysApiClient {
36    pub fn new(configuration: Arc<Configuration>) -> Self {
37        Self { configuration }
38    }
39}
40
41#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
42#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
43impl UserKeysApi for UserKeysApiClient {
44    async fn get_user_key(&self) -> Result<UserKeyResponseModel, Error> {
45        let response = request(&self.configuration, Method::GET, None::<()>).await?;
46
47        let body = response.text().await?;
48        let response_model = serde_json::from_str::<UserKeyResponseModel>(&body)?;
49        Ok(response_model)
50    }
51
52    async fn post_user_key(&self, request_model: UserKeyKeyRequestModel) -> Result<(), Error> {
53        request(&self.configuration, Method::POST, Some(request_model)).await?;
54
55        Ok(())
56    }
57
58    async fn put_user_key(&self, request_model: UserKeyKeyRequestModel) -> Result<(), Error> {
59        request(&self.configuration, Method::PUT, Some(request_model)).await?;
60
61        Ok(())
62    }
63}
64
65async fn request(
66    configuration: &Arc<Configuration>,
67    method: Method,
68    body: Option<impl Serialize>,
69) -> Result<reqwest::Response, Error> {
70    let url = format!("{}/user-keys", configuration.base_path);
71
72    let mut request = configuration
73        .client
74        .request(method, url)
75        .header(reqwest::header::CONTENT_TYPE, "application/json")
76        .header(reqwest::header::ACCEPT, "application/json")
77        .with_extension(AuthRequired::Bearer);
78
79    if let Some(ref body) = body {
80        request =
81            request.body(serde_json::to_string(&body).expect("Serialize should be infallible"))
82    }
83
84    let response = request.send().await?;
85
86    Ok(response.error_for_status()?)
87}
88
89#[cfg(test)]
90mod tests {
91    use std::sync::Arc;
92
93    use bitwarden_api_base::Configuration;
94    use wiremock::{
95        Mock, MockServer, ResponseTemplate,
96        matchers::{header, method, path},
97    };
98
99    use crate::{
100        apis::user_keys_api::{UserKeysApi, UserKeysApiClient},
101        models::user_key_request_model::UserKeyKeyRequestModel,
102    };
103
104    const KEY_CONNECTOR_KEY: &str = "test_key_connector_key";
105
106    async fn setup_mock_server_with_auth() -> (MockServer, Configuration) {
107        let server = MockServer::start().await;
108
109        let configuration = Configuration::new(format!("http://{}", server.address()));
110        (server, configuration)
111    }
112
113    #[tokio::test]
114    async fn test_get() {
115        let (server, configuration) = setup_mock_server_with_auth().await;
116
117        Mock::given(method("GET"))
118            .and(path("/user-keys"))
119            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
120                "key": KEY_CONNECTOR_KEY.to_string()
121            })))
122            .expect(1)
123            .mount(&server)
124            .await;
125
126        let api_client = UserKeysApiClient::new(Arc::new(configuration));
127
128        let result = api_client.get_user_key().await;
129
130        assert!(result.is_ok());
131        assert_eq!(KEY_CONNECTOR_KEY, result.unwrap().key);
132    }
133
134    #[tokio::test]
135    async fn test_post() {
136        let (server, configuration) = setup_mock_server_with_auth().await;
137
138        Mock::given(method("POST"))
139            .and(path("/user-keys"))
140            .and(header("content-type", "application/json"))
141            .respond_with(ResponseTemplate::new(200))
142            .expect(1)
143            .mount(&server)
144            .await;
145
146        let request_model = UserKeyKeyRequestModel {
147            key: KEY_CONNECTOR_KEY.to_string(),
148        };
149
150        let api_client = UserKeysApiClient::new(Arc::new(configuration));
151
152        let result = api_client.post_user_key(request_model).await;
153
154        assert!(result.is_ok());
155    }
156
157    #[tokio::test]
158    async fn test_put() {
159        let (server, configuration) = setup_mock_server_with_auth().await;
160
161        Mock::given(method("PUT"))
162            .and(path("/user-keys"))
163            .and(header("content-type", "application/json"))
164            .respond_with(ResponseTemplate::new(200))
165            .expect(1)
166            .mount(&server)
167            .await;
168
169        let request_model = UserKeyKeyRequestModel {
170            key: KEY_CONNECTOR_KEY.to_string(),
171        };
172
173        let api_client = UserKeysApiClient::new(Arc::new(configuration));
174
175        let result = api_client.put_user_key(request_model).await;
176
177        assert!(result.is_ok());
178    }
179}
bitwarden_api_key_connector/apis/user_keys_api.rs

bitwarden_api_key_connector/apis/
user_keys_api.rs
