polyphony-chat / polyproto-rs / #8

Committed 23 Feb 2025 10:48AM UTC coverage: 68.198% (-8.2%) from 76.367%

Build # #8

Build Type

push

Committed by

Commit Message

Use LLVM and no-dead-code as recommended by tarpaulin for linux

Run Details

980 of 1437 relevant lines covered (68.2%)

30.71 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

38.1

/src/api/mod.rs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

use serde::Deserialize;
use serde_json::from_str;
use url::Url;

use crate::errors::RequestError;

/// The `core` module contains all API routes for implementing the core polyproto protocol in a client or server.
pub mod core;

#[derive(Debug, Clone)]
/// A client for making HTTP requests to a polyproto home server. Stores headers such as the
/// authentication token, and the base URL of the server. Both the headers and the URL can be
/// modified after the client is created. However, the intended use case is to create one client
/// per actor, and use it for all requests made by that actor.
///
/// # Example
///
/// ```rs
/// let mut header_map = reqwest::header::HeaderMap::new();
/// header_map.insert("Authorization", "nx8r902hjkxlo2n8n72x0");
/// let client = HttpClient::new("https://example.com").unwrap();
/// client.headers(header_map);
///
/// let challenge: ChallengeString = client.get_challenge_string().await.unwrap();
/// ```
pub struct HttpClient {
    /// The reqwest client used to make requests.
    pub client: reqwest::Client,
    headers: reqwest::header::HeaderMap,
    version: http::Version, //TODO: Allow setting HTTP version?
    pub(crate) url: Url,
    zstd_compression: bool,
}

/// A type alias for the result of an HTTP request.
pub type HttpResult<T> = Result<T, RequestError>;

impl HttpClient {
    /// Creates a new instance of the client with no further configuration. To access routes which
    /// require authentication, you must set the authentication header using the `headers` method.
    ///
    /// # Arguments
    ///
    /// * `url` - The base URL of a polyproto home server.
    ///
    /// # Errors
    ///
    /// Will fail if the URL is invalid or if there are issues creating the reqwest client.
    pub fn new(url: &str) -> HttpResult<Self> {
        let client = reqwest::ClientBuilder::new()
            .zstd(true)
            .user_agent(format!("polyproto-rs/{}", env!("CARGO_PKG_VERSION")))
            .build()?;
        let headers = reqwest::header::HeaderMap::new();
        let url = Url::parse(url)?;
        let version = http::Version::HTTP_11;

        Ok(Self {
            client,
            headers,
            url,
            version,
            zstd_compression: true,
        })
    }

    /// Creates a new instance of the client with the specified arguments. To access routes which
    /// require authentication, you must set an authentication header.
    ///
    /// # Arguments
    ///
    /// * `url` - The base URL of a polyproto home server.
    /// * `headers`: [reqwest::header::HeaderMap]
    /// * `version`: Version of the HTTP spec
    /// * `zstd_compression`: Whether to use zstd compression for responses.
    ///
    /// # Errors
    ///
    /// Will fail if the URL is invalid or if there are issues creating the reqwest client.
    pub fn new_with_args(
        url: &str,
        headers: reqwest::header::HeaderMap,
        version: http::Version,
        zstd_compression: bool,
    ) -> HttpResult<Self> {
        let client = reqwest::ClientBuilder::new()
            .zstd(zstd_compression)
            .user_agent(format!("polyproto-rs/{}", env!("CARGO_PKG_VERSION")))
            .build()?;
        let url = Url::parse(url)?;
        Ok(Self {
            client,
            headers,
            version,
            url,
            zstd_compression,
        })
    }

    /// Sets the headers for the client.
    pub fn headers(&mut self, headers: reqwest::header::HeaderMap) {
        self.headers = headers;
    }

    /// Returns the URL
    pub fn url(&self) -> String {
        self.url.to_string()
    }

    /// Sets the base URL of the client.
    pub fn set_url(&mut self, url: &str) -> HttpResult<()> {
        self.url = Url::parse(url)?;
        Ok(())
    }

    /// Sends a request and returns the response.
    pub async fn request<T: Into<reqwest::Body>>(
        &self,
        method: reqwest::Method,
        url: &str,
        body: Option<T>,
    ) -> HttpResult<reqwest::Response> {
        Url::parse(url)?;
        let mut request = self.client.request(method, url);
        request = request.headers(self.headers.clone());
        if let Some(body) = body {
            request = request.body(body);
        }
        Ok(request.send().await?)
    }

    /// Sends a request, handles the response, and returns the deserialized object.
    pub(crate) async fn handle_response<T: for<'a> Deserialize<'a>>(
        response: Result<reqwest::Response, reqwest::Error>,
    ) -> Result<T, RequestError> {
        let response = response?;
        let response_text = response.text().await?;
        let object = from_str::<T>(&response_text)?;
        Ok(object)
    }
}

