Merge branch 'main' into fix-3037

meilisearch/tests/documents/add_documents.rs

@@ -0,0 +1,988 @@
+use actix_web::test;
+use serde_json::{json, Value};
+use time::format_description::well_known::Rfc3339;
+use time::OffsetDateTime;
+
+use crate::common::encoder::Encoder;
+use crate::common::{GetAllDocumentsOptions, Server};
+
+/// This is the basic usage of our API and every other tests uses the content-type application/json
+#[actix_rt::test]
+async fn add_documents_test_json_content_types() {
+    let document = json!([
+        {
+            "id": 1,
+            "content": "Bouvier Bernois",
+        }
+    ]);
+
+    // this is a what is expected and should work
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 202);
+    assert_eq!(response["taskUid"], 0);
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 202);
+    assert_eq!(response["taskUid"], 1);
+}
+
+/// Here we try to send a single document instead of an array with a single document inside.
+#[actix_rt::test]
+async fn add_single_document_test_json_content_types() {
+    let document = json!({
+        "id": 1,
+        "content": "Bouvier Bernois",
+    });
+
+    // this is a what is expected and should work
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 202);
+    assert_eq!(response["taskUid"], 0);
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 202);
+    assert_eq!(response["taskUid"], 1);
+}
+
+/// Here we try sending encoded (compressed) document request
+#[actix_rt::test]
+async fn add_single_document_gzip_encoded() {
+    let document = json!({
+        "id": 1,
+        "content": "Bouvier Bernois",
+    });
+
+    // this is a what is expected and should work
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+    // post
+    let document = serde_json::to_string(&document).unwrap();
+    let encoder = Encoder::Gzip;
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(encoder.encode(document.clone()))
+        .insert_header(("content-type", "application/json"))
+        .insert_header(encoder.header().unwrap())
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 202);
+    assert_eq!(response["taskUid"], 0);
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(encoder.encode(document))
+        .insert_header(("content-type", "application/json"))
+        .insert_header(encoder.header().unwrap())
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 202);
+    assert_eq!(response["taskUid"], 1);
+}
+
+/// Here we try document request with every encoding
+#[actix_rt::test]
+async fn add_single_document_with_every_encoding() {
+    let document = json!({
+        "id": 1,
+        "content": "Bouvier Bernois",
+    });
+
+    // this is a what is expected and should work
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+    // post
+    let document = serde_json::to_string(&document).unwrap();
+
+    for (task_uid, encoder) in Encoder::iterator().enumerate() {
+        let mut req = test::TestRequest::post()
+            .uri("/indexes/dog/documents")
+            .set_payload(encoder.encode(document.clone()))
+            .insert_header(("content-type", "application/json"));
+        req = match encoder.header() {
+            Some(header) => req.insert_header(header),
+            None => req,
+        };
+        let req = req.to_request();
+        let res = test::call_service(&app, req).await;
+        let status_code = res.status();
+        let body = test::read_body(res).await;
+        let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+        assert_eq!(status_code, 202);
+        assert_eq!(response["taskUid"], task_uid);
+    }
+}
+
+/// any other content-type is must be refused
+#[actix_rt::test]
+async fn error_add_documents_test_bad_content_types() {
+    let document = json!([
+        {
+            "id": 1,
+            "content": "Leonberg",
+        }
+    ]);
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "text/plain"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 415);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The Content-Type `text/plain` is invalid. Accepted values for the Content-Type header are: `application/json`, `application/x-ndjson`, `text/csv`"#
+        )
+    );
+    assert_eq!(response["code"], "invalid_content_type");
+    assert_eq!(response["type"], "invalid_request");
+    assert_eq!(response["link"], "https://docs.meilisearch.com/errors#invalid_content_type");
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "text/plain"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 415);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The Content-Type `text/plain` is invalid. Accepted values for the Content-Type header are: `application/json`, `application/x-ndjson`, `text/csv`"#
+        )
+    );
+    assert_eq!(response["code"], "invalid_content_type");
+    assert_eq!(response["type"], "invalid_request");
+    assert_eq!(response["link"], "https://docs.meilisearch.com/errors#invalid_content_type");
+}
+
+/// missing content-type must be refused
+#[actix_rt::test]
+async fn error_add_documents_test_no_content_type() {
+    let document = json!([
+        {
+            "id": 1,
+            "content": "Leonberg",
+        }
+    ]);
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 415);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"A Content-Type header is missing. Accepted values for the Content-Type header are: `application/json`, `application/x-ndjson`, `text/csv`"#
+        )
+    );
+    assert_eq!(response["code"], "missing_content_type");
+    assert_eq!(response["type"], "invalid_request");
+    assert_eq!(response["link"], "https://docs.meilisearch.com/errors#missing_content_type");
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 415);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"A Content-Type header is missing. Accepted values for the Content-Type header are: `application/json`, `application/x-ndjson`, `text/csv`"#
+        )
+    );
+    assert_eq!(response["code"], "missing_content_type");
+    assert_eq!(response["type"], "invalid_request");
+    assert_eq!(response["link"], "https://docs.meilisearch.com/errors#missing_content_type");
+}
+
+#[actix_rt::test]
+async fn error_add_malformed_csv_documents() {
+    let document = "id, content\n1234, hello, world\n12, hello world";
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "text/csv"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The `csv` payload provided is malformed: `CSV error: record 1 (line: 2, byte: 12): found record with 3 fields, but the previous record has 2 fields`."#
+        )
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "text/csv"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The `csv` payload provided is malformed: `CSV error: record 1 (line: 2, byte: 12): found record with 3 fields, but the previous record has 2 fields`."#
+        )
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+}
+
+#[actix_rt::test]
+async fn error_add_malformed_json_documents() {
+    let document = r#"[{"id": 1}, {id: 2}]"#;
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The `json` payload provided is malformed. `Couldn't serialize document value: key must be a string at line 1 column 14`."#
+        )
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The `json` payload provided is malformed. `Couldn't serialize document value: key must be a string at line 1 column 14`."#
+        )
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+
+    // truncate
+
+    // length = 100
+    let long = "0123456789".repeat(10);
+
+    let document = format!("\"{}\"", long);
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document)
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The `json` payload provided is malformed. `Couldn't serialize document value: data are neither an object nor a list of objects`."#
+        )
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+
+    // add one more char to the long string to test if the truncating works.
+    let document = format!("\"{}m\"", long);
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document)
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!("The `json` payload provided is malformed. `Couldn't serialize document value: data are neither an object nor a list of objects`.")
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+}
+
+#[actix_rt::test]
+async fn error_add_malformed_ndjson_documents() {
+    let document = "{\"id\": 1}\n{id: 2}";
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/x-ndjson"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!(
+            r#"The `ndjson` payload provided is malformed. `Couldn't serialize document value: trailing characters at line 2 column 1`."#
+        )
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/x-ndjson"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(
+        response["message"],
+        json!("The `ndjson` payload provided is malformed. `Couldn't serialize document value: trailing characters at line 2 column 1`.")
+    );
+    assert_eq!(response["code"], json!("malformed_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#malformed_payload"));
+}
+
+#[actix_rt::test]
+async fn error_add_missing_payload_csv_documents() {
+    let document = "";
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "text/csv"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(response["message"], json!(r#"A csv payload is missing."#));
+    assert_eq!(response["code"], json!("missing_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#missing_payload"));
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "text/csv"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(response["message"], json!(r#"A csv payload is missing."#));
+    assert_eq!(response["code"], json!("missing_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#missing_payload"));
+}
+
+#[actix_rt::test]
+async fn error_add_missing_payload_json_documents() {
+    let document = "";
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(response["message"], json!(r#"A json payload is missing."#));
+    assert_eq!(response["code"], json!("missing_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#missing_payload"));
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/json"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(response["message"], json!(r#"A json payload is missing."#));
+    assert_eq!(response["code"], json!("missing_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#missing_payload"));
+}
+
+#[actix_rt::test]
+async fn error_add_missing_payload_ndjson_documents() {
+    let document = "";
+
+    let server = Server::new().await;
+    let app = server.init_web_app().await;
+
+    // post
+    let req = test::TestRequest::post()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/x-ndjson"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(response["message"], json!(r#"A ndjson payload is missing."#));
+    assert_eq!(response["code"], json!("missing_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#missing_payload"));
+
+    // put
+    let req = test::TestRequest::put()
+        .uri("/indexes/dog/documents")
+        .set_payload(document.to_string())
+        .insert_header(("content-type", "application/x-ndjson"))
+        .to_request();
+    let res = test::call_service(&app, req).await;
+    let status_code = res.status();
+    let body = test::read_body(res).await;
+    let response: Value = serde_json::from_slice(&body).unwrap_or_default();
+    assert_eq!(status_code, 400);
+    assert_eq!(response["message"], json!(r#"A ndjson payload is missing."#));
+    assert_eq!(response["code"], json!("missing_payload"));
+    assert_eq!(response["type"], json!("invalid_request"));
+    assert_eq!(response["link"], json!("https://docs.meilisearch.com/errors#missing_payload"));
+}
+
+#[actix_rt::test]
+async fn add_documents_no_index_creation() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "id": 1,
+            "content": "foo",
+        }
+    ]);
+
+    let (response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202);
+    assert_eq!(response["taskUid"], 0);
+    /*
+     * currently we don’t check these field to stay ISO with meilisearch
+     * assert_eq!(response["status"], "pending");
+     * assert_eq!(response["meta"]["type"], "DocumentsAddition");
+     * assert_eq!(response["meta"]["format"], "Json");
+     * assert_eq!(response["meta"]["primaryKey"], Value::Null);
+     * assert!(response.get("enqueuedAt").is_some());
+     */
+
+    index.wait_task(0).await;
+
+    let (response, code) = index.get_task(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+    assert_eq!(response["uid"], 0);
+    assert_eq!(response["type"], "documentAdditionOrUpdate");
+    assert_eq!(response["details"]["receivedDocuments"], 1);
+    assert_eq!(response["details"]["indexedDocuments"], 1);
+
+    let processed_at =
+        OffsetDateTime::parse(response["finishedAt"].as_str().unwrap(), &Rfc3339).unwrap();
+    let enqueued_at =
+        OffsetDateTime::parse(response["enqueuedAt"].as_str().unwrap(), &Rfc3339).unwrap();
+    assert!(processed_at > enqueued_at);
+
+    // index was created, and primary key was inferred.
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "id");
+}
+
+#[actix_rt::test]
+async fn error_document_add_create_index_bad_uid() {
+    let server = Server::new().await;
+    let index = server.index("883  fj!");
+    let (response, code) = index.add_documents(json!([{"id": 1}]), None).await;
+
+    let expected_response = json!({
+        "message": "`883  fj!` is not a valid index uid. Index uid can be an integer or a string containing only alphanumeric characters, hyphens (-) and underscores (_).",
+        "code": "invalid_index_uid",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#invalid_index_uid"
+    });
+
+    assert_eq!(code, 400);
+    assert_eq!(response, expected_response);
+}
+
+#[actix_rt::test]
+async fn document_addition_with_primary_key() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "primary": 1,
+            "content": "foo",
+        }
+    ]);
+    let (response, code) = index.add_documents(documents, Some("primary")).await;
+    assert_eq!(code, 202, "response: {}", response);
+
+    index.wait_task(0).await;
+
+    let (response, code) = index.get_task(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+    assert_eq!(response["uid"], 0);
+    assert_eq!(response["type"], "documentAdditionOrUpdate");
+    assert_eq!(response["details"]["receivedDocuments"], 1);
+    assert_eq!(response["details"]["indexedDocuments"], 1);
+
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "primary");
+}
+
+#[actix_rt::test]
+async fn replace_document() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "content": "foo",
+        }
+    ]);
+
+    let (response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202, "response: {}", response);
+
+    index.wait_task(0).await;
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "other": "bar",
+        }
+    ]);
+
+    let (_response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202);
+
+    index.wait_task(1).await;
+
+    let (response, code) = index.get_task(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+
+    let (response, code) = index.get_document(1, None).await;
+    assert_eq!(code, 200);
+    assert_eq!(response.to_string(), r##"{"doc_id":1,"other":"bar"}"##);
+}
+
+#[actix_rt::test]
+async fn add_no_documents() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.add_documents(json!([]), None).await;
+    assert_eq!(code, 202);
+}
+
+#[actix_rt::test]
+async fn add_larger_dataset() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let update_id = index.load_test_set().await;
+    let (response, code) = index.get_task(update_id).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+    assert_eq!(response["type"], "documentAdditionOrUpdate");
+    assert_eq!(response["details"]["indexedDocuments"], 77);
+    assert_eq!(response["details"]["receivedDocuments"], 77);
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions { limit: Some(1000), ..Default::default() })
+        .await;
+    assert_eq!(code, 200, "failed with `{}`", response);
+    assert_eq!(response["results"].as_array().unwrap().len(), 77);
+}
+
+#[actix_rt::test]
+async fn error_add_documents_bad_document_id() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(Some("docid")).await;
+    let documents = json!([
+        {
+            "docid": "foo & bar",
+            "content": "foobar"
+        }
+    ]);
+    index.add_documents(documents, None).await;
+    index.wait_task(1).await;
+    let (response, code) = index.get_task(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], json!("failed"));
+    assert_eq!(
+        response["error"]["message"],
+        json!(
+            r#"Document identifier `"foo & bar"` is invalid. A document identifier can be of type integer or string, only composed of alphanumeric characters (a-z A-Z 0-9), hyphens (-) and underscores (_)."#
+        )
+    );
+    assert_eq!(response["error"]["code"], json!("invalid_document_id"));
+    assert_eq!(response["error"]["type"], json!("invalid_request"));
+    assert_eq!(
+        response["error"]["link"],
+        json!("https://docs.meilisearch.com/errors#invalid_document_id")
+    );
+}
+
+#[actix_rt::test]
+async fn error_add_documents_missing_document_id() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(Some("docid")).await;
+    let documents = json!([
+        {
+            "id": "11",
+            "content": "foobar"
+        }
+    ]);
+    index.add_documents(documents, None).await;
+    index.wait_task(1).await;
+    let (response, code) = index.get_task(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "failed");
+    assert_eq!(
+        response["error"]["message"],
+        json!(r#"Document doesn't have a `docid` attribute: `{"id":"11","content":"foobar"}`."#)
+    );
+    assert_eq!(response["error"]["code"], json!("missing_document_id"));
+    assert_eq!(response["error"]["type"], json!("invalid_request"));
+    assert_eq!(
+        response["error"]["link"],
+        json!("https://docs.meilisearch.com/errors#missing_document_id")
+    );
+}
+
+#[actix_rt::test]
+#[ignore] // // TODO: Fix in an other PR: this does not provoke any error.
+async fn error_document_field_limit_reached() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    index.create(Some("id")).await;
+
+    let mut big_object = std::collections::HashMap::new();
+    big_object.insert("id".to_owned(), "wow");
+    for i in 0..65535 {
+        let key = i.to_string();
+        big_object.insert(key, "I am a text!");
+    }
+
+    let documents = json!([big_object]);
+
+    let (_response, code) = index.update_documents(documents, Some("id")).await;
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
+    let (response, code) = index.get_task(0).await;
+    assert_eq!(code, 200);
+    // Documents without a primary key are not accepted.
+    assert_eq!(response["status"], "failed");
+
+    let expected_error = json!({
+        "message": "A document cannot contain more than 65,535 fields.",
+        "code": "document_fields_limit_reached",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#document_fields_limit_reached"
+    });
+
+    assert_eq!(response["error"], expected_error);
+}
+
+#[actix_rt::test]
+async fn add_documents_invalid_geo_field() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(Some("id")).await;
+    index.update_settings(json!({"sortableAttributes": ["_geo"]})).await;
+
+    let documents = json!([
+        {
+            "id": "11",
+            "_geo": "foobar"
+        }
+    ]);
+
+    index.add_documents(documents, None).await;
+    index.wait_task(2).await;
+    let (response, code) = index.get_task(2).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "failed");
+}
+
+#[actix_rt::test]
+async fn error_add_documents_payload_size() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(Some("id")).await;
+    let document = json!(
+        {
+            "id": "11",
+            "content": "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec metus erat, consequat in blandit venenatis, ultricies eu ipsum. Etiam luctus elit et mollis ultrices. Nam turpis risus, dictum non eros in, eleifend feugiat elit. Morbi non dolor pulvinar, sagittis mi sed, ultricies lorem. Nulla ultricies sem metus. Donec at suscipit quam, sed elementum mi. Suspendisse potenti. Fusce pharetra turpis tortor, sed eleifend odio dapibus ut. Nulla facilisi. Suspendisse elementum, dui eget aliquet dignissim, ex tellus aliquam nisl, at eleifend nisl metus tempus diam. Mauris fermentum sollicitudin efficitur. Donec dignissim est vitae elit finibus faucibus"
+        }
+    );
+    let documents: Vec<_> = (0..16000).into_iter().map(|_| document.clone()).collect();
+    let documents = json!(documents);
+    let (response, code) = index.add_documents(documents, None).await;
+
+    let expected_response = json!({
+        "message": "The provided payload reached the size limit.",
+        "code": "payload_too_large",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#payload_too_large"
+    });
+
+    assert_eq!(response, expected_response);
+    assert_eq!(code, 413);
+}
+
+#[actix_rt::test]
+async fn error_primary_key_inference() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "title": "11",
+            "desc": "foobar"
+        }
+    ]);
+
+    index.add_documents(documents, None).await;
+    index.wait_task(0).await;
+    let (response, code) = index.get_task(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "failed");
+
+    let expected_error = json!({
+        "message": r#"The primary key inference process failed because the engine did not find any fields containing `id` substring in their name. If your document identifier does not contain any `id` substring, you can set the primary key of the index."#,
+        "code": "primary_key_inference_failed",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#primary_key_inference_failed"
+    });
+
+    assert_eq!(response["error"], expected_error);
+}
+
+#[actix_rt::test]
+async fn add_documents_with_primary_key_twice() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "title": "11",
+            "desc": "foobar"
+        }
+    ]);
+
+    index.add_documents(documents.clone(), Some("title")).await;
+    index.wait_task(0).await;
+    let (response, _code) = index.get_task(0).await;
+    assert_eq!(response["status"], "succeeded");
+
+    index.add_documents(documents, Some("title")).await;
+    index.wait_task(1).await;
+    let (response, _code) = index.get_task(1).await;
+    assert_eq!(response["status"], "succeeded");
+}
+
+#[actix_rt::test]
+async fn batch_several_documents_addition() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let mut documents: Vec<_> = (0..150usize)
+        .into_iter()
+        .map(|id| {
+            json!(
+                {
+                    "id": id,
+                    "title": "foo",
+                    "desc": "bar"
+                }
+            )
+        })
+        .collect();
+
+    documents[100] = json!({"title": "error", "desc": "error"});
+
+    // enqueue batch of documents
+    let mut waiter = Vec::new();
+    for chunk in documents.chunks(30) {
+        waiter.push(index.add_documents(json!(chunk), Some("id")));
+    }
+
+    // wait first batch of documents to finish
+    futures::future::join_all(waiter).await;
+    index.wait_task(4).await;
+
+    // run a second completely failing batch
+    documents[40] = json!({"title": "error", "desc": "error"});
+    documents[70] = json!({"title": "error", "desc": "error"});
+    documents[130] = json!({"title": "error", "desc": "error"});
+    let mut waiter = Vec::new();
+    for chunk in documents.chunks(30) {
+        waiter.push(index.add_documents(json!(chunk), Some("id")));
+    }
+    // wait second batch of documents to finish
+    futures::future::join_all(waiter).await;
+    index.wait_task(9).await;
+
+    let (response, _code) = index.filtered_tasks(&[], &["failed"]).await;
+
+    // Check if only the 6th task failed
+    println!("{}", &response);
+    assert_eq!(response["results"].as_array().unwrap().len(), 5);
+
+    // Check if there are exactly 120 documents (150 - 30) in the index;
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions { limit: Some(200), ..Default::default() })
+        .await;
+    assert_eq!(code, 200, "failed with `{}`", response);
+    assert_eq!(response["results"].as_array().unwrap().len(), 120);
+}

