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::store::InMemoryStorage;
mod hydration_search_changes;
mod query_search_changes;
#[test]
fn resolved_read_plans_do_not_leak_arguments_or_values_between_reads() {
pollster::block_on(async {
let query = "query Page($input: SoupInput!) { user { id soup(input: $input) { items { __typename id ... on GraphqlSoupDocument { name } } nextCursor } } }";
let mut engine = Engine::with_capacity(InMemoryStorage::new(), 1);
let variables = |limit| {
serde_json::json!({"input": {"limit": limit}})
.as_object()
.unwrap()
.clone()
};
let response = |id: &str, name: &str| {
serde_json::json!({"user": {"id": "viewer", "soup": {
"items": [{"__typename": "GraphqlSoupDocument", "id": id, "name": name}], "nextCursor": null
}}})
};
for (limit, id, name) in [(1, "first", "First"), (2, "second", "Second")] {
engine
.write_query(
None,
query,
Some("Page"),
&variables(limit),
&response(id, name),
None,
)
.await
.unwrap();
}
for (limit, id, name) in [
(1, "first", "First"),
(2, "second", "Second"),
(1, "first", "First"),
] {
let read = engine
.read_query(Some(1), query, Some("Page"), &variables(limit))
.await
.unwrap();
assert!(matches!(read, ReadResult::Hit { data } if data == response(id, name)));
}
engine
.write_query(
None,
query,
Some("Page"),
&variables(1),
&response("first", "Renamed"),
None,
)
.await
.unwrap();
let read = engine
.read_query(Some(1), query, Some("Page"), &variables(1))
.await
.unwrap();
assert!(matches!(read, ReadResult::Hit { data } if data == response("first", "Renamed")));
let read = engine
.read_query(Some(1), query, Some("Page"), &variables(2))
.await
.unwrap();
assert!(matches!(read, ReadResult::Hit { data } if data == response("second", "Second")));
});
}
#[test]
fn storage_generation_survives_reopening_and_preserves_existing_records() {
pollster::block_on(async {
let query = "query Viewer { user { id } }";
let data = serde_json::json!({"user": {"id": "viewer"}});
let variables = serde_json::Map::new();
let mut original = Engine::new(InMemoryStorage::new());
original
.write_query(None, query, None, &variables, &data, None)
.await
.unwrap();
let revision = original.current_revision();
let first = original.current_storage_generation().await.unwrap();
assert_eq!(first.get_version_num(), 7);
assert_eq!(original.current_revision(), revision);
assert_eq!(original.current_storage_generation().await.unwrap(), first);
let mut reopened = Engine::new(original.into_storage());
assert_eq!(reopened.current_storage_generation().await.unwrap(), first);
assert!(matches!(
reopened.read_query(None, query, None, &variables).await.unwrap(),
ReadResult::Hit { data: read } if read == data
));
});
}
#[test]
fn storage_generation_changes_after_logical_clear_and_identity_rebinding() {
pollster::block_on(async {
let mut engine = Engine::new(InMemoryStorage::new());
let first = engine.current_storage_generation().await.unwrap();
engine.clear().await.unwrap();
let after_clear = engine.current_storage_generation().await.unwrap();
assert_ne!(after_clear, first);
let query = "query Viewer { user { id } }";
let variables = serde_json::Map::new();
engine
.write_query(
None,
query,
None,
&variables,
&serde_json::json!({"user": {"id": "one"}}),
Some("one"),
)
.await
.unwrap();
assert_eq!(
engine.current_storage_generation().await.unwrap(),
after_clear
);
let write = engine
.write_query(
None,
query,
None,
&variables,
&serde_json::json!({"user": {"id": "two"}}),
Some("two"),
)
.await
.unwrap();
assert!(write.reset);
let after_identity_change = engine.current_storage_generation().await.unwrap();
assert_ne!(after_identity_change, after_clear);
assert_ne!(after_identity_change, first);
});
}
#[test]
fn storage_generation_reads_external_clears_and_repairs_invalid_markers() {
pollster::block_on(async {
let mut engine = Engine::new(InMemoryStorage::new());
let first = engine.current_storage_generation().await.unwrap();
// Storage is authoritative even when this engine receives no reset notification.
engine.storage.clear().await.unwrap();
let replacement = engine.current_storage_generation().await.unwrap();
assert_ne!(replacement, first);
let mut malformed = Record::default();
malformed.fields.insert(
STORAGE_GENERATION_VALUE_FIELD.to_string(),
crate::value::CacheValue::String("invalid-generation".to_string()),
);
engine
.storage
.put_batch(vec![(
EntityKey(STORAGE_GENERATION_META_KEY.into()),
malformed,
)])
.await
.unwrap();
let repaired = engine.current_storage_generation().await.unwrap();
assert_ne!(repaired, replacement);
assert_eq!(engine.current_storage_generation().await.unwrap(), repaired);
});
}
#[test]
fn ordinary_network_refresh_loads_each_cold_batch_only_once() {
pollster::block_on(async {
let query = "query Page { user { id soup(input: {limit: 50}) { items { __typename id ... on GraphqlSoupDocument { name } } nextCursor } } }";
let data = serde_json::json!({"user": {"id": "viewer", "soup": {
"items": (0..12).map(|id| serde_json::json!({
"__typename": "GraphqlSoupDocument", "id": id.to_string(), "name": "Cached"
})).collect::<Vec<_>>(), "nextCursor": null
}}});
let variables = serde_json::Map::new();
let mut original = Engine::new(InMemoryStorage::new());
original
.write_query(None, query, Some("Page"), &variables, &data, None)
.await
.unwrap();
let storage = original.into_storage();
let before = storage.record_get_count();
let mut reopened = Engine::with_capacity(storage, 1);
let result = reopened
.write_query(None, query, Some("Page"), &variables, &data, None)
.await
.unwrap();
assert!(result.changed.is_empty());
assert!(!result.revision_advanced);
assert_eq!(reopened.storage().record_get_count() - before, 1);
assert!(
matches!(reopened.read_query(None, query, Some("Page"), &variables).await.unwrap(), ReadResult::Hit { data: read } if read == data)
);
});
}
#[test]
fn revision_overflow_is_rejected_without_mutating_storage() {
pollster::block_on(async {
let mut engine = Engine::new(InMemoryStorage::new());
engine.revision = u64::MAX.to_string().parse().unwrap();
let result = engine.clear().await;
assert!(matches!(result, Err(EngineError::RevisionOverflow)));
assert_eq!(engine.current_revision().to_string(), u64::MAX.to_string());
assert!(engine.storage().is_empty());
});
}
#[test]
fn parsed_documents_are_bounded_reused_and_errors_are_not_cached() {
let mut engine = Engine::new(InMemoryStorage::new());
let query = |index| format!("query Q{index} {{ user {{ id }} }}");
for index in 0..DOCUMENT_CACHE_CAPACITY {
Engine::<InMemoryStorage>::document(&mut engine.docs, &query(index)).unwrap();
}
Engine::<InMemoryStorage>::document(&mut engine.docs, &query(0)).unwrap();
Engine::<InMemoryStorage>::document(&mut engine.docs, &query(DOCUMENT_CACHE_CAPACITY)).unwrap();
assert_eq!(engine.docs.len(), DOCUMENT_CACHE_CAPACITY);
assert!(engine.docs.contains(&query(0)));
assert!(!engine.docs.contains(&query(1)));
assert!(Engine::<InMemoryStorage>::document(&mut engine.docs, "query Broken {").is_err());
assert_eq!(engine.docs.len(), DOCUMENT_CACHE_CAPACITY);
let document = Engine::<InMemoryStorage>::document(&mut engine.docs, &query(1)).unwrap();
assert!(document.operation(Some("Q1")).is_ok());
}
#[test]
fn fragment_reads_keep_hot_and_cold_linked_records_in_the_working_set() {
use crate::value::CacheValue;
pollster::block_on(async {
for message_is_hot in [true, false] {
let mut engine = Engine::with_capacity(InMemoryStorage::new(), 3);
let message_key = EntityKey("GraphqlSoupEmailMessage:message".into());
let thread_key = EntityKey("GraphqlSoupEmailThread:thread".into());
let unrelated_key = EntityKey("GraphqlSoupDocument:unrelated".into());
let message = Record {
fields: [
(
"__typename".into(),
CacheValue::String("GraphqlSoupEmailMessage".into()),
),
("id".into(), CacheValue::String("message".into())),
("subject".into(), CacheValue::String("Subject".into())),
(
"bodyText".into(),
CacheValue::String("unselected body".repeat(4096)),
),
]
.into(),
};
let thread = Record {
fields: [
(
"__typename".into(),
CacheValue::String("GraphqlSoupEmailThread".into()),
),
("id".into(), CacheValue::String("thread".into())),
(
crate::value::field_key("messages", Some(r#"{"limit":1,"offset":0}"#)),
CacheValue::List(vec![CacheValue::Ref(message_key.clone())]),
),
]
.into(),
};
engine
.storage
.put_batch(vec![(message_key.clone(), message.clone())])
.await
.unwrap();
if message_is_hot {
engine.hot.put(message_key.clone(), message);
}
engine.hot.put(thread_key.clone(), thread);
engine.hot.put(unrelated_key.clone(), Record::default());
if !message_is_hot {
engine.hot.put(
EntityKey("GraphqlSoupDocument:other".into()),
Record::default(),
);
}
let selection = RecordSelection::parse(crate::meta::bundled_schema_ref(),
"fragment Thread on GraphqlSoupEmailThread { id messages(offset: 0, limit: 1) { id subject } }",
"Thread",
).unwrap();
let reads = engine.storage().record_get_count();
for _ in 0..2 {
let result = engine
.read_records_by_keys(&selection, std::slice::from_ref(&thread_key))
.await
.unwrap();
assert_eq!(
result.value[0].record,
serde_json::json!({"id": "thread", "messages": [{"id": "message", "subject": "Subject"}]})
);
}
assert_eq!(
engine.storage().record_get_count(),
reads + usize::from(!message_is_hot)
);
engine.hot.put(
EntityKey("GraphqlSoupDocument:new".into()),
Record::default(),
);
assert!(engine.hot.contains(&thread_key));
assert!(engine.hot.contains(&message_key));
assert!(!engine.hot.contains(&unrelated_key));
}
});
}
#[test]
fn opaque_json_numbers_round_trip_exactly_through_hot_and_cold_reads() {
pollster::block_on(async {
let query = "query Payload { user { id activity(input: {limit: 1}) { items { __typename id action { __typename ... on GraphqlActivityUnknownAction { payload } } } } } }";
let data = serde_json::json!({"user": {"id": "viewer", "activity": {"items": [{
"__typename": "GraphqlActivityEvent", "id": "event", "action": {
"__typename": "GraphqlActivityUnknownAction", "payload": {
"large": 15_588_948_318_755_801_000.0,
"negative": -15_588_948_318_755_801_000.0,
"fraction": 1.0000000000000002,
"tiny": 1.2345678901234567e-200
}
}
}]}}});
let variables = serde_json::Map::new();
let mut engine = Engine::new(InMemoryStorage::new());
engine
.write_query(None, query, Some("Payload"), &variables, &data, None)
.await
.unwrap();
for _ in 0..2 {
let read = engine
.read_query(None, query, Some("Payload"), &variables)
.await
.unwrap();
assert!(matches!(read, ReadResult::Hit { data: actual } if actual == data));
engine = Engine::new(engine.into_storage());
}
});
}