Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

26.6 KB
Raw Blame
use cache_core::calendar::{
    CalendarCommit, CalendarFreshness, CalendarLinkWatermark, CalendarRangeRequest,
    CalendarReplacedEvent, CalendarSpan, CalendarSpanKind, CalendarWatermarkUpdate,
};
use cache_core::engine::{BeginOptimisticWrite, Engine, InitialClaimOutcome};
use cache_core::identity::IdentityBinding;
use cache_core::queue::{MutationClaimRequest, MutationClaimToken};
use cache_core::store::{InMemoryStorage, Storage};
use cache_core::value::{CacheValue, EntityKey, Record};
use pollster::block_on;
use serde_json::{Value as Json, json};
use std::collections::BTreeMap;

const HOUR_MS: i64 = 3_600_000;
const DAY_MS: i64 = 24 * HOUR_MS;
// 2026-10-05T00:00:00Z
const MONDAY_MS: i64 = 1_791_158_400_000;
const MONDAY_DAY: i64 = 20_731;

const MUTATION: &str = "mutation Save { setEntityProperty { __typename id displayName } }";
const UUID: &str = "22222222-2222-4222-8222-222222222222";

fn key(value: &str) -> EntityKey<'static> {
    EntityKey(value.to_owned().into())
}

fn text(value: &str) -> CacheValue {
    CacheValue::String(value.into())
}

fn iso(ms: i64) -> String {
    chrono::DateTime::from_timestamp_millis(ms)
        .unwrap()
        .to_rfc3339()
}

fn date(day: i64) -> String {
    (chrono::NaiveDate::from_ymd_opt(1970, 1, 1).unwrap() + chrono::Duration::days(day)).to_string()
}

fn time_object(fields: Vec<(&str, String)>) -> CacheValue {
    CacheValue::Object(
        fields
            .into_iter()
            .map(|(field, value)| (field.to_owned(), CacheValue::String(value)))
            .collect::<BTreeMap<_, _>>(),
    )
}

fn occurrence(event: &str, link: &str, time: CacheValue) -> Record {
    let mut record = Record::default();
    for (field, value) in [
        ("__typename", text("GraphqlCalendarOccurrence")),
        ("eventId", text(event)),
        ("linkId", text(link)),
        ("isCancelled", CacheValue::Bool(false)),
        ("time", time),
    ] {
        record.fields.insert(field.into(), value);
    }
    record
}

fn timed(event: &str, link: &str, start_ms: i64, end_ms: i64) -> (EntityKey<'static>, Record) {
    let start = iso(start_ms);
    (
        key(&format!("GraphqlCalendarOccurrence:{event}:{start}")),
        occurrence(
            event,
            link,
            time_object(vec![
                ("__typename", "GraphqlTimedEventTime".into()),
                ("startsAt", start),
                ("endsAt", iso(end_ms)),
            ]),
        ),
    )
}

fn all_day(event: &str, link: &str, start_day: i64, end_day: i64) -> (EntityKey<'static>, Record) {
    (
        key(&format!(
            "GraphqlCalendarOccurrence:{event}:{}",
            date(start_day)
        )),
        occurrence(
            event,
            link,
            time_object(vec![
                ("__typename", "GraphqlAllDayEventTime".into()),
                ("startDate", date(start_day)),
                ("endDate", date(end_day)),
            ]),
        ),
    )
}

fn linked(typename: &str, id: &str, link: &str) -> (EntityKey<'static>, Record) {
    let mut record = Record::default();
    record.fields.insert("__typename".into(), text(typename));
    record.fields.insert("id".into(), text(id));
    record.fields.insert("linkId".into(), text(link));
    (EntityKey::entity(typename, &[id]), record)
}

fn week() -> CalendarRangeRequest {
    CalendarRangeRequest {
        start_ms: MONDAY_MS,
        end_ms: MONDAY_MS + 7 * DAY_MS,
        start_day: MONDAY_DAY,
        end_day: MONDAY_DAY + 7,
        event_key: None,
    }
}

fn week_coverage() -> Vec<CalendarSpan> {
    vec![
        CalendarSpan {
            kind: CalendarSpanKind::Timed,
            start: MONDAY_MS,
            end: MONDAY_MS + 7 * DAY_MS,
        },
        CalendarSpan {
            kind: CalendarSpanKind::AllDay,
            start: MONDAY_DAY,
            end: MONDAY_DAY + 7,
        },
    ]
}