meilisearch/tests/documents/delete_documents.rs

@@ -0,0 +1,137 @@
+use serde_json::json;
+
+use crate::common::{GetAllDocumentsOptions, Server};
+
+#[actix_rt::test]
+async fn delete_one_document_unexisting_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.delete_document(0).await;
+    assert_eq!(code, 202);
+
+    let response = index.wait_task(0).await;
+
+    assert_eq!(response["status"], "failed");
+}
+
+#[actix_rt::test]
+async fn delete_one_unexisting_document() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    let (response, code) = index.delete_document(0).await;
+    assert_eq!(code, 202, "{}", response);
+    let update = index.wait_task(0).await;
+    assert_eq!(update["status"], "succeeded");
+}
+
+#[actix_rt::test]
+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.wait_task(0).await;
+    let (_response, code) = server.index("test").delete_document(0).await;
+    assert_eq!(code, 202);
+    index.wait_task(1).await;
+
+    let (_response, code) = index.get_document(0, None).await;
+    assert_eq!(code, 404);
+}
+
+#[actix_rt::test]
+async fn clear_all_documents_unexisting_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.clear_all_documents().await;
+    assert_eq!(code, 202);
+
+    let response = index.wait_task(0).await;
+
+    assert_eq!(response["status"], "failed");
+}
+
+#[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.wait_task(0).await;
+    let (_response, code) = index.clear_all_documents().await;
+    assert_eq!(code, 202);
+
+    let _update = index.wait_task(1).await;
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert!(response["results"].as_array().unwrap().is_empty());
+}
+
+#[actix_rt::test]
+async fn clear_all_documents_empty_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+
+    let (_response, code) = index.clear_all_documents().await;
+    assert_eq!(code, 202);
+
+    let _update = index.wait_task(0).await;
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert!(response["results"].as_array().unwrap().is_empty());
+}
+
+#[actix_rt::test]
+async fn error_delete_batch_unexisting_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_, code) = index.delete_batch(vec![]).await;
+    let expected_response = json!({
+        "message": "Index `test` not found.",
+        "code": "index_not_found",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#index_not_found"
+    });
+    assert_eq!(code, 202);
+
+    let response = index.wait_task(0).await;
+
+    assert_eq!(response["status"], "failed");
+    assert_eq!(response["error"], expected_response);
+}
+
+#[actix_rt::test]
+async fn delete_batch() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.add_documents(json!([{ "id": 1, "content": "foobar" }, { "id": 0, "content": "foobar" }, { "id": 3, "content": "foobar" }]), Some("id")).await;
+    index.wait_task(0).await;
+    let (_response, code) = index.delete_batch(vec![1, 0]).await;
+    assert_eq!(code, 202);
+
+    let _update = index.wait_task(1).await;
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 1);
+    assert_eq!(response["results"][0]["id"], json!(3));
+}
+
+#[actix_rt::test]
+async fn delete_no_document_batch() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.add_documents(json!([{ "id": 1, "content": "foobar" }, { "id": 0, "content": "foobar" }, { "id": 3, "content": "foobar" }]), Some("id")).await;
+    index.wait_task(0).await;
+    let (_response, code) = index.delete_batch(vec![]).await;
+    assert_eq!(code, 202, "{}", _response);
+
+    let _update = index.wait_task(1).await;
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 3);
+}

