fix the error messages and add tests

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::InvalidTaskDate { .. } => Code::InvalidTaskDateFilter,
-            Error::InvalidTaskUids { .. } => Code::InvalidTaskUids,
+            Error::InvalidTaskUids { .. } => Code::InvalidTaskUidsFilter,
-            Error::InvalidTaskStatuses { .. } => Code::InvalidTaskStatuses,
+            Error::InvalidTaskStatuses { .. } => Code::InvalidTaskStatusesFilter,
-            Error::InvalidTaskTypes { .. } => Code::InvalidTaskTypes,
+            Error::InvalidTaskTypes { .. } => Code::InvalidTaskTypesFilter,
-            Error::InvalidTaskCanceledBy { .. } => Code::InvalidTaskCanceledBy,
+            Error::InvalidTaskCanceledBy { .. } => Code::InvalidTaskCanceledByFilter,
             Error::InvalidIndexUid { .. } => Code::InvalidIndexUid,
             Error::TaskNotFound(_) => Code::TaskNotFound,
             Error::TaskDeletionWithEmptyQuery => Code::TaskDeletionWithEmptyQuery,

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() {
+        if !types.is_empty() {
-            let _ = write!(url, "&types={}", type_.join(","));
+            let _ = write!(url, "&types={}", types.join(","));
         }
-        if !status.is_empty() {
+        if !statuses.is_empty() {
-            let _ = write!(url, "&statuses={}", status.join(","));
+            let _ = write!(url, "&statuses={}", statuses.join(","));
         }
         self.service.get(url).await
     }

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
     }
 

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,