1	// This Source Code Form is subject to the terms of the Mozilla Public
2	// License, v. 2.0. If a copy of the MPL was not distributed with this
3	// file, You can obtain one at https://mozilla.org/MPL/2.0/.
4
5	use serde::Deserialize;
6	use serde_json::from_str;
7	use url::Url;
8
9	use crate::errors::RequestError;
10
11	/// The `core` module contains all API routes for implementing the core polyproto protocol in a client or server.
12	pub mod core;
13
14	#[derive(Debug, Clone)]
15	/// A client for making HTTP requests to a polyproto home server. Stores headers such as the
16	/// authentication token, and the base URL of the server. Both the headers and the URL can be
17	/// modified after the client is created. However, the intended use case is to create one client
18	/// per actor, and use it for all requests made by that actor.
19	///
20	/// # Example
21	///
22	/// ```rs
23	/// let mut header_map = reqwest::header::HeaderMap::new();
24	/// header_map.insert("Authorization", "nx8r902hjkxlo2n8n72x0");
25	/// let client = HttpClient::new("https://example.com").unwrap();
26	/// client.headers(header_map);
27	///
28	/// let challenge: ChallengeString = client.get_challenge_string().await.unwrap();
29	/// ```
30	pub struct HttpClient {
31	/// The reqwest client used to make requests.
32	pub client: reqwest::Client,
33	headers: reqwest::header::HeaderMap,
34	version: http::Version, //TODO: Allow setting HTTP version?
35	pub(crate) url: Url,
36	zstd_compression: bool,
37	}
38
39	/// A type alias for the result of an HTTP request.
40	pub type HttpResult<T> = Result<T, RequestError>;
41
42	impl HttpClient {
43	/// Creates a new instance of the client with no further configuration. To access routes which
44	/// require authentication, you must set the authentication header using the `headers` method.
45	///
46	/// # Arguments
47	///
48	/// * `url` - The base URL of a polyproto home server.
49	///
50	/// # Errors
51	///
52	/// Will fail if the URL is invalid or if there are issues creating the reqwest client.
53	pub fn new(url: &str) -> HttpResult<Self> {	17✔
54	let client = reqwest::ClientBuilder::new()	34✔
55	.zstd(true)
56	.user_agent(format!("polyproto-rs/{}", env!("CARGO_PKG_VERSION")))	17✔
57	.build()?;
58	let headers = reqwest::header::HeaderMap::new();	×
59	let url = Url::parse(url)?;	17✔
60	let version = http::Version::HTTP_11;	17✔
61
62	Ok(Self {	17✔
63	client,	17✔
64	headers,	17✔
65	url,	17✔
66	version,	17✔
67	zstd_compression: true,	17✔
68	})
69	}
70
71	/// Creates a new instance of the client with the specified arguments. To access routes which
72	/// require authentication, you must set an authentication header.
73	///
74	/// # Arguments
75	///
76	/// * `url` - The base URL of a polyproto home server.
77	/// * `headers`: [reqwest::header::HeaderMap]
78	/// * `version`: Version of the HTTP spec
79	/// * `zstd_compression`: Whether to use zstd compression for responses.
80	///
81	/// # Errors
82	///
83	/// Will fail if the URL is invalid or if there are issues creating the reqwest client.
84	pub fn new_with_args(	×
85	url: &str,
86	headers: reqwest::header::HeaderMap,
87	version: http::Version,
88	zstd_compression: bool,
89	) -> HttpResult<Self> {
90	let client = reqwest::ClientBuilder::new()	×
91	.zstd(zstd_compression)	×
92	.user_agent(format!("polyproto-rs/{}", env!("CARGO_PKG_VERSION")))	×
93	.build()?;
94	let url = Url::parse(url)?;	×
95	Ok(Self {	×
96	client,	×
97	headers,	×
98	version,	×
99	url,	×
100	zstd_compression,	×
101	})
102	}
103
104	/// Sets the headers for the client.
105	pub fn headers(&mut self, headers: reqwest::header::HeaderMap) {	×
106	self.headers = headers;	×
107	}
108
109	/// Returns the URL
110	pub fn url(&self) -> String {	×
111	self.url.to_string()	×
112	}
113
114	/// Sets the base URL of the client.
115	pub fn set_url(&mut self, url: &str) -> HttpResult<()> {	×
116	self.url = Url::parse(url)?;	×
117	Ok(())	×
118	}
119
120	/// Sends a request and returns the response.
121	pub async fn request<T: Into<reqwest::Body>>(	×
122	&self,
123	method: reqwest::Method,
124	url: &str,
125	body: Option<T>,
126	) -> HttpResult<reqwest::Response> {
127	Url::parse(url)?;	×
128	let mut request = self.client.request(method, url);	×
129	request = request.headers(self.headers.clone());	×
130	if let Some(body) = body {	×
131	request = request.body(body);	×
132	}
133	Ok(request.send().await?)	×
134	}
135
136	/// Sends a request, handles the response, and returns the deserialized object.
137	pub(crate) async fn handle_response<T: for<'a> Deserialize<'a>>(	17✔
138	response: Result<reqwest::Response, reqwest::Error>,
139	) -> Result<T, RequestError> {
140	let response = response?;	34✔
141	let response_text = response.text().await?;	17✔
142	let object = from_str::<T>(&response_text)?;	34✔
143	Ok(object)	17✔
144	}
145	}

polyphony-chat / polyproto-rs / #8

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous