Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use super::*;
use crate::domain::ports::editing::MockEditingWorkerService;
use ai_billing::domain::{
DenyReason,
admission::{AdmissionFuture, AiAdmissionError},
};
use ai_usage::UsageEvent;
use entity_access::domain::models::{Entity, EntityPermission, EntityType, RequiredPermission};
use std::sync::Mutex;
const DOCUMENT: &str = "019fd3b9-3c6c-7c05-89c2-a27f0121813b";
const SECRET: &str = "local-canvas-test-secret";
#[tokio::test]
async fn render_mints_view_access_and_does_not_admit_or_meter_a_model() {
let mut worker = MockEditingWorkerService::new();
worker.expect_canvas().times(1).returning(|id, token, request, _| {
assert_eq!(id, DOCUMENT);
assert!(matches!(request, CanvasRequest::Render { .. }));
let claims: serde_json::Value = macro_sync_service_jwt::decode(token.as_str(), SECRET).unwrap();
assert_eq!(claims["access_level"], "view");
assert_eq!(claims["actor"], "macro|[email protected]");
assert_eq!(serde_json::to_value(request).unwrap(), serde_json::json!({"action":"render"}));
Box::pin(async { Ok(CanvasResult { failure: None, usage: vec![], response: CanvasResponse {
render: Some(serde_json::from_value(serde_json::json!({"revision":"snapshot-1","clock":{},"crop":{"x":0,"y":0,"width":100,"height":80},"width":200,"height":160,"objects":[],"unavailable":[],"modelMedia":[{"type":"image","mediaType":"image/png","data":"iVBORw0KGgo="}]})).unwrap()),
canvas: None, operations_applied: 0, summary: "Rendered".into(), clarification: None,
} }) })
});
let recorder = Arc::new(Recorder::default());
let service = CanvasService::new(
Arc::new(documents("canvas")),
Arc::new(worker),
SECRET.into(),
Arc::new(Admission(Err(AiAdmissionError::Unavailable))),
recorder.clone(),
);
let render = service
.render(
receipt(AccessLevel::View),
&user(),
"macro|[email protected]",
None,
None,
)
.await
.unwrap();
assert_eq!(render.revision, "snapshot-1");
assert!(recorder.0.lock().unwrap().is_empty());
}
#[tokio::test]
async fn invalid_render_crop_never_starts_storage_or_worker_access() {
let service = CanvasService::new(
Arc::new(MockCanvasDocumentLookup::new()),
Arc::new(MockEditingWorkerService::new()),
SECRET.into(),
Arc::new(Admission(Ok(()))),
Arc::new(Recorder::default()),
);
assert!(
service
.render(
receipt(AccessLevel::View),
&user(),
"macro|[email protected]",
None,
Some(CanvasBounds {
x: 0.0,
y: 0.0,
width: -1.0,
height: 100.0
})
)
.await
.is_err()
);
}
fn user() -> MacroUserIdStr<'static> {
"macro|[email protected]".to_owned().try_into().unwrap()
}
fn receipt<T: RequiredPermission>(access_level: AccessLevel) -> EntityAccessReceipt<T> {
EntityAccessReceipt::try_new_authenticated_user(
user(),
Entity {
entity_id: DOCUMENT.into(),
entity_type: EntityType::Document,
},
EntityPermission::AccessLevel { access_level },
)
.unwrap()
}
struct Admission(Result<(), AiAdmissionError>);
impl AiAdmissionService for Admission {
fn admit<'a>(
&'a self,
caller: &'a MacroUserIdStr<'_>,
feature: AiFeature,
) -> AdmissionFuture<'a> {
Box::pin(async move {
assert_eq!(caller, &user());
assert_eq!(feature, AiFeature::AiEditing);
self.0
})
}
}
#[derive(Default)]
struct Recorder(Mutex<Vec<UsageEvent>>);
impl UsageRecorder for Recorder {
fn record(&self, event: UsageEvent) {
self.0.lock().unwrap().push(event);
}
}
fn documents(file_type: &str) -> MockCanvasDocumentLookup {
let mut documents = MockCanvasDocumentLookup::new();
let file_type = file_type.to_owned();
documents
.expect_file_type()
.withf(|id| id == DOCUMENT)
.times(1)
.returning(move |_| {
let file_type = file_type.clone();
Box::pin(async move { Ok(Some(file_type)) })
});
documents
}
#[tokio::test]
async fn read_mints_only_view_access_and_preserves_actor_without_admission_or_usage() {
let mut worker = MockEditingWorkerService::new();
worker
.expect_canvas()
.times(1)
.returning(|id, token, request, _| {
assert_eq!(id, DOCUMENT);
assert!(matches!(request, CanvasRequest::Read { .. }));
let claims: serde_json::Value =
macro_sync_service_jwt::decode(token.as_str(), SECRET).unwrap();
assert_eq!(claims["document_id"], DOCUMENT);
assert_eq!(claims["access_level"], "view");
assert_eq!(claims["actor"], "macro|[email protected]");
assert_eq!(claims["user_id"], "macro|[email protected]");
Box::pin(async {
Ok(CanvasResult {
failure: None,
response: CanvasResponse {
render: None,
canvas: Some("scene".into()),
operations_applied: 0,
summary: "Read".into(),
clarification: None,
},
usage: vec![],
})
})
});
let recorder = Arc::new(Recorder::default());
let service = CanvasService::new(
Arc::new(documents("canvas")),
Arc::new(worker),
SECRET.into(),
Arc::new(Admission(Err(AiAdmissionError::Unavailable))),
recorder.clone(),
);
assert_eq!(
service
.read(
receipt(AccessLevel::View),
&user(),
"macro|[email protected]",
None,
None
)
.await
.unwrap()
.canvas
.as_deref(),
Some("scene")
);
assert!(recorder.0.lock().unwrap().is_empty());
}
#[tokio::test]
async fn invalid_file_type_and_denied_admission_never_start_worker() {
for (file_type, admission) in [
("md", Ok(())),
(
"canvas",
Err(AiAdmissionError::Denied(DenyReason::AllowanceExhausted)),
),
("canvas", Err(AiAdmissionError::Unavailable)),
] {
let recorder = Arc::new(Recorder::default());
let service = CanvasService::new(
Arc::new(documents(file_type)),
Arc::new(MockEditingWorkerService::new()),
SECRET.into(),
Arc::new(Admission(admission)),
recorder.clone(),
);
assert!(
service
.edit(
receipt(AccessLevel::Edit),
&user(),
"macro|[email protected]",
"Make a flowchart".into(),
None
)
.await
.is_err()
);
assert!(recorder.0.lock().unwrap().is_empty());
}
}
#[tokio::test]
async fn admitted_edit_mints_edit_access_and_records_actual_worker_usage() {
let mut worker = MockEditingWorkerService::new();
worker.expect_canvas().times(1).returning(|_, token, request, _| {
assert!(matches!(request,CanvasRequest::Edit {instructions, ..} if instructions=="Make a flowchart"));
let claims: serde_json::Value=macro_sync_service_jwt::decode(token.as_str(),SECRET).unwrap();
assert_eq!(claims["access_level"],"edit");
assert_eq!(claims["actor"],"macro|[email protected]");
Box::pin(async {Ok(CanvasResult { failure: None,response:CanvasResponse { render: None,canvas:None,operations_applied:3,summary:"Applied".into(),clarification:None},usage:vec![EditUsage {model:"test-model".into(),input_tokens:100,output_tokens:20}]})})
});
let recorder = Arc::new(Recorder::default());
let service = CanvasService::new(
Arc::new(documents("canvas")),
Arc::new(worker),
SECRET.into(),
Arc::new(Admission(Ok(()))),
recorder.clone(),
);
assert_eq!(
service
.edit(
receipt(AccessLevel::Edit),
&user(),
"macro|[email protected]",
"Make a flowchart".into(),
None
)
.await
.unwrap()
.operations_applied,
3
);
let events = recorder.0.lock().unwrap();
assert_eq!(events.len(), 1);
assert_eq!(
events[0].amount,
UsageAmount::Tokens {
input: 100,
output: 20,
cache_read: 0,
cache_write: 0
}
);
}
#[test]
fn view_only_permission_cannot_construct_an_edit_receipt() {
assert!(
EntityAccessReceipt::<EditAccessLevel>::try_new_authenticated_user(
user(),
Entity {
entity_id: DOCUMENT.into(),
entity_type: EntityType::Document
},
EntityPermission::AccessLevel {
access_level: AccessLevel::View
}
)
.is_err()
);
}
#[tokio::test]
async fn failed_later_step_still_records_completed_provider_usage() {
let mut worker = MockEditingWorkerService::new();
worker.expect_canvas().times(1).returning(|_, _, _, _| {
Box::pin(async {
Ok(CanvasResult {
failure: Some(
"Provider failed after one acknowledged edit. ReadCanvas before retrying."
.into(),
),
response: CanvasResponse {
render: None,
canvas: None,
operations_applied: 1,
summary: "Stopped".into(),
clarification: None,
},
usage: vec![EditUsage {
model: "test-model".into(),
input_tokens: 70,
output_tokens: 30,
}],
})
})
});
let recorder = Arc::new(Recorder::default());
let service = CanvasService::new(
Arc::new(documents("canvas")),
Arc::new(worker),
SECRET.into(),
Arc::new(Admission(Ok(()))),
recorder.clone(),
);
let error = service
.edit(
receipt(AccessLevel::Edit),
&user(),
"macro|[email protected]",
"Make a flowchart".into(),
None,
)
.await
.unwrap_err();
assert!(error.to_string().contains("acknowledged edit"));
let events = recorder.0.lock().unwrap();
assert_eq!(events.len(), 1);
assert_eq!(
events[0].amount,
UsageAmount::Tokens {
input: 70,
output: 30,
cache_read: 0,
cache_write: 0
}
);
}
#[tokio::test]
async fn direct_batch_has_edit_capability_without_a_second_model_or_admission() {
let mut worker = MockEditingWorkerService::new();
worker.expect_canvas().times(1).returning(|_, token, request, _| {
let claims: serde_json::Value = macro_sync_service_jwt::decode(token.as_str(), SECRET).unwrap();
assert_eq!(claims["access_level"], "edit");
assert_eq!(claims["actor"], "macro|[email protected]");
assert!(matches!(request, CanvasRequest::Apply { code, .. } if code == "editor.move(['a'],0,20)"));
Box::pin(async { Ok(CanvasResult { failure: None, usage: vec![], response: CanvasResponse {
render: None, canvas: Some("verified scene".into()), operations_applied: 1, summary: "Applied".into(), clarification: None,
} }) })
});
let recorder = Arc::new(Recorder::default());
let service = CanvasService::new(
Arc::new(documents("canvas")),
Arc::new(worker),
SECRET.into(),
Arc::new(Admission(Err(AiAdmissionError::Unavailable))),
recorder.clone(),
);
let result = service
.apply(
receipt(AccessLevel::Edit),
&user(),
"macro|[email protected]",
CanvasRequest::Apply {
expected_revision: "a".repeat(64),
code: "editor.move(['a'],0,20)".into(),
snippets: None,
editor_name: None,
},
)
.await
.unwrap();
assert_eq!(result.operations_applied, 1);
assert!(recorder.0.lock().unwrap().is_empty());
}
#[tokio::test]
async fn invalid_direct_revision_never_reads_storage_or_calls_worker() {
let service = CanvasService::new(
Arc::new(MockCanvasDocumentLookup::new()),
Arc::new(MockEditingWorkerService::new()),
SECRET.into(),
Arc::new(Admission(Ok(()))),
Arc::new(Recorder::default()),
);
assert!(
service
.apply(
receipt(AccessLevel::Edit),
&user(),
"macro|[email protected]",
CanvasRequest::Apply {
expected_revision: "stale".into(),
code: "editor.move(['a'],0,20)".into(),
snippets: None,
editor_name: None,
}
)
.await
.is_err()
);
}
#[tokio::test]
async fn the_artifacts_rollout_reaches_the_worker_only_when_set() {
for (service_setting, expected) in [(None, false), (Some(false), false), (Some(true), true)] {
let mut worker = MockEditingWorkerService::new();
worker
.expect_canvas()
.times(1)
.returning(move |_, _, _, artifacts| {
assert_eq!(artifacts, expected);
Box::pin(async {
Ok(CanvasResult {
failure: None,
response: CanvasResponse {
render: None,
canvas: Some("scene".into()),
operations_applied: 0,
summary: "Read".into(),
clarification: None,
},
usage: vec![],
})
})
});
let mut service = CanvasService::new(
Arc::new(documents("canvas")),
Arc::new(worker),
SECRET.into(),
Arc::new(Admission(Err(AiAdmissionError::Unavailable))),
Arc::new(Recorder::default()),
);
if let Some(artifacts) = service_setting {
service = service.with_artifacts(artifacts);
}
service
.read(
receipt(AccessLevel::View),
&user(),
"macro|[email protected]",
None,
None,
)
.await
.unwrap();
}
}