Send qualified User-Agent to Meilisearch server

Author: brunoocasali

src/client.rs

@@ -637,6 +637,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

@@ -28,11 +28,13 @@ pub(crate) async fn request<
     trace!("{:?} on {}", method, url);
 
     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()
@@ -41,6 +43,7 @@ pub(crate) async fn request<
         Method::Delete => {
             Request::delete(url)
                 .header(header::AUTHORIZATION, auth)
+                .header(header::USER_AGENT, user_agent)
                 .body(())
                 .map_err(|_| crate::errors::Error::InvalidRequest)?
                 .send_async()
@@ -50,6 +53,7 @@ pub(crate) async fn request<
             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()
@@ -59,6 +63,7 @@ pub(crate) async fn request<
             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()
@@ -68,6 +73,7 @@ pub(crate) async fn request<
             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()
@@ -105,11 +111,13 @@ pub(crate) async fn request<
 
     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);
@@ -199,3 +207,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"))
+}