Merge pull request #49 from meilisearch/tests

tests

src/data/mod.rs

@@ -122,7 +122,7 @@ impl Data {
         Ok(self
             .list_indexes()?
             .into_iter()
-            .find(|i| i.name == name.as_ref()))
+            .find(|i| i.uid == name.as_ref()))
     }
 
     pub fn create_index(&self, name: impl AsRef<str>, primary_key: Option<impl AsRef<str>>) -> anyhow::Result<IndexMetadata> {

src/data/updates.rs

@@ -1,13 +1,13 @@
 use std::ops::Deref;
 
-use milli::update::{IndexDocumentsMethod, UpdateFormat};
 use async_compression::tokio_02::write::GzipEncoder;
 use futures_util::stream::StreamExt;
+use milli::update::{IndexDocumentsMethod, UpdateFormat};
 use tokio::io::AsyncWriteExt;
 
-use super::Data;
-use crate::index_controller::{IndexController, Settings, IndexSettings, IndexMetadata};
 use crate::index_controller::UpdateStatus;
+use crate::index_controller::{IndexController, Settings, IndexSettings, IndexMetadata};
+use super::Data;
 
 impl Data {
     pub async fn add_documents<B, E>(

src/index_controller/local_index_controller/mod.rs

@@ -70,7 +70,7 @@ impl IndexController for LocalIndexController {
         }
 
         let meta = IndexMetadata {
-            name: index_name,
+            uid: index_name,
             uuid: meta.uuid.clone(),
             created_at: meta.created_at,
             updated_at: meta.created_at,
@@ -124,18 +124,18 @@ impl IndexController for LocalIndexController {
     fn list_indexes(&self) -> anyhow::Result<Vec<IndexMetadata>> {
         let metas = self.indexes.list_indexes()?;
         let mut output_meta = Vec::new();
-        for (name, meta, primary_key) in metas {
+        for (uid, meta, primary_key) in metas {
             let created_at = meta.created_at;
             let uuid = meta.uuid;
             let updated_at = self
-                .all_update_status(&name)?
+                .all_update_status(&uid)?
                 .iter()
                 .filter_map(|u| u.processed().map(|u| u.processed_at))
                 .max()
                 .unwrap_or(created_at);
 
             let index_meta = IndexMetadata {
-                name,
+                uid,
                 created_at,
                 updated_at,
                 uuid,
@@ -146,7 +146,7 @@ impl IndexController for LocalIndexController {
         Ok(output_meta)
     }
 
-    fn update_index(&self, name: impl AsRef<str>, index_settings: IndexSettings) -> anyhow::Result<IndexMetadata> {
+    fn update_index(&self, uid: impl AsRef<str>, index_settings: IndexSettings) -> anyhow::Result<IndexMetadata> {
         if index_settings.name.is_some() {
             bail!("can't udpate an index name.")
         }
@@ -154,7 +154,7 @@ impl IndexController for LocalIndexController {
         let (primary_key, meta) = match index_settings.primary_key {
             Some(ref primary_key) => {
                 self.indexes
-                    .update_index(&name, |index| {
+                    .update_index(&uid, |index| {
                         let mut txn = index.write_txn()?;
                         if index.primary_key(&txn)?.is_some() {
                             bail!("primary key already exists.")
@@ -166,8 +166,8 @@ impl IndexController for LocalIndexController {
             },
             None => {
                 let (index, meta) = self.indexes
-                    .index_with_meta(&name)?
-                    .with_context(|| format!("index {:?} doesn't exist.", name.as_ref()))?;
+                    .index_with_meta(&uid)?
+                    .with_context(|| format!("index {:?} doesn't exist.", uid.as_ref()))?;
                 let primary_key = index
                     .primary_key(&index.read_txn()?)?
                     .map(String::from);
@@ -176,7 +176,7 @@ impl IndexController for LocalIndexController {
         };
 
         Ok(IndexMetadata {
-            name: name.as_ref().to_string(),
+            uid: uid.as_ref().to_string(),
             uuid: meta.uuid.clone(),
             created_at: meta.created_at,
             updated_at: meta.updated_at,

src/index_controller/mod.rs

@@ -21,7 +21,7 @@ pub type UpdateStatus = updates::UpdateStatus<UpdateMeta, UpdateResult, String>;
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct IndexMetadata {
-    pub name: String,
+    pub uid: String,
     uuid: Uuid,
     created_at: DateTime<Utc>,
     updated_at: DateTime<Utc>,
@@ -223,8 +223,8 @@ pub(crate) mod test {
 
         let indexes = controller.list_indexes().unwrap();
         assert_eq!(indexes.len(), 2);
-        assert_eq!(indexes[0].name, "test_index");
-        assert_eq!(indexes[1].name, "test_index2");
+        assert_eq!(indexes[0].uid, "test_index");
+        assert_eq!(indexes[1].uid, "test_index2");
         assert_eq!(indexes[1].primary_key.clone().unwrap(), "foo");
     }
 
@@ -252,7 +252,7 @@ pub(crate) mod test {
         };
 
         let result = controller.update_index("test", settings).unwrap();
-        assert_eq!(result.name, "test");
+        assert_eq!(result.uid, "test");
         assert_eq!(result.created_at, result.updated_at);
         assert!(result.primary_key.is_none());
 
@@ -271,7 +271,7 @@ pub(crate) mod test {
         };
 
         let result = controller.update_index("test", settings.clone()).unwrap();
-        assert_eq!(result.name, "test");
+        assert_eq!(result.uid, "test");
         assert!(result.created_at < result.updated_at);
         assert_eq!(result.primary_key.unwrap(), "foo");
 

src/index_controller/updates.rs

@@ -2,6 +2,7 @@ use chrono::{Utc, DateTime};
 use serde::{Serialize, Deserialize};
 
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct Pending<M> {
     pub update_id: u64,
     pub meta: M,
@@ -41,6 +42,7 @@ impl<M> Pending<M> {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct Processed<M, N> {
     pub success: N,
     pub processed_at: DateTime<Utc>,
@@ -55,6 +57,7 @@ impl<M, N> Processed<M, N> {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct Processing<M> {
     #[serde(flatten)]
     pub from: Pending<M>,
@@ -88,6 +91,7 @@ impl<M> Processing<M> {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct Aborted<M> {
     #[serde(flatten)]
     from: Pending<M>,
@@ -101,6 +105,7 @@ impl<M> Aborted<M> {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
 pub struct Failed<M, E> {
     #[serde(flatten)]
     from: Processing<M>,
@@ -115,7 +120,7 @@ impl<M, E> Failed<M, E> {
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Serialize)]
-#[serde(tag = "status")]
+#[serde(tag = "status", rename_all = "camelCase")]
 pub enum UpdateStatus<M, N, E> {
     Processing(Processing<M>),
     Pending(Pending<M>),

src/option.rs

@@ -64,7 +64,6 @@ pub struct IndexerOpts {
     pub indexing_jobs: Option<usize>,
 }
 
-#[cfg(test)]
 impl Default for IndexerOpts {
     fn default() -> Self {
         Self {
@@ -104,8 +103,8 @@ pub struct Opt {
     pub sentry_dsn: String,
 
     /// Disable Sentry error reporting.
-    #[cfg(all(not(debug_assertions), feature = "sentry"))]
     #[structopt(long, env = "MEILI_NO_SENTRY")]
+    #[cfg(all(not(debug_assertions), feature = "sentry"))]
     pub no_sentry: bool,
 
     /// This environment variable must be set to `production` if you are running in production.

src/routes/index.rs

@@ -52,7 +52,7 @@ async fn get_index(
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase", deny_unknown_fields)]
 struct IndexCreateRequest {
-    name: String,
+    uid: String,
     primary_key: Option<String>,
 }
 
@@ -61,7 +61,7 @@ async fn create_index(
     data: web::Data<Data>,
     body: web::Json<IndexCreateRequest>,
 ) -> Result<HttpResponse, ResponseError> {
-    match data.create_index(&body.name, body.primary_key.clone()) {
+    match data.create_index(&body.uid, body.primary_key.clone()) {
         Ok(meta) => {
             let json = serde_json::to_string(&meta).unwrap();
             Ok(HttpResponse::Ok().body(json))

src/routes/settings/mod.rs

@@ -1,5 +1,4 @@
 use actix_web::{web, HttpResponse, delete, get, post};
-use log::error;
 
 use crate::Data;
 use crate::error::ResponseError;
@@ -33,8 +32,7 @@ macro_rules! make_setting_route {
                         Ok(HttpResponse::Ok().body(json))
                     }
                     Err(e) => {
-                        log::error!("{}", e);
-                        unimplemented!();
+                        Ok(HttpResponse::BadRequest().body(serde_json::json!({ "error": e.to_string() })))
                     }
                 }
             }
@@ -56,8 +54,7 @@ macro_rules! make_setting_route {
                         Ok(HttpResponse::Ok().body(json))
                     }
                     Err(e) => {
-                        log::error!("{}", e);
-                        unimplemented!();
+                        Ok(HttpResponse::BadRequest().body(serde_json::json!({ "error": e.to_string() })))
                     }
                 }
             }
@@ -74,8 +71,7 @@ macro_rules! make_setting_route {
                         Ok(HttpResponse::Ok().body(json))
                     }
                     Err(e) => {
-                        log::error!("{}", e);
-                        unimplemented!();
+                        Ok(HttpResponse::BadRequest().body(serde_json::json!({ "error": e.to_string() })))
                     }
                 }
             }
@@ -147,8 +143,7 @@ async fn update_all(
             Ok(HttpResponse::Ok().body(json))
         }
         Err(e) => {
-            error!("{}", e);
-            unimplemented!();
+            Ok(HttpResponse::BadRequest().body(serde_json::json!({ "error": e.to_string() })))
         }
     }
 }
@@ -164,8 +159,7 @@ async fn get_all(
             Ok(HttpResponse::Ok().body(json))
         }
         Err(e) => {
-            error!("{}", e);
-            unimplemented!();
+            Ok(HttpResponse::BadRequest().body(serde_json::json!({ "error": e.to_string() })))
         }
     }
 }
@@ -182,8 +176,7 @@ async fn delete_all(
             Ok(HttpResponse::Ok().body(json))
         }
         Err(e) => {
-            error!("{}", e);
-            unimplemented!();
+            Ok(HttpResponse::BadRequest().body(serde_json::json!({ "error": e.to_string() })))
         }
     }
 }

tests/common/index.rs

@@ -0,0 +1,158 @@
+use std::time::Duration;
+
+use actix_web::http::StatusCode;
+use serde_json::{json, Value};
+use tokio::time::delay_for;
+
+use super::service::Service;
+
+pub struct Index<'a> {
+    pub uid: String,
+    pub service: &'a Service,
+}
+
+impl Index<'_> {
+    pub async fn get(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}", self.uid);
+        self.service.get(url).await
+    }
+
+    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;
+        assert_eq!(code, 200);
+        let update_id = response["updateId"].as_i64().unwrap();
+        self.wait_update_id(update_id as u64).await;
+        update_id as u64
+    }
+
+    pub async fn create<'a>(&'a self, primary_key: Option<&str>) -> (Value, StatusCode) {
+        let body = json!({
+            "uid": self.uid,
+            "primaryKey": primary_key,
+        });
+        self.service.post("/indexes", body).await
+    }
+
+    pub async fn update(&self, primary_key: Option<&str>) -> (Value, StatusCode) {
+        let body = json!({
+            "primaryKey": primary_key,
+        });
+        let url = format!("/indexes/{}", self.uid);
+
+        self.service.put(url, body).await
+    }
+
+    pub async fn delete(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}", self.uid);
+        self.service.delete(url).await
+    }
+
+    pub async fn add_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),
+        };
+        self.service.post(url, documents).await
+    }
+
+    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),
+        };
+        self.service.put(url, documents).await
+    }
+
+    pub async fn wait_update_id(&self, update_id: u64) -> Value {
+        // try 10 times to get status, or panic to not wait forever
+        let url = format!("/indexes/{}/updates/{}", self.uid, update_id);
+        for _ in 0..10 {
+            let (response, status_code) = self.service.get(&url).await;
+            assert_eq!(status_code, 200);
+
+            if response["status"] == "processed" || response["status"] == "failed" {
+                return response;
+            }
+
+            delay_for(Duration::from_secs(1)).await;
+        }
+        panic!("Timeout waiting for update id");
+    }
+
+    pub async fn get_update(&self, udpate_id: u64) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/updates/{}", self.uid, udpate_id);
+        self.service.get(url).await
+    }
+
+    #[allow(dead_code)]
+    pub async fn list_updates(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/updates", self.uid);
+        self.service.get(url).await
+    }
+
+    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
+    }
+
+    pub async fn get_all_documents(&self, options: GetAllDocumentsOptions) -> (Value, StatusCode) {
+        let mut url = format!("/indexes/{}/documents?", self.uid);
+        if let Some(limit) = options.limit {
+            url.push_str(&format!("limit={}&", limit));
+        }
+
+        if let Some(offset) = options.offset {
+            url.push_str(&format!("offset={}&", offset));
+        }
+
+        if let Some(attributes_to_retrieve) = options.attributes_to_retrieve {
+            url.push_str(&format!("attributesToRetrieve={}&", attributes_to_retrieve.join(",")));
+        }
+
+        self.service.get(url).await
+    }
+
+    pub async fn delete_document(&self, id: u64) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/documents/{}", self.uid, id);
+        self.service.delete(url).await
+    }
+
+    pub async fn clear_all_documents(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/documents", self.uid);
+        self.service.delete(url).await
+    }
+
+    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
+    }
+
+    pub async fn settings(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/settings", self.uid);
+        self.service.get(url).await
+    }
+
+    pub async fn update_settings(&self, settings: Value) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/settings", self.uid);
+        self.service.post(url, settings).await
+    }
+
+    pub async fn delete_settings(&self) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/settings", self.uid);
+        self.service.delete(url).await
+    }
+}
+
+pub struct GetDocumentOptions;
+
+#[derive(Debug, Default)]
+pub struct GetAllDocumentsOptions {
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+    pub attributes_to_retrieve: Option<Vec<&'static str>>,
+}

tests/common/mod.rs

@@ -0,0 +1,31 @@
+mod index;
+mod server;
+mod service;
+
+pub use server::Server;
+pub use index::{GetDocumentOptions, GetAllDocumentsOptions};
+
+/// Performs a search test on both post and get routes
+#[macro_export]
+macro_rules! test_post_get_search {
+    ($server:expr, $query:expr, |$response:ident, $status_code:ident | $block:expr) => {
+        let post_query: meilisearch_http::routes::search::SearchQueryPost =
+            serde_json::from_str(&$query.clone().to_string()).unwrap();
+        let get_query: meilisearch_http::routes::search::SearchQuery = post_query.into();
+        let get_query = ::serde_url_params::to_string(&get_query).unwrap();
+        let ($response, $status_code) = $server.search_get(&get_query).await;
+        let _ = ::std::panic::catch_unwind(|| $block).map_err(|e| {
+            panic!(
+                "panic in get route: {:?}",
+                e.downcast_ref::<&str>().unwrap()
+            )
+        });
+        let ($response, $status_code) = $server.search_post($query).await;
+        let _ = ::std::panic::catch_unwind(|| $block).map_err(|e| {
+            panic!(
+                "panic in post route: {:?}",
+                e.downcast_ref::<&str>().unwrap()
+            )
+        });
+    };
+}

tests/common/server.rs

@@ -0,0 +1,71 @@
+use tempdir::TempDir;
+use byte_unit::{Byte, ByteUnit};
+use serde_json::Value;
+use actix_web::http::StatusCode;
+
+use meilisearch_http::data::Data;
+use meilisearch_http::option::{Opt, IndexerOpts};
+
+use super::index::Index;
+use super::service::Service;
+
+pub struct Server {
+    pub service: Service,
+}
+
+impl Server {
+    pub async fn new() -> Self {
+        let tmp_dir = TempDir::new("meilisearch").unwrap();
+
+        let opt = Opt {
+            db_path: tmp_dir.path().join("db"),
+            dumps_dir: tmp_dir.path().join("dump"),
+            dump_batch_size: 16,
+            http_addr: "127.0.0.1:7700".to_owned(),
+            master_key: None,
+            env: "development".to_owned(),
+            no_analytics: true,
+            max_mdb_size: Byte::from_unit(4.0, ByteUnit::GiB).unwrap(),
+            max_udb_size: Byte::from_unit(4.0, ByteUnit::GiB).unwrap(),
+            http_payload_size_limit: Byte::from_unit(10.0, ByteUnit::MiB).unwrap(),
+            ssl_cert_path: None,
+            ssl_key_path: None,
+            ssl_auth_path: None,
+            ssl_ocsp_path: None,
+            ssl_require_auth: false,
+            ssl_resumption: false,
+            ssl_tickets: false,
+            import_snapshot: None,
+            ignore_missing_snapshot: false,
+            ignore_snapshot_if_db_exists: false,
+            snapshot_dir: ".".into(),
+            schedule_snapshot: false,
+            snapshot_interval_sec: None,
+            import_dump: None,
+            indexer_options: IndexerOpts::default(),
+            #[cfg(all(not(debug_assertions), feature = "sentry"))]
+            sentry_dsn: String::from(""),
+            #[cfg(all(not(debug_assertions), feature = "sentry"))]
+            no_sentry: true,
+        };
+
+        let data = Data::new(opt).unwrap();
+        let service = Service(data);
+
+        Server {
+            service,
+        }
+    }
+
+    /// Returns a view to an index. There is no guarantee that the index exists.
+    pub fn index<'a>(&'a self, uid: impl AsRef<str>) -> Index<'a> {
+        Index {
+            uid: uid.as_ref().to_string(),
+            service: &self.service,
+        }
+    }
+
+    pub async fn list_indexes(&self) -> (Value, StatusCode) {
+        self.service.get("/indexes").await
+    }
+}

tests/common/service.rs

@@ -0,0 +1,85 @@
+use actix_web::{http::StatusCode, test};
+use serde_json::Value;
+
+use meilisearch_http::data::Data;
+use meilisearch_http::helpers::NormalizePath;
+
+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(meilisearch_http::create_app(&self.0, true).wrap(NormalizePath)).await;
+
+        let req = test::TestRequest::post()
+            .uri(url.as_ref())
+            .set_json(&body)
+            .to_request();
+        let res = test::call_service(&mut app, req).await;
+        let status_code = res.status();
+
+        let body = test::read_body(res).await;
+        let response = serde_json::from_slice(&body).unwrap_or_default();
+        (response, status_code)
+    }
+
+    /// 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(meilisearch_http::create_app(&self.0, true).wrap(NormalizePath)).await;
+
+        let req = test::TestRequest::post()
+            .uri(url.as_ref())
+            .set_payload(body.as_ref().to_string())
+            .header("content-type", "application/json")
+            .to_request();
+        let res = test::call_service(&mut app, req).await;
+        let status_code = res.status();
+
+        let body = test::read_body(res).await;
+        let response = serde_json::from_slice(&body).unwrap_or_default();
+        (response, status_code)
+    }
+
+    pub async fn get(&self, url: impl AsRef<str>) -> (Value, StatusCode) {
+        let mut app =
+            test::init_service(meilisearch_http::create_app(&self.0, true).wrap(NormalizePath)).await;
+
+        let req = test::TestRequest::get().uri(url.as_ref()).to_request();
+        let res = test::call_service(&mut app, req).await;
+        let status_code = res.status();
+
+        let body = test::read_body(res).await;
+        let response = serde_json::from_slice(&body).unwrap_or_default();
+        (response, status_code)
+    }
+
+    pub async fn put(&self, url: impl AsRef<str>, body: Value) -> (Value, StatusCode) {
+        let mut app =
+            test::init_service(meilisearch_http::create_app(&self.0, true).wrap(NormalizePath)).await;
+
+        let req = test::TestRequest::put()
+            .uri(url.as_ref())
+            .set_json(&body)
+            .to_request();
+        let res = test::call_service(&mut app, req).await;
+        let status_code = res.status();
+
+        let body = test::read_body(res).await;
+        let response = serde_json::from_slice(&body).unwrap_or_default();
+        (response, status_code)
+    }
+
+    pub async fn delete(&self, url: impl AsRef<str>) -> (Value, StatusCode) {
+        let mut app =
+            test::init_service(meilisearch_http::create_app(&self.0, true).wrap(NormalizePath)).await;
+
+        let req = test::TestRequest::delete().uri(url.as_ref()).to_request();
+        let res = test::call_service(&mut app, req).await;
+        let status_code = res.status();
+
+        let body = test::read_body(res).await;
+        let response = serde_json::from_slice(&body).unwrap_or_default();
+        (response, status_code)
+    }
+}

tests/documents/add_documents.rs

@@ -0,0 +1,318 @@
+use serde_json::{json, Value};
+use chrono::DateTime;
+
+use crate::common::{Server, GetAllDocumentsOptions};
+
+#[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, 200);
+    assert_eq!(response["status"], "pending");
+    assert_eq!(response["updateId"], 0);
+    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_update_id(0).await;
+
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    println!("response: {}", response);
+    assert_eq!(response["status"], "processed");
+    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();
+    assert!(processed_at > started_processing_at);
+    assert!(started_processing_at > enqueued_at);
+
+    // index was created, and primary key was infered.
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "id");
+}
+
+#[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, 200);
+
+    index.wait_update_id(0).await;
+
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+    assert_eq!(response["updateId"], 0);
+    assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 1);
+
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "primary");
+}
+
+#[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, 200);
+
+    index.wait_update_id(0).await;
+
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+    assert_eq!(response["updateId"], 0);
+    assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 1);
+
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "primary");
+}
+
+#[actix_rt::test]
+async fn add_documents_with_primary_key_and_primary_key_already_exists() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    index.create(Some("primary")).await;
+    let documents = json!([
+        {
+            "id": 1,
+            "content": "foo",
+        }
+    ]);
+
+    let (_response, code) = index.add_documents(documents, Some("id")).await;
+    assert_eq!(code, 200);
+
+    index.wait_update_id(0).await;
+
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+    assert_eq!(response["updateId"], 0);
+    assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 1);
+
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], "primary");
+}
+
+#[actix_rt::test]
+async fn update_documents_with_primary_key_and_primary_key_already_exists() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    index.create(Some("primary")).await;
+    let documents = json!([
+        {
+            "id": 1,
+            "content": "foo",
+        }
+    ]);
+
+    let (_response, code) = index.update_documents(documents, Some("id")).await;
+    assert_eq!(code, 200);
+
+    index.wait_update_id(0).await;
+let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+    assert_eq!(response["updateId"], 0);
+    assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 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, 200);
+
+    index.wait_update_id(0).await;
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "other": "bar",
+        }
+    ]);
+
+    let (_response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 200);
+
+    index.wait_update_id(1).await;
+
+    let (response, code) = index.get_update(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+
+    let (response, code) = index.get_document(1, None).await;
+    assert_eq!(code, 200);
+    assert_eq!(response.to_string(), r##"{"doc_id":1,"other":"bar"}"##);
+}
+
+// test broken, see issue milli#92
+#[actix_rt::test]
+#[ignore]
+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, 200);
+
+    index.wait_update_id(0).await;
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+    assert_eq!(response["updateId"], 0);
+    assert_eq!(response["success"]["DocumentsAddition"]["nb_documents"], 0);
+
+    let (response, code) = index.get().await;
+    assert_eq!(code, 200);
+    assert_eq!(response["primaryKey"], Value::Null);
+}
+
+#[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, 200);
+
+    index.wait_update_id(0).await;
+
+    let documents = json!([
+        {
+            "doc_id": 1,
+            "other": "bar",
+        }
+    ]);
+
+    let (_response, code) = index.update_documents(documents, None).await;
+    assert_eq!(code, 200);
+
+    index.wait_update_id(1).await;
+
+    let (response, code) = index.get_update(1).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "processed");
+
+    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 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_update(update_id).await;
+    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;
+    assert_eq!(code, 200);
+    assert_eq!(response.as_array().unwrap().len(), 77);
+}
+
+#[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_update_id(0).await;
+    let (response, code) = index.get_update(0).await;
+    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;
+    assert_eq!(code, 200);
+    assert_eq!(response.as_array().unwrap().len(), 77);
+}
+
+#[actix_rt::test]
+async fn add_documents_bad_primary_key() {
+    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_update_id(0).await;
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "failed");
+}
+
+#[actix_rt::test]
+async fn update_documents_bad_primary_key() {
+    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;
+    index.wait_update_id(0).await;
+    let (response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    assert_eq!(response["status"], "failed");
+}

tests/documents/delete_documents.rs

@@ -0,0 +1,112 @@
+use serde_json::json;
+
+use crate::common::{Server, GetAllDocumentsOptions};
+
+#[actix_rt::test]
+async fn delete_one_document_unexisting_index() {
+    let server = Server::new().await;
+    let (_response, code) = server.index("test").delete_document(0).await;
+    assert_eq!(code, 400);
+}
+
+#[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, 200);
+    let update = index.wait_update_id(0).await;
+    assert_eq!(update["status"], "processed");
+}
+
+#[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_update_id(0).await;
+    let (_response, code) = server.index("test").delete_document(0).await;
+    assert_eq!(code, 200);
+    index.wait_update_id(1).await;
+
+    let (_response, code) = index.get_document(0, None).await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+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.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;
+    assert_eq!(code, 200);
+    assert!(response.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, 200);
+
+    let _update = index.wait_update_id(0).await;
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert!(response.as_array().unwrap().is_empty());
+}
+
+#[actix_rt::test]
+async fn delete_batch_unexisting_index() {
+    let server = Server::new().await;
+    let (_response, code) = server.index("test").delete_batch(vec![]).await;
+    assert_eq!(code, 400);
+}
+
+#[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_update_id(0).await;
+    let (_response, code) = index.delete_batch(vec![1, 0]).await;
+    assert_eq!(code, 200);
+
+    let _update = index.wait_update_id(1).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;
+    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_update_id(0).await;
+    let (_response, code) = index.delete_batch(vec![]).await;
+    assert_eq!(code, 200);
+
+    let _update = index.wait_update_id(1).await;
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert_eq!(response.as_array().unwrap().len(), 3);
+}

tests/documents/get_documents.rs

@@ -0,0 +1,149 @@
+use crate::common::Server;
+use crate::common::GetAllDocumentsOptions;
+
+// 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, 400);
+}
+
+#[actix_rt::test]
+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;
+    assert_eq!(code, 400);
+}
+
+#[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,
+            "content": "foobar",
+        }
+    ]);
+    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;
+    assert_eq!(code, 200);
+    assert_eq!(response, serde_json::json!(        {
+        "id": 0,
+        "content": "foobar",
+    }));
+}
+
+#[actix_rt::test]
+async fn get_unexisting_index_all_documents() {
+    let server = Server::new().await;
+    let (_response, code) = server
+        .index("test")
+        .get_all_documents(GetAllDocumentsOptions::default())
+        .await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+async fn get_no_documents() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_, code) = index.create(None).await;
+    assert_eq!(code, 200);
+
+    let (response, code) = index.get_all_documents(GetAllDocumentsOptions::default()).await;
+    assert_eq!(code, 200);
+    assert!(response.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.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 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.as_array().unwrap().len(), 5);
+    assert_eq!(response.as_array().unwrap()[0]["id"], 0);
+}
+
+#[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.as_array().unwrap().len(), 20);
+    assert_eq!(response.as_array().unwrap()[0]["id"], 13);
+}
+
+#[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.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());
+
+    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);
+
+    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);
+}