meilisearch/tests/documents/get_documents.rs

@@ -0,0 +1,380 @@
+use actix_web::test;
+use http::header::ACCEPT_ENCODING;
+use serde_json::{json, Value};
+use urlencoding::encode as urlencode;
+
+use crate::common::encoder::Encoder;
+use crate::common::{GetAllDocumentsOptions, GetDocumentOptions, Server};
+
+// TODO: partial test since we are testing error, amd error is not yet fully implemented in
+// transplant
+#[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;
+    assert_eq!(code, 404);
+}
+
+#[actix_rt::test]
+async fn error_get_unexisting_document() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    index.wait_task(0).await;
+    let (response, code) = index.get_document(1, None).await;
+
+    let expected_response = json!({
+        "message": "Document `1` not found.",
+        "code": "document_not_found",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#document_not_found"
+    });
+
+    assert_eq!(response, expected_response);
+    assert_eq!(code, 404);
+}
+
+#[actix_rt::test]
+async fn get_document() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    let documents = serde_json::json!([
+        {
+            "id": 0,
+            "nested": { "content": "foobar" },
+        }
+    ]);
+    let (_, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202);
+    index.wait_task(1).await;
+    let (response, code) = index.get_document(0, None).await;
+    assert_eq!(code, 200);
+    assert_eq!(
+        response,
+        serde_json::json!({
+            "id": 0,
+            "nested": { "content": "foobar" },
+        })
+    );
+
+    let (response, code) =
+        index.get_document(0, Some(GetDocumentOptions { fields: Some(vec!["id"]) })).await;
+    assert_eq!(code, 200);
+    assert_eq!(
+        response,
+        serde_json::json!({
+            "id": 0,
+        })
+    );
+
+    let (response, code) = index
+        .get_document(0, Some(GetDocumentOptions { fields: Some(vec!["nested.content"]) }))
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(
+        response,
+        serde_json::json!({
+            "nested": { "content": "foobar" },
+        })
+    );
+}
+
+#[actix_rt::test]
+async fn error_get_unexisting_index_all_documents() {
+    let server = Server::new().await;
+    let (response, code) =
+        server.index("test").get_all_documents(GetAllDocumentsOptions::default()).await;
+
+    let expected_response = json!({
+        "message": "Index `test` not found.",
+        "code": "index_not_found",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#index_not_found"
+    });
+
+    assert_eq!(response, expected_response);
+    assert_eq!(code, 404);
+}
+
+#[actix_rt::test]
+async fn get_no_document() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_, code) = index.create(None).await;
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
+
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert!(response["results"].as_array().unwrap().is_empty());
+}
+
+#[actix_rt::test]
+async fn get_all_documents_no_options() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.load_test_set().await;
+
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    let arr = response["results"].as_array().unwrap();
+    assert_eq!(arr.len(), 20);
+    let first = serde_json::json!({
+        "id":0,
+        "isActive":false,
+        "balance":"$2,668.55",
+        "picture":"http://placehold.it/32x32",
+        "age":36,
+        "color":"Green",
+        "name":"Lucas Hess",
+        "gender":"male",
+        "email":"lucashess@chorizon.com",
+        "phone":"+1 (998) 478-2597",
+        "address":"412 Losee Terrace, Blairstown, Georgia, 2825",
+        "about":"Mollit ad in exercitation quis. Anim est ut consequat fugiat duis magna aliquip velit nisi. Commodo eiusmod est consequat proident consectetur aliqua enim fugiat. Aliqua adipisicing laboris elit proident enim veniam laboris mollit. Incididunt fugiat minim ad nostrud deserunt tempor in. Id irure officia labore qui est labore nulla nisi. Magna sit quis tempor esse consectetur amet labore duis aliqua consequat.\r\n",
+        "registered":"2016-06-21T09:30:25 -02:00",
+        "latitude":-44.174957,
+        "longitude":-145.725388,
+        "tags":["bug"
+            ,"bug"]});
+    assert_eq!(first, arr[0]);
+}
+
+#[actix_rt::test]
+async fn get_all_documents_no_options_with_response_compression() {
+    let server = Server::new().await;
+    let index_uid = "test";
+    let index = server.index(index_uid);
+    index.load_test_set().await;
+
+    let app = server.init_web_app().await;
+    let req = test::TestRequest::get()
+        .uri(&format!("/indexes/{}/documents?", urlencode(index_uid)))
+        .insert_header((ACCEPT_ENCODING, "gzip"))
+        .to_request();
+
+    let res = test::call_service(&app, req).await;
+
+    assert_eq!(res.status(), 200);
+
+    let bytes = test::read_body(res).await;
+    let decoded = Encoder::Gzip.decode(bytes);
+    let parsed_response =
+        serde_json::from_slice::<Value>(decoded.into().as_ref()).expect("Expecting valid json");
+
+    let arr = parsed_response["results"].as_array().unwrap();
+    assert_eq!(arr.len(), 20);
+}
+
+#[actix_rt::test]
+async fn test_get_all_documents_limit() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.load_test_set().await;
+
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions { limit: Some(5), ..Default::default() })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 5);
+    assert_eq!(response["results"][0]["id"], json!(0));
+    assert_eq!(response["offset"], json!(0));
+    assert_eq!(response["limit"], json!(5));
+    assert_eq!(response["total"], json!(77));
+}
+
+#[actix_rt::test]
+async fn test_get_all_documents_offset() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.load_test_set().await;
+
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions { offset: Some(5), ..Default::default() })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    assert_eq!(response["results"][0]["id"], json!(5));
+    assert_eq!(response["offset"], json!(5));
+    assert_eq!(response["limit"], json!(20));
+    assert_eq!(response["total"], json!(77));
+}
+
+#[actix_rt::test]
+async fn test_get_all_documents_attributes_to_retrieve() {
+    let server = Server::new().await;
+    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;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    for results in response["results"].as_array().unwrap() {
+        assert_eq!(results.as_object().unwrap().keys().count(), 1);
+        assert!(results["name"] != json!(null));
+    }
+    assert_eq!(response["offset"], json!(0));
+    assert_eq!(response["limit"], json!(20));
+    assert_eq!(response["total"], json!(77));
+
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec![]),
+            ..Default::default()
+        })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    for results in response["results"].as_array().unwrap() {
+        assert_eq!(results.as_object().unwrap().keys().count(), 0);
+    }
+    assert_eq!(response["offset"], json!(0));
+    assert_eq!(response["limit"], json!(20));
+    assert_eq!(response["total"], json!(77));
+
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec!["wrong"]),
+            ..Default::default()
+        })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    for results in response["results"].as_array().unwrap() {
+        assert_eq!(results.as_object().unwrap().keys().count(), 0);
+    }
+    assert_eq!(response["offset"], json!(0));
+    assert_eq!(response["limit"], json!(20));
+    assert_eq!(response["total"], json!(77));
+
+    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["results"].as_array().unwrap().len(), 20);
+    for results in response["results"].as_array().unwrap() {
+        assert_eq!(results.as_object().unwrap().keys().count(), 2);
+        assert!(results["name"] != json!(null));
+        assert!(results["tags"] != json!(null));
+    }
+
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec!["*"]),
+            ..Default::default()
+        })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    for results in response["results"].as_array().unwrap() {
+        assert_eq!(results.as_object().unwrap().keys().count(), 16);
+    }
+
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions {
+            attributes_to_retrieve: Some(vec!["*", "wrong"]),
+            ..Default::default()
+        })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    for results in response["results"].as_array().unwrap() {
+        assert_eq!(results.as_object().unwrap().keys().count(), 16);
+    }
+}
+
+#[actix_rt::test]
+async fn get_document_s_nested_attributes_to_retrieve() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    let documents = json!([
+        {
+            "id": 0,
+            "content.truc": "foobar",
+        },
+        {
+            "id": 1,
+            "content": {
+                "truc": "foobar",
+                "machin": "bidule",
+            },
+        },
+    ]);
+    let (_, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202);
+    index.wait_task(1).await;
+
+    let (response, code) =
+        index.get_document(0, Some(GetDocumentOptions { fields: Some(vec!["content"]) })).await;
+    assert_eq!(code, 200);
+    assert_eq!(response, json!({}));
+    let (response, code) =
+        index.get_document(1, Some(GetDocumentOptions { fields: Some(vec!["content"]) })).await;
+    assert_eq!(code, 200);
+    assert_eq!(
+        response,
+        json!({
+            "content": {
+                "truc": "foobar",
+                "machin": "bidule",
+            },
+        })
+    );
+
+    let (response, code) = index
+        .get_document(0, Some(GetDocumentOptions { fields: Some(vec!["content.truc"]) }))
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(
+        response,
+        json!({
+            "content.truc": "foobar",
+        })
+    );
+    let (response, code) = index
+        .get_document(1, Some(GetDocumentOptions { fields: Some(vec!["content.truc"]) }))
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(
+        response,
+        json!({
+            "content": {
+                "truc": "foobar",
+            },
+        })
+    );
+}
+
+#[actix_rt::test]
+async fn get_documents_displayed_attributes_is_ignored() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.update_settings(json!({"displayedAttributes": ["gender"]})).await;
+    index.load_test_set().await;
+
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 20);
+    assert_eq!(response["results"][0].as_object().unwrap().keys().count(), 16);
+    assert!(response["results"][0]["gender"] != json!(null));
+
+    assert_eq!(response["offset"], json!(0));
+    assert_eq!(response["limit"], json!(20));
+    assert_eq!(response["total"], json!(77));
+
+    let (response, code) = index.get_document(0, None).await;
+    assert_eq!(code, 200);
+    assert_eq!(response.as_object().unwrap().keys().count(), 16);
+    assert!(response.as_object().unwrap().get("gender").is_some());
+}

meilisearch/tests/documents/mod.rs

@@ -0,0 +1,4 @@
+mod add_documents;
+mod delete_documents;
+mod get_documents;
+mod update_documents;

meilisearch/tests/documents/update_documents.rs

@@ -0,0 +1,198 @@
+use serde_json::json;
+
+use crate::common::encoder::Encoder;
+use crate::common::{GetAllDocumentsOptions, Server};
+
+#[actix_rt::test]
+async fn error_document_update_create_index_bad_uid() {
+    let server = Server::new().await;
+    let index = server.index("883  fj!");
+    let (response, code) = index.update_documents(json!([{"id": 1}]), None).await;
+
+    let expected_response = json!({
+        "message": "`883  fj!` is not a valid index uid. Index uid can be an integer or a string containing only alphanumeric characters, hyphens (-) and underscores (_).",
+        "code": "invalid_index_uid",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#invalid_index_uid"
+    });
+
+    assert_eq!(code, 400);
+    assert_eq!(response, expected_response);
+}
+
+#[actix_rt::test]
+async fn document_update_with_primary_key() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "primary": 1,
+            "content": "foo",
+        }
+    ]);
+    let (_response, code) = index.update_documents(documents, Some("primary")).await;
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
+
+    let (response, code) = index.get_task(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+    assert_eq!(response["uid"], 0);
+    assert_eq!(response["type"], "documentAdditionOrUpdate");
+    assert_eq!(response["details"]["indexedDocuments"], 1);
+    assert_eq!(response["details"]["receivedDocuments"], 1);
+
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "primary");
+}
+
+#[actix_rt::test]
+async fn update_document() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "content": "foo",
+        }
+    ]);
+
+    let (_response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "other": "bar",
+        }
+    ]);
+
+    let (response, code) = index.update_documents(documents, None).await;
+    assert_eq!(code, 202, "response: {}", response);
+
+    index.wait_task(1).await;
+
+    let (response, code) = index.get_task(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+
+    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"}"##);
+}
+
+#[actix_rt::test]
+async fn update_document_gzip_encoded() {
+    let server = Server::new().await;
+    let index = server.index_with_encoder("test", Encoder::Gzip);
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "content": "foo",
+        }
+    ]);
+
+    let (_response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "other": "bar",
+        }
+    ]);
+
+    let (response, code) = index.update_documents(documents, None).await;
+    assert_eq!(code, 202, "response: {}", response);
+
+    index.wait_task(1).await;
+
+    let (response, code) = index.get_task(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "succeeded");
+
+    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"}"##);
+}
+
+#[actix_rt::test]
+async fn update_larger_dataset() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let documents = serde_json::from_str(include_str!("../assets/test_set.json")).unwrap();
+    index.update_documents(documents, None).await;
+    index.wait_task(0).await;
+    let (response, code) = index.get_task(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["type"], "documentAdditionOrUpdate");
+    assert_eq!(response["details"]["indexedDocuments"], 77);
+    let (response, code) = index
+        .get_all_documents(GetAllDocumentsOptions { limit: Some(1000), ..Default::default() })
+        .await;
+    assert_eq!(code, 200);
+    assert_eq!(response["results"].as_array().unwrap().len(), 77);
+}
+
+#[actix_rt::test]
+async fn error_update_documents_bad_document_id() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(Some("docid")).await;
+    let documents = json!([
+        {
+            "docid": "foo & bar",
+            "content": "foobar"
+        }
+    ]);
+    index.update_documents(documents, None).await;
+    let response = index.wait_task(1).await;
+    assert_eq!(response["status"], json!("failed"));
+    assert_eq!(
+        response["error"]["message"],
+        json!(
+            r#"Document identifier `"foo & bar"` is invalid. A document identifier can be of type integer or string, only composed of alphanumeric characters (a-z A-Z 0-9), hyphens (-) and underscores (_)."#
+        )
+    );
+    assert_eq!(response["error"]["code"], json!("invalid_document_id"));
+    assert_eq!(response["error"]["type"], json!("invalid_request"));
+    assert_eq!(
+        response["error"]["link"],
+        json!("https://docs.meilisearch.com/errors#invalid_document_id")
+    );
+}
+
+#[actix_rt::test]
+async fn error_update_documents_missing_document_id() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(Some("docid")).await;
+    let documents = json!([
+        {
+            "id": "11",
+            "content": "foobar"
+        }
+    ]);
+    index.update_documents(documents, None).await;
+    let response = index.wait_task(1).await;
+    assert_eq!(response["status"], "failed");
+    assert_eq!(
+        response["error"]["message"],
+        r#"Document doesn't have a `docid` attribute: `{"id":"11","content":"foobar"}`."#
+    );
+    assert_eq!(response["error"]["code"], "missing_document_id");
+    assert_eq!(response["error"]["type"], "invalid_request");
+    assert_eq!(
+        response["error"]["link"],
+        "https://docs.meilisearch.com/errors#missing_document_id"
+    );
+}