diff --git a/index-scheduler/src/error.rs b/index-scheduler/src/error.rs index 1cde58905..cfbf7a25e 100644 --- a/index-scheduler/src/error.rs +++ b/index-scheduler/src/error.rs @@ -60,9 +60,9 @@ pub enum Error { InvalidIndexUid { index_uid: String }, #[error("Task `{0}` not found.")] TaskNotFound(TaskId), - #[error("Query parameters to filter the tasks to delete are missing. Available query parameters are: `uid`, `indexUid`, `status`, `type`.")] + #[error("Query parameters to filter the tasks to delete are missing. Available query parameters are: `uids`, `indexUids`, `statuses`, `types`, `beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`, `beforeFinishedAt`, `afterFinishedAt`.")] TaskDeletionWithEmptyQuery, - #[error("Query parameters to filter the tasks to cancel are missing. Available query parameters are: `uid`, `indexUid`, `status`, `type`.")] + #[error("Query parameters to filter the tasks to cancel are missing. Available query parameters are: `uids`, `indexUids`, `statuses`, `types`, `beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`, `beforeFinishedAt`, `afterFinishedAt`.")] TaskCancelationWithEmptyQuery, #[error(transparent)] @@ -102,11 +102,11 @@ impl ErrorCode for Error { Error::IndexAlreadyExists(_) => Code::IndexAlreadyExists, Error::SwapDuplicateIndexesFound(_) => Code::DuplicateIndexFound, Error::SwapDuplicateIndexFound(_) => Code::DuplicateIndexFound, - Error::InvalidTaskDate { .. } => Code::InvalidTaskDate, - Error::InvalidTaskUids { .. } => Code::InvalidTaskUids, - Error::InvalidTaskStatuses { .. } => Code::InvalidTaskStatuses, - Error::InvalidTaskTypes { .. } => Code::InvalidTaskTypes, - Error::InvalidTaskCanceledBy { .. } => Code::InvalidTaskCanceledBy, + Error::InvalidTaskDate { .. } => Code::InvalidTaskDateFilter, + Error::InvalidTaskUids { .. } => Code::InvalidTaskUidsFilter, + Error::InvalidTaskStatuses { .. } => Code::InvalidTaskStatusesFilter, + Error::InvalidTaskTypes { .. } => Code::InvalidTaskTypesFilter, + Error::InvalidTaskCanceledBy { .. } => Code::InvalidTaskCanceledByFilter, Error::InvalidIndexUid { .. } => Code::InvalidIndexUid, Error::TaskNotFound(_) => Code::TaskNotFound, Error::TaskDeletionWithEmptyQuery => Code::TaskDeletionWithEmptyQuery, diff --git a/meilisearch-http/tests/common/index.rs b/meilisearch-http/tests/common/index.rs index 6a488d8aa..dac3653f7 100644 --- a/meilisearch-http/tests/common/index.rs +++ b/meilisearch-http/tests/common/index.rs @@ -110,13 +110,13 @@ impl Index<'_> { self.service.get(url).await } - pub async fn filtered_tasks(&self, type_: &[&str], status: &[&str]) -> (Value, StatusCode) { + pub async fn filtered_tasks(&self, types: &[&str], statuses: &[&str]) -> (Value, StatusCode) { let mut url = format!("/tasks?indexUids={}", self.uid); - if !type_.is_empty() { - let _ = write!(url, "&types={}", type_.join(",")); + if !types.is_empty() { + let _ = write!(url, "&types={}", types.join(",")); } - if !status.is_empty() { - let _ = write!(url, "&statuses={}", status.join(",")); + if !statuses.is_empty() { + let _ = write!(url, "&statuses={}", statuses.join(",")); } self.service.get(url).await } diff --git a/meilisearch-http/tests/common/server.rs b/meilisearch-http/tests/common/server.rs index b7ddc772c..3f72248c5 100644 --- a/meilisearch-http/tests/common/server.rs +++ b/meilisearch-http/tests/common/server.rs @@ -132,6 +132,10 @@ impl Server { self.service.get("/tasks").await } + pub async fn tasks_filter(&self, filter: Value) -> (Value, StatusCode) { + self.service.get(format!("/tasks?{}", yaup::to_string(&filter).unwrap())).await + } + pub async fn get_dump_status(&self, uid: &str) -> (Value, StatusCode) { self.service.get(format!("/dumps/{}/status", uid)).await } @@ -144,13 +148,13 @@ impl Server { self.service.post("/swap-indexes", value).await } - pub async fn cancel_task(&self, value: Value) -> (Value, StatusCode) { + pub async fn cancel_tasks(&self, value: Value) -> (Value, StatusCode) { self.service .post(format!("/tasks/cancel?{}", yaup::to_string(&value).unwrap()), json!(null)) .await } - pub async fn delete_task(&self, value: Value) -> (Value, StatusCode) { + pub async fn delete_tasks(&self, value: Value) -> (Value, StatusCode) { self.service.delete(format!("/tasks?{}", yaup::to_string(&value).unwrap())).await } diff --git a/meilisearch-http/tests/tasks/mod.rs b/meilisearch-http/tests/tasks/mod.rs index 145bb1b01..222906f6e 100644 --- a/meilisearch-http/tests/tasks/mod.rs +++ b/meilisearch-http/tests/tasks/mod.rs @@ -1,4 +1,4 @@ -use meili_snap::insta::assert_json_snapshot; +use meili_snap::insta::{self, assert_json_snapshot}; use serde_json::json; use time::format_description::well_known::Rfc3339; use time::OffsetDateTime; @@ -173,6 +173,131 @@ async fn list_tasks_status_and_type_filtered() { assert_eq!(response["results"].as_array().unwrap().len(), 2); } +#[actix_rt::test] +async fn get_task_filter_error() { + let server = Server::new().await; + + let (response, code) = server.tasks_filter(json!( { "lol": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Query deserialize error: unknown field `lol`", + "code": "bad_request", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#bad_request" + } + "###); + + let (response, code) = server.tasks_filter(json!( { "uids": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Task uid `pied` is invalid. It should only contain numeric characters.", + "code": "invalid_task_uids_filter", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#invalid_task_uids_filter" + } + "###); + + let (response, code) = server.tasks_filter(json!( { "from": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Query deserialize error: invalid digit found in string", + "code": "bad_request", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#bad_request" + } + "###); + + let (response, code) = server.tasks_filter(json!( { "beforeStartedAt": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Task `beforeStartedAt` `pied` is invalid. It should follow the YYYY-MM-DD or RFC 3339 date-time format.", + "code": "invalid_task_date_filter", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#invalid_task_date_filter" + } + "###); +} + +#[actix_rt::test] +async fn delete_task_filter_error() { + let server = Server::new().await; + + let (response, code) = server.delete_tasks(json!(null)).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Query parameters to filter the tasks to delete are missing. Available query parameters are: `uids`, `indexUids`, `statuses`, `types`, `beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`, `beforeFinishedAt`, `afterFinishedAt`.", + "code": "missing_task_filters", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#missing_task_filters" + } + "###); + + let (response, code) = server.delete_tasks(json!({ "lol": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Query deserialize error: unknown field `lol`", + "code": "bad_request", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#bad_request" + } + "###); + + let (response, code) = server.delete_tasks(json!({ "uids": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Task uid `pied` is invalid. It should only contain numeric characters.", + "code": "invalid_task_uids_filter", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#invalid_task_uids_filter" + } + "###); +} + +#[actix_rt::test] +async fn cancel_task_filter_error() { + let server = Server::new().await; + + let (response, code) = server.cancel_tasks(json!(null)).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Query parameters to filter the tasks to cancel are missing. Available query parameters are: `uids`, `indexUids`, `statuses`, `types`, `beforeEnqueuedAt`, `afterEnqueuedAt`, `beforeStartedAt`, `afterStartedAt`, `beforeFinishedAt`, `afterFinishedAt`.", + "code": "missing_task_filters", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#missing_task_filters" + } + "###); + + let (response, code) = server.cancel_tasks(json!({ "lol": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Query deserialize error: unknown field `lol`", + "code": "bad_request", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#bad_request" + } + "###); + + let (response, code) = server.cancel_tasks(json!({ "uids": "pied" })).await; + assert_eq!(code, 400, "{}", response); + insta::assert_json_snapshot!(response, @r###" + { + "message": "Task uid `pied` is invalid. It should only contain numeric characters.", + "code": "invalid_task_uids_filter", + "type": "invalid_request", + "link": "https://docs.meilisearch.com/errors#invalid_task_uids_filter" + } + "###); +} + macro_rules! assert_valid_summarized_task { ($response:expr, $task_type:literal, $index:literal) => {{ assert_eq!($response.as_object().unwrap().len(), 5); @@ -789,7 +914,7 @@ async fn test_summarized_task_cancelation() { // to avoid being flaky we're only going to cancel an already finished task :( index.create(None).await; index.wait_task(0).await; - server.cancel_task(json!({ "uids": [0] })).await; + server.cancel_tasks(json!({ "uids": [0] })).await; index.wait_task(1).await; let (task, _) = index.get_task(1).await; assert_json_snapshot!(task, @@ -822,7 +947,7 @@ async fn test_summarized_task_deletion() { // to avoid being flaky we're only going to delete an already finished task :( index.create(None).await; index.wait_task(0).await; - server.delete_task(json!({ "uids": [0] })).await; + server.delete_tasks(json!({ "uids": [0] })).await; index.wait_task(1).await; let (task, _) = index.get_task(1).await; assert_json_snapshot!(task,