tests/documents/mod.rs

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

tests/index/create_index.rs

@@ -0,0 +1,76 @@
+use crate::common::Server;
+use serde_json::Value;
+
+#[actix_rt::test]
+async fn create_index_no_primary_key() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (response, code) = index.create(None).await;
+
+    assert_eq!(code, 200);
+    assert_eq!(response["uid"], "test");
+    assert!(response.get("uuid").is_some());
+    assert!(response.get("createdAt").is_some());
+    assert!(response.get("updatedAt").is_some());
+    assert_eq!(response["createdAt"], response["updatedAt"]);
+    assert_eq!(response["primaryKey"], Value::Null);
+    assert_eq!(response.as_object().unwrap().len(), 5);
+}
+
+#[actix_rt::test]
+async fn create_index_with_primary_key() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (response, code) = index.create(Some("primary")).await;
+
+    assert_eq!(code, 200);
+    assert_eq!(response["uid"], "test");
+    assert!(response.get("uuid").is_some());
+    assert!(response.get("createdAt").is_some());
+    assert!(response.get("updatedAt").is_some());
+    assert_eq!(response["createdAt"], response["updatedAt"]);
+    assert_eq!(response["primaryKey"], "primary");
+    assert_eq!(response.as_object().unwrap().len(), 5);
+}
+
+// TODO: partial test since we are testing error, amd error is not yet fully implemented in
+// transplant
+#[actix_rt::test]
+async fn create_existing_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_, code) = index.create(Some("primary")).await;
+
+    assert_eq!(code, 200);
+
+    let (_response, code) = index.create(Some("primary")).await;
+    assert_eq!(code, 400);
+}
+
+// test fails (issue #46)
+#[actix_rt::test]
+#[ignore]
+async fn create_with_invalid_index_uid() {
+    let server = Server::new().await;
+    let index = server.index("test test");
+    let (_, code) = index.create(None).await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+async fn test_create_multiple_indexes() {
+    let server = Server::new().await;
+    let index1 = server.index("test1");
+    let index2 = server.index("test2");
+    let index3 = server.index("test3");
+    let index4 = server.index("test4");
+
+    index1.create(None).await;
+    index2.create(None).await;
+    index3.create(None).await;
+
+    assert_eq!(index1.get().await.1, 200);
+    assert_eq!(index2.get().await.1, 200);
+    assert_eq!(index3.get().await.1, 200);
+    assert_eq!(index4.get().await.1, 400);
+}

tests/index/delete_index.rs

@@ -0,0 +1,25 @@
+use crate::common::Server;
+
+#[actix_rt::test]
+async fn create_and_delete_index() {
+    let server = Server::new().await;
+    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);
+}
+
+#[actix_rt::test]
+async fn delete_unexisting_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.delete().await;
+
+    assert_eq!(code, 400);
+}

