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.

16.0 KB
Raw Blame
use super::*;
use std::collections::{BTreeMap, HashMap};

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

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

fn time(fields: &[(&str, &str)]) -> CacheValue {
    CacheValue::Object(
        fields
            .iter()
            .map(|(field, value)| ((*field).to_owned(), text(value)))
            .collect::<BTreeMap<_, _>>(),
    )
}

fn occurrence(time_value: CacheValue) -> Record {
    let mut record = Record::default();
    record
        .fields
        .insert("__typename".into(), text(OCCURRENCE_TYPENAME));
    record.fields.insert("eventId".into(), text("e1"));
    record.fields.insert("linkId".into(), text("l1"));
    record
        .fields
        .insert("isCancelled".into(), CacheValue::Bool(false));
    record.fields.insert("time".into(), time_value);
    record
}

fn timed(starts_at: &str, ends_at: &str) -> CacheValue {
    time(&[
        ("__typename", "GraphqlTimedEventTime"),
        ("startsAt", starts_at),
        ("endsAt", ends_at),
    ])
}

fn all_day(start_date: &str, end_date: &str) -> CacheValue {
    time(&[
        ("__typename", "GraphqlAllDayEventTime"),
        ("startDate", start_date),
        ("endDate", end_date),
    ])
}

fn span(kind: CalendarSpanKind, start: i64, end: i64) -> CalendarSpan {
    CalendarSpan { kind, start, end }
}

fn timed_span(start: i64, end: i64) -> CalendarSpan {
    span(CalendarSpanKind::Timed, start, end)
}

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

fn row(record_key: &str, event: &str, span: CalendarSpan) -> CalendarRangeRow {
    CalendarRangeRow {
        record_key: key(record_key),
        event_key: EntityKey::entity(EVENT_TYPENAME, &[event]),
        link_id: "l1".into(),
        span,
    }
}

fn request(start_ms: i64, end_ms: i64) -> CalendarRangeRequest {
    CalendarRangeRequest {
        start_ms,
        end_ms,
        start_day: 0,
        end_day: 0,
        event_key: None,
    }
}

#[test]
fn projects_timed_and_all_day_occurrences() {
    let occurrence_key = key("GraphqlCalendarOccurrence:e1:2026-10-06T12:00:00+00:00");
    let projected = project_calendar_range(
        &occurrence_key,
        &occurrence(timed(
            "2026-10-06T12:00:00+00:00",
            "2026-10-06T13:30:00+00:00",
        )),
    )
    .unwrap();
    assert_eq!(projected.record_key, occurrence_key);
    assert_eq!(projected.event_key.as_ref(), "GraphqlCalendarEvent:e1");
    assert_eq!(projected.link_id, "l1");
    assert_eq!(
        projected.span,
        timed_span(1_791_288_000_000, 1_791_293_400_000)
    );
    assert!(!projected.is_long());

    let projected = project_calendar_range(
        &key("GraphqlCalendarOccurrence:e1:2026-10-06"),
        &occurrence(all_day("2026-10-06", "2026-10-07")),
    )
    .unwrap();
    assert_eq!(
        projected.span,
        span(CalendarSpanKind::AllDay, 20_732, 20_733)
    );

    // Offsets are normalized to UTC instants.
    let projected = project_calendar_range(
        &occurrence_key,
        &occurrence(timed(
            "2026-10-06T08:00:00-04:00",
            "2026-10-06T09:00:00-04:00",
        )),
    )
    .unwrap();
    assert_eq!(projected.span.start, 1_791_288_000_000);
}

#[test]
fn infers_the_time_kind_without_a_typename_and_flags_long_spans() {
    let projected = project_calendar_range(
        &key("GraphqlCalendarOccurrence:e1:k"),
        &occurrence(time(&[
            ("startDate", "2026-10-01"),
            ("endDate", "2026-10-09"),
        ])),
    )
    .unwrap();
    assert_eq!(projected.span.kind, CalendarSpanKind::AllDay);
    assert!(projected.is_long());

    let projected = project_calendar_range(
        &key("GraphqlCalendarOccurrence:e1:k"),
        &occurrence(timed("2026-10-01T00:00:00Z", "2026-10-08T00:00:00Z")),
    )
    .unwrap();
    assert!(!projected.is_long(), "exactly seven days stays short");
}

