make the Client and Index uses our IsahcClient by default

Author: irevoire

examples/cli-app-with-reqwest/src/main.rs

@@ -12,22 +12,13 @@ use std::fmt;
 use std::io::stdin;
 
 lazy_static! {
-    static ref CLIENT: Client<ReqwestClient> = Client::new_with_client(
-        "http://localhost:7700",
-        Some("masterKey"),
-        ReqwestClient::new()
-    );
+    static ref CLIENT: Client<ReqwestClient> =
+        Client::new_with_client("http://localhost:7700", Some("masterKey"), ReqwestClient);
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub struct ReqwestClient;
 
-impl ReqwestClient {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
 #[async_trait(?Send)]
 impl HttpClient for ReqwestClient {
     async fn request<Query, Body, Output>(

examples/settings.rs

@@ -1,4 +1,4 @@
-use meilisearch_sdk::prelude::*;
+use meilisearch_sdk::{prelude::*, settings::Settings};
 
 // we need an async runtime
 #[tokio::main(flavor = "current_thread")]

meilisearch-test-macro/src/lib.rs

@@ -1,12 +1,14 @@
-#![warn(clippy::pedantic)]
 #![recursion_limit = "4096"]
 
 extern crate proc_macro;
 
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use quote::quote;
-use syn::*;
+use syn::{
+    parse_macro_input, parse_quote, Expr, FnArg, Ident, Item, PatType, Path, Stmt, Type, TypePath,
+    Visibility,
+};
 
 #[proc_macro_attribute]
 pub fn meilisearch_test(params: TokenStream, input: TokenStream) -> TokenStream {

src/client.rs

@@ -29,7 +29,7 @@ pub struct SwapIndexes {
 
 #[cfg(feature = "isahc")]
 #[cfg(not(target_arch = "wasm32"))]
-impl Client<IsahcClient> {
+impl Client {
     /// Create a client using the specified server.
     ///
     /// Don't put a '/' at the end of the host.
@@ -46,7 +46,7 @@ impl Client<IsahcClient> {
     ///
     /// let client = Client::new(MEILISEARCH_URL, Some(MEILISEARCH_API_KEY));
     /// ```
-    pub fn new(host: impl Into<String>, api_key: Option<impl Into<String>>) -> Client<IsahcClient> {
+    pub fn new(host: impl Into<String>, api_key: Option<impl Into<String>>) -> Client {
         Client {
             host: host.into(),
             api_key: api_key.map(|api_key| api_key.into()),
@@ -1211,7 +1211,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_swapping_two_indexes(client: Client<IsahcClient>) {
+    async fn test_swapping_two_indexes(client: Client) {
         let index_1 = client.index("test_swapping_two_indexes_1");
         let index_2 = client.index("test_swapping_two_indexes_2");
 
@@ -1273,7 +1273,7 @@ mod tests {
                     .match_header("User-Agent", user_agent)
                     .create_async()
                     .await,
-                client.http_client.clone().request::<(), (), ()>(
+                client.http_client.request::<(), (), ()>(
                     address,
                     None,
                     Method::Get { query: () },
@@ -1285,7 +1285,7 @@ mod tests {
                     .match_header("User-Agent", user_agent)
                     .create_async()
                     .await,
-                client.http_client.clone().request::<(), (), ()>(
+                client.http_client.request::<(), (), ()>(
                     address,
                     None,
                     Method::Post {
@@ -1300,7 +1300,7 @@ mod tests {
                     .match_header("User-Agent", user_agent)
                     .create_async()
                     .await,
-                client.http_client.clone().request::<(), (), ()>(
+                client.http_client.request::<(), (), ()>(
                     address,
                     None,
                     Method::Delete { query: () },
@@ -1312,7 +1312,7 @@ mod tests {
                     .match_header("User-Agent", user_agent)
                     .create_async()
                     .await,
-                client.http_client.clone().request::<(), (), ()>(
+                client.http_client.request::<(), (), ()>(
                     address,
                     None,
                     Method::Put {
@@ -1327,7 +1327,7 @@ mod tests {
                     .match_header("User-Agent", user_agent)
                     .create_async()
                     .await,
-                client.http_client.clone().request::<(), (), ()>(
+                client.http_client.request::<(), (), ()>(
                     address,
                     None,
                     Method::Patch {
@@ -1347,28 +1347,28 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_get_tasks(client: Client<IsahcClient>) {
+    async fn test_get_tasks(client: Client) {
         let tasks = client.get_tasks().await.unwrap();
         assert_eq!(tasks.limit, 20);
     }
 
     #[meilisearch_test]
-    async fn test_get_tasks_with_params(client: Client<IsahcClient>) {
+    async fn test_get_tasks_with_params(client: Client) {
         let query = TasksSearchQuery::new(&client);
         let tasks = client.get_tasks_with(&query).await.unwrap();
 
         assert_eq!(tasks.limit, 20);
     }
 
     #[meilisearch_test]
-    async fn test_get_keys(client: Client<IsahcClient>) {
+    async fn test_get_keys(client: Client) {
         let keys = client.get_keys().await.unwrap();
 
         assert!(keys.results.len() >= 2);
     }
 
     #[meilisearch_test]
-    async fn test_delete_key(client: Client<IsahcClient>, name: String) {
+    async fn test_delete_key(client: Client, name: String) {
         let mut key = KeyBuilder::new();
         key.with_name(&name);
         let key = client.create_key(key).await.unwrap();
@@ -1384,7 +1384,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_error_delete_key(mut client: Client<IsahcClient>, name: String) {
+    async fn test_error_delete_key(mut client: Client, name: String) {
         // ==> accessing a key that does not exist
         let error = client.delete_key("invalid_key").await.unwrap_err();
         assert!(matches!(
@@ -1431,7 +1431,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_create_key(client: Client<IsahcClient>, name: String) {
+    async fn test_create_key(client: Client, name: String) {
         let expires_at = OffsetDateTime::now_utc() + time::Duration::HOUR;
         let mut key = KeyBuilder::new();
         key.with_action(Action::DocumentsAdd)
@@ -1454,7 +1454,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_error_create_key(mut client: Client<IsahcClient>, name: String) {
+    async fn test_error_create_key(mut client: Client, name: String) {
         // ==> Invalid index name
         /* TODO: uncomment once meilisearch fix this bug: https://github.com/meilisearch/meilisearch/issues/2158
         let mut key = KeyBuilder::new();
@@ -1500,7 +1500,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_update_key(client: Client<IsahcClient>, description: String) {
+    async fn test_update_key(client: Client, description: String) {
         let mut key = KeyBuilder::new();
         key.with_name("test_update_key");
         let mut key = client.create_key(key).await.unwrap();
@@ -1518,7 +1518,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_get_index(client: Client<IsahcClient>, index_uid: String) -> Result<(), Error> {
+    async fn test_get_index(client: Client, index_uid: String) -> Result<(), Error> {
         let task = client.create_index(&index_uid, None).await?;
         let index = client
             .wait_for_task(task, None, None)
@@ -1536,10 +1536,7 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_error_create_index(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
-    ) -> Result<(), Error> {
+    async fn test_error_create_index(client: Client, index: Index) -> Result<(), Error> {
         let error = client
             .create_index("Wrong index name", None)
             .await
@@ -1574,15 +1571,15 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_list_all_indexes(client: Client<IsahcClient>) {
+    async fn test_list_all_indexes(client: Client) {
         let all_indexes = client.list_all_indexes().await.unwrap();
 
         assert_eq!(all_indexes.limit, 20);
         assert_eq!(all_indexes.offset, 0);
     }
 
     #[meilisearch_test]
-    async fn test_list_all_indexes_with_params(client: Client<IsahcClient>) {
+    async fn test_list_all_indexes_with_params(client: Client) {
         let mut query = IndexesQuery::new(&client);
         query.with_limit(1);
         let all_indexes = client.list_all_indexes_with(&query).await.unwrap();
@@ -1592,15 +1589,15 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_list_all_indexes_raw(client: Client<IsahcClient>) {
+    async fn test_list_all_indexes_raw(client: Client) {
         let all_indexes_raw = client.list_all_indexes_raw().await.unwrap();
 
         assert_eq!(all_indexes_raw["limit"], json!(20));
         assert_eq!(all_indexes_raw["offset"], json!(0));
     }
 
     #[meilisearch_test]
-    async fn test_list_all_indexes_raw_with_params(client: Client<IsahcClient>) {
+    async fn test_list_all_indexes_raw_with_params(client: Client) {
         let mut query = IndexesQuery::new(&client);
         query.with_limit(1);
         let all_indexes_raw = client.list_all_indexes_raw_with(&query).await.unwrap();
@@ -1610,18 +1607,15 @@ mod tests {
     }
 
     #[meilisearch_test]
-    async fn test_get_primary_key_is_none(mut index: Index<IsahcClient>) {
+    async fn test_get_primary_key_is_none(mut index: Index) {
         let primary_key = index.get_primary_key().await;
 
         assert!(primary_key.is_ok());
         assert!(primary_key.unwrap().is_none());
     }
 
     #[meilisearch_test]
-    async fn test_get_primary_key(
-        client: Client<IsahcClient>,
-        index_uid: String,
-    ) -> Result<(), Error> {
+    async fn test_get_primary_key(client: Client, index_uid: String) -> Result<(), Error> {
         let mut index = client
             .create_index(index_uid, Some("primary_key"))
             .await?

src/documents.rs

@@ -39,11 +39,11 @@ use serde::{de::DeserializeOwned, Deserialize, Serialize};
 ///     genres: Vec<String>,
 /// }
 ///
-/// async fn usage(client: Client<IsahcClient>) {
+/// async fn usage(client: Client) {
 ///     // Default settings with the distinct, searchable, displayed, filterable, and sortable fields set correctly.
 ///     let settings: Settings = Movie::generate_settings();
 ///     // Index created with the name `movie` and the primary key set to `movie_id`
-///     let index: Index<IsahcClient> = Movie::generate_index(&client).await.unwrap();
+///     let index: Index = Movie::generate_index(&client).await.unwrap();
 /// }
 /// ```
 pub use meilisearch_index_setting_macro::IndexConfig;
@@ -396,8 +396,8 @@ mod tests {
     }
 
     async fn setup_test_index(
-        client: &Client<IsahcClient>,
-        index: &Index<IsahcClient>,
+        client: &Client,
+        index: &Index,
     ) -> Result<(), Error> {
         let t0 = index
             .add_documents(
@@ -430,8 +430,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_get_documents_with_execute(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
         let documents = DocumentsQuery::new(&index)
@@ -451,8 +451,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_delete_documents_with(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
         index
@@ -485,8 +485,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_delete_documents_with_filter_not_filterable(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -514,8 +514,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_get_documents_with_only_one_param(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
         // let documents = index.get_documents(None, None, None).await.unwrap();
@@ -534,8 +534,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_get_documents_with_filter(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -592,8 +592,8 @@ mod tests {
 
     #[meilisearch_test]
     async fn test_get_documents_with_error_hint_meilisearch_api_error(
-        index: Index<IsahcClient>,
-        client: Client<IsahcClient>,
+        index: Index,
+        client: Client,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -623,8 +623,8 @@ Hint: It might not be working because you're not up to date with the Meilisearch
 
     #[meilisearch_test]
     async fn test_get_documents_with_invalid_filter(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -649,8 +649,8 @@ Hint: It might not be working because you're not up to date with the Meilisearch
 
     #[meilisearch_test]
     async fn test_settings_generated_by_macro(
-        client: Client<IsahcClient>,
-        index: Index<IsahcClient>,
+        client: Client,
+        index: Index,
     ) -> Result<(), Error> {
         setup_test_index(&client, &index).await?;
 
@@ -682,8 +682,8 @@ Hint: It might not be working because you're not up to date with the Meilisearch
     }
 
     #[meilisearch_test]
-    async fn test_generate_index(client: Client<IsahcClient>) -> Result<(), Error> {
-        let index: Index<IsahcClient> = MovieClips::generate_index(&client).await.unwrap();
+    async fn test_generate_index(client: Client) -> Result<(), Error> {
+        let index: Index = MovieClips::generate_index(&client).await.unwrap();
 
         assert_eq!(index.uid, "movie_clips");