tests/index/get_index.rs

@@ -0,0 +1,59 @@
+use crate::common::Server;
+use serde_json::Value;
+
+#[actix_rt::test]
+async fn create_and_get_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_, code) = index.create(None).await;
+
+    assert_eq!(code, 200);
+
+    let (response, code) = index.get().await;
+
+    assert_eq!(code, 200);
+    assert_eq!(response["uid"], "test");
+    assert!(response.get("uuid").is_some());
+    assert!(response.get("createdAt").is_some());
+    assert!(response.get("updatedAt").is_some());
+    assert_eq!(response["createdAt"], response["updatedAt"]);
+    assert_eq!(response["primaryKey"], Value::Null);
+    assert_eq!(response.as_object().unwrap().len(), 5);
+}
+
+// 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() {
+    let server = Server::new().await;
+    let index = server.index("test");
+
+    let (_response, code) = index.get().await;
+
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+async fn no_index_return_empty_list() {
+    let server = Server::new().await;
+    let (response, code) = server.list_indexes().await;
+    assert_eq!(code, 200);
+    assert!(response.is_array());
+    assert!(response.as_array().unwrap().is_empty());
+}
+
+#[actix_rt::test]
+async fn list_multiple_indexes() {
+    let server = Server::new().await;
+    server.index("test").create(None).await;
+    server.index("test1").create(Some("key")).await;
+
+    let (response, code) = server.list_indexes().await;
+    assert_eq!(code, 200);
+    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());
+
+}

