use jmap_tasks_types::Task;
use jmap_types::{Id, Invocation, JmapError, PatchObject};
use serde::Deserialize;
use serde_json::{json, Value};
use crate::backend::{BackendSetError, TasksBackend};
use crate::helpers::{
enforce_max_objects_in_set, extract_account_id, finalize_set_response, set_error_value,
SetAccumulators,
};
use jmap_server::{server_fail_from_backend, server_fail_value_from_backend};
pub async fn handle_task_get<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<(Value, Vec<Invocation>), JmapError> {
let want_utc = match args.get("properties") {
None | Some(Value::Null) => true, Some(Value::Array(props)) => props
.iter()
.any(|p| p.as_str().is_some_and(|s| s == "utcStart" || s == "utcDue")),
_ => false,
};
let account_id: Id = args
.get("accountId")
.and_then(|v| v.as_str())
.ok_or_else(|| JmapError::invalid_arguments("accountId is required"))
.and_then(|s| {
Id::new_validated(s).map_err(|e| {
JmapError::invalid_arguments(format!("accountId is not a valid Id: {e}"))
})
})?;
let (mut response, tail) =
jmap_server::handlers::handle_get::<Task, B>(backend, caller, args).await?;
if want_utc {
if let Some(Value::Array(list)) = response.get_mut("list") {
for item in list.iter_mut() {
if let Ok(task) = Task::deserialize(&*item) {
let (utc_start, utc_due) = backend
.compute_utc_times(caller, &account_id, &task, None)
.await;
if let Some(s) = utc_start {
item["utcStart"] = Value::String(s.into_inner());
}
if let Some(d) = utc_due {
item["utcDue"] = Value::String(d.into_inner());
}
}
}
}
}
Ok((response, tail))
}
pub async fn handle_task_changes<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<(Value, Vec<Invocation>), JmapError> {
jmap_server::handlers::handle_changes::<Task, B>(backend, caller, args).await
}
pub async fn handle_task_set<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<(Value, Vec<Invocation>), JmapError> {
let (account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
enforce_max_objects_in_set(&args, backend.max_objects_in_set(caller, &account_id))?;
let old_state = backend
.get_state::<Task>(caller, &account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if let Some(if_in_state) = args.get("ifInState").and_then(|v| v.as_str()) {
if if_in_state != old_state.as_ref() {
return Err(JmapError::state_mismatch());
}
}
let mut created = serde_json::Map::new();
let mut not_created = serde_json::Map::new();
let mut updated = serde_json::Map::new();
let mut not_updated = serde_json::Map::new();
let mut destroyed_list: Vec<Value> = Vec::new();
let mut not_destroyed = serde_json::Map::new();
let mut mutated = false;
if let Some(Value::Object(create_map)) = args.remove("create") {
for (create_id, obj_val) in create_map {
if obj_val.get("id").is_some() {
not_created.insert(
create_id,
json!({"type": "invalidProperties", "properties": ["id"]}),
);
continue;
}
let obj_with_id = match obj_val {
Value::Object(mut m) => {
m.entry("id")
.or_insert_with(|| Value::String("placeholder".to_owned()));
Value::Object(m)
}
other => other,
};
let task: Task = match serde_json::from_value(obj_with_id) {
Ok(t) => t,
Err(e) => {
not_created.insert(
create_id,
json!({ "type": "invalidProperties", "description": e.to_string() }),
);
continue;
}
};
match backend
.create_object::<Task>(caller, &account_id, &create_id, task)
.await
{
Ok((_new_id, created_obj)) => {
mutated = true;
created.insert(
create_id,
serde_json::to_value(&created_obj)
.expect("derive(Serialize) on plain data is infallible"),
);
}
Err(BackendSetError::SetError(set_err)) => {
not_created.insert(create_id, set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_created.insert(create_id, server_fail_value_from_backend(&e));
}
Err(other) => {
not_created.insert(create_id, server_fail_value_from_backend(&other));
}
}
}
}
if let Some(Value::Object(update_map)) = args.remove("update") {
for (id_str, patch_val) in update_map {
if patch_val.get("isDraft").and_then(|v| v.as_bool()) == Some(true)
&& !backend.enforce_is_draft_atomically()
{
let task_id = Id::from(id_str.as_str());
match backend
.get_objects::<Task>(caller, &account_id, Some(&[task_id]), None)
.await
{
Ok((tasks, _)) => {
if tasks.first().and_then(|t| t.is_draft) == Some(false) {
not_updated.insert(
id_str,
json!({
"type": "invalidProperties",
"properties": ["isDraft"]
}),
);
continue;
}
}
Err(e) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
continue;
}
}
}
let id = Id::from(id_str.as_str());
let is_per_user_only = patch_val.as_object().is_some_and(|m| {
!m.is_empty()
&& m.keys().all(|k| {
let head = k.split('/').next().unwrap_or(k);
B::is_per_user_property(head)
})
});
let patch = match serde_json::from_value::<PatchObject>(patch_val) {
Ok(p) => p,
Err(e) => {
not_updated.insert(
id_str,
json!({ "type": "invalidPatch", "description": e.to_string() }),
);
continue;
}
};
let update_result = if is_per_user_only {
backend
.update_task_per_user(caller, &account_id, &id, patch)
.await
} else {
backend
.update_object::<Task>(caller, &account_id, &id, patch)
.await
};
match update_result {
Ok(Some(obj)) => {
mutated = true;
updated.insert(
id_str,
serde_json::to_value(&obj)
.expect("derive(Serialize) on plain data is infallible"),
);
}
Ok(None) => {
mutated = true;
updated.insert(id_str, Value::Null);
}
Err(BackendSetError::SetError(set_err)) => {
not_updated.insert(id_str, set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_updated.insert(id_str, server_fail_value_from_backend(&e));
}
Err(other) => {
not_updated.insert(id_str, server_fail_value_from_backend(&other));
}
}
}
}
if let Some(Value::Array(destroy_arr)) = args.remove("destroy") {
if let Some(bad) = destroy_arr.iter().find(|v| !v.is_string()) {
return Err(JmapError::invalid_arguments(format!(
"destroy: every element must be a string Id; got {bad}"
)));
}
for id_val in destroy_arr {
let id_str = match id_val.as_str() {
Some(s) => s.to_owned(),
None => continue, };
let id = Id::from(id_str.as_str());
match backend
.destroy_object::<Task>(caller, &account_id, &id)
.await
{
Ok(()) => {
mutated = true;
destroyed_list.push(Value::String(id_str));
}
Err(BackendSetError::SetError(set_err)) => {
not_destroyed.insert(id_str, set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_destroyed.insert(id_str, server_fail_value_from_backend(&e));
}
Err(other) => {
not_destroyed.insert(id_str, server_fail_value_from_backend(&other));
}
}
}
}
finalize_set_response::<B, Task>(
backend,
caller,
&account_id,
old_state,
mutated,
SetAccumulators {
created,
updated,
destroyed: destroyed_list,
not_created,
not_updated,
not_destroyed,
},
)
.await
}
pub async fn handle_task_copy<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
call_id: &str,
) -> Result<(Value, Vec<Invocation>), JmapError> {
let (to_account_id, mut args) = extract_account_id(args)?;
if !backend
.account_exists(caller, &to_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::account_not_found());
}
let from_account_id_str = args
.remove("fromAccountId")
.and_then(|v| v.as_str().map(|s| s.to_owned()))
.ok_or_else(|| JmapError::invalid_arguments("fromAccountId is required"))?;
let from_account_id = Id::from(from_account_id_str.as_str());
if from_account_id == to_account_id {
return Err(JmapError::invalid_arguments(
"fromAccountId must be different from accountId",
));
}
if !backend
.account_exists(caller, &from_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
{
return Err(JmapError::from_account_not_found());
}
if let Some(if_from_in_state) = args.get("ifFromInState").and_then(|v| v.as_str()) {
let from_state = backend
.get_state::<Task>(caller, &from_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if if_from_in_state != from_state.as_ref() {
return Err(JmapError::state_mismatch());
}
}
let old_state = backend
.get_state::<Task>(caller, &to_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
if let Some(if_in_state) = args.get("ifInState").and_then(|v| v.as_str()) {
if if_in_state != old_state.as_ref() {
return Err(JmapError::state_mismatch());
}
}
let on_success_destroy_original: bool = args
.get("onSuccessDestroyOriginal")
.and_then(|v| v.as_bool())
.unwrap_or(false);
let destroy_from_if_in_state: Option<String> = args
.get("destroyFromIfInState")
.and_then(|v| v.as_str())
.map(|s| s.to_owned());
let mut created = serde_json::Map::new();
let mut not_created = serde_json::Map::new();
let mut mutated = false;
let mut copied_source_ids: Vec<(String, Id)> = Vec::new();
if let Some(Value::Object(create_map)) = args.remove("create") {
for (create_id, client_val) in create_map {
let Some(source_id_str) = client_val.get("id").and_then(|v| v.as_str()) else {
not_created.insert(
create_id,
json!({"type": "invalidProperties", "properties": ["id"]}),
);
continue;
};
let source_id: Id = Id::from(source_id_str);
let source_tasks: Vec<Task> = match backend
.get_objects::<Task>(
caller,
&from_account_id,
Some(std::slice::from_ref(&source_id)),
None,
)
.await
{
Ok((objs, not_found)) => {
if !not_found.is_empty() || objs.is_empty() {
not_created.insert(create_id, json!({"type": "notFound"}));
continue;
}
objs
}
Err(e) => {
not_created.insert(create_id, server_fail_value_from_backend(&e));
continue;
}
};
let Ok(Value::Object(mut merged)) = serde_json::to_value(&source_tasks[0]) else {
not_created.insert(
create_id,
json!({
"type": "serverFail",
"description": "failed to serialize source Task",
}),
);
continue;
};
if let Value::Object(client_props) = client_val {
for (k, v) in client_props {
if k != "id" {
merged.insert(k, v);
}
}
}
merged.remove("id");
let task: Task = match serde_json::from_value(Value::Object(merged)) {
Ok(t) => t,
Err(e) => {
not_created.insert(
create_id,
json!({ "type": "invalidProperties", "description": e.to_string() }),
);
continue;
}
};
match backend
.create_object::<Task>(caller, &to_account_id, &create_id, task)
.await
{
Ok((_new_id, created_task)) => {
mutated = true;
created.insert(
create_id.clone(),
serde_json::to_value(&created_task)
.expect("derive(Serialize) on plain data is infallible"),
);
copied_source_ids.push((create_id, source_id));
}
Err(BackendSetError::SetError(set_err)) => {
not_created.insert(create_id, set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_created.insert(create_id, server_fail_value_from_backend(&e));
}
Err(other) => {
not_created.insert(create_id, server_fail_value_from_backend(&other));
}
}
}
}
let new_state = if mutated {
backend
.get_state::<Task>(caller, &to_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?
} else {
old_state.clone()
};
let resp = json!({
"fromAccountId": from_account_id.as_ref(),
"accountId": to_account_id.as_ref(),
"oldState": old_state.as_ref(),
"newState": new_state.as_ref(),
"created": if created.is_empty() { Value::Null } else { Value::Object(created) },
"notCreated": if not_created.is_empty() { Value::Null } else { Value::Object(not_created) },
});
let mut extra: Vec<Invocation> = Vec::new();
if on_success_destroy_original && !copied_source_ids.is_empty() {
let from_old_state = backend
.get_state::<Task>(caller, &from_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let mut destroy_state_mismatch = false;
if let Some(if_state) = destroy_from_if_in_state.as_deref() {
if if_state != from_old_state.as_ref() {
destroy_state_mismatch = true;
}
}
let mut destroyed_arr: Vec<Value> = Vec::new();
let mut not_destroyed = serde_json::Map::new();
if !destroy_state_mismatch {
for (_, source_id) in &copied_source_ids {
match backend
.destroy_object::<Task>(caller, &from_account_id, source_id)
.await
{
Ok(()) => {
destroyed_arr.push(Value::String(source_id.as_ref().to_owned()));
}
Err(BackendSetError::SetError(set_err)) => {
not_destroyed
.insert(source_id.as_ref().to_owned(), set_error_value(&set_err));
}
Err(BackendSetError::Other(e)) => {
not_destroyed.insert(
source_id.as_ref().to_owned(),
server_fail_value_from_backend(&e),
);
}
Err(other) => {
not_destroyed.insert(
source_id.as_ref().to_owned(),
server_fail_value_from_backend(&other),
);
}
}
}
}
let from_new_state = backend
.get_state::<Task>(caller, &from_account_id)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let set_resp = if destroy_state_mismatch {
json!({
"type": "stateMismatch",
})
} else {
json!({
"accountId": from_account_id.as_ref(),
"oldState": from_old_state.as_ref(),
"newState": from_new_state.as_ref(),
"created": Value::Null,
"updated": Value::Null,
"destroyed": if destroyed_arr.is_empty() { Value::Null } else { Value::Array(destroyed_arr) },
"notCreated": Value::Null,
"notUpdated": Value::Null,
"notDestroyed": if not_destroyed.is_empty() { Value::Null } else { Value::Object(not_destroyed) },
})
};
let method_name = if destroy_state_mismatch {
"error".to_owned()
} else {
"Task/set".to_owned()
};
extra.push((method_name, set_resp, call_id.to_owned()));
}
Ok((resp, extra))
}
pub async fn handle_task_query<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<(Value, Vec<Invocation>), JmapError> {
jmap_server::handlers::handle_query::<Task, B>(backend, caller, args).await
}
pub async fn handle_task_query_changes<B: TasksBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<(Value, Vec<Invocation>), JmapError> {
jmap_server::handlers::handle_query_changes::<Task, B>(backend, caller, args).await
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
use crate::test_support::MockBackend;
#[tokio::test]
async fn get_unknown_account_returns_account_not_found() {
let backend = MockBackend::new();
let args = json!({ "accountId": "unknown", "ids": null });
let result = handle_task_get(&backend, &(), args).await;
let err = result.expect_err("must return error for unknown account");
assert_eq!(err.error_type.as_str(), "accountNotFound");
}
#[tokio::test]
async fn copy_missing_from_account_id_returns_invalid_arguments() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"create": {}
});
let result = handle_task_copy(&backend, &(), args, "c0").await;
let err = result.expect_err("must return error when fromAccountId missing");
assert_eq!(err.error_type.as_str(), "invalidArguments");
}
#[tokio::test]
async fn copy_same_account_returns_invalid_arguments() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc1",
"create": {}
});
let result = handle_task_copy(&backend, &(), args, "c0").await;
let err = result.expect_err("must reject same-account Task/copy per RFC 8620 §5.4");
assert_eq!(err.error_type.as_str(), "invalidArguments");
}
#[tokio::test]
async fn copy_unknown_from_account_returns_from_account_not_found() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"fromAccountId": "no-such-account",
"create": {}
});
let result = handle_task_copy(&backend, &(), args, "c0").await;
let err = result.expect_err("must reject unknown fromAccountId");
assert_eq!(err.error_type.as_str(), "fromAccountNotFound");
}
#[tokio::test]
async fn copy_if_from_in_state_mismatch_returns_state_mismatch() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"ifFromInState": "stale-source-state",
"create": {}
});
let result = handle_task_copy(&backend, &(), args, "c0").await;
let err = result.expect_err("must reject stale ifFromInState");
assert_eq!(err.error_type.as_str(), "stateMismatch");
}
#[tokio::test]
async fn copy_if_in_state_mismatch_returns_state_mismatch() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"ifInState": "stale-destination-state",
"create": {}
});
let result = handle_task_copy(&backend, &(), args, "c0").await;
let err = result.expect_err("must reject stale ifInState");
assert_eq!(err.error_type.as_str(), "stateMismatch");
}
#[tokio::test]
async fn copy_create_entry_without_id_returns_invalid_properties() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"create": { "c1": {} }
});
let (resp, _) = handle_task_copy(&backend, &(), args, "c0")
.await
.expect("top-level call must succeed");
let nc = resp["notCreated"].as_object().expect("notCreated present");
let err = nc.get("c1").expect("c1 in notCreated");
assert_eq!(err["type"], "invalidProperties");
assert_eq!(err["properties"][0], "id");
}
#[tokio::test]
async fn copy_unknown_source_id_returns_not_found() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"create": { "c1": { "id": "no-such-task" } }
});
let (resp, _) = handle_task_copy(&backend, &(), args, "c0")
.await
.expect("top-level call must succeed");
let nc = resp["notCreated"].as_object().expect("notCreated present");
assert_eq!(nc["c1"]["type"], "notFound");
}
#[tokio::test]
async fn copy_fetches_source_and_overlays_client_overrides() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
backend.seed_task("acc2", "src1", true);
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"create": {
"c1": { "id": "src1", "title": "Overridden title" }
}
});
let (resp, _) = handle_task_copy(&backend, &(), args, "c0")
.await
.expect("top-level call must succeed");
let created = resp["created"].as_object().expect("created present");
let c1 = created.get("c1").expect("c1 in created");
assert_eq!(
c1["title"], "Overridden title",
"client-supplied title must override source value: {resp}"
);
}
#[tokio::test]
async fn copy_on_success_destroy_original_emits_implicit_task_set() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
backend.seed_task("acc2", "src1", true);
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"onSuccessDestroyOriginal": true,
"create": {
"c1": { "id": "src1" }
}
});
let (_, extra) = handle_task_copy(&backend, &(), args, "c0")
.await
.expect("top-level call must succeed");
assert_eq!(extra.len(), 1, "must emit one implicit Task/set: {extra:?}");
let (method, val, ci) = &extra[0];
assert_eq!(method, "Task/set");
assert_eq!(ci, "c0");
assert_eq!(val["accountId"], "acc2", "implicit set targets fromAccount");
let destroyed = val["destroyed"]
.as_array()
.expect("destroyed must be array");
assert_eq!(destroyed.len(), 1);
assert_eq!(destroyed[0], "src1");
assert!(val.get("oldState").is_some(), "oldState must be present");
assert!(val.get("newState").is_some(), "newState must be present");
}
#[tokio::test]
async fn copy_destroy_from_if_in_state_mismatch_aborts_destroy() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
backend.seed_task("acc2", "src1", true);
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"onSuccessDestroyOriginal": true,
"destroyFromIfInState": "stale-source-state",
"create": {
"c1": { "id": "src1" }
}
});
let (_, extra) = handle_task_copy(&backend, &(), args, "c0")
.await
.expect("top-level call must succeed");
assert_eq!(extra.len(), 1);
let (_, val, _) = &extra[0];
assert_eq!(val["type"], "stateMismatch");
}
#[tokio::test]
async fn copy_without_on_success_emits_no_extra_invocations() {
let mut backend = MockBackend::new_with_account("acc1");
backend.add_account("acc2");
backend.seed_task("acc2", "src1", true);
let args = json!({
"accountId": "acc1",
"fromAccountId": "acc2",
"create": {
"c1": { "id": "src1" }
}
});
let (_, extra) = handle_task_copy(&backend, &(), args, "c0")
.await
.expect("top-level call must succeed");
assert!(
extra.is_empty(),
"no extra invocations without onSuccessDestroyOriginal: {extra:?}"
);
}
#[tokio::test]
async fn set_empty_destroy_returns_valid_response() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({ "accountId": "acc1", "destroy": [] });
let (resp, _) = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(resp["accountId"], "acc1");
}
#[tokio::test]
async fn set_is_draft_revert_rejected_when_current_is_false() {
let mut backend = MockBackend::new_with_account("acc1");
backend.seed_task("acc1", "t1", false);
let args = json!({
"accountId": "acc1",
"update": {
"t1": { "isDraft": true }
}
});
let (resp, _) = handle_task_set(&backend, &(), args)
.await
.expect("must not return a top-level error");
let not_updated = resp["notUpdated"]
.as_object()
.expect("notUpdated must be an object");
assert!(
not_updated.contains_key("t1"),
"t1 must appear in notUpdated: {resp}"
);
assert_eq!(
not_updated["t1"]["type"].as_str(),
Some("invalidProperties"),
"error type must be invalidProperties"
);
assert_eq!(
not_updated["t1"]["properties"][0].as_str(),
Some("isDraft"),
"properties must list isDraft"
);
}
#[tokio::test]
async fn set_is_draft_true_on_draft_task_passes_to_backend() {
let mut backend = MockBackend::new_with_account("acc1");
backend.seed_task("acc1", "t2", true);
let args = json!({
"accountId": "acc1",
"update": {
"t2": { "isDraft": true }
}
});
let (resp, _) = handle_task_set(&backend, &(), args)
.await
.expect("must not return a top-level error");
if let Some(not_updated) = resp["notUpdated"].as_object() {
if let Some(err) = not_updated.get("t2") {
assert_ne!(
err["type"].as_str(),
Some("invalidProperties"),
"isDraft:true on an existing draft must not produce invalidProperties"
);
}
}
}
#[tokio::test]
async fn set_is_draft_false_passes_to_backend() {
let mut backend = MockBackend::new_with_account("acc1");
backend.seed_task("acc1", "t3", true);
let args = json!({
"accountId": "acc1",
"update": {
"t3": { "isDraft": false }
}
});
let (resp, _) = handle_task_set(&backend, &(), args)
.await
.expect("must not return a top-level error");
if let Some(not_updated) = resp["notUpdated"].as_object() {
if let Some(err) = not_updated.get("t3") {
assert_ne!(
err["type"].as_str(),
Some("invalidProperties"),
"isDraft:false must never produce invalidProperties"
);
}
}
}
#[tokio::test]
async fn get_without_utc_properties_omits_utc_fields() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"ids": null,
"properties": ["id", "title"] });
let (resp, _) = handle_task_get(&backend, &(), args)
.await
.expect("must succeed");
assert_eq!(resp["accountId"], "acc1");
let list = resp["list"].as_array().expect("list must be an array");
for item in list {
assert!(
item.get("utcStart").is_none(),
"utcStart must not appear when not in properties"
);
}
}
#[tokio::test]
async fn get_with_utc_start_in_properties_does_not_error() {
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"ids": null,
"properties": ["id", "utcStart", "utcDue"]
});
let (resp, _) = handle_task_get(&backend, &(), args)
.await
.expect("must succeed with utcStart in properties");
assert_eq!(resp["accountId"], "acc1");
}
#[tokio::test]
async fn set_per_user_only_patch_routes_to_per_user_update() {
use std::sync::atomic::Ordering;
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": { "t1": { "color": "#ff0000" } }
});
let _ = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(
backend.per_user_calls.load(Ordering::Relaxed),
1,
"per-user-only patch must route to update_task_per_user"
);
}
#[tokio::test]
async fn set_per_user_json_pointer_patch_routes_to_per_user_update() {
use std::sync::atomic::Ordering;
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": {
"t1": {
"keywords/done": true,
"alerts/0/offset": null
}
}
});
let _ = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(
backend.per_user_calls.load(Ordering::Relaxed),
1,
"JSON-pointer patch on per-user properties must route to update_task_per_user"
);
}
#[tokio::test]
async fn set_shared_property_patch_routes_to_update_object() {
use std::sync::atomic::Ordering;
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": { "t1": { "title": "New title" } }
});
let _ = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(
backend.per_user_calls.load(Ordering::Relaxed),
0,
"shared-property patch must NOT route to update_task_per_user"
);
}
#[tokio::test]
async fn set_shared_property_null_patch_routes_to_update_object() {
use std::sync::atomic::Ordering;
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": { "t1": { "title": null } }
});
let _ = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(
backend.per_user_calls.load(Ordering::Relaxed),
0,
"delete-shared-property patch must NOT route to update_task_per_user"
);
}
#[tokio::test]
async fn set_mixed_patch_routes_to_update_object() {
use std::sync::atomic::Ordering;
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": { "t1": { "color": "#ff0000", "title": "New" } }
});
let _ = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(
backend.per_user_calls.load(Ordering::Relaxed),
0,
"mixed patch must route to update_object"
);
}
#[tokio::test]
async fn set_empty_patch_routes_to_update_object() {
use std::sync::atomic::Ordering;
let backend = MockBackend::new_with_account("acc1");
let args = json!({
"accountId": "acc1",
"update": { "t1": {} }
});
let _ = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
assert_eq!(
backend.per_user_calls.load(Ordering::Relaxed),
0,
"empty patch must NOT route to update_task_per_user"
);
}
#[tokio::test]
async fn set_is_draft_revert_rejected_with_prefetch() {
let mut backend = MockBackend::new_with_account("acc1");
backend.seed_task("acc1", "t1", false);
let args = json!({
"accountId": "acc1",
"update": { "t1": { "isDraft": true } }
});
let (resp, _) = handle_task_set(&backend, &(), args)
.await
.expect("must not return top-level error");
let not_updated = resp["notUpdated"].as_object().expect("notUpdated");
assert_eq!(
not_updated["t1"]["type"], "invalidProperties",
"pre-fetch path must reject isDraft revert: {resp}"
);
assert_eq!(not_updated["t1"]["properties"][0], "isDraft");
}
}