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 std::cell::{Cell, RefCell};
fn document() -> LoroDoc {
let doc = LoroDoc::new();
doc.get_map("metadata").insert("title", "Document").unwrap();
doc.commit();
doc
}
fn access() -> DocumentAccess {
DocumentAccess::authorize("doc", "doc", true).unwrap()
}
fn delta(doc: &LoroDoc, root: &str, key: &str, value: &str) -> Vec<u8> {
let fork = doc.fork();
fork.get_map(root).insert(key, value).unwrap();
fork.export(ExportMode::Updates {
from: Cow::Owned(doc.oplog_vv()),
})
.unwrap()
}
#[test]
fn permission_policy_requires_matching_document_and_edit_grant() {
assert!(matches!(
DocumentAccess::authorize("other", "doc", true),
Err(DocumentError::Unauthorized)
));
let reader = DocumentAccess::authorize("doc", "doc", false).unwrap();
let doc = document();
assert!(snapshot(&reader, &doc).is_ok());
assert!(matches!(
prepare_update(
&reader,
&doc,
&doc.oplog_vv().encode(),
&delta(&doc, "properties", "A1", "x")
),
Err(DocumentError::Forbidden)
));
}
#[test]
fn preflight_is_isolated_and_stale_revision_never_changes_live_state() {
let doc = document();
let revision = doc.oplog_vv().encode();
let update = delta(&doc, "properties", "A1", "42");
let prepared = prepare_update(&access(), &doc, &revision, &update).unwrap();
assert!(prepared.applied);
assert!(doc.get_map("properties").get("A1").is_none());
doc.get_map("properties").insert("B1", "peer").unwrap();
doc.commit();
assert!(matches!(
prepare_update(&access(), &doc, &revision, &update),
Err(DocumentError::Conflict)
));
assert!(doc.get_map("properties").get("A1").is_none());
}
#[test]
fn applied_delta_retry_is_idempotent_even_after_another_edit() {
let doc = document();
let revision = doc.oplog_vv().encode();
let update = delta(&doc, "properties", "A1", "42");
doc.import(&update).unwrap();
doc.get_map("properties").insert("B1", "peer").unwrap();
doc.commit();
let retried = prepare_update(&access(), &doc, &revision, &update).unwrap();
assert!(!retried.applied);
assert_eq!(retried.revision, doc.oplog_vv().encode());
}
#[test]
fn snapshots_and_updates_accept_text_maps_and_nested_containers() {
let doc = document();
doc.get_text("content").insert(0, "text").unwrap();
doc.commit();
let (bytes, revision) = snapshot(&access(), &doc).unwrap();
let copy = LoroDoc::new();
copy.import(&bytes).unwrap();
assert_eq!(copy.oplog_vv().encode(), revision);
assert_eq!(copy.get_deep_value(), doc.get_deep_value());
let fork = doc.fork();
fork.get_map("arbitrary")
.insert_container("nested", loro::LoroText::new())
.unwrap()
.insert(0, "nested text")
.unwrap();
let update = fork
.export(ExportMode::Updates {
from: Cow::Owned(doc.oplog_vv()),
})
.unwrap();
let prepared = prepare_update(&access(), &doc, &revision, &update).unwrap();
assert!(prepared.applied);
doc.import(&prepared.update).unwrap();
assert_eq!(doc.get_deep_value(), fork.get_deep_value());
}
#[test]
fn rejects_snapshots_malformed_updates_and_missing_dependencies_without_mutation() {
let doc = document();
let revision = doc.oplog_vv().encode();
let fork = doc.fork();
fork.get_map("properties")
.insert("first", "missing")
.unwrap();
fork.commit();
let from = fork.oplog_vv();
fork.get_map("properties")
.insert("second", "pending")
.unwrap();
let pending = fork
.export(ExportMode::Updates {
from: Cow::Owned(from),
})
.unwrap();
for update in [
doc.export(ExportMode::Snapshot).unwrap(),
vec![1, 2, 3],
pending,
] {
assert!(matches!(
prepare_update(&access(), &doc, &revision, &update),
Err(DocumentError::Invalid(_))
));
assert_eq!(doc.oplog_vv().encode(), revision);
}
}
#[test]
fn enforces_binary_revision_and_operation_bounds() {
let doc = document();
let revision = doc.oplog_vv().encode();
let update = delta(&doc, "properties", "field", "value");
for (revision, update) in [
(revision.clone(), vec![0; MAX_BINARY_BYTES + 1]),
(vec![0; MAX_REVISION_BYTES + 1], update.clone()),
] {
assert!(matches!(
prepare_update(&access(), &doc, &revision, &update),
Err(DocumentError::TooLarge)
));
}
assert!(matches!(
prepare_update(&access(), &doc, &[255], &update),
Err(DocumentError::Invalid(_))
));
let fork = doc.fork();
fork.get_text("content")
.insert(0, &"x".repeat(MAX_UPDATE_OPERATIONS as usize + 1))
.unwrap();
let update = fork
.export(ExportMode::Updates {
from: Cow::Owned(doc.oplog_vv()),
})
.unwrap();
assert!(matches!(
prepare_update(&access(), &doc, &revision, &update),
Err(DocumentError::TooLarge)
));
assert_eq!(doc.oplog_vv().encode(), revision);
}
struct UpdateHarness {
doc: LoroDoc,
calls: RefCell<Vec<&'static str>>,
fail_persist: bool,
fail_publish: Cell<bool>,
}
impl UpdateHarness {
fn new() -> Self {
Self {
doc: document(),
calls: RefCell::new(Vec::new()),
fail_persist: false,
fail_publish: Cell::new(false),
}
}
}
impl DocumentUpdatePort for UpdateHarness {
fn document(&self) -> &LoroDoc {
&self.doc
}
async fn apply_and_persist(&self, update: &[u8]) -> Result<(), DocumentError> {
self.calls.borrow_mut().push("persist");
self.doc.import(update).unwrap();
if self.fail_persist {
return Err(DocumentError::Persistence);
}
Ok(())
}
}
impl DocumentUpdateEffects for UpdateHarness {
fn broadcast(&self, update: &[u8]) -> Result<(), DocumentError> {
self.calls.borrow_mut().push("broadcast");
let preview = self.doc.fork();
preview.import(update).unwrap();
assert_eq!(preview.oplog_vv(), self.doc.oplog_vv());
Ok(())
}
fn publish_changed_document(&self) -> Result<(), DocumentError> {
self.calls.borrow_mut().push("publish");
if self.fail_publish.get() {
return Err(DocumentError::Notification);
}
Ok(())
}
async fn keep_alive(&self) -> Result<(), DocumentError> {
self.calls.borrow_mut().push("keep_alive");
Ok(())
}
}
#[test]
fn update_use_case_persists_before_broadcast_and_publishes_new_edits() {
let port = UpdateHarness::new();
let revision = port.doc.oplog_vv().encode();
let delta = delta(&port.doc, "properties", "A1", "42");
let prepared =
futures::executor::block_on(update(&access(), &port, &port, &revision, &delta)).unwrap();
assert!(prepared.applied);
assert_eq!(
*port.calls.borrow(),
["persist", "broadcast", "publish", "keep_alive"]
);
port.calls.borrow_mut().clear();
let retried =
futures::executor::block_on(update(&access(), &port, &port, &revision, &delta)).unwrap();
assert!(!retried.applied);
assert_eq!(*port.calls.borrow(), ["persist", "broadcast", "keep_alive"]);
}
#[test]
fn rejected_or_unpersisted_update_never_notifies() {
let mut port = UpdateHarness::new();
let revision = port.doc.oplog_vv().encode();
let delta = delta(&port.doc, "properties", "A1", "42");
let viewer = DocumentAccess::authorize("doc", "doc", false).unwrap();
let result = futures::executor::block_on(update(&viewer, &port, &port, &revision, &delta));
assert!(matches!(result, Err(DocumentError::Forbidden)));
assert!(port.calls.borrow().is_empty());
port.fail_persist = true;
let result = futures::executor::block_on(update(&access(), &port, &port, &revision, &delta));
assert!(matches!(result, Err(DocumentError::Persistence)));
assert_eq!(*port.calls.borrow(), ["persist"]);
}
#[test]
fn notification_failure_preserves_durable_update_and_allows_idempotent_retry() {
let port = UpdateHarness::new();
let revision = port.doc.oplog_vv().encode();
let delta = delta(&port.doc, "properties", "A1", "42");
port.fail_publish.set(true);
let result = futures::executor::block_on(update(&access(), &port, &port, &revision, &delta));
assert!(matches!(result, Err(DocumentError::Notification)));
assert_eq!(*port.calls.borrow(), ["persist", "broadcast", "publish"]);
assert!(port.doc.get_map("properties").get("A1").is_some());
port.calls.borrow_mut().clear();
port.fail_publish.set(false);
let retried =
futures::executor::block_on(update(&access(), &port, &port, &revision, &delta)).unwrap();
assert!(!retried.applied);
assert_eq!(*port.calls.borrow(), ["persist", "broadcast", "keep_alive"]);
}
#[test]
fn session_attribution_uses_the_verified_human_or_agent_identity() {
let long_user = format!(
"macro|{}@{}.{}.{}",
"a".repeat(64),
"b".repeat(63),
"c".repeat(63),
"d".repeat(61)
);
assert_eq!(long_user.len(), 260);
assert_eq!(
DocumentAttribution::from_session_claims(None, Some(long_user.clone()), None)
.unwrap()
.unwrap()
.actor,
long_user
);
let user = "macro|[email protected]".to_string();
assert_eq!(
DocumentAttribution::from_session_claims(None, Some(user.clone()), None).unwrap(),
Some(DocumentAttribution {
agent_correlation_id: None,
actor: user.clone(),
on_behalf_of: None
})
);
assert_eq!(
DocumentAttribution::from_session_claims(
Some("bot|agent".into()),
Some(user.clone()),
None
)
.unwrap(),
Some(DocumentAttribution {
agent_correlation_id: None,
actor: "bot|agent".into(),
on_behalf_of: Some(user)
})
);
assert_eq!(
DocumentAttribution::from_session_claims(None, None, None).unwrap(),
None
);
assert!(DocumentAttribution::from_session_claims(None, Some("x".repeat(1025)), None).is_err());
}
#[test]
fn writing_peers_are_the_peers_with_operations_in_the_blob() {
let doc = LoroDoc::new();
doc.set_peer_id(11).unwrap();
doc.get_text("content").insert(0, "imported").unwrap();
doc.commit();
doc.set_peer_id(22).unwrap();
doc.get_text("content").insert(0, "edited ").unwrap();
doc.commit();
let snapshot = doc.export(ExportMode::Snapshot).unwrap();
assert_eq!(writing_peers(&snapshot).unwrap(), [11, 22]);
let seen = doc.oplog_vv();
doc.set_peer_id(33).unwrap();
doc.get_text("content").insert(0, "more ").unwrap();
doc.commit();
let update = doc
.export(ExportMode::Updates {
from: Cow::Owned(seen),
})
.unwrap();
assert_eq!(writing_peers(&update).unwrap(), [33]);
assert!(writing_peers(b"not a loro blob").is_err());
}
#[test]
fn persisted_editor_metadata_distinguishes_invocations_by_the_same_actor() {
let first = uuid::Uuid::from_u128(1);
let second = uuid::Uuid::from_u128(2);
let one = DocumentAttribution::from_session_claims(
Some("bot|agent".into()),
Some("macro|[email protected]".into()),
Some(first),
)
.unwrap()
.unwrap();
let two = DocumentAttribution::from_session_claims(
Some("bot|agent".into()),
Some("macro|[email protected]".into()),
Some(second),
)
.unwrap()
.unwrap();
let editors = std::collections::BTreeSet::from([one.clone(), two, one.clone()]);
assert_eq!(editors.len(), 2);
assert_eq!(
serde_json::to_value(one).unwrap()["agent_correlation_id"],
first.to_string()
);
}