feat(all): Task store

implements:
https://github.com/meilisearch/specifications/blob/develop/text/0060-refashion-updates-apis.md

linked PR:

- #1889
- #1891
- #1892
- #1902
- #1906
- #1911
- #1914
- #1915
- #1916
- #1918
- #1924
- #1925
- #1926
- #1930
- #1936
- #1937
- #1942
- #1944
- #1945
- #1946
- #1947
- #1950
- #1951
- #1957
- #1959
- #1960
- #1961
- #1962
- #1964

- https://github.com/meilisearch/milli/pull/414
- https://github.com/meilisearch/milli/pull/409
- https://github.com/meilisearch/milli/pull/406
- https://github.com/meilisearch/milli/pull/418

- close #1687
- close #1786
- close #1940
- close #1948
- close #1949
- close #1932
- close #1956

meilisearch-http/tests/index/create_index.rs

@@ -7,14 +7,15 @@ async fn create_index_no_primary_key() {
     let index = server.index("test");
     let (response, code) = index.create(None).await;
 
-    assert_eq!(code, 201);
-    assert_eq!(response["uid"], "test");
-    assert_eq!(response["name"], "test");
-    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);
+    assert_eq!(code, 202);
+
+    assert_eq!(response["status"], "enqueued");
+
+    let response = index.wait_task(0).await;
+
+    assert_eq!(response["status"], "succeeded");
+    assert_eq!(response["type"], "indexCreation");
+    assert_eq!(response["details"]["primaryKey"], Value::Null);
 }
 
 #[actix_rt::test]
@@ -23,14 +24,15 @@ async fn create_index_with_primary_key() {
     let index = server.index("test");
     let (response, code) = index.create(Some("primary")).await;
 
-    assert_eq!(code, 201);
-    assert_eq!(response["uid"], "test");
-    assert_eq!(response["name"], "test");
-    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);
+    assert_eq!(code, 202);
+
+    assert_eq!(response["status"], "enqueued");
+
+    let response = index.wait_task(0).await;
+
+    assert_eq!(response["status"], "succeeded");
+    assert_eq!(response["type"], "indexCreation");
+    assert_eq!(response["details"]["primaryKey"], "primary");
 }
 
 #[actix_rt::test]
@@ -42,7 +44,7 @@ async fn create_index_with_invalid_primary_key() {
     let (_response, code) = index.add_documents(document, Some("title")).await;
     assert_eq!(code, 202);
 
-    index.wait_update_id(0).await;
+    index.wait_task(0).await;
 
     let (response, code) = index.get().await;
     assert_eq!(code, 200);
@@ -61,6 +63,10 @@ async fn test_create_multiple_indexes() {
     index2.create(None).await;
     index3.create(None).await;
 
+    index1.wait_task(0).await;
+    index1.wait_task(1).await;
+    index1.wait_task(2).await;
+
     assert_eq!(index1.get().await.1, 200);
     assert_eq!(index2.get().await.1, 200);
     assert_eq!(index3.get().await.1, 200);
@@ -73,9 +79,11 @@ async fn error_create_existing_index() {
     let index = server.index("test");
     let (_, code) = index.create(Some("primary")).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
 
-    let (response, code) = index.create(Some("primary")).await;
+    index.create(Some("primary")).await;
+
+    let response = index.wait_task(1).await;
 
     let expected_response = json!({
         "message": "Index `test` already exists.",
@@ -84,8 +92,7 @@ async fn error_create_existing_index() {
         "link":"https://docs.meilisearch.com/errors#index_already_exists"
     });
 
-    assert_eq!(response, expected_response);
-    assert_eq!(code, 409);
+    assert_eq!(response["error"], expected_response);
 }
 
 #[actix_rt::test]

meilisearch-http/tests/index/delete_index.rs

@@ -8,11 +8,17 @@ async fn create_and_delete_index() {
     let index = server.index("test");
     let (_response, code) = index.create(None).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
+
+    assert_eq!(index.get().await.1, 200);
 
     let (_response, code) = index.delete().await;
 
-    assert_eq!(code, 204);
+    assert_eq!(code, 202);
+
+    index.wait_task(1).await;
 
     assert_eq!(index.get().await.1, 404);
 }
@@ -21,7 +27,9 @@ async fn create_and_delete_index() {
 async fn error_delete_unexisting_index() {
     let server = Server::new().await;
     let index = server.index("test");
-    let (response, code) = index.delete().await;
+    let (_, code) = index.delete().await;
+
+    assert_eq!(code, 202);
 
     let expected_response = json!({
         "message": "Index `test` not found.",
@@ -30,19 +38,29 @@ async fn error_delete_unexisting_index() {
         "link": "https://docs.meilisearch.com/errors#index_not_found"
     });
 
-    assert_eq!(response, expected_response);
-    assert_eq!(code, 404);
+    let response = index.wait_task(0).await;
+    assert_eq!(response["status"], "failed");
+    assert_eq!(response["error"], expected_response);
 }
 
+#[cfg(not(windows))]
 #[actix_rt::test]
 async fn loop_delete_add_documents() {
     let server = Server::new().await;
     let index = server.index("test");
     let documents = json!([{"id": 1, "field1": "hello"}]);
+    let mut tasks = Vec::new();
     for _ in 0..50 {
         let (response, code) = index.add_documents(documents.clone(), None).await;
+        tasks.push(response["uid"].as_u64().unwrap());
         assert_eq!(code, 202, "{}", response);
         let (response, code) = index.delete().await;
-        assert_eq!(code, 204, "{}", response);
+        tasks.push(response["uid"].as_u64().unwrap());
+        assert_eq!(code, 202, "{}", response);
+    }
+
+    for task in tasks {
+        let response = index.wait_task(task).await;
+        assert_eq!(response["status"], "succeeded", "{}", response);
     }
 }

meilisearch-http/tests/index/get_index.rs

@@ -8,7 +8,9 @@ async fn create_and_get_index() {
     let index = server.index("test");
     let (_, code) = index.create(None).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
 
     let (response, code) = index.get().await;
 
@@ -55,6 +57,8 @@ async fn list_multiple_indexes() {
     server.index("test").create(None).await;
     server.index("test1").create(Some("key")).await;
 
+    server.index("test").wait_task(1).await;
+
     let (response, code) = server.list_indexes().await;
     assert_eq!(code, 200);
     assert!(response.is_array());
@@ -67,3 +71,22 @@ async fn list_multiple_indexes() {
         .iter()
         .any(|entry| entry["uid"] == "test1" && entry["primaryKey"] == "key"));
 }
+
+#[actix_rt::test]
+async fn get_invalid_index_uid() {
+    let server = Server::new().await;
+    let index = server.index("this is not a valid index name");
+    let (response, code) = index.get().await;
+
+    assert_eq!(code, 404);
+    assert_eq!(
+        response,
+        json!(
+        {
+        "message": "Index `this is not a valid index name` not found.",
+        "code": "index_not_found",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#index_not_found"
+            })
+    );
+}

meilisearch-http/tests/index/stats.rs

@@ -8,7 +8,9 @@ async fn stats() {
     let index = server.index("test");
     let (_, code) = index.create(Some("id")).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
+
+    index.wait_task(0).await;
 
     let (response, code) = index.stats().await;
 
@@ -33,9 +35,9 @@ async fn stats() {
 
     let (response, code) = index.add_documents(documents, None).await;
     assert_eq!(code, 202);
-    assert_eq!(response["updateId"], 0);
+    assert_eq!(response["uid"], 1);
 
-    index.wait_update_id(0).await;
+    index.wait_task(1).await;
 
     let (response, code) = index.stats().await;
 

meilisearch-http/tests/index/update_index.rs

@@ -8,11 +8,18 @@ async fn update_primary_key() {
     let index = server.index("test");
     let (_, code) = index.create(None).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
 
-    let (response, code) = index.update(Some("primary")).await;
+    index.update(Some("primary")).await;
+
+    let response = index.wait_task(1).await;
+
+    assert_eq!(response["status"], "succeeded");
+
+    let (response, code) = index.get().await;
 
     assert_eq!(code, 200);
+
     assert_eq!(response["uid"], "test");
     assert_eq!(response["name"], "test");
     assert!(response.get("createdAt").is_some());
@@ -30,14 +37,19 @@ async fn update_primary_key() {
 async fn update_nothing() {
     let server = Server::new().await;
     let index = server.index("test");
-    let (response, code) = index.create(None).await;
+    let (_, code) = index.create(None).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
 
-    let (update, code) = index.update(None).await;
+    index.wait_task(0).await;
 
-    assert_eq!(code, 200);
-    assert_eq!(response, update);
+    let (_, code) = index.update(None).await;
+
+    assert_eq!(code, 202);
+
+    let response = index.wait_task(1).await;
+
+    assert_eq!(response["status"], "succeeded");
 }
 
 #[actix_rt::test]
@@ -46,7 +58,7 @@ async fn error_update_existing_primary_key() {
     let index = server.index("test");
     let (_response, code) = index.create(Some("id")).await;
 
-    assert_eq!(code, 201);
+    assert_eq!(code, 202);
 
     let documents = json!([
         {
@@ -55,9 +67,12 @@ async fn error_update_existing_primary_key() {
         }
     ]);
     index.add_documents(documents, None).await;
-    index.wait_update_id(0).await;
 
-    let (response, code) = index.update(Some("primary")).await;
+    let (_, code) = index.update(Some("primary")).await;
+
+    assert_eq!(code, 202);
+
+    let response = index.wait_task(2).await;
 
     let expected_response = json!({
         "message": "Index already has a primary key: `id`.",
@@ -66,14 +81,17 @@ async fn error_update_existing_primary_key() {
         "link": "https://docs.meilisearch.com/errors#index_primary_key_already_exists"
     });
 
-    assert_eq!(response, expected_response);
-    assert_eq!(code, 400);
+    assert_eq!(response["error"], expected_response);
 }
 
 #[actix_rt::test]
 async fn error_update_unexisting_index() {
     let server = Server::new().await;
-    let (response, code) = server.index("test").update(None).await;
+    let (_, code) = server.index("test").update(None).await;
+
+    assert_eq!(code, 202);
+
+    let response = server.index("test").wait_task(0).await;
 
     let expected_response = json!({
         "message": "Index `test` not found.",
@@ -82,6 +100,5 @@ async fn error_update_unexisting_index() {
         "link": "https://docs.meilisearch.com/errors#index_not_found"
     });
 
-    assert_eq!(response, expected_response);
-    assert_eq!(code, 404);
+    assert_eq!(response["error"], expected_response);
 }