fn link(link_id: &str, seq: i64) -> CalendarLinkWatermark {
    CalendarLinkWatermark {
        link_id: link_id.into(),
        seq,
    }
}

async fn seeded(entries: Vec<(EntityKey<'static>, Record)>) -> Engine<InMemoryStorage> {
    let mut engine = Engine::new(InMemoryStorage::new());
    engine
        .put_records_with_projections(None, entries, Vec::new())
        .await
        .unwrap();
    engine
}

#[test]
fn ranges_return_overlapping_occurrences_of_both_kinds() {
    block_on(async {
        let inside = timed(
            "e1",
            "l1",
            MONDAY_MS + 9 * HOUR_MS,
            MONDAY_MS + 10 * HOUR_MS,
        );
        let ends_at_start = timed("e2", "l1", MONDAY_MS - HOUR_MS, MONDAY_MS);
        let starts_at_end = timed("e3", "l1", MONDAY_MS + 7 * DAY_MS, MONDAY_MS + 8 * DAY_MS);
        let long = timed("e4", "l1", MONDAY_MS - 30 * DAY_MS, MONDAY_MS + HOUR_MS);
        let holiday = all_day("e5", "l1", MONDAY_DAY + 6, MONDAY_DAY + 7);
        let next_week = all_day("e6", "l1", MONDAY_DAY + 7, MONDAY_DAY + 8);
        let mut engine = seeded(vec![
            inside.clone(),
            ends_at_start,
            starts_at_end,
            long.clone(),
            holiday.clone(),
            next_week,
        ])
        .await;

        let result = engine.calendar_range(&week()).await.unwrap();
        assert_eq!(
            result.occurrence_keys,
            [long.0.clone(), inside.0.clone(), holiday.0.clone()]
        );
        assert_eq!(result.gaps, week_coverage());
        assert_eq!(result.freshness, CalendarFreshness::Unknown);
        assert_eq!(result.watermark, None);
        assert!(!result.optimistic);

        let mut only_e1 = week();
        only_e1.event_key = Some(key("GraphqlCalendarEvent:e1"));
        assert_eq!(
            engine
                .calendar_range(&only_e1)
                .await
                .unwrap()
                .occurrence_keys,
            [inside.0]
        );
    });
}

#[test]
fn coverage_and_watermarks_persist_across_commits() {
    block_on(async {
        let mut engine = seeded(Vec::new()).await;
        let first = engine
            .calendar_commit(&CalendarCommit {
                coverage: week_coverage(),
                watermark: Some(CalendarWatermarkUpdate::Merge {
                    links: vec![link("l1", 10), link("l2", 4)],
                }),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        assert!(first.revision_advanced);
        let result = engine.calendar_range(&week()).await.unwrap();
        assert!(result.gaps.is_empty());
        assert_eq!(result.watermark, Some(vec![link("l1", 10), link("l2", 4)]));

        let mut two_weeks = week();
        two_weeks.end_ms += 7 * DAY_MS;
        two_weeks.end_day += 7;
        assert_eq!(
            engine.calendar_range(&two_weeks).await.unwrap().gaps,
            [
                CalendarSpan {
                    kind: CalendarSpanKind::Timed,
                    start: MONDAY_MS + 7 * DAY_MS,
                    end: MONDAY_MS + 14 * DAY_MS,
                },
                CalendarSpan {
                    kind: CalendarSpanKind::AllDay,
                    start: MONDAY_DAY + 7,
                    end: MONDAY_DAY + 14,
                },
            ]
        );

        // A page captured before an older replica read lowers the watermark.
        engine
            .calendar_commit(&CalendarCommit {
                watermark: Some(CalendarWatermarkUpdate::Merge {
                    links: vec![link("l1", 7)],
                }),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        engine
            .calendar_commit(&CalendarCommit {
                watermark: Some(CalendarWatermarkUpdate::Advance {
                    since: vec![link("l1", 7), link("l2", 4)],
                    to: vec![link("l1", 12), link("l2", 6)],
                }),
                freshness: Some(CalendarFreshness::Fresh),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        let result = engine.calendar_range(&week()).await.unwrap();
        assert_eq!(result.watermark, Some(vec![link("l1", 12), link("l2", 6)]));
        assert_eq!(result.freshness, CalendarFreshness::Fresh);
    });
}

#[test]
fn commits_replace_occurrence_sets_and_delete_by_event_and_link() {
    block_on(async {
        let kept = timed("e1", "l1", MONDAY_MS + HOUR_MS, MONDAY_MS + 2 * HOUR_MS);
        let moved_away = timed("e1", "l1", MONDAY_MS + DAY_MS, MONDAY_MS + DAY_MS + HOUR_MS);
        let deleted_event = timed("e2", "l1", MONDAY_MS + 3 * HOUR_MS, MONDAY_MS + 4 * HOUR_MS);
        let other_link = timed("e3", "l2", MONDAY_MS + 5 * HOUR_MS, MONDAY_MS + 6 * HOUR_MS);
        let event_e2 = linked("GraphqlCalendarEvent", "e2", "l1");
        let event_e3 = linked("GraphqlCalendarEvent", "e3", "l2");
        let calendar_l1 = linked("GraphqlCalendar", "c1", "l1");
        let calendar_l2 = linked("GraphqlCalendar", "c2", "l2");
        let mut engine = seeded(vec![
            kept.clone(),
            moved_away.clone(),
            deleted_event.clone(),
            other_link.clone(),
            event_e2.clone(),
            event_e3.clone(),
            calendar_l1.clone(),
            calendar_l2.clone(),
        ])
        .await;

        let result = engine
            .calendar_commit(&CalendarCommit {
                replaced_events: vec![CalendarReplacedEvent {
                    event_key: key("GraphqlCalendarEvent:e1"),
                    occurrence_keys: vec![kept.0.clone()],
                }],
                deleted_event_keys: vec![event_e2.0.clone()],
                deleted_calendar_keys: vec![calendar_l1.0.clone()],
                removed_link_ids: vec!["l2".into()],
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        assert_eq!(
            result.changed.into_iter().collect::<Vec<_>>(),
            [
                calendar_l1.0.clone(),
                calendar_l2.0.clone(),
                event_e2.0.clone(),
                event_e3.0.clone(),
                deleted_event.0.clone(),
                moved_away.0.clone(),
                other_link.0.clone(),
            ]
            .into_iter()
            .collect::<std::collections::BTreeSet<_>>()
            .into_iter()
            .collect::<Vec<_>>()
        );
        assert_eq!(
            engine
                .calendar_range(&week())
                .await
                .unwrap()
                .occurrence_keys,
            std::slice::from_ref(&kept.0)
        );
        let stored = engine
            .storage()
            .get_batch(&[
                moved_away.0,
                event_e2.0,
                event_e3.0,
                calendar_l1.0,
                calendar_l2.0,
                kept.0,
            ])
            .await
            .unwrap();
        assert_eq!(
            stored.iter().map(Option::is_some).collect::<Vec<_>>(),
            [false, false, false, false, false, true]
        );
    });
}

#[test]
fn reset_drops_calendar_records_coverage_and_sync_state() {
    block_on(async {
        let occurrence = timed("e1", "l1", MONDAY_MS, MONDAY_MS + HOUR_MS);
        let event = linked("GraphqlCalendarEvent", "e1", "l1");
        let calendar = linked("GraphqlCalendar", "c1", "l1");
        let mut engine = seeded(vec![occurrence.clone(), event.clone(), calendar.clone()]).await;
        engine
            .calendar_commit(&CalendarCommit {
                coverage: week_coverage(),
                watermark: Some(CalendarWatermarkUpdate::Merge {
                    links: vec![link("l1", 3), link("l2", 8)],
                }),
                freshness: Some(CalendarFreshness::Fresh),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();

        engine
            .calendar_commit(&CalendarCommit {
                reset: true,
                watermark: Some(CalendarWatermarkUpdate::Advance {
                    since: vec![link("l1", 3), link("l2", 8)],
                    to: vec![link("l1", 40)],
                }),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        let result = engine.calendar_range(&week()).await.unwrap();
        assert!(result.occurrence_keys.is_empty());
        assert_eq!(result.gaps, week_coverage());
        assert_eq!(result.watermark, Some(vec![link("l1", 40)]));
        assert_eq!(result.freshness, CalendarFreshness::Unknown);
        let stored = engine
            .storage()
            .get_batch(&[occurrence.0, event.0, calendar.0])
            .await
            .unwrap();
        assert_eq!(
            stored.iter().map(Option::is_some).collect::<Vec<_>>(),
            [false, false, true]
        );
    });
}

#[test]
fn records_rewritten_out_of_range_or_cancelled_leave_the_index() {
    block_on(async {
        let (occurrence_key, mut record) =
            timed("e1", "l1", MONDAY_MS + HOUR_MS, MONDAY_MS + 2 * HOUR_MS);
        let mut engine = seeded(vec![(occurrence_key.clone(), record.clone())]).await;
        record
            .fields
            .insert("isCancelled".into(), CacheValue::Bool(true));
        engine
            .put_records_with_projections(None, vec![(occurrence_key.clone(), record)], Vec::new())
            .await
            .unwrap();
        assert!(
            engine
                .calendar_range(&week())
                .await
                .unwrap()
                .occurrence_keys
                .is_empty()
        );
        engine
            .delete_keys(std::slice::from_ref(&occurrence_key))
            .await
            .unwrap();
        assert!(
            engine
                .calendar_range(&week())
                .await
                .unwrap()
                .occurrence_keys
                .is_empty()
        );
    });
}

async fn enqueue_delete(
    engine: &mut Engine<InMemoryStorage>,
    occurrence_key: &EntityKey<'static>,
    uncertain: Vec<EntityKey<'static>>,
) -> (u64, MutationClaimToken) {
    let result = engine
        .enqueue_optimistic_mutation_with_calendar(
            None,
            BeginOptimisticWrite {
                client_metadata: None,
                uuid: UUID,
                query: MUTATION,
                operation_name: None,
                variables: &Default::default(),
                data: &json!({"setEntityProperty": {"__typename": "GraphqlProperty", "id": "p1", "displayName": "x"}}),
                link_patches: &[],
                revalidations: &[],
                created_at_ms: 0,
                identity_bindings: &[IdentityBinding {
                    local_key: occurrence_key.clone(),
                    delete_record: true,
                    response_path: vec![],
                    reference_fields: vec![],
                    revalidation_variables: vec![],
                }],
            },
            MutationClaimRequest {
                owner: "runner".into(),
                now_ms: 0,
                lease_expires_at_ms: 100,
            },
            Vec::new(),
            uncertain,
        )
        .await
        .unwrap();
    let InitialClaimOutcome::Claimed(claimed) = result.initial_claim else {
        panic!("the only queued mutation is claimable");
    };
    (
        result.transaction_id,
        MutationClaimToken {
            owner: "runner".into(),
            generation: claimed.lease_generation,
        },
    )
}

#[test]
fn optimistic_deletes_and_uncertain_events_shape_reads_until_rollback() {
    block_on(async {
        let deleted = timed("e1", "l1", MONDAY_MS + HOUR_MS, MONDAY_MS + 2 * HOUR_MS);
        let kept = timed("e2", "l1", MONDAY_MS + 3 * HOUR_MS, MONDAY_MS + 4 * HOUR_MS);
        let mut engine = seeded(vec![deleted.clone(), kept.clone()]).await;
        let (transaction, claim) = enqueue_delete(
            &mut engine,
            &deleted.0,
            vec![key("GraphqlCalendarEvent:e2")],
        )
        .await;

        let result = engine.calendar_range(&week()).await.unwrap();
        assert_eq!(result.occurrence_keys, std::slice::from_ref(&kept.0));
        assert!(result.optimistic);
        assert_eq!(
            result.uncertain_event_keys,
            [key("GraphqlCalendarEvent:e2")]
        );
        let mut only_e1 = week();
        only_e1.event_key = Some(key("GraphqlCalendarEvent:e1"));
        assert!(
            engine
                .calendar_range(&only_e1)
                .await
                .unwrap()
                .uncertain_event_keys
                .is_empty()
        );

        // The layer survives an engine restart over the same storage.
        let mut engine = Engine::new(engine.into_storage());
        assert_eq!(
            engine
                .calendar_range(&week())
                .await
                .unwrap()
                .occurrence_keys,
            std::slice::from_ref(&kept.0)
        );

        engine
            .rollback_optimistic_write(transaction, claim)
            .await
            .unwrap();
        let result = engine.calendar_range(&week()).await.unwrap();
        assert_eq!(result.occurrence_keys, [deleted.0, kept.0]);
        assert!(!result.optimistic);
        assert!(result.uncertain_event_keys.is_empty());
    });
}

#[test]
fn committed_optimistic_deletes_retire_the_authoritative_row() {
    block_on(async {
        let deleted = timed("e1", "l1", MONDAY_MS + HOUR_MS, MONDAY_MS + 2 * HOUR_MS);
        let mut engine = seeded(vec![deleted.clone()]).await;
        let (transaction, claim) = enqueue_delete(&mut engine, &deleted.0, Vec::new()).await;
        engine
            .commit_optimistic_write(
                transaction,
                claim,
                MUTATION,
                None,
                &Default::default(),
                &json!({"setEntityProperty": {"__typename": "GraphqlProperty", "id": "p1", "displayName": "x"}}),
            )
            .await
            .unwrap();
        let result = engine.calendar_range(&week()).await.unwrap();
        assert!(result.occurrence_keys.is_empty());
        assert!(!result.optimistic);
    });
}

#[test]
fn uncertain_keys_must_name_calendar_events() {
    block_on(async {
        let occurrence = timed("e1", "l1", MONDAY_MS, MONDAY_MS + HOUR_MS);
        let mut engine = seeded(vec![occurrence.clone()]).await;
        let error = engine
            .enqueue_optimistic_mutation_with_calendar(
                None,
                BeginOptimisticWrite {
                    client_metadata: None,
                    uuid: UUID,
                    query: MUTATION,
                    operation_name: None,
                    variables: &Default::default(),
                    data: &json!({"setEntityProperty": {"__typename": "GraphqlProperty", "id": "p1", "displayName": "x"}}),
                    link_patches: &[],
                    revalidations: &[],
                    created_at_ms: 0,
                    identity_bindings: &[],
                },
                MutationClaimRequest {
                    owner: "runner".into(),
                    now_ms: 0,
                    lease_expires_at_ms: 100,
                },
                Vec::new(),
                vec![occurrence.0],
            )
            .await;
        assert!(error.is_err());
        assert!(
            engine
                .storage()
                .load_mutation_queue()
                .await
                .unwrap()
                .is_empty()
        );
    });
}

#[test]
fn identity_changes_and_clears_wipe_calendar_state() {
    const VIEWER: &str = "query Viewer { user { id } }";
    block_on(async {
        let occurrence = timed("e1", "l1", MONDAY_MS, MONDAY_MS + HOUR_MS);
        let mut engine = seeded(vec![occurrence]).await;
        engine
            .write_query(
                None,
                VIEWER,
                None,
                &Default::default(),
                &json!({"user": {"id": "u1"}}),
                Some("u1"),
            )
            .await
            .unwrap();
        engine
            .calendar_commit(&CalendarCommit {
                coverage: week_coverage(),
                watermark: Some(CalendarWatermarkUpdate::Merge {
                    links: vec![link("l1", 1)],
                }),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        let write = engine
            .write_query(
                None,
                VIEWER,
                None,
                &Default::default(),
                &json!({"user": {"id": "u2"}}),
                Some("u2"),
            )
            .await
            .unwrap();
        assert!(write.reset);
        let result = engine.calendar_range(&week()).await.unwrap();
        assert!(result.occurrence_keys.is_empty());
        assert_eq!(result.gaps, week_coverage());
        assert_eq!(result.watermark, None);

        engine
            .calendar_commit(&CalendarCommit {
                coverage: week_coverage(),
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        engine.clear().await.unwrap();
        assert_eq!(
            engine.calendar_range(&week()).await.unwrap().gaps,
            week_coverage()
        );
    });
}

#[test]
fn invalid_requests_and_commits_are_rejected_before_storage() {
    block_on(async {
        let mut engine = seeded(Vec::new()).await;
        let mut inverted = week();
        inverted.end_ms = inverted.start_ms - 1;
        assert!(engine.calendar_range(&inverted).await.is_err());
        let revision = engine.current_revision();
        assert!(
            engine
                .calendar_commit(&CalendarCommit {
                    deleted_event_keys: vec![key("GraphqlCalendarOccurrence:e1:k")],
                    ..CalendarCommit::default()
                })
                .await
                .is_err()
        );
        assert_eq!(engine.current_revision(), revision);
    });
}

const OCCURRENCES: &str = r#"
query CalendarOccurrences($input: CalendarRangeInput!) {
  user {
    id
    calendarOccurrences(input: $input) {
      nodes {
        __typename
        id
        eventId
        linkId
        occurrenceKey
        isCancelled
        time {
          __typename
          ... on GraphqlTimedEventTime { startsAt endsAt timeZone }
          ... on GraphqlAllDayEventTime { startDate endDate }
        }
        event { __typename id linkId title }
      }
      hasNextPage
      endCursor
      syncStatus
      watermark { linkId seq }
    }
  }
}
"#;

fn occurrence_node(
    event: &str,
    key: &str,
    time: serde_json::Value,
    cancelled: bool,
) -> serde_json::Value {
    json!({
        "__typename": "GraphqlCalendarOccurrence",
        "id": format!("{event}:{key}"),
        "eventId": event,
        "linkId": "l1",
        "occurrenceKey": key,
        "isCancelled": cancelled,
        "time": time,
        "event": { "__typename": "GraphqlCalendarEvent", "id": event, "linkId": "l1", "title": event },
    })
}

fn occurrence_page(nodes: Vec<serde_json::Value>) -> serde_json::Value {
    json!({
        "user": {
            "id": "u1",
            "calendarOccurrences": {
                "nodes": nodes,
                "hasNextPage": false,
                "endCursor": null,
                "syncStatus": "READY",
                "watermark": [{ "linkId": "l1", "seq": "4" }],
            }
        }
    })
}

#[test]
fn network_pages_are_indexed_through_normalization() {
    block_on(async {
        let mut engine = Engine::new(InMemoryStorage::new());
        let Json::Object(variables) = json!({
            "input": { "start": iso(MONDAY_MS), "end": iso(MONDAY_MS + 7 * DAY_MS) }
        }) else {
            unreachable!()
        };
        let standup = iso(MONDAY_MS + 9 * HOUR_MS);
        let page = occurrence_page(vec![
            occurrence_node(
                "e1",
                &standup,
                json!({
                    "__typename": "GraphqlTimedEventTime",
                    "startsAt": standup,
                    "endsAt": iso(MONDAY_MS + 10 * HOUR_MS),
                    "timeZone": "America/New_York",
                }),
                false,
            ),
            occurrence_node(
                "e2",
                &date(MONDAY_DAY + 2),
                json!({
                    "__typename": "GraphqlAllDayEventTime",
                    "startDate": date(MONDAY_DAY + 2),
                    "endDate": date(MONDAY_DAY + 3),
                }),
                false,
            ),
            occurrence_node(
                "e3",
                &date(MONDAY_DAY + 4),
                json!({
                    "__typename": "GraphqlAllDayEventTime",
                    "startDate": date(MONDAY_DAY + 4),
                    "endDate": date(MONDAY_DAY + 5),
                }),
                true,
            ),
        ]);
        engine
            .write_query(None, OCCURRENCES, None, &variables, &page, Some("u1"))
            .await
            .unwrap();
        let result = engine.calendar_range(&week()).await.unwrap();
        assert_eq!(
            result.occurrence_keys,
            [
                key(&format!("GraphqlCalendarOccurrence:e1:{standup}")),
                key(&format!(
                    "GraphqlCalendarOccurrence:e2:{}",
                    date(MONDAY_DAY + 2)
                )),
            ]
        );

        // The delta rewrites e1 later in the week and commits its full set.
        let moved = iso(MONDAY_MS + 2 * DAY_MS + 9 * HOUR_MS);
        let moved_page = occurrence_page(vec![occurrence_node(
            "e1",
            &moved,
            json!({
                "__typename": "GraphqlTimedEventTime",
                "startsAt": moved,
                "endsAt": iso(MONDAY_MS + 2 * DAY_MS + 10 * HOUR_MS),
                "timeZone": null,
            }),
            false,
        )]);
        engine
            .write_query(None, OCCURRENCES, None, &variables, &moved_page, Some("u1"))
            .await
            .unwrap();
        let commit = engine
            .calendar_commit(&CalendarCommit {
                replaced_events: vec![CalendarReplacedEvent {
                    event_key: key("GraphqlCalendarEvent:e1"),
                    occurrence_keys: vec![key(&format!("GraphqlCalendarOccurrence:e1:{moved}"))],
                }],
                ..CalendarCommit::default()
            })
            .await
            .unwrap();
        assert_eq!(
            commit.changed.into_iter().collect::<Vec<_>>(),
            [key(&format!("GraphqlCalendarOccurrence:e1:{standup}"))]
        );
        let mut only_e1 = week();
        only_e1.event_key = Some(key("GraphqlCalendarEvent:e1"));
        assert_eq!(
            engine
                .calendar_range(&only_e1)
                .await
                .unwrap()
                .occurrence_keys,
            [key(&format!("GraphqlCalendarOccurrence:e1:{moved}"))]
        );
    });
}