#[test]
fn hidden_or_incomplete_occurrences_do_not_project() {
    let occurrence_key = key("GraphqlCalendarOccurrence:e1:k");
    let valid = occurrence(timed("2026-10-06T12:00:00Z", "2026-10-06T13:00:00Z"));
    assert!(project_calendar_range(&occurrence_key, &valid).is_some());
    assert!(project_calendar_range(&key("GraphqlCalendarEvent:e1"), &valid).is_none());

    let hidden = [
        (DELETED_FIELD, CacheValue::Bool(true)),
        (ALIAS_FIELD, text("GraphqlCalendarOccurrence:server")),
        ("isCancelled", CacheValue::Bool(true)),
        ("eventId", CacheValue::Null),
        ("linkId", text("")),
        ("time", CacheValue::Null),
        (
            "time",
            timed("2026-10-06T13:00:00Z", "2026-10-06T12:00:00Z"),
        ),
        ("time", all_day("2026-10-06", "2026-10-06")),
        ("time", all_day("2026-10-07", "2026-10-06")),
        (
            "time",
            timed("2026-10-06T13:00:00.0009Z", "2026-10-06T13:00:00.0001Z"),
        ),
        ("time", timed("not a date", "2026-10-06T13:00:00Z")),
        (
            "time",
            time(&[("__typename", "Unknown"), ("startDate", "2026-10-06")]),
        ),
    ];
    for (field, value) in hidden {
        let mut record = valid.clone();
        record.fields.insert(field.into(), value);
        assert!(
            project_calendar_range(&occurrence_key, &record).is_none(),
            "{field} should hide the occurrence"
        );
    }
}

#[test]
fn timed_points_project_and_use_left_inclusive_right_exclusive_membership() {
    let occurrence_key = key("GraphqlCalendarOccurrence:e1:point");
    let projected = project_calendar_range(
        &occurrence_key,
        &occurrence(timed("2026-10-06T08:00:00-04:00", "2026-10-06T12:00:00Z")),
    )
    .unwrap();
    assert_eq!(
        projected.span,
        timed_span(1_791_288_000_000, 1_791_288_000_000)
    );
    assert!(!projected.is_long());

    let viewport = timed_span(10, 20);
    for (at, expected) in [(9, false), (10, true), (15, true), (20, false)] {
        let point = timed_span(at, at);
        assert_eq!(point.overlaps(&viewport), expected);
        assert_eq!(viewport.overlaps(&point), expected);
        assert_eq!(
            request(10, 20).includes(&row("point", "e1", point)),
            expected
        );
    }
    assert!(!request(15, 15).includes(&row("point", "e1", timed_span(15, 15))));
    assert!(!request(15, 15).includes(&row("duration", "e1", timed_span(10, 20))));
    assert!(!span(CalendarSpanKind::AllDay, 15, 15).overlaps(&span(
        CalendarSpanKind::AllDay,
        10,
        20
    )));
}

#[test]
fn merges_spans_per_kind_including_adjacent_spans() {
    let merged = merge_spans([
        timed_span(10, 20),
        timed_span(0, 5),
        timed_span(20, 30),
        timed_span(4, 8),
        timed_span(40, 40),
        span(CalendarSpanKind::AllDay, 0, 10),
        span(CalendarSpanKind::AllDay, 5, 6),
    ]);
    assert_eq!(
        merged,
        [
            timed_span(0, 8),
            timed_span(10, 30),
            span(CalendarSpanKind::AllDay, 0, 10),
        ]
    );
}

#[test]
fn gaps_are_the_uncovered_parts_of_the_request() {
    let coverage = [
        timed_span(10, 20),
        timed_span(30, 40),
        span(CalendarSpanKind::AllDay, 0, 100),
    ];
    assert_eq!(
        coverage_gaps(&coverage, timed_span(0, 50)),
        [timed_span(0, 10), timed_span(20, 30), timed_span(40, 50)]
    );
    assert_eq!(coverage_gaps(&coverage, timed_span(12, 18)), []);
    assert_eq!(
        coverage_gaps(&coverage, timed_span(15, 35)),
        [timed_span(20, 30)]
    );
    assert_eq!(
        coverage_gaps(&coverage, timed_span(40, 45)),
        [timed_span(40, 45)]
    );
    assert_eq!(coverage_gaps(&coverage, timed_span(5, 5)), []);
    assert_eq!(
        coverage_gaps(&[], span(CalendarSpanKind::AllDay, 1, 2)),
        [span(CalendarSpanKind::AllDay, 1, 2)]
    );
}

#[test]
fn page_watermarks_lower_each_link_and_adopt_new_links() {
    let stored = [link("a", 10), link("b", 5)];
    let merged = apply_watermark_update(
        Some(&stored),
        Some(&CalendarWatermarkUpdate::Merge {
            links: vec![link("a", 7), link("b", 9), link("c", 3)],
        }),
        &[],
    );
    assert_eq!(merged, [link("a", 7), link("b", 5), link("c", 3)]);
    let again = apply_watermark_update(
        Some(&merged),
        Some(&CalendarWatermarkUpdate::Merge {
            links: vec![link("a", 7), link("b", 9), link("c", 3)],
        }),
        &[],
    );
    assert_eq!(again, merged, "re-delivery is idempotent");
}

#[test]
fn deltas_advance_untouched_links_and_keep_concurrent_lowerings() {
    let since = vec![link("a", 10), link("b", 5)];
    let to = vec![link("a", 20), link("b", 8), link("c", 4)];
    let advance = CalendarWatermarkUpdate::Advance {
        since: since.clone(),
        to,
    };
    assert_eq!(
        apply_watermark_update(Some(&since), Some(&advance), &[]),
        [link("a", 20), link("b", 8), link("c", 4)]
    );

    // A page lowered `a` while the delta was in flight: its change is replayed.
    let lowered = [link("a", 3), link("b", 5)];
    assert_eq!(
        apply_watermark_update(Some(&lowered), Some(&advance), &[]),
        [link("a", 3), link("b", 8), link("c", 4)]
    );

    // A delta from an empty watermark bootstraps every link.
    let bootstrap = CalendarWatermarkUpdate::Advance {
        since: Vec::new(),
        to: vec![link("a", 2)],
    };
    assert_eq!(
        apply_watermark_update(None, Some(&bootstrap), &[]),
        [link("a", 2)]
    );
}

#[test]
fn removed_links_leave_the_watermark() {
    assert_eq!(
        apply_watermark_update(Some(&[link("a", 1), link("b", 2)]), None, &["a".to_owned()]),
        [link("b", 2)]
    );
}

#[test]
fn watermark_seq_crosses_the_wire_as_a_decimal_string() {
    let encoded = serialize_watermark(&[link("a", 9_007_199_254_740_993)]);
    assert_eq!(encoded, r#"[{"linkId":"a","seq":"9007199254740993"}]"#);
    assert_eq!(
        parse_watermark(&encoded).unwrap(),
        [link("a", 9_007_199_254_740_993)]
    );
    assert!(parse_watermark(r#"[{"linkId":"a","seq":"-1"}]"#).is_none());
    assert!(parse_watermark(r#"[{"linkId":"a","seq":1}]"#).is_none());
}

#[test]
fn sync_state_resets_before_applying_the_commit() {
    let stored = CalendarSyncState {
        watermark: Some(vec![link("a", 10), link("b", 4)]),
        freshness: CalendarFreshness::Fresh,
    };
    let reset = CalendarCommit {
        reset: true,
        watermark: Some(CalendarWatermarkUpdate::Advance {
            since: vec![link("a", 10)],
            to: vec![link("a", 30)],
        }),
        ..CalendarCommit::default()
    };
    assert_eq!(
        next_sync_state(&stored, &reset),
        CalendarSyncState {
            watermark: Some(vec![link("a", 30)]),
            freshness: CalendarFreshness::Unknown,
        }
    );

    let stale = CalendarCommit {
        freshness: Some(CalendarFreshness::Stale),
        ..CalendarCommit::default()
    };
    assert_eq!(
        next_sync_state(&CalendarSyncState::default(), &stale),
        CalendarSyncState {
            watermark: None,
            freshness: CalendarFreshness::Stale,
        }
    );
}

#[test]
fn commits_reject_foreign_keys_and_invalid_sync_values() {
    let valid = CalendarCommit {
        coverage: vec![timed_span(0, 1)],
        replaced_events: vec![CalendarReplacedEvent {
            event_key: key("GraphqlCalendarEvent:e1"),
            occurrence_keys: vec![key("GraphqlCalendarOccurrence:e1:k")],
        }],
        deleted_event_keys: vec![key("GraphqlCalendarEvent:e2")],
        deleted_calendar_keys: vec![key("GraphqlCalendar:c1")],
        removed_link_ids: vec!["l2".into()],
        watermark: Some(CalendarWatermarkUpdate::Merge {
            links: vec![link("l1", 1)],
        }),
        freshness: Some(CalendarFreshness::Fresh),
        reset: false,
    };
    assert_eq!(valid.validate(), Ok(()));

    let invalid = [
        (
            CalendarCommit {
                coverage: vec![timed_span(2, 1)],
                ..valid.clone()
            },
            CalendarError::InvalidSpan,
        ),
        (
            CalendarCommit {
                deleted_event_keys: vec![key("GraphqlCalendar:e2")],
                ..valid.clone()
            },
            CalendarError::InvalidKey,
        ),
        (
            CalendarCommit {
                replaced_events: vec![CalendarReplacedEvent {
                    event_key: key("GraphqlCalendarEvent:e1"),
                    occurrence_keys: vec![key("GraphqlCalendarEvent:e1")],
                }],
                ..valid.clone()
            },
            CalendarError::InvalidKey,
        ),
        (
            CalendarCommit {
                freshness: Some(CalendarFreshness::Unknown),
                ..valid.clone()
            },
            CalendarError::InvalidFreshness,
        ),
        (
            CalendarCommit {
                watermark: Some(CalendarWatermarkUpdate::Merge {
                    links: vec![link("l1", 1), link("l1", 2)],
                }),
                ..valid.clone()
            },
            CalendarError::InvalidWatermark,
        ),
        (
            CalendarCommit {
                coverage: vec![timed_span(0, 1); MAX_CALENDAR_COMMIT_ITEMS + 1],
                ..valid.clone()
            },
            CalendarError::TooLarge,
        ),
    ];
    for (commit, error) in invalid {
        assert_eq!(commit.validate(), Err(error));
    }
}

#[test]
fn requests_validate_spans_and_event_filters() {
    assert_eq!(request(0, 0).validate(), Ok(()));
    assert_eq!(request(2, 1).validate(), Err(CalendarError::InvalidSpan));
    let mut filtered = request(0, 10);
    filtered.event_key = Some(key("GraphqlCalendarOccurrence:e1:k"));
    assert_eq!(filtered.validate(), Err(CalendarError::InvalidKey));
    filtered.event_key = Some(key("GraphqlCalendarEvent:e1"));
    assert_eq!(filtered.validate(), Ok(()));
}

#[test]
fn overlay_replaces_moves_hides_and_adds_rows() {
    let request = request(0, 100);
    let authoritative = vec![
        row("GraphqlCalendarOccurrence:e1:a", "e1", timed_span(10, 20)),
        row("GraphqlCalendarOccurrence:e1:b", "e1", timed_span(30, 40)),
        row("GraphqlCalendarOccurrence:e2:c", "e2", timed_span(50, 60)),
    ];
    let (keys, optimistic) =
        compose_calendar_rows(&request, authoritative.clone(), &HashMap::new());
    assert!(!optimistic);
    assert_eq!(
        keys,
        authoritative
            .iter()
            .map(|row| row.record_key.clone())
            .collect::<Vec<_>>()
    );

    let overlay = HashMap::from([
        // Moved earlier inside the range.
        (
            key("GraphqlCalendarOccurrence:e1:b"),
            Some(row(
                "GraphqlCalendarOccurrence:e1:b",
                "e1",
                timed_span(0, 5),
            )),
        ),
        // Deleted.
        (key("GraphqlCalendarOccurrence:e2:c"), None),
        // Moved out of the range.
        (
            key("GraphqlCalendarOccurrence:e1:a"),
            Some(row(
                "GraphqlCalendarOccurrence:e1:a",
                "e1",
                timed_span(500, 600),
            )),
        ),
        // Created.
        (
            key("GraphqlCalendarOccurrence:local:d"),
            Some(row(
                "GraphqlCalendarOccurrence:local:d",
                "local",
                timed_span(70, 80),
            )),
        ),
    ]);
    let (keys, optimistic) = compose_calendar_rows(&request, authoritative, &overlay);
    assert!(optimistic);
    assert_eq!(
        keys,
        [
            key("GraphqlCalendarOccurrence:e1:b"),
            key("GraphqlCalendarOccurrence:local:d"),
        ]
    );
}

#[test]
fn event_filters_apply_to_overlay_rows() {
    let mut request = request(0, 100);
    request.event_key = Some(key("GraphqlCalendarEvent:e1"));
    let overlay = HashMap::from([(
        key("GraphqlCalendarOccurrence:e2:a"),
        Some(row(
            "GraphqlCalendarOccurrence:e2:a",
            "e2",
            timed_span(10, 20),
        )),
    )]);
    let (keys, optimistic) = compose_calendar_rows(&request, Vec::new(), &overlay);
    assert!(keys.is_empty());
    assert!(!optimistic);
}