tests/index/mod.rs

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

tests/index/update_index.rs

@@ -0,0 +1,64 @@
+use crate::common::Server;
+use chrono::DateTime;
+
+#[actix_rt::test]
+async fn update_primary_key() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_, code) = index.create(None).await;
+
+    assert_eq!(code, 200);
+
+    let (response, code) = index.update(Some("primary")).await;
+
+    assert_eq!(code, 200);
+    assert_eq!(response["uid"], "test");
+    assert!(response.get("uuid").is_some());
+    assert!(response.get("createdAt").is_some());
+    assert!(response.get("updatedAt").is_some());
+
+    let created_at = DateTime::parse_from_rfc3339(response["createdAt"].as_str().unwrap()).unwrap();
+    let updated_at = DateTime::parse_from_rfc3339(response["updatedAt"].as_str().unwrap()).unwrap();
+    assert!(created_at < updated_at);
+
+    assert_eq!(response["primaryKey"], "primary");
+    assert_eq!(response.as_object().unwrap().len(), 5);
+}
+
+#[actix_rt::test]
+async fn update_nothing() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (response, code) = index.create(None).await;
+
+    assert_eq!(code, 200);
+
+    let (update, code) = index.update(None).await;
+
+    assert_eq!(code, 200);
+    assert_eq!(response, update);
+}
+
+// TODO: partial test since we are testing error, amd error is not yet fully implemented in
+// transplant
+#[actix_rt::test]
+async fn update_existing_primary_key() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.create(Some("primary")).await;
+
+    assert_eq!(code, 200);
+
+    let (_update, code) = index.update(Some("primary2")).await;
+
+    assert_eq!(code, 400);
+}
+
+// TODO: partial test since we are testing error, amd error is not yet fully implemented in
+// transplant
+#[actix_rt::test]
+async fn test_unexisting_index() {
+    let server = Server::new().await;
+    let (_response, code) = server.index("test").update(None).await;
+    assert_eq!(code, 400);
+}

