#[macro_use]
mod common;
use std::sync::Arc;
use common::*;
use jmap_scene_server::memory::MemoryBackend;
use jmap_scene_server::{handle_scene_object_interact, register_scene_handlers};
use jmap_scene_types::SceneObject;
use jmap_server::{Dispatcher, JmapBackend};
use jmap_types::{Id, JmapRequest, State};
use serde_json::{Value, json};
const R1: &str = "01J5ABC0000000000000000001";
const OBJ2: &str = "01J5QBJ0000000000000000002";
const OBJ3: &str = "01J5QBJ0000000000000000003";
const VAULT: &str = "01J5ABC0000000000000000002";
const VAULT_OBJ: &str = "01J5QBJ0000000000000000004";
fn object(id: &str, region: &str, interactable: bool) -> Value {
let mut o = stored_object(id, region, json!([0, 0, 0]), "2026-06-02T10:00:00Z");
o["interactable"] = json!(interactable);
o
}
fn avatar(id: &str, region: &str, user: &str, left_at: Value) -> Value {
json!({
"id": id,
"regionId": region,
"userId": user,
"displayName": user,
"position": [0, 0, 5],
"orientation": [0, 0, 0, 1],
"visualRef": null,
"visualType": null,
"joinedAt": "2026-06-06T10:00:00Z",
"leftAt": left_at,
"worldState": null
})
}
fn scene() -> MemoryBackend {
let backend = backend();
seed_as(
&backend,
"SceneRegion",
stored_region(R1, "Plaza", "2026-06-01T10:00:00Z"),
);
let mut vault = stored_region(VAULT, "Vault", "2026-06-01T11:00:00Z");
vault["accessPolicy"] = json!("invite");
seed_as(&backend, "SceneRegion", vault);
for (id, region, interactable) in [
(OBJ2, R1, true),
(OBJ3, R1, false),
(VAULT_OBJ, VAULT, true),
] {
seed_as(&backend, "SceneObject", object(id, region, interactable));
}
for (id, region, user, left_at) in [
("01J5AVT0000000000000000001", R1, ALICE, json!(null)),
("01J5AVT0000000000000000002", VAULT, ALICE, json!(null)),
("01J5AVT0000000000000000003", R1, BOB, json!(null)),
("01J5AVT0000000000000000004", VAULT, BOB, json!(null)),
(
"01J5AVT0000000000000000005",
R1,
ADMIN,
json!("2026-06-06T11:00:00Z"),
),
] {
seed_as(&backend, "SceneAvatar", avatar(id, region, user, left_at));
}
backend
}
async fn interact_one(backend: &MemoryBackend, caller: &str, interaction: Value) -> Value {
call!(
handle_scene_object_interact,
backend,
caller,
json!({ "interactions": { "i0": interaction } }),
)
}
fn click(region: &str, object_id: &str) -> Value {
json!({ "regionId": region, "objectId": object_id, "action": "click", "data": null })
}
async fn refusal(backend: &MemoryBackend, caller: &str, interaction: Value) -> Value {
let resp = interact_one(backend, caller, interaction).await;
assert_eq!(resp["accepted"], Value::Null, "{resp}");
resp["notAccepted"]["i0"].clone()
}
#[tokio::test]
async fn draft_example_through_the_dispatcher() {
let backend = Arc::new(scene());
let mut dispatcher: Dispatcher<String> = Dispatcher::new();
register_scene_handlers(&mut dispatcher, Arc::clone(&backend));
let request: JmapRequest = serde_json::from_value(json!({
"using": [
"urn:ietf:params:jmap:core",
"urn:ietf:params:jmap:scene"
],
"methodCalls": [
["SceneObject/interact", {
"accountId": "acct-001",
"interactions": {
"i0": {
"regionId": "01J5ABC0000000000000000001",
"objectId": "01J5QBJ0000000000000000002",
"action": "click",
"data": null
},
"i1": {
"regionId": "01J5ABC0000000000000000001",
"objectId": "01J5QBJ0000000000000000003",
"action": "grab",
"data": {"hand": "left"}
}
}
}, "x0"]
]
}))
.unwrap();
let response = dispatcher
.dispatch(request, ALICE.to_owned(), State::from("s0"))
.await;
assert_eq!(
serde_json::to_value(&response).unwrap()["methodResponses"],
json!([
["SceneObject/interact", {
"accountId": "acct-001",
"accepted": ["i0"],
"notAccepted": {
"i1": {
"type": "forbidden",
"description": "The object is not interactable."
}
}
}, "x0"]
])
);
}
#[tokio::test]
async fn accepted_interaction_reaches_the_backend_as_an_event() {
let backend = scene();
let resp = interact_one(
&backend,
BOB,
json!({
"regionId": R1,
"objectId": OBJ2,
"action": "grab",
"data": {"hand": "left"}
}),
)
.await;
assert_eq!(
resp,
json!({ "accountId": ACCOUNT, "accepted": ["i0"], "notAccepted": null })
);
let events = backend.accepted_interactions();
assert_eq!(events.len(), 1);
assert_eq!(
serde_json::to_value(&events[0]).unwrap(),
json!({
"accountId": ACCOUNT,
"regionId": R1,
"objectId": OBJ2,
"userId": BOB,
"action": "grab",
"data": {"hand": "left"}
})
);
}
#[tokio::test]
async fn interact_changes_no_state() {
let backend = scene();
let caller = ALICE.to_owned();
let account = Id::from(ACCOUNT);
let before = backend
.get_state::<SceneObject>(&caller, &account)
.await
.unwrap();
interact_one(&backend, ALICE, click(R1, OBJ2)).await;
let after = backend
.get_state::<SceneObject>(&caller, &account)
.await
.unwrap();
assert_eq!(before, after);
}
#[tokio::test]
async fn not_found_cases() {
let backend = scene();
backend.hide_object(BOB, OBJ2);
for (caller, interaction) in [
(ALICE, click(R1, "01J5QBJ0000000000000000099")),
(ALICE, click("01J5ABC0000000000000000099", OBJ2)),
(ALICE, click(R1, VAULT_OBJ)),
(CAROL, click(VAULT, VAULT_OBJ)),
(BOB, click(R1, OBJ2)),
] {
let err = refusal(&backend, caller, interaction.clone()).await;
assert_eq!(err["type"], "notFound", "{caller} {interaction}: {err}");
}
assert!(backend.accepted_interactions().is_empty());
}
#[tokio::test]
async fn forbidden_cases() {
let backend = scene();
backend.grant_region_access(VAULT, CAROL);
for (caller, interaction) in [
(ADMIN, click(R1, OBJ2)),
(CAROL, click(VAULT, VAULT_OBJ)),
(ALICE, click(R1, OBJ3)),
] {
let err = refusal(&backend, caller, interaction.clone()).await;
assert_eq!(err["type"], "forbidden", "{caller} {interaction}: {err}");
}
assert!(backend.accepted_interactions().is_empty());
}
const CAROL: &str = "user:carol@example.com";
#[tokio::test]
async fn rate_limit() {
let backend = scene();
backend.rate_limit_interactions(ALICE);
let err = refusal(&backend, ALICE, click(R1, OBJ2)).await;
assert_eq!(err["type"], "rateLimit", "{err}");
assert!(backend.accepted_interactions().is_empty());
}
#[tokio::test]
async fn invalid_properties_name_the_property() {
let backend = scene();
for (interaction, properties) in [
(
json!({ "regionId": R1, "objectId": OBJ2 }),
json!(["action"]),
),
(
json!({ "regionId": 7, "objectId": OBJ2, "action": "click" }),
json!(["regionId"]),
),
(
json!({ "regionId": R1, "action": "click", "data": "left" }),
json!(["objectId", "data"]),
),
] {
let err = refusal(&backend, ALICE, interaction.clone()).await;
assert_eq!(err["type"], "invalidProperties", "{interaction}: {err}");
assert_eq!(err["properties"], properties, "{interaction}: {err}");
}
let err = refusal(&backend, ALICE, json!("click")).await;
assert_eq!(err["type"], "invalidProperties", "{err}");
}
#[tokio::test]
async fn mixed_batch_splits_accepted_and_not_accepted() {
let backend = scene();
let resp = call!(
handle_scene_object_interact,
&backend,
ALICE,
json!({ "interactions": {
"a": click(R1, OBJ2),
"b": click(R1, "01J5QBJ0000000000000000099"),
"c": click(VAULT, VAULT_OBJ)
} }),
);
let mut accepted: Vec<&str> = resp["accepted"]
.as_array()
.unwrap()
.iter()
.map(|v| v.as_str().unwrap())
.collect();
accepted.sort_unstable();
assert_eq!(accepted, ["a", "c"]);
assert_eq!(resp["notAccepted"]["b"]["type"], "notFound");
assert_eq!(backend.accepted_interactions().len(), 2);
}
#[tokio::test]
async fn method_level_errors() {
let backend = scene();
let caller = ALICE.to_owned();
let err = handle_scene_object_interact(&backend, &caller, json!({ "accountId": ACCOUNT }))
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "invalidArguments");
let err = handle_scene_object_interact(
&backend,
&caller,
json!({ "accountId": "acct-404", "interactions": {} }),
)
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "accountNotFound");
}
#[tokio::test]
async fn interactions_over_max_objects_in_set_are_request_too_large() {
let backend = scene();
let caller = ALICE.to_owned();
let cap = JmapBackend::max_objects_in_set(&backend, &caller, &Id::from(ACCOUNT));
let args = |n: u64| {
let interactions: serde_json::Map<String, Value> =
(0..n).map(|i| (format!("i{i}"), click(R1, OBJ2))).collect();
json!({ "accountId": ACCOUNT, "interactions": interactions })
};
let err = handle_scene_object_interact(&backend, &caller, args(cap + 1))
.await
.unwrap_err();
assert_eq!(err.error_type.to_string(), "requestTooLarge");
assert!(backend.accepted_interactions().is_empty());
handle_scene_object_interact(&backend, &caller, args(cap))
.await
.expect("exactly maxObjectsInSet interactions are processed");
}