last review edits + fmt

meilisearch-http/tests/common/index.rs

@@ -19,7 +19,10 @@ impl Index<'_> {
 
     pub async fn load_test_set(&self) -> u64 {
         let url = format!("/indexes/{}/documents", self.uid);
-        let (response, code) = self.service.post_str(url, include_str!("../assets/test_set.json")).await;
+        let (response, code) = self
+            .service
+            .post_str(url, include_str!("../assets/test_set.json"))
+            .await;
         assert_eq!(code, 200);
         let update_id = response["updateId"].as_i64().unwrap();
         self.wait_update_id(update_id as u64).await;
@@ -60,7 +63,11 @@ impl Index<'_> {
         self.service.post(url, documents).await
     }
 
-    pub async fn update_documents(&self, documents: Value, primary_key: Option<&str>) -> (Value, StatusCode) {
+    pub async fn update_documents(
+        &self,
+        documents: Value,
+        primary_key: Option<&str>,
+    ) -> (Value, StatusCode) {
         let url = match primary_key {
             Some(key) => format!("/indexes/{}/documents?primaryKey={}", self.uid, key),
             None => format!("/indexes/{}/documents", self.uid),
@@ -95,7 +102,11 @@ impl Index<'_> {
         self.service.get(url).await
     }
 
-    pub async fn get_document(&self, id: u64, _options: Option<GetDocumentOptions>) -> (Value, StatusCode) {
+    pub async fn get_document(
+        &self,
+        id: u64,
+        _options: Option<GetDocumentOptions>,
+    ) -> (Value, StatusCode) {
         let url = format!("/indexes/{}/documents/{}", self.uid, id);
         self.service.get(url).await
     }
@@ -111,7 +122,10 @@ impl Index<'_> {
         }
 
         if let Some(attributes_to_retrieve) = options.attributes_to_retrieve {
-            url.push_str(&format!("attributesToRetrieve={}&", attributes_to_retrieve.join(",")));
+            url.push_str(&format!(
+                "attributesToRetrieve={}&",
+                attributes_to_retrieve.join(",")
+            ));
         }
 
         self.service.get(url).await
@@ -129,7 +143,9 @@ impl Index<'_> {
 
     pub async fn delete_batch(&self, ids: Vec<u64>) -> (Value, StatusCode) {
         let url = format!("/indexes/{}/documents/delete-batch", self.uid);
-        self.service.post(url, serde_json::to_value(&ids).unwrap()).await
+        self.service
+            .post(url, serde_json::to_value(&ids).unwrap())
+            .await
     }
 
     pub async fn settings(&self) -> (Value, StatusCode) {

meilisearch-http/tests/common/mod.rs

@@ -2,8 +2,8 @@ mod index;
 mod server;
 mod service;
 
+pub use index::{GetAllDocumentsOptions, GetDocumentOptions};
 pub use server::Server;
-pub use index::{GetDocumentOptions, GetAllDocumentsOptions};
 
 /// Performs a search test on both post and get routes
 #[macro_export]

meilisearch-http/tests/common/server.rs

@@ -5,7 +5,7 @@ use tempdir::TempDir;
 use urlencoding::encode;
 
 use meilisearch_http::data::Data;
-use meilisearch_http::option::{Opt, IndexerOpts};
+use meilisearch_http::option::{IndexerOpts, Opt};
 
 use super::index::Index;
 use super::service::Service;
@@ -55,10 +55,7 @@ impl Server {
         let data = Data::new(opt).unwrap();
         let service = Service(data);
 
-        Server {
-            service,
-            _dir: dir,
-        }
+        Server { service, _dir: dir }
     }
 
     /// Returns a view to an index. There is no guarantee that the index exists.

meilisearch-http/tests/common/service.rs

@@ -1,15 +1,14 @@
 use actix_web::{http::StatusCode, test};
 use serde_json::Value;
 
-use meilisearch_http::data::Data;
 use meilisearch_http::create_app;
+use meilisearch_http::data::Data;
 
 pub struct Service(pub Data);
 
 impl Service {
     pub async fn post(&self, url: impl AsRef<str>, body: Value) -> (Value, StatusCode) {
-        let mut app =
-            test::init_service(create_app!(&self.0, true)).await;
+        let mut app = test::init_service(create_app!(&self.0, true)).await;
 
         let req = test::TestRequest::post()
             .uri(url.as_ref())
@@ -24,9 +23,12 @@ impl Service {
     }
 
     /// Send a test post request from a text body, with a `content-type:application/json` header.
-    pub async fn post_str(&self, url: impl AsRef<str>, body: impl AsRef<str>) -> (Value, StatusCode) {
-        let mut app =
-            test::init_service(create_app!(&self.0, true)).await;
+    pub async fn post_str(
+        &self,
+        url: impl AsRef<str>,
+        body: impl AsRef<str>,
+    ) -> (Value, StatusCode) {
+        let mut app = test::init_service(create_app!(&self.0, true)).await;
 
         let req = test::TestRequest::post()
             .uri(url.as_ref())
@@ -42,8 +44,7 @@ impl Service {
     }
 
     pub async fn get(&self, url: impl AsRef<str>) -> (Value, StatusCode) {
-        let mut app =
-            test::init_service(create_app!(&self.0, true)).await;
+        let mut app = test::init_service(create_app!(&self.0, true)).await;
 
         let req = test::TestRequest::get().uri(url.as_ref()).to_request();
         let res = test::call_service(&mut app, req).await;
@@ -55,8 +56,7 @@ impl Service {
     }
 
     pub async fn put(&self, url: impl AsRef<str>, body: Value) -> (Value, StatusCode) {
-        let mut app =
-            test::init_service(create_app!(&self.0, true)).await;
+        let mut app = test::init_service(create_app!(&self.0, true)).await;
 
         let req = test::TestRequest::put()
             .uri(url.as_ref())
@@ -71,8 +71,7 @@ impl Service {
     }
 
     pub async fn delete(&self, url: impl AsRef<str>) -> (Value, StatusCode) {
-        let mut app =
-            test::init_service(create_app!(&self.0, true)).await;
+        let mut app = test::init_service(create_app!(&self.0, true)).await;
 
         let req = test::TestRequest::delete().uri(url.as_ref()).to_request();
         let res = test::call_service(&mut app, req).await;

meilisearch-http/tests/documents/add_documents.rs

@@ -1,7 +1,7 @@
-use serde_json::{json, Value};
 use chrono::DateTime;
+use serde_json::{json, Value};
 
-use crate::common::{Server, GetAllDocumentsOptions};
+use crate::common::{GetAllDocumentsOptions, Server};
 
 #[actix_rt::test]
 async fn add_documents_no_index_creation() {
@@ -32,9 +32,12 @@ async fn add_documents_no_index_creation() {
     assert_eq!(response["updateId"], 0);
     assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 1);
 
-    let processed_at = DateTime::parse_from_rfc3339(response["processedAt"].as_str().unwrap()).unwrap();
-    let enqueued_at = DateTime::parse_from_rfc3339(response["enqueuedAt"].as_str().unwrap()).unwrap();
-    let started_processing_at = DateTime::parse_from_rfc3339(response["startedProcessingAt"].as_str().unwrap()).unwrap();
+    let processed_at =
+        DateTime::parse_from_rfc3339(response["processedAt"].as_str().unwrap()).unwrap();
+    let enqueued_at =
+        DateTime::parse_from_rfc3339(response["enqueuedAt"].as_str().unwrap()).unwrap();
+    let started_processing_at =
+        DateTime::parse_from_rfc3339(response["startedProcessingAt"].as_str().unwrap()).unwrap();
     assert!(processed_at > started_processing_at);
     assert!(started_processing_at > enqueued_at);
 
@@ -71,7 +74,8 @@ async fn document_addition_with_primary_key() {
             "content": "foo",
         }
     ]);
-    let (_response, code) = index.add_documents(documents, Some("primary")).await; assert_eq!(code, 200);
+    let (_response, code) = index.add_documents(documents, Some("primary")).await;
+    assert_eq!(code, 200);
 
     index.wait_update_id(0).await;
 
@@ -97,7 +101,8 @@ async fn document_update_with_primary_key() {
             "content": "foo",
         }
     ]);
-    let (_response, code) = index.update_documents(documents, Some("primary")).await; assert_eq!(code, 200);
+    let (_response, code) = index.update_documents(documents, Some("primary")).await;
+    assert_eq!(code, 200);
 
     index.wait_update_id(0).await;
 
@@ -158,7 +163,7 @@ async fn update_documents_with_primary_key_and_primary_key_already_exists() {
     assert_eq!(code, 200);
 
     index.wait_update_id(0).await;
-let (response, code) = index.get_update(0).await;
+    let (response, code) = index.get_update(0).await;
     assert_eq!(code, 200);
     assert_eq!(response["status"], "processed");
     assert_eq!(response["updateId"], 0);
@@ -263,7 +268,10 @@ async fn update_document() {
 
     let (response, code) = index.get_document(1, None).await;
     assert_eq!(code, 200);
-    assert_eq!(response.to_string(), r##"{"doc_id":1,"content":"foo","other":"bar"}"##);
+    assert_eq!(
+        response.to_string(),
+        r##"{"doc_id":1,"content":"foo","other":"bar"}"##
+    );
 }
 
 #[actix_rt::test]
@@ -275,7 +283,12 @@ async fn add_larger_dataset() {
     assert_eq!(code, 200);
     assert_eq!(response["status"], "processed");
     assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 77);
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { limit: Some(1000), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            limit: Some(1000),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 77);
 }
@@ -291,7 +304,12 @@ async fn update_larger_dataset() {
     assert_eq!(code, 200);
     assert_eq!(response["status"], "processed");
     assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 77);
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { limit: Some(1000), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            limit: Some(1000),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 77);
 }

meilisearch-http/tests/documents/delete_documents.rs

@@ -1,6 +1,6 @@
 use serde_json::json;
 
-use crate::common::{Server, GetAllDocumentsOptions};
+use crate::common::{GetAllDocumentsOptions, Server};
 
 #[actix_rt::test]
 async fn delete_one_document_unexisting_index() {
@@ -24,7 +24,9 @@ async fn delete_one_unexisting_document() {
 async fn delete_one_document() {
     let server = Server::new().await;
     let index = server.index("test");
-    index.add_documents(json!([{ "id": 0, "content": "foobar" }]), None).await;
+    index
+        .add_documents(json!([{ "id": 0, "content": "foobar" }]), None)
+        .await;
     index.wait_update_id(0).await;
     let (_response, code) = server.index("test").delete_document(0).await;
     assert_eq!(code, 200);
@@ -39,20 +41,26 @@ async fn clear_all_documents_unexisting_index() {
     let server = Server::new().await;
     let (_response, code) = server.index("test").clear_all_documents().await;
     assert_eq!(code, 400);
-
 }
 
 #[actix_rt::test]
 async fn clear_all_documents() {
     let server = Server::new().await;
     let index = server.index("test");
-    index.add_documents(json!([{ "id": 1, "content": "foobar" }, { "id": 0, "content": "foobar" }]), None).await;
+    index
+        .add_documents(
+            json!([{ "id": 1, "content": "foobar" }, { "id": 0, "content": "foobar" }]),
+            None,
+        )
+        .await;
     index.wait_update_id(0).await;
     let (_response, code) = index.clear_all_documents().await;
     assert_eq!(code, 200);
 
     let _update = index.wait_update_id(1).await;
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     assert!(response.as_array().unwrap().is_empty());
 }
@@ -67,7 +75,9 @@ async fn clear_all_documents_empty_index() {
     assert_eq!(code, 200);
 
     let _update = index.wait_update_id(0).await;
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     assert!(response.as_array().unwrap().is_empty());
 }
@@ -89,13 +99,14 @@ async fn delete_batch() {
     assert_eq!(code, 200);
 
     let _update = index.wait_update_id(1).await;
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 1);
     assert_eq!(response.as_array().unwrap()[0]["id"], 3);
 }
 
-
 #[actix_rt::test]
 async fn delete_no_document_batch() {
     let server = Server::new().await;
@@ -106,7 +117,9 @@ async fn delete_no_document_batch() {
     assert_eq!(code, 200);
 
     let _update = index.wait_update_id(1).await;
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 3);
 }

meilisearch-http/tests/documents/get_documents.rs

@@ -1,5 +1,5 @@
-use crate::common::Server;
 use crate::common::GetAllDocumentsOptions;
+use crate::common::Server;
 
 use serde_json::json;
 
@@ -8,10 +8,7 @@ use serde_json::json;
 #[actix_rt::test]
 async fn get_unexisting_index_single_document() {
     let server = Server::new().await;
-    let (_response, code) = server
-        .index("test")
-        .get_document(1, None)
-        .await;
+    let (_response, code) = server.index("test").get_document(1, None).await;
     assert_eq!(code, 400);
 }
 
@@ -20,9 +17,7 @@ async fn get_unexisting_document() {
     let server = Server::new().await;
     let index = server.index("test");
     index.create(None).await;
-    let (_response, code) = index
-        .get_document(1, None)
-        .await;
+    let (_response, code) = index.get_document(1, None).await;
     assert_eq!(code, 400);
 }
 
@@ -40,14 +35,15 @@ async fn get_document() {
     let (_, code) = index.add_documents(documents, None).await;
     assert_eq!(code, 200);
     index.wait_update_id(0).await;
-    let (response, code) = index
-        .get_document(0, None)
-        .await;
+    let (response, code) = index.get_document(0, None).await;
     assert_eq!(code, 200);
-    assert_eq!(response, serde_json::json!(        {
-        "id": 0,
-        "content": "foobar",
-    }));
+    assert_eq!(
+        response,
+        serde_json::json!(        {
+            "id": 0,
+            "content": "foobar",
+        })
+    );
 }
 
 #[actix_rt::test]
@@ -67,7 +63,9 @@ async fn get_no_documents() {
     let (_, code) = index.create(None).await;
     assert_eq!(code, 200);
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     assert!(response.as_array().unwrap().is_empty());
 }
@@ -78,7 +76,9 @@ async fn get_all_documents_no_options() {
     let index = server.index("test");
     index.load_test_set().await;
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     let arr = response.as_array().unwrap();
     assert_eq!(arr.len(), 20);
@@ -109,7 +109,12 @@ async fn test_get_all_documents_limit() {
     let index = server.index("test");
     index.load_test_set().await;
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { limit: Some(5), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            limit: Some(5),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 5);
     assert_eq!(response.as_array().unwrap()[0]["id"], 0);
@@ -121,7 +126,12 @@ async fn test_get_all_documents_offset() {
     let index = server.index("test");
     index.load_test_set().await;
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { offset: Some(5), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            offset: Some(5),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 20);
     assert_eq!(response.as_array().unwrap()[0]["id"], 13);
@@ -133,35 +143,90 @@ async fn test_get_all_documents_attributes_to_retrieve() {
     let index = server.index("test");
     index.load_test_set().await;
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { attributes_to_retrieve: Some(vec!["name"]), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec!["name"]),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 20);
-    assert_eq!(response.as_array().unwrap()[0].as_object().unwrap().keys().count(), 1);
-    assert!(response.as_array().unwrap()[0].as_object().unwrap().get("name").is_some());
+    assert_eq!(
+        response.as_array().unwrap()[0]
+            .as_object()
+            .unwrap()
+            .keys()
+            .count(),
+        1
+    );
+    assert!(response.as_array().unwrap()[0]
+        .as_object()
+        .unwrap()
+        .get("name")
+        .is_some());
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { attributes_to_retrieve: Some(vec![]), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec![]),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 20);
-    assert_eq!(response.as_array().unwrap()[0].as_object().unwrap().keys().count(), 0);
+    assert_eq!(
+        response.as_array().unwrap()[0]
+            .as_object()
+            .unwrap()
+            .keys()
+            .count(),
+        0
+    );
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions { attributes_to_retrieve: Some(vec!["name", "tags"]), ..Default::default() }).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec!["name", "tags"]),
+            ..Default::default()
+        })
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 20);
-    assert_eq!(response.as_array().unwrap()[0].as_object().unwrap().keys().count(), 2);
+    assert_eq!(
+        response.as_array().unwrap()[0]
+            .as_object()
+            .unwrap()
+            .keys()
+            .count(),
+        2
+    );
 }
 
 #[actix_rt::test]
 async fn get_documents_displayed_attributes() {
     let server = Server::new().await;
     let index = server.index("test");
-    index.update_settings(json!({"displayedAttributes": ["gender"]})).await;
+    index
+        .update_settings(json!({"displayedAttributes": ["gender"]}))
+        .await;
     index.load_test_set().await;
 
-    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 20);
-    assert_eq!(response.as_array().unwrap()[0].as_object().unwrap().keys().count(), 1);
-    assert!(response.as_array().unwrap()[0].as_object().unwrap().get("gender").is_some());
+    assert_eq!(
+        response.as_array().unwrap()[0]
+            .as_object()
+            .unwrap()
+            .keys()
+            .count(),
+        1
+    );
+    assert!(response.as_array().unwrap()[0]
+        .as_object()
+        .unwrap()
+        .get("gender")
+        .is_some());
 
     let (response, code) = index.get_document(0, None).await;
     assert_eq!(code, 200);

meilisearch-http/tests/documents/mod.rs

@@ -1,3 +1,3 @@
 mod add_documents;
-mod get_documents;
 mod delete_documents;
+mod get_documents;

meilisearch-http/tests/index/create_index.rs

@@ -7,7 +7,6 @@ async fn create_index_no_primary_key() {
     let index = server.index("test");
     let (response, code) = index.create(None).await;
 
-
     assert_eq!(code, 200);
     assert_eq!(response["uid"], "test");
     assert!(response.get("createdAt").is_some());

meilisearch-http/tests/index/delete_index.rs

@@ -6,12 +6,10 @@ async fn create_and_delete_index() {
     let index = server.index("test");
     let (_response, code) = index.create(None).await;
 
-
     assert_eq!(code, 200);
 
     let (_response, code) = index.delete().await;
 
-
     assert_eq!(code, 200);
 
     assert_eq!(index.get().await.1, 400);

meilisearch-http/tests/index/get_index.rs

@@ -52,6 +52,12 @@ async fn list_multiple_indexes() {
     assert!(response.is_array());
     let arr = response.as_array().unwrap();
     assert_eq!(arr.len(), 2);
-    assert!(arr.iter().find(|entry| entry["uid"] == "test" && entry["primaryKey"] == Value::Null).is_some());
-    assert!(arr.iter().find(|entry| entry["uid"] == "test1" && entry["primaryKey"] == "key").is_some());
+    assert!(arr
+        .iter()
+        .find(|entry| entry["uid"] == "test" && entry["primaryKey"] == Value::Null)
+        .is_some());
+    assert!(arr
+        .iter()
+        .find(|entry| entry["uid"] == "test1" && entry["primaryKey"] == "key")
+        .is_some());
 }

meilisearch-http/tests/index/mod.rs

@@ -1,4 +1,4 @@
 mod create_index;
+mod delete_index;
 mod get_index;
 mod update_index;
-mod delete_index;

meilisearch-http/tests/integration.rs

@@ -1,8 +1,8 @@
 mod common;
+mod documents;
 mod index;
 mod search;
 mod settings;
-mod documents;
 mod updates;
 
 // Tests are isolated by features in different modules to allow better readability, test

meilisearch-http/tests/search/mod.rs

@@ -1,3 +1,2 @@
 // This modules contains all the test concerning search. Each particular feture of the search
 // should be tested in its own module to isolate tests and keep the tests readable.
-

meilisearch-http/tests/settings/get_settings.rs

@@ -21,7 +21,17 @@ async fn get_settings() {
     assert_eq!(settings["searchableAttributes"], json!(["*"]));
     println!("{:?}", settings);
     assert_eq!(settings["attributesForFaceting"], json!({}));
-    assert_eq!(settings["rankingRules"], json!(["typo", "words", "proximity", "attribute", "wordsPosition", "exactness"]));
+    assert_eq!(
+        settings["rankingRules"],
+        json!([
+            "typo",
+            "words",
+            "proximity",
+            "attribute",
+            "wordsPosition",
+            "exactness"
+        ])
+    );
 }
 
 #[actix_rt::test]
@@ -36,20 +46,24 @@ async fn update_settings_unknown_field() {
 async fn test_partial_update() {
     let server = Server::new().await;
     let index = server.index("test");
-    let (_response, _code) = index.update_settings(json!({"displayedAttributes": ["foo"]})).await;
+    let (_response, _code) = index
+        .update_settings(json!({"displayedAttributes": ["foo"]}))
+        .await;
     index.wait_update_id(0).await;
     let (response, code) = index.settings().await;
     assert_eq!(code, 200);
-    assert_eq!(response["displayedAttributes"],json!(["foo"]));
-    assert_eq!(response["searchableAttributes"],json!(["*"]));
+    assert_eq!(response["displayedAttributes"], json!(["foo"]));
+    assert_eq!(response["searchableAttributes"], json!(["*"]));
 
-    let (_response, _) = index.update_settings(json!({"searchableAttributes": ["bar"]})).await;
+    let (_response, _) = index
+        .update_settings(json!({"searchableAttributes": ["bar"]}))
+        .await;
     index.wait_update_id(1).await;
 
     let (response, code) = index.settings().await;
     assert_eq!(code, 200);
-    assert_eq!(response["displayedAttributes"],json!(["foo"]));
-    assert_eq!(response["searchableAttributes"],json!(["bar"]));
+    assert_eq!(response["displayedAttributes"], json!(["foo"]));
+    assert_eq!(response["searchableAttributes"], json!(["bar"]));
 }
 
 #[actix_rt::test]
@@ -64,20 +78,22 @@ async fn delete_settings_unexisting_index() {
 async fn reset_all_settings() {
     let server = Server::new().await;
     let index = server.index("test");
-    index.update_settings(json!({"displayedAttributes": ["foo"], "searchableAttributes": ["bar"]})).await;
+    index
+        .update_settings(json!({"displayedAttributes": ["foo"], "searchableAttributes": ["bar"]}))
+        .await;
     index.wait_update_id(0).await;
     let (response, code) = index.settings().await;
     assert_eq!(code, 200);
-    assert_eq!(response["displayedAttributes"],json!(["foo"]));
-    assert_eq!(response["searchableAttributes"],json!(["bar"]));
+    assert_eq!(response["displayedAttributes"], json!(["foo"]));
+    assert_eq!(response["searchableAttributes"], json!(["bar"]));
 
     index.delete_settings().await;
     index.wait_update_id(1).await;
 
     let (response, code) = index.settings().await;
     assert_eq!(code, 200);
-    assert_eq!(response["displayedAttributes"],json!(["*"]));
-    assert_eq!(response["searchableAttributes"],json!(["*"]));
+    assert_eq!(response["displayedAttributes"], json!(["*"]));
+    assert_eq!(response["searchableAttributes"], json!(["*"]));
 }
 
 #[actix_rt::test]
@@ -149,4 +165,5 @@ macro_rules! test_setting_routes {
 test_setting_routes!(
     attributes_for_faceting,
     displayed_attributes,
-    searchable_attributes);
+    searchable_attributes
+);

meilisearch-http/tests/updates/mod.rs

@@ -21,13 +21,15 @@ async fn get_update_status() {
     let server = Server::new().await;
     let index = server.index("test");
     index.create(None).await;
-    index.add_documents(
-        serde_json::json!([{
-            "id": 1,
-            "content": "foobar",
-        }]),
-        None
-    ).await;
+    index
+        .add_documents(
+            serde_json::json!([{
+                "id": 1,
+                "content": "foobar",
+            }]),
+            None,
+        )
+        .await;
     let (_response, code) = index.get_update(0).await;
     assert_eq!(code, 200);
     // TODO check resonse format, as per #48
@@ -55,10 +57,12 @@ async fn list_updates() {
     let server = Server::new().await;
     let index = server.index("test");
     index.create(None).await;
-    index.add_documents(
-        serde_json::from_str(include_str!("../assets/test_set.json")).unwrap(),
-        None
-    ).await;
+    index
+        .add_documents(
+            serde_json::from_str(include_str!("../assets/test_set.json")).unwrap(),
+            None,
+        )
+        .await;
     let (response, code) = index.list_updates().await;
     assert_eq!(code, 200);
     assert_eq!(response.as_array().unwrap().len(), 1);