Send qualified User-Agent to Meilisearch server

Author: brunoocasali

src/client.rs

@@ -656,6 +656,46 @@ mod tests {
     };
     use meilisearch_test_macro::meilisearch_test;
     use time::OffsetDateTime;
+    use mockito::mock;
+    use std::mem;
+
+    #[meilisearch_test]
+    async fn test_methods_has_qualified_version_as_header() {
+        let mock_server_url = &mockito::server_url();
+        let path = "/hello";
+        let address = &format!("{}{}", mock_server_url, path);
+        let user_agent = &*qualified_version();
+
+        let assertions = vec![
+            (
+                mock("GET", path).match_header("User-Agent", user_agent).create(),
+                request::<String, ()>(address, "", Method::Get, 200)
+            ),
+            (
+                mock("POST", path).match_header("User-Agent", user_agent).create(),
+                request::<String, ()>(address, "", Method::Post("".to_string()), 200)
+            ),
+            (
+                mock("DELETE", path).match_header("User-Agent", user_agent).create(),
+                request::<String, ()>(address, "", Method::Delete, 200)
+            ),
+            (
+                mock("PUT", path).match_header("User-Agent", user_agent).create(),
+                request::<String, ()>(address, "", Method::Put("".to_string()), 200)
+            ),
+            (
+                mock("PATCH", path).match_header("User-Agent", user_agent).create(),
+                request::<String, ()>(address, "", Method::Patch("".to_string()), 200)
+            )
+        ];
+
+        for (m, req) in assertions {
+            let _ = req.await;
+
+            m.assert();
+            mem::drop(m);
+        }
+    }
 
     #[meilisearch_test]
     async fn test_get_keys(client: Client) {

src/request.rs

@@ -23,11 +23,13 @@ pub(crate) async fn request<Input: Serialize, Output: DeserializeOwned + 'static
     use isahc::*;
 
     let auth = format!("Bearer {}", apikey);
+    let user_agent = qualified_version();
 
     let mut response = match &method {
         Method::Get => {
             Request::get(url)
                 .header(header::AUTHORIZATION, auth)
+                .header(header::USER_AGENT, user_agent)
                 .body(())
                 .map_err(|_| crate::errors::Error::InvalidRequest)?
                 .send_async()
@@ -36,6 +38,7 @@ pub(crate) async fn request<Input: Serialize, Output: DeserializeOwned + 'static
         Method::Delete => {
             Request::delete(url)
                 .header(header::AUTHORIZATION, auth)
+                .header(header::USER_AGENT, user_agent)
                 .body(())
                 .map_err(|_| crate::errors::Error::InvalidRequest)?
                 .send_async()
@@ -45,6 +48,7 @@ pub(crate) async fn request<Input: Serialize, Output: DeserializeOwned + 'static
             Request::post(url)
                 .header(header::AUTHORIZATION, auth)
                 .header(header::CONTENT_TYPE, "application/json")
+                .header(header::USER_AGENT, user_agent)
                 .body(to_string(&body).unwrap())
                 .map_err(|_| crate::errors::Error::InvalidRequest)?
                 .send_async()
@@ -54,6 +58,7 @@ pub(crate) async fn request<Input: Serialize, Output: DeserializeOwned + 'static
             Request::patch(url)
                 .header(header::AUTHORIZATION, auth)
                 .header(header::CONTENT_TYPE, "application/json")
+                .header(header::USER_AGENT, user_agent)
                 .body(to_string(&body).unwrap())
                 .map_err(|_| crate::errors::Error::InvalidRequest)?
                 .send_async()
@@ -63,6 +68,7 @@ pub(crate) async fn request<Input: Serialize, Output: DeserializeOwned + 'static
             Request::put(url)
                 .header(header::AUTHORIZATION, auth)
                 .header(header::CONTENT_TYPE, "application/json")
+                .header(header::USER_AGENT, user_agent)
                 .body(to_string(&body).unwrap())
                 .map_err(|_| crate::errors::Error::InvalidRequest)?
                 .send_async()
@@ -95,11 +101,13 @@ pub(crate) async fn request<Input: Serialize, Output: DeserializeOwned + 'static
 
     const CONTENT_TYPE: &str = "Content-Type";
     const JSON: &str = "application/json";
+    const user_agent: str = qualified_version();
 
     // The 2 following unwraps should not be able to fail
 
     let headers = Headers::new().unwrap();
     headers.append("Authorization: Bearer", apikey).unwrap();
+    headers.append("User-Agent", &user_agent).unwrap();
 
     let mut request: RequestInit = RequestInit::new();
     request.headers(&headers);
@@ -189,3 +197,9 @@ fn parse_response<Output: DeserializeOwned>(
         Err(e) => Err(Error::ParseError(e)),
     }
 }
+
+pub fn qualified_version() -> String {
+    const VERSION: Option<&str> = option_env!("CARGO_PKG_VERSION");
+
+    format!("Meilisearch Rust (v{})", VERSION.unwrap_or("unknown"))
+}