snowykami/meilisearch
1
0
Fork 0
mirror of https://github.com/meilisearch/meilisearch.git synced 2025-07-28 01:01:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

tests: Faster tasks::mode IT tests

Browse Source 
Use shared server + unique indices

Related-to: https://github.com/meilisearch/meilisearch/issues/4840

Signed-off-by: Martin Tzvetanov Grigorov <mgrigorov@apache.org>
This commit is contained in:
Martin Tzvetanov Grigorov
2025-06-02 10:56:43 +03:00
parent d416b3b390
commit 5a7cfc57fd
1 changed files with 180 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

359
crates/meilisearch/tests/tasks/mod.rs
View File

@ -1,8 +1,8 @@
mod errors; mod errors;
mod webhook; mod webhook;
use meili_snap::insta::assert_json_snapshot; use insta::assert_json_snapshot;
use meili_snap::snapshot; use meili_snap::{json_string, snapshot};
use time::format_description::well_known::Rfc3339; use time::format_description::well_known::Rfc3339;
use time::OffsetDateTime; use time::OffsetDateTime;
@ -11,11 +11,11 @@ use crate::json;
#[actix_rt::test] #[actix_rt::test]
async fn error_get_unexisting_task_status() { async fn error_get_unexisting_task_status() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (response, code) = index.get_task(1).await; let (response, code) = index.get_task(u32::MAX as u64).await;
let expected_response = json!({ let expected_response = json!({
"message": "Task `1` not found.", "message": "Task `1` not found.",
@ -30,8 +30,8 @@ async fn error_get_unexisting_task_status() {
#[actix_rt::test] #[actix_rt::test]
async fn get_task_status() { async fn get_task_status() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (create_task, _status_code) = index.create(None).await; let (create_task, _status_code) = index.create(None).await;
let (add_task, _status_code) = index let (add_task, _status_code) = index
.add_documents( .add_documents(
@ -50,8 +50,8 @@ async fn get_task_status() {
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks() { async fn list_tasks() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
index index
@ -64,14 +64,14 @@ async fn list_tasks() {
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks_pagination_and_reverse() { async fn list_tasks_pagination_and_reverse() {
let server = Server::new().await; let server = Server::new_shared();
// First of all we want to create a lot of tasks very quickly. The fastest way is to delete a lot of unexisting indexes // First of all we want to create a lot of tasks very quickly. The fastest way is to delete a lot of unexisting indexes
let mut last_task = None; let mut last_task = None;
for i in 0..10 { for _ in 0..10 {
let index = server.index(format!("test-{i}")); let index = server.unique_index();
last_task = Some(index.create(None).await.0.uid()); last_task = Some(index.create(None).await.0.uid());
} }
server.wait_task(last_task.unwrap()).await; server.wait_task(last_task.unwrap()).await.succeeded();
let (response, code) = server.tasks_filter("limit=3").await; let (response, code) = server.tasks_filter("limit=3").await;
assert_eq!(code, 200); assert_eq!(code, 200);
@ -102,14 +102,14 @@ async fn list_tasks_pagination_and_reverse() {
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks_with_star_filters() { async fn list_tasks_with_star_filters() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _code) = index.create(None).await; let (task, _code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
index index
.add_documents(serde_json::from_str(include_str!("../assets/test_set.json")).unwrap(), None) .add_documents(serde_json::from_str(include_str!("../assets/test_set.json")).unwrap(), None)
.await; .await;
let (response, code) = index.service.get("/tasks?indexUids=test").await; let (response, code) = index.service.get(format!("/tasks?indexUids={}", index.uid)).await;
assert_eq!(code, 200); assert_eq!(code, 200);
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
@ -127,50 +127,50 @@ async fn list_tasks_with_star_filters() {
let (response, code) = let (response, code) =
index.service.get("/tasks?types=*,documentAdditionOrUpdate&statuses=*").await; index.service.get("/tasks?types=*,documentAdditionOrUpdate&statuses=*").await;
assert_eq!(code, 200, "{:?}", response); assert_eq!(code, 200, "{response:?}");
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
let (response, code) = index let (response, code) = index
.service .service
.get("/tasks?types=*,documentAdditionOrUpdate&statuses=*,failed&indexUids=test") .get(format!("/tasks?types=*,documentAdditionOrUpdate&statuses=*,failed&indexUids={}", index.uid))
.await; .await;
assert_eq!(code, 200, "{:?}", response); assert_eq!(code, 200, "{response:?}");
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
let (response, code) = index let (response, code) = index
.service .service
.get("/tasks?types=*,documentAdditionOrUpdate&statuses=*,failed&indexUids=test,*") .get("/tasks?types=*,documentAdditionOrUpdate&statuses=*,failed&indexUids=test,*")
.await; .await;
assert_eq!(code, 200, "{:?}", response); assert_eq!(code, 200, "{response:?}");
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
} }
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks_status_filtered() { async fn list_tasks_status_filtered() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (response, code) = index.filtered_tasks(&[], &["succeeded"], &[]).await; let (response, code) = index.filtered_tasks(&[], &["succeeded"], &[]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 1); assert_eq!(response["results"].as_array().unwrap().len(), 1);
let (response, code) = index.filtered_tasks(&[], &["succeeded"], &[]).await; let (response, code) = index.filtered_tasks(&[], &["succeeded"], &[]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 1); assert_eq!(response["results"].as_array().unwrap().len(), 1);
let (response, code) = index.filtered_tasks(&[], &["succeeded", "failed"], &[]).await; let (response, code) = index.filtered_tasks(&[], &["succeeded", "failed"], &[]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
} }
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks_type_filtered() { async fn list_tasks_type_filtered() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
index index
@ -178,19 +178,19 @@ async fn list_tasks_type_filtered() {
.await; .await;
let (response, code) = index.filtered_tasks(&["indexCreation"], &[], &[]).await; let (response, code) = index.filtered_tasks(&["indexCreation"], &[], &[]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 1); assert_eq!(response["results"].as_array().unwrap().len(), 1);
let (response, code) = let (response, code) =
index.filtered_tasks(&["indexCreation", "documentAdditionOrUpdate"], &[], &[]).await; index.filtered_tasks(&["indexCreation", "documentAdditionOrUpdate"], &[], &[]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
} }
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks_invalid_canceled_by_filter() { async fn list_tasks_invalid_canceled_by_filter() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
index index
@ -198,14 +198,14 @@ async fn list_tasks_invalid_canceled_by_filter() {
.await; .await;
let (response, code) = index.filtered_tasks(&[], &[], &["0"]).await; let (response, code) = index.filtered_tasks(&[], &[], &["0"]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 0); assert_eq!(response["results"].as_array().unwrap().len(), 0);
} }
#[actix_rt::test] #[actix_rt::test]
async fn list_tasks_status_and_type_filtered() { async fn list_tasks_status_and_type_filtered() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
index index
@ -213,7 +213,7 @@ async fn list_tasks_status_and_type_filtered() {
.await; .await;
let (response, code) = index.filtered_tasks(&["indexCreation"], &["failed"], &[]).await; let (response, code) = index.filtered_tasks(&["indexCreation"], &["failed"], &[]).await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 0); assert_eq!(response["results"].as_array().unwrap().len(), 0);
let (response, code) = index let (response, code) = index
@ -223,12 +223,12 @@ async fn list_tasks_status_and_type_filtered() {
&[], &[],
) )
.await; .await;
assert_eq!(code, 200, "{}", response); assert_eq!(code, 200, "{response}");
assert_eq!(response["results"].as_array().unwrap().len(), 2); assert_eq!(response["results"].as_array().unwrap().len(), 2);
} }
macro_rules! assert_valid_summarized_task { macro_rules! assert_valid_summarized_task {
($response:expr, $task_type:literal, $index:literal) => {{ ($response:expr, $task_type:literal, $index:tt) => {{
assert_eq!($response.as_object().unwrap().len(), 5); assert_eq!($response.as_object().unwrap().len(), 5);
assert!($response["taskUid"].as_u64().is_some()); assert!($response["taskUid"].as_u64().is_some());
assert_eq!($response["indexUid"], $index); assert_eq!($response["indexUid"], $index);
@ -242,49 +242,49 @@ macro_rules! assert_valid_summarized_task {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_task_view() { async fn test_summarized_task_view() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let index_uid = index.uid.clone();
let (response, _) = index.create(None).await; let (response, _) = index.create(None).await;
assert_valid_summarized_task!(response, "indexCreation", "test"); assert_valid_summarized_task!(response, "indexCreation", index_uid);
let (response, _) = index.update(None).await; let (response, _) = index.update(None).await;
assert_valid_summarized_task!(response, "indexUpdate", "test"); assert_valid_summarized_task!(response, "indexUpdate", index_uid);
let (response, _) = index.update_settings(json!({})).await; let (response, _) = index.update_settings(json!({})).await;
assert_valid_summarized_task!(response, "settingsUpdate", "test"); assert_valid_summarized_task!(response, "settingsUpdate", index_uid);
let (response, _) = index.update_documents(json!([{"id": 1}]), None).await; let (response, _) = index.update_documents(json!([{"id": 1}]), None).await;
assert_valid_summarized_task!(response, "documentAdditionOrUpdate", "test"); assert_valid_summarized_task!(response, "documentAdditionOrUpdate", index_uid);
let (response, _) = index.add_documents(json!([{"id": 1}]), None).await; let (response, _) = index.add_documents(json!([{"id": 1}]), None).await;
assert_valid_summarized_task!(response, "documentAdditionOrUpdate", "test"); assert_valid_summarized_task!(response, "documentAdditionOrUpdate", index_uid);
let (response, _) = index.delete_document(1).await; let (response, _) = index.delete_document(1).await;
assert_valid_summarized_task!(response, "documentDeletion", "test"); assert_valid_summarized_task!(response, "documentDeletion", index_uid);
let (response, _) = index.clear_all_documents().await; let (response, _) = index.clear_all_documents().await;
assert_valid_summarized_task!(response, "documentDeletion", "test"); assert_valid_summarized_task!(response, "documentDeletion", index_uid);
let (response, _) = index.delete().await; let (response, _) = index.delete().await;
assert_valid_summarized_task!(response, "indexDeletion", "test"); assert_valid_summarized_task!(response, "indexDeletion", index_uid);
} }
#[actix_web::test] #[actix_web::test]
async fn test_summarized_document_addition_or_update() { async fn test_summarized_document_addition_or_update() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = let (task, _status_code) =
index.add_documents(json!({ "id": 42, "content": "doggos & fluff" }), None).await; index.add_documents(json!({ "id": 42, "content": "doggos & fluff" }), None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(0).await; snapshot!(json_string!(task,
assert_json_snapshot!(task, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" },
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "documentAdditionOrUpdate", "type": "documentAdditionOrUpdate",
"canceledBy": null, "canceledBy": null,
@ -329,18 +329,17 @@ async fn test_summarized_document_addition_or_update() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_delete_documents_by_batch() { async fn test_summarized_delete_documents_by_batch() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.delete_batch(vec![1, 2, 3]).await; let (task, _status_code) = index.delete_batch(vec![1, 2, 3]).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(0).await; snapshot!(json_string!(task,
assert_json_snapshot!(task, { ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" },
@r###" @r###"
{ {
"uid": 0, "uid": 0,
"batchUid": 0, "batchUid": 0,
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -366,13 +365,13 @@ async fn test_summarized_delete_documents_by_batch() {
let (del_task, _status_code) = index.delete_batch(vec![42]).await; let (del_task, _status_code) = index.delete_batch(vec![42]).await;
index.wait_task(del_task.uid()).await.succeeded(); index.wait_task(del_task.uid()).await.succeeded();
let (task, _) = index.get_task(del_task.uid()).await; let (task, _) = index.get_task(del_task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 2, "uid": 2,
"batchUid": 2, "batchUid": 2,
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -392,20 +391,20 @@ async fn test_summarized_delete_documents_by_batch() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_delete_documents_by_filter() { async fn test_summarized_delete_documents_by_filter() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = let (task, _status_code) =
index.delete_document_by_filter(json!({ "filter": "doggo = bernese" })).await; index.delete_document_by_filter(json!({ "filter": "doggo = bernese" })).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -415,7 +414,7 @@ async fn test_summarized_delete_documents_by_filter() {
"originalFilter": "\"doggo = bernese\"" "originalFilter": "\"doggo = bernese\""
}, },
"error": { "error": {
"message": "Index `test` not found.", "message": "Index `[uuid]` not found.",
"code": "index_not_found", "code": "index_not_found",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_not_found" "link": "https://docs.meilisearch.com/errors#index_not_found"
@ -432,13 +431,13 @@ async fn test_summarized_delete_documents_by_filter() {
index.delete_document_by_filter(json!({ "filter": "doggo = bernese" })).await; index.delete_document_by_filter(json!({ "filter": "doggo = bernese" })).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 2, "uid": "[uid]",
"batchUid": 2, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -448,7 +447,7 @@ async fn test_summarized_delete_documents_by_filter() {
"originalFilter": "\"doggo = bernese\"" "originalFilter": "\"doggo = bernese\""
}, },
"error": { "error": {
"message": "Index `test`: Attribute `doggo` is not filterable. This index does not have configured filterable attributes.\n1:6 doggo = bernese", "message": "Index `[uuid]`: Attribute `doggo` is not filterable. This index does not have configured filterable attributes.\n1:6 doggo = bernese",
"code": "invalid_document_filter", "code": "invalid_document_filter",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#invalid_document_filter" "link": "https://docs.meilisearch.com/errors#invalid_document_filter"
@ -465,13 +464,13 @@ async fn test_summarized_delete_documents_by_filter() {
index.delete_document_by_filter(json!({ "filter": "doggo = bernese" })).await; index.delete_document_by_filter(json!({ "filter": "doggo = bernese" })).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 4, "uid": "[uid]",
"batchUid": 4, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -491,18 +490,18 @@ async fn test_summarized_delete_documents_by_filter() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_delete_document_by_id() { async fn test_summarized_delete_document_by_id() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.delete_document(1).await; let (task, _status_code) = index.delete_document(1).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -512,7 +511,7 @@ async fn test_summarized_delete_document_by_id() {
"originalFilter": null "originalFilter": null
}, },
"error": { "error": {
"message": "Index `test` not found.", "message": "Index `[uuid]` not found.",
"code": "index_not_found", "code": "index_not_found",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_not_found" "link": "https://docs.meilisearch.com/errors#index_not_found"
@ -528,13 +527,13 @@ async fn test_summarized_delete_document_by_id() {
let (task, _status_code) = index.delete_document(42).await; let (task, _status_code) = index.delete_document(42).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 2, "uid": "[uid]",
"batchUid": 2, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "documentDeletion", "type": "documentDeletion",
"canceledBy": null, "canceledBy": null,
@ -554,12 +553,12 @@ async fn test_summarized_delete_document_by_id() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_settings_update() { async fn test_summarized_settings_update() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
// here we should find my payload even in the failed task. // here we should find my payload even in the failed task.
let (response, code) = index.update_settings(json!({ "rankingRules": ["custom"] })).await; let (response, code) = index.update_settings(json!({ "rankingRules": ["custom"] })).await;
meili_snap::snapshot!(code, @"400 Bad Request"); snapshot!(code, @"400 Bad Request");
meili_snap::snapshot!(meili_snap::json_string!(response), @r###" snapshot!(json_string!(response), @r###"
{ {
"message": "Invalid value at `.rankingRules[0]`: `custom` ranking rule is invalid. Valid ranking rules are words, typo, sort, proximity, attribute, exactness and custom ranking rules.", "message": "Invalid value at `.rankingRules[0]`: `custom` ranking rule is invalid. Valid ranking rules are words, typo, sort, proximity, attribute, exactness and custom ranking rules.",
"code": "invalid_settings_ranking_rules", "code": "invalid_settings_ranking_rules",
@ -571,13 +570,13 @@ async fn test_summarized_settings_update() {
let (task,_status_code) = index.update_settings(json!({ "displayedAttributes": ["doggos", "name"], "filterableAttributes": ["age", "nb_paw_pads"], "sortableAttributes": ["iq"] })).await; let (task,_status_code) = index.update_settings(json!({ "displayedAttributes": ["doggos", "name"], "filterableAttributes": ["age", "nb_paw_pads"], "sortableAttributes": ["iq"] })).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "settingsUpdate", "type": "settingsUpdate",
"canceledBy": null, "canceledBy": null,
@ -605,18 +604,18 @@ async fn test_summarized_settings_update() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_index_creation() { async fn test_summarized_index_creation() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "indexCreation", "type": "indexCreation",
"canceledBy": null, "canceledBy": null,
@ -634,13 +633,13 @@ async fn test_summarized_index_creation() {
let (task, _status_code) = index.create(Some("doggos")).await; let (task, _status_code) = index.create(Some("doggos")).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 1, "uid": "[uid]",
"batchUid": 1, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "indexCreation", "type": "indexCreation",
"canceledBy": null, "canceledBy": null,
@ -648,7 +647,7 @@ async fn test_summarized_index_creation() {
"primaryKey": "doggos" "primaryKey": "doggos"
}, },
"error": { "error": {
"message": "Index `test` already exists.", "message": "Index `[uuid]` already exists.",
"code": "index_already_exists", "code": "index_already_exists",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_already_exists" "link": "https://docs.meilisearch.com/errors#index_already_exists"
@ -663,8 +662,8 @@ async fn test_summarized_index_creation() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_index_deletion() { async fn test_summarized_index_deletion() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
let (ret, _code) = index.delete().await; let (ret, _code) = index.delete().await;
let task = index.wait_task(ret.uid()).await; let task = index.wait_task(ret.uid()).await;
snapshot!(task, snapshot!(task,
@ -672,7 +671,7 @@ async fn test_summarized_index_deletion() {
{ {
"uid": "[uid]", "uid": "[uid]",
"batchUid": "[batch_uid]", "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "indexDeletion", "type": "indexDeletion",
"canceledBy": null, "canceledBy": null,
@ -680,7 +679,7 @@ async fn test_summarized_index_deletion() {
"deletedDocuments": 0 "deletedDocuments": 0
}, },
"error": { "error": {
"message": "Index `test` not found.", "message": "Index `[uuid]` not found.",
"code": "index_not_found", "code": "index_not_found",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_not_found" "link": "https://docs.meilisearch.com/errors#index_not_found"
@ -703,7 +702,7 @@ async fn test_summarized_index_deletion() {
{ {
"uid": "[uid]", "uid": "[uid]",
"batchUid": "[batch_uid]", "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "documentAdditionOrUpdate", "type": "documentAdditionOrUpdate",
"canceledBy": null, "canceledBy": null,
@ -726,7 +725,7 @@ async fn test_summarized_index_deletion() {
{ {
"uid": "[uid]", "uid": "[uid]",
"batchUid": "[batch_uid]", "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "indexDeletion", "type": "indexDeletion",
"canceledBy": null, "canceledBy": null,
@ -749,7 +748,7 @@ async fn test_summarized_index_deletion() {
{ {
"uid": "[uid]", "uid": "[uid]",
"batchUid": "[batch_uid]", "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "indexDeletion", "type": "indexDeletion",
"canceledBy": null, "canceledBy": null,
@ -757,7 +756,7 @@ async fn test_summarized_index_deletion() {
"deletedDocuments": 0 "deletedDocuments": 0
}, },
"error": { "error": {
"message": "Index `test` not found.", "message": "Index `[uuid]` not found.",
"code": "index_not_found", "code": "index_not_found",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_not_found" "link": "https://docs.meilisearch.com/errors#index_not_found"
@ -772,19 +771,19 @@ async fn test_summarized_index_deletion() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_index_update() { async fn test_summarized_index_update() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("test"); let index = server.unique_index();
// If the index doesn't exist yet, we should get errors with or without the primary key. // If the index doesn't exist yet, we should get errors with or without the primary key.
let (task, _status_code) = index.update(None).await; let (task, _status_code) = index.update(None).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "indexUpdate", "type": "indexUpdate",
"canceledBy": null, "canceledBy": null,
@ -792,7 +791,7 @@ async fn test_summarized_index_update() {
"primaryKey": null "primaryKey": null
}, },
"error": { "error": {
"message": "Index `test` not found.", "message": "Index `[uuid]` not found.",
"code": "index_not_found", "code": "index_not_found",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_not_found" "link": "https://docs.meilisearch.com/errors#index_not_found"
@ -807,13 +806,13 @@ async fn test_summarized_index_update() {
let (task, _status_code) = index.update(Some("bones")).await; let (task, _status_code) = index.update(Some("bones")).await;
index.wait_task(task.uid()).await.failed(); index.wait_task(task.uid()).await.failed();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 1, "uid": "[uid]",
"batchUid": 1, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "failed", "status": "failed",
"type": "indexUpdate", "type": "indexUpdate",
"canceledBy": null, "canceledBy": null,
@ -821,7 +820,7 @@ async fn test_summarized_index_update() {
"primaryKey": "bones" "primaryKey": "bones"
}, },
"error": { "error": {
"message": "Index `test` not found.", "message": "Index `[uuid]` not found.",
"code": "index_not_found", "code": "index_not_found",
"type": "invalid_request", "type": "invalid_request",
"link": "https://docs.meilisearch.com/errors#index_not_found" "link": "https://docs.meilisearch.com/errors#index_not_found"
@ -839,13 +838,13 @@ async fn test_summarized_index_update() {
let (task, _status_code) = index.update(None).await; let (task, _status_code) = index.update(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 3, "uid": "[uid]",
"batchUid": 3, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "indexUpdate", "type": "indexUpdate",
"canceledBy": null, "canceledBy": null,
@ -863,13 +862,13 @@ async fn test_summarized_index_update() {
let (task, _status_code) = index.update(Some("bones")).await; let (task, _status_code) = index.update(Some("bones")).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 4, "uid": "[uid]",
"batchUid": 4, "batchUid": "[batch_uid]",
"indexUid": "test", "indexUid": "[uuid]",
"status": "succeeded", "status": "succeeded",
"type": "indexUpdate", "type": "indexUpdate",
"canceledBy": null, "canceledBy": null,
@ -887,7 +886,7 @@ async fn test_summarized_index_update() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_index_swap() { async fn test_summarized_index_swap() {
let server = Server::new().await; let server = Server::new_shared();
let (task, _status_code) = server let (task, _status_code) = server
.index_swap(json!([ .index_swap(json!([
{ "indexes": ["doggos", "cattos"] } { "indexes": ["doggos", "cattos"] }
@ -895,12 +894,12 @@ async fn test_summarized_index_swap() {
.await; .await;
server.wait_task(task.uid()).await.failed(); server.wait_task(task.uid()).await.failed();
let (task, _) = server.get_task(task.uid()).await; let (task, _) = server.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": null, "indexUid": null,
"status": "failed", "status": "failed",
"type": "indexSwap", "type": "indexSwap",
@ -928,23 +927,25 @@ async fn test_summarized_index_swap() {
} }
"###); "###);
let (task, _code) = server.index("doggos").create(None).await; let doggos_index = server.unique_index();
let (task, _code) = doggos_index.create(None).await;
server.wait_task(task.uid()).await.succeeded(); server.wait_task(task.uid()).await.succeeded();
let (task, _code) = server.index("cattos").create(None).await; let cattos_index = server.unique_index();
let (task, _code) = cattos_index.create(None).await;
server.wait_task(task.uid()).await.succeeded(); server.wait_task(task.uid()).await.succeeded();
let (task, _code) = server let (task, _code) = server
.index_swap(json!([ .index_swap(json!([
{ "indexes": ["doggos", "cattos"] } { "indexes": [doggos_index.uid, cattos_index.uid] }
])) ]))
.await; .await;
server.wait_task(task.uid()).await.succeeded(); server.wait_task(task.uid()).await.succeeded();
let (task, _) = server.get_task(task.uid()).await; let (task, _) = server.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".**.indexes[0]" => "doggos", ".**.indexes[1]" => "cattos", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 3, "uid": "[uid]",
"batchUid": 3, "batchUid": "[batch_uid]",
"indexUid": null, "indexUid": null,
"status": "succeeded", "status": "succeeded",
"type": "indexSwap", "type": "indexSwap",
@ -970,20 +971,20 @@ async fn test_summarized_index_swap() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_task_cancelation() { async fn test_summarized_task_cancelation() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("doggos"); let index = server.unique_index();
// to avoid being flaky we're only going to cancel an already finished task :( // to avoid being flaky we're only going to cancel an already finished task :(
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _status_code) = server.cancel_tasks("uids=0").await; let (task, _status_code) = server.cancel_tasks("uids=0").await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 1, "uid": "[uid]",
"batchUid": 1, "batchUid": "[batch_uid]",
"indexUid": null, "indexUid": null,
"status": "succeeded", "status": "succeeded",
"type": "taskCancelation", "type": "taskCancelation",
@ -1004,20 +1005,20 @@ async fn test_summarized_task_cancelation() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_task_deletion() { async fn test_summarized_task_deletion() {
let server = Server::new().await; let server = Server::new_shared();
let index = server.index("doggos"); let index = server.unique_index();
// to avoid being flaky we're only going to delete an already finished task :( // to avoid being flaky we're only going to delete an already finished task :(
let (task, _status_code) = index.create(None).await; let (task, _status_code) = index.create(None).await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _status_code) = server.delete_tasks("uids=0").await; let (task, _status_code) = server.delete_tasks("uids=0").await;
index.wait_task(task.uid()).await.succeeded(); index.wait_task(task.uid()).await.succeeded();
let (task, _) = index.get_task(task.uid()).await; let (task, _) = index.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 1, "uid": "[uid]",
"batchUid": 1, "batchUid": "[batch_uid]",
"indexUid": null, "indexUid": null,
"status": "succeeded", "status": "succeeded",
"type": "taskDeletion", "type": "taskDeletion",
@ -1038,16 +1039,16 @@ async fn test_summarized_task_deletion() {
#[actix_web::test] #[actix_web::test]
async fn test_summarized_dump_creation() { async fn test_summarized_dump_creation() {
let server = Server::new().await; let server = Server::new_shared();
let (task, _status_code) = server.create_dump().await; let (task, _status_code) = server.create_dump().await;
server.wait_task(task.uid()).await; server.wait_task(task.uid()).await;
let (task, _) = server.get_task(task.uid()).await; let (task, _) = server.get_task(task.uid()).await;
assert_json_snapshot!(task, snapshot!(json_string!(task,
{ ".details.dumpUid" => "[dumpUid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".details.dumpUid" => "[dumpUid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
@r###" @r###"
{ {
"uid": 0, "uid": "[uid]",
"batchUid": 0, "batchUid": "[batch_uid]",
"indexUid": null, "indexUid": null,
"status": "succeeded", "status": "succeeded",
"type": "dumpCreation", "type": "dumpCreation",