#[macro_use]
mod common;
use std::f64::consts::FRAC_1_SQRT_2;
use common::*;
use jmap_scene_server::memory::MemoryBackend;
use jmap_scene_server::{handle_scene_object_query, handle_scene_object_query_changes};
use jmap_types::JmapError;
use serde_json::{Value, json};
const REGION: &str = "01J5ABC0000000000000000001";
const OTHER_REGION: &str = "01J5ABC0000000000000000002";
const O1: &str = "01J5OBJ0000000000000000001";
const O2: &str = "01J5OBJ0000000000000000002";
const FAR: &str = "01J5OBJ0000000000000000003";
const ELSEWHERE: &str = "01J5OBJ0000000000000000004";
fn backend_with_objects() -> MemoryBackend {
let backend = backend();
seed_as(
&backend,
"SceneObject",
json!({
"id": "01J5OBJ0000000000000000001",
"regionId": "01J5ABC0000000000000000001",
"parentId": null,
"name": "Sculpture: Convergence",
"position": [12.5, 0, -3.2],
"orientation": [0, 0.707, 0, 0.707],
"scale": [1, 1, 1],
"visualRef": "blob-gltf-sculpture-001",
"visualType": "model/gltf-binary",
"assetUri": "https://cdn.example.com/assets/sculpture-001.glb",
"physicsMode": "static",
"interactable": true,
"visible": true,
"ownerId": "user:curator@example.com",
"createdAt": "2026-06-01T12:00:00Z",
"updatedAt": "2026-06-01T12:00:00Z",
"worldState": {
"artist": "Elena Voss",
"year": 2025,
"medium": "Bronze"
}
}),
);
seed_as(
&backend,
"SceneObject",
json!({
"id": "01J5OBJ0000000000000000002",
"regionId": "01J5ABC0000000000000000001",
"parentId": null,
"name": "Info Kiosk",
"position": [0, 0, 8],
"orientation": [0, 0, 0, 1],
"scale": [0.8, 0.8, 0.8],
"visualRef": "blob-gltf-kiosk-001",
"visualType": "model/gltf-binary",
"assetUri": "https://cdn.example.com/assets/kiosk-001.glb",
"physicsMode": "static",
"interactable": true,
"visible": true,
"ownerId": "user:curator@example.com",
"createdAt": "2026-06-01T12:30:00Z",
"updatedAt": "2026-06-03T09:15:00Z",
"worldState": null
}),
);
let mut far = stored_object(FAR, REGION, json!([26, 0, -2]), "2026-06-01T11:00:00Z");
far["interactable"] = json!(true);
far["name"] = json!("Bench");
far["physicsMode"] = json!("dynamic");
seed_as(&backend, "SceneObject", far);
let mut elsewhere = stored_object(
ELSEWHERE,
OTHER_REGION,
json!([5, 0, -2]),
"2026-06-01T09:00:00Z",
);
elsewhere["interactable"] = json!(true);
seed_as(&backend, "SceneObject", elsewhere);
backend
}
async fn query(backend: &MemoryBackend, args: Value) -> Result<Value, JmapError> {
let mut args = args;
args["accountId"] = json!(ACCOUNT);
handle_scene_object_query(backend, &ALICE.to_owned(), args)
.await
.map(|o| o.primary)
}
async fn ids(backend: &MemoryBackend, args: Value) -> Value {
query(backend, args).await.expect("query")["ids"].clone()
}
async fn assert_total(backend: &MemoryBackend, mut args: Value, resp: &Value) {
assert!(resp.get("total").is_none(), "{resp}");
args["calculateTotal"] = json!(true);
let resp = query(backend, args).await.expect("query");
assert_eq!(resp["total"], 2);
}
#[tokio::test]
async fn spec_within_radius_example() {
let backend = backend_with_objects();
let args = json!({
"filter": {
"regionId": "01J5ABC0000000000000000001",
"interactable": true,
"withinRadius": {
"center": [5.0, 0, -2.0],
"radius": 20
}
},
"sort": [
{"property": "name", "isAscending": true}
],
"position": 0,
"limit": 25
});
let resp = query(&backend, args.clone()).await.expect("query");
assert_eq!(resp["ids"], json!([O2, O1]));
assert_total(&backend, args, &resp).await;
}
#[tokio::test]
async fn spec_within_bounds_example() {
let backend = backend_with_objects();
let args = json!({
"filter": {
"regionId": "01J5ABC0000000000000000001",
"withinBounds": {
"min": [-15, 0, -15],
"max": [15, 10, 15]
}
},
"sort": [
{"property": "createdAt", "isAscending": true}
],
"position": 0,
"limit": 50
});
let resp = query(&backend, args.clone()).await.expect("query");
assert_eq!(resp["ids"], json!([O1, O2]));
assert_total(&backend, args, &resp).await;
}
#[tokio::test]
async fn default_sort_is_created_at_ascending() {
let backend = backend_with_objects();
let got = ids(&backend, json!({ "filter": { "regionId": REGION } })).await;
assert_eq!(got, json!([FAR, O1, O2]));
}
#[tokio::test]
async fn property_filters_are_anded() {
let backend = backend_with_objects();
let got = ids(
&backend,
json!({ "filter": { "regionId": REGION, "physicsMode": "dynamic" } }),
)
.await;
assert_eq!(got, json!([FAR]));
let got = ids(
&backend,
json!({ "filter": { "regionId": REGION, "visualType": "model/gltf-binary", "name": "kiosk" } }),
)
.await;
assert_eq!(got, json!([O2]));
}
fn backend_with_graph() -> MemoryBackend {
let backend = backend();
let mut p = stored_object("P", REGION, json!([10, 0, 0]), "2026-06-01T10:00:00Z");
p["orientation"] = json!([0, FRAC_1_SQRT_2, 0, FRAC_1_SQRT_2]);
p["scale"] = json!([2, 2, 2]);
let mut c = stored_object("C", REGION, json!([1, 0, 0]), "2026-06-01T10:01:00Z");
c["parentId"] = json!("P");
let mut g = stored_object("G", REGION, json!([0, 0, 1]), "2026-06-01T10:02:00Z");
g["parentId"] = json!("C");
for o in [p, c, g] {
seed_as(&backend, "SceneObject", o);
}
backend
}
#[tokio::test]
async fn spatial_filters_use_region_local_positions() {
let backend = backend_with_graph();
let near = |center: [f64; 3]| json!({ "filter": { "regionId": REGION, "withinRadius": { "center": center, "radius": 0.001 } } });
assert_eq!(ids(&backend, near([10.0, 0.0, -2.0])).await, json!(["C"]));
assert_eq!(ids(&backend, near([12.0, 0.0, -2.0])).await, json!(["G"]));
assert_eq!(ids(&backend, near([10.0, 0.0, 0.0])).await, json!(["P"]));
assert_eq!(ids(&backend, near([1.0, 0.0, 0.0])).await, json!([]));
let got = ids(
&backend,
json!({ "filter": { "regionId": REGION, "withinBounds": { "min": [9, -1, -3], "max": [11, 1, -1] } } }),
)
.await;
assert_eq!(got, json!(["C"]));
}
#[tokio::test]
async fn parent_id_filter_selects_roots_or_children() {
let backend = backend_with_graph();
let roots = ids(
&backend,
json!({ "filter": { "regionId": REGION, "parentId": null } }),
)
.await;
assert_eq!(roots, json!(["P"]));
let kids = ids(
&backend,
json!({ "filter": { "regionId": REGION, "parentId": "C" } }),
)
.await;
assert_eq!(kids, json!(["G"]));
}
#[tokio::test]
async fn region_id_is_required() {
let backend = backend_with_objects();
for args in [
json!({}),
json!({ "filter": { "interactable": true } }),
json!({ "filter": { "operator": "AND", "conditions": [
{ "regionId": REGION },
{ "visible": true }
] } }),
] {
let err = query(&backend, args.clone()).await.expect_err("must fail");
assert_eq!(err.error_type.to_string(), "invalidArguments", "{args}");
}
}
#[tokio::test]
async fn unknown_physics_mode_filter_is_invalid_arguments() {
let backend = backend_with_objects();
let err = query(
&backend,
json!({ "filter": { "regionId": REGION, "physicsMode": "floating" } }),
)
.await
.expect_err("must fail");
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn non_positive_radius_is_invalid_arguments() {
let backend = backend_with_objects();
for radius in [json!(0), json!(-5)] {
let err = query(
&backend,
json!({ "filter": { "regionId": REGION, "withinRadius": { "center": [0, 0, 0], "radius": radius } } }),
)
.await
.expect_err("must fail");
assert_eq!(err.error_type.to_string(), "invalidArguments", "{radius}");
}
}
#[tokio::test]
async fn inverted_bounds_are_invalid_arguments() {
let backend = backend_with_objects();
let err = query(
&backend,
json!({ "filter": { "regionId": REGION, "withinBounds": { "min": [0, 5, 0], "max": [10, 1, 10] } } }),
)
.await
.expect_err("must fail");
assert_eq!(err.error_type.to_string(), "invalidArguments");
}
#[tokio::test]
async fn sort_outside_created_at_and_name_is_unsupported() {
let backend = backend_with_objects();
let err = query(
&backend,
json!({ "filter": { "regionId": REGION }, "sort": [{ "property": "position" }] }),
)
.await
.expect_err("must fail");
assert_eq!(err.error_type.to_string(), "unsupportedSort");
}
#[tokio::test]
async fn query_changes_applies_the_filter_validation() {
let backend = backend_with_objects();
let err = handle_scene_object_query_changes(
&backend,
&ALICE.to_owned(),
json!({ "accountId": ACCOUNT, "sinceQueryState": "0", "filter": {} }),
)
.await
.expect_err("must fail");
assert_eq!(err.error_type.to_string(), "invalidArguments");
}