tests/integration.rs

@@ -0,0 +1,12 @@
+mod common;
+mod index;
+mod search;
+mod settings;
+mod documents;
+mod updates;
+
+// Tests are isolated by features in different modules to allow better readability, test
+// targetability, and improved incremental compilation times.
+//
+// All the integration tests live in the same root module so only one test executable is generated,
+// thus improving linking time.

tests/search/mod.rs

@@ -0,0 +1,3 @@
+// 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.
+

tests/settings/get_settings.rs

@@ -0,0 +1,145 @@
+use crate::common::Server;
+use serde_json::json;
+
+#[actix_rt::test]
+async fn get_settings_unexisting_index() {
+    let server = Server::new().await;
+    let (_response, code) = server.index("test").settings().await;
+    assert_eq!(code, 400)
+}
+
+#[actix_rt::test]
+async fn get_settings() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    let (response, code) = index.settings().await;
+    assert_eq!(code, 200);
+    let settings = response.as_object().unwrap();
+    assert_eq!(settings.keys().len(), 3);
+    assert_eq!(settings["displayedAttributes"], json!(["*"]));
+    assert_eq!(settings["searchableAttributes"], json!(["*"]));
+    assert_eq!(settings["facetedAttributes"], json!({}));
+}
+
+#[actix_rt::test]
+async fn update_settings_unknown_field() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.update_settings(json!({"foo": 12})).await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+async fn test_partial_update() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    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!(["*"]));
+
+    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"]));
+}
+
+#[actix_rt::test]
+#[ignore]
+// need fix #54
+async fn delete_settings_unexisting_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.delete_settings().await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+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.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"]));
+
+    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!(["*"]));
+}
+
+#[actix_rt::test]
+async fn update_setting_unexisting_index() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    let (_response, code) = index.update_settings(json!({})).await;
+    assert_eq!(code, 200);
+    let (_response, code) = index.get().await;
+    assert_eq!(code, 200);
+}
+
+macro_rules! test_setting_routes {
+    ($($setting:ident), *) => {
+        $(
+            mod $setting {
+                use crate::common::Server;
+
+                #[actix_rt::test]
+                async fn get_unexisting_index() {
+                    let server = Server::new().await;
+                    let url = format!("/indexes/test/settings/{}",
+                        stringify!($setting)
+                        .chars()
+                        .map(|c| if c == '_' { '-' } else { c })
+                        .collect::<String>());
+                    let (_response, code) = server.service.get(url).await;
+                    assert_eq!(code, 400);
+                }
+
+                #[actix_rt::test]
+                async fn update_unexisting_index() {
+                    let server = Server::new().await;
+                    let url = format!("/indexes/test/settings/{}",
+                        stringify!($setting)
+                        .chars()
+                        .map(|c| if c == '_' { '-' } else { c })
+                        .collect::<String>());
+                    let (_response, code) = server.service.post(url, serde_json::Value::Null).await;
+                    assert_eq!(code, 200);
+                    let (_response, code) = server.index("test").get().await;
+                    assert_eq!(code, 200);
+                }
+
+                #[actix_rt::test]
+                #[ignore]
+                async fn delete_unexisting_index() {
+                    let server = Server::new().await;
+                    let url = format!("/indexes/test/settings/{}",
+                        stringify!($setting)
+                        .chars()
+                        .map(|c| if c == '_' { '-' } else { c })
+                        .collect::<String>());
+                    let (_response, code) = server.service.delete(url).await;
+                    assert_eq!(code, 400);
+                }
+            }
+        )*
+    };
+}
+
+test_setting_routes!(
+    attributes_for_faceting,
+    displayed_attributes,
+    searchable_attributes);

tests/settings/mod.rs

@@ -0,0 +1 @@
+mod get_settings;

tests/updates/mod.rs

@@ -0,0 +1,67 @@
+use crate::common::Server;
+
+#[actix_rt::test]
+async fn get_update_unexisting_index() {
+    let server = Server::new().await;
+    let (_response, code) = server.index("test").get_update(0).await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+async fn get_unexisting_udpate_status() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    let (_response, code) = index.get_update(0).await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+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;
+    let (_response, code) = index.get_update(0).await;
+    assert_eq!(code, 200);
+    // TODO check resonse format, as per #48
+}
+
+#[actix_rt::test]
+async fn list_updates_unexisting_index() {
+    let server = Server::new().await;
+    let (_response, code) = server.index("test").list_updates().await;
+    assert_eq!(code, 400);
+}
+
+#[actix_rt::test]
+async fn list_no_updates() {
+    let server = Server::new().await;
+    let index = server.index("test");
+    index.create(None).await;
+    let (response, code) = index.list_updates().await;
+    assert_eq!(code, 200);
+    assert!(response.as_array().unwrap().is_empty());
+}
+
+// TODO: fix #32
+#[actix_rt::test]
+#[ignore]
+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;
+    let (response, code) = index.list_updates().await;
+    assert_eq!(code, 200);
+    assert_eq!(response.as_array().unwrap().len(), 1);
+}