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.

18.3 KB
Raw Blame
use std::sync::{Arc, Mutex};

use async_graphql::{EmptyMutation, EmptySubscription, Schema};
use calendar_events::domain::{
    changes::{
        CalendarChangeQueryService, CalendarChangesPage, CalendarEventChange,
        CalendarLinkWatermark, CalendarWatermark, EventOccurrence,
    },
    models::{
        CalendarCapabilities, CalendarMentionPreview, CalendarMentionRequestItem,
        CalendarOccurrenceCursor, CalendarProvider, CalendarSyncStatus, OccurrenceListing,
        OccurrenceRange, TeamOutOfOffice, VisibleCalendar,
    },
    ports::CalendarOccurrenceService,
    service::CalendarValidationError,
};
use macro_user_id::user_id::MacroUserIdStr;
use rootcause::Report;
use serde_json::Value;

use super::GraphqlCalendarQuery;
use crate::{
    CalendarGraphqlContext,
    test_fixtures::{EVENT_ID, LINK_ID, timed_listing},
};

#[derive(Clone, Copy, Default)]
enum Failure {
    #[default]
    None,
    Validation,
    Internal,
}

#[derive(Default)]
struct FakeReads {
    listings: Vec<OccurrenceListing>,
    calendars: Vec<VisibleCalendar>,
    watermark: CalendarWatermark,
    changes: CalendarChangesPage,
    failure: Failure,
    requests: Mutex<Vec<(String, Option<CalendarOccurrenceCursor>, u16)>>,
    calls: Mutex<Vec<&'static str>>,
    since: Mutex<Vec<CalendarWatermark>>,
}

impl FakeReads {
    fn fail(&self) -> Result<(), Report> {
        match self.failure {
            Failure::None => Ok(()),
            Failure::Validation => {
                Err(rootcause::report!(CalendarValidationError::InvalidRange).into())
            }
            Failure::Internal => Err(rootcause::report!("database host db-7 refused").into()),
        }
    }
}

impl CalendarOccurrenceService for FakeReads {
    async fn list_occurrences(
        &self,
        requester_id: &str,
        _range: OccurrenceRange,
        cursor: Option<CalendarOccurrenceCursor>,
        limit: u16,
    ) -> Result<Vec<OccurrenceListing>, Report> {
        self.requests
            .lock()
            .unwrap()
            .push((requester_id.to_owned(), cursor, limit));
        self.calls.lock().unwrap().push("occurrences");
        self.fail()?;
        Ok(self
            .listings
            .iter()
            .take(usize::from(limit))
            .cloned()
            .collect())
    }

    async fn sync_status(&self, _requester_id: &str) -> Result<CalendarSyncStatus, Report> {
        Ok(CalendarSyncStatus::Syncing)
    }

    async fn list_visible_calendars(
        &self,
        requester_id: &str,
    ) -> Result<Vec<VisibleCalendar>, Report> {
        self.requests
            .lock()
            .unwrap()
            .push((requester_id.to_owned(), None, 0));
        self.fail()?;
        Ok(self.calendars.clone())
    }

    async fn mention_previews(
        &self,
        _requester_id: &str,
        _items: Vec<CalendarMentionRequestItem>,
    ) -> Result<Vec<CalendarMentionPreview>, Report> {
        unreachable!("calendar GraphQL reads never resolve mention previews")
    }

    async fn list_team_out_of_office(
        &self,
        _requester_id: &str,
        _range: OccurrenceRange,
        _limit: u16,
    ) -> Result<Vec<TeamOutOfOffice>, Report> {
        unreachable!("calendar GraphQL reads never list team out-of-office")
    }

    async fn primary_time_zone(&self, _requester_id: &str) -> Result<Option<String>, Report> {
        unreachable!("calendar GraphQL reads never resolve the primary time zone")
    }

    async fn meeting_copies(
        &self,
        _requester_id: &str,
        _event_id: uuid::Uuid,
    ) -> Result<Vec<calendar_events::domain::models::MeetingCopy>, Report> {
        unreachable!("no GraphQL read lists a meeting's copies")
    }

    async fn event_ics(
        &self,
        _requester_id: &str,
        _event_id: uuid::Uuid,
    ) -> Result<Option<calendar_events::domain::ics::CalendarEventIcs>, Report> {
        unreachable!("calendar GraphQL reads never export an event")
    }
}

impl CalendarChangeQueryService for FakeReads {
    async fn current_watermark(&self, _viewer: &str) -> Result<CalendarWatermark, Report> {
        self.calls.lock().unwrap().push("watermark");
        Ok(self.watermark.clone())
    }

    async fn changes_since(
        &self,
        _viewer: &str,
        since: CalendarWatermark,
    ) -> Result<CalendarChangesPage, Report> {
        self.since.lock().unwrap().push(since);
        self.fail()?;
        Ok(self.changes.clone())
    }
    async fn event_change(
        &self,
        _viewer: &str,
        _event_id: uuid::Uuid,
    ) -> Result<Option<CalendarEventChange>, Report> {
        unreachable!("queries never read one event's committed state")
    }
}

const VIEWER: &str = "macro|[email protected]";

async fn execute(reads: Arc<FakeReads>, query: &str) -> async_graphql::Response {
    let schema = Schema::build(
        GraphqlCalendarQuery::new(MacroUserIdStr::parse_from_str(VIEWER).unwrap()),
        EmptyMutation,
        EmptySubscription,
    )
    .data(CalendarGraphqlContext::new(Arc::clone(&reads), reads))
    .finish();
    schema.execute(query).await
}

const PAGE_QUERY: &str = r#"{
    calendarOccurrences(input: {
        start: "2026-10-05T00:00:00Z", end: "2026-10-12T00:00:00Z", first: 2
    }) {
        nodes {
            __typename id eventId linkId occurrenceKey
            time { __typename ... on GraphqlTimedEventTime { startsAt endsAt } }
            event { __typename id linkId title }
        }
        hasNextPage endCursor syncStatus watermark { linkId seq }
    }
}"#;

#[tokio::test]
async fn a_full_page_reports_a_cursor_and_requests_one_extra_row() {
    let reads = Arc::new(FakeReads {
        listings: vec![timed_listing(6), timed_listing(7), timed_listing(8)],
        ..Default::default()
    });

    let response = execute(Arc::clone(&reads), PAGE_QUERY).await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    let page = &data["calendarOccurrences"];
    let nodes = page["nodes"].as_array().unwrap();
    assert_eq!(nodes.len(), 2);
    assert_eq!(nodes[0]["__typename"], "GraphqlCalendarOccurrence");
    assert_eq!(
        nodes[0]["id"],
        format!("{EVENT_ID}:2026-10-06T15:00:00+00:00")
    );
    assert_eq!(nodes[0]["eventId"], EVENT_ID.to_string());
    assert_eq!(nodes[0]["linkId"], LINK_ID.to_string());
    assert_eq!(nodes[0]["time"]["__typename"], "GraphqlTimedEventTime");
    assert_eq!(nodes[0]["event"]["__typename"], "GraphqlCalendarEvent");
    assert_eq!(nodes[0]["event"]["linkId"], LINK_ID.to_string());
    assert_eq!(page["hasNextPage"], true);
    assert_eq!(page["syncStatus"], "SYNCING");
    assert_eq!(page["watermark"], Value::Array(Vec::new()));
    assert_eq!(
        reads.calls.lock().unwrap()[..2],
        ["watermark", "occurrences"],
        "the watermark is captured before the page is read"
    );

    let cursor = page["endCursor"].as_str().unwrap().to_owned();
    let requests = reads.requests.lock().unwrap().clone();
    assert_eq!(requests, vec![(VIEWER.to_owned(), None, 3)]);

    let next = PAGE_QUERY.replace("first: 2", &format!("first: 2, after: \"{cursor}\""));
    let response = execute(Arc::clone(&reads), &next).await;
    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let requests = reads.requests.lock().unwrap().clone();
    let resumed = requests[1].1.as_ref().expect("decoded cursor");
    assert_eq!(resumed.event_id, EVENT_ID);
    assert_eq!(resumed.occurrence_key, "2026-10-07T15:00:00+00:00");
}

#[tokio::test]
async fn a_short_page_has_no_cursor() {
    let reads = Arc::new(FakeReads {
        listings: vec![timed_listing(6)],
        ..Default::default()
    });

    let response = execute(reads, PAGE_QUERY).await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(data["calendarOccurrences"]["hasNextPage"], false);
    assert_eq!(data["calendarOccurrences"]["endCursor"], Value::Null);
}

#[tokio::test]
async fn calendars_are_listed_for_the_viewer() {
    let reads = Arc::new(FakeReads {
        calendars: vec![VisibleCalendar {
            id: uuid::Uuid::from_u128(5),
            email_link_id: LINK_ID,
            email_address: "[email protected]".to_owned(),
            name: "Work".to_owned(),
            color: None,
            is_primary: true,
            is_writable: true,
            is_subscription: false,
            contributes_to_availability: true,
            sync_error: None,
            provider: CalendarProvider::Google,
            capabilities: CalendarCapabilities::google(),
            default_reminders: Vec::new(),
        }],
        ..Default::default()
    });

    let response = execute(
        Arc::clone(&reads),
        "{ calendars { __typename id linkId name isWritable } }",
    )
    .await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(data["calendars"][0]["__typename"], "GraphqlCalendar");
    assert_eq!(data["calendars"][0]["linkId"], LINK_ID.to_string());
    assert_eq!(reads.requests.lock().unwrap()[0].0, VIEWER);
}

#[tokio::test]
async fn calendar_lists_and_deltas_preserve_actual_provider_capabilities() {
    let cases = [
        (
            CalendarProvider::Google,
            CalendarCapabilities::google(),
            "GOOGLE",
            Some("GOOGLE_MEET"),
        ),
        (
            CalendarProvider::Outlook,
            CalendarCapabilities::outlook(true),
            "OUTLOOK",
            Some("MICROSOFT_TEAMS"),
        ),
        (
            CalendarProvider::Outlook,
            CalendarCapabilities::outlook(false),
            "OUTLOOK",
            None,
        ),
        (
            CalendarProvider::Outlook,
            CalendarCapabilities {
                auto_decline: false,
                email_reminders: false,
                ..CalendarCapabilities::outlook(false)
            },
            "OUTLOOK",
            None,
        ),
    ];
    let calendars: Vec<_> = cases
        .iter()
        .enumerate()
        .map(|(index, (provider, capabilities, _, _))| VisibleCalendar {
            id: uuid::Uuid::from_u128(index as u128 + 1),
            email_link_id: LINK_ID,
            email_address: "[email protected]".to_owned(),
            name: "Work".to_owned(),
            color: None,
            is_primary: true,
            is_writable: true,
            is_subscription: false,
            contributes_to_availability: true,
            sync_error: None,
            provider: *provider,
            capabilities: capabilities.clone(),
            default_reminders: Vec::new(),
        })
        .collect();
    let reads = Arc::new(FakeReads {
        calendars: calendars.clone(),
        changes: CalendarChangesPage {
            calendars,
            ..Default::default()
        },
        ..Default::default()
    });

    let response = execute(reads, r#"{
        calendars { ...ProviderFields }
        calendarChanges(input: { since: [] }) { calendars { ...ProviderFields } }
    }
    fragment ProviderFields on GraphqlCalendar {
        id provider capabilities {
            autoDecline conferenceProvider customRecurrence emailReminders removeConference resetRsvp
        }
    }"#).await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(data["calendars"], data["calendarChanges"]["calendars"]);
    for (calendar, (_, capabilities, provider, conference)) in
        data["calendars"].as_array().unwrap().iter().zip(cases)
    {
        assert_eq!(calendar["provider"], provider);
        assert_eq!(
            calendar["capabilities"],
            serde_json::json!({
                "autoDecline": capabilities.auto_decline,
                "conferenceProvider": conference,
                "customRecurrence": capabilities.custom_recurrence,
                "emailReminders": capabilities.email_reminders,
                "removeConference": capabilities.remove_conference,
                "resetRsvp": capabilities.reset_rsvp,
            })
        );
    }
}

#[tokio::test]
async fn validation_failures_are_user_errors() {
    let reads = Arc::new(FakeReads {
        failure: Failure::Validation,
        ..Default::default()
    });

    let response = execute(reads, PAGE_QUERY).await;

    let error = &response.errors[0];
    assert!(error.message.contains("370 days"), "{}", error.message);
    assert_eq!(
        error
            .extensions
            .as_ref()
            .unwrap()
            .get("code")
            .unwrap()
            .to_string(),
        "\"BAD_USER_INPUT\""
    );
}

#[tokio::test]
async fn infrastructure_failures_are_masked() {
    let reads = Arc::new(FakeReads {
        failure: Failure::Internal,
        ..Default::default()
    });

    let occurrences = execute(Arc::clone(&reads), PAGE_QUERY).await;
    let calendars = execute(reads, "{ calendars { id } }").await;

    for (response, message) in [
        (occurrences, "calendar occurrences are unavailable"),
        (calendars, "calendars are unavailable"),
    ] {
        let error = &response.errors[0];
        assert_eq!(error.message, message);
        assert!(!error.message.contains("db-7"));
        assert_eq!(
            error
                .extensions
                .as_ref()
                .unwrap()
                .get("code")
                .unwrap()
                .to_string(),
            "\"INTERNAL_SERVER_ERROR\""
        );
    }
}

#[tokio::test]
async fn pages_report_the_watermark_as_decimal_strings() {
    let reads = Arc::new(FakeReads {
        listings: vec![timed_listing(6)],
        watermark: CalendarWatermark::from_links([CalendarLinkWatermark {
            link_id: LINK_ID,
            seq: 9_007_199_254_740_993,
        }]),
        ..Default::default()
    });

    let response = execute(reads, PAGE_QUERY).await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(
        data["calendarOccurrences"]["watermark"],
        serde_json::json!([{ "linkId": LINK_ID.to_string(), "seq": "9007199254740993" }])
    );
}

#[tokio::test]
async fn occurrences_of_one_event_share_the_series_event() {
    let reads = Arc::new(FakeReads {
        listings: vec![timed_listing(6), timed_listing(7)],
        ..Default::default()
    });

    let response = execute(reads, PAGE_QUERY).await;

    let data = response.data.into_json().unwrap();
    let nodes = data["calendarOccurrences"]["nodes"].as_array().unwrap();
    assert_eq!(nodes[0]["event"], nodes[1]["event"]);
}

const CHANGES_QUERY: &str = r#"{
    calendarChanges(input: { since: [{ linkId: "LINK", seq: "4" }] }) {
        events {
            event { __typename id linkId }
            occurrences { id eventId linkId event { id } }
        }
        deletedEventIds
        calendars { id }
        deletedCalendarIds
        newWatermark { linkId seq }
        hasMore
        resetRequired
    }
}"#;

fn changes_query() -> String {
    CHANGES_QUERY.replace("LINK", &LINK_ID.to_string())
}

#[tokio::test]
async fn changes_map_the_page_and_parse_the_watermark() {
    let listing = timed_listing(6);
    let deleted_event = uuid::Uuid::from_u128(0x99);
    let deleted_calendar = uuid::Uuid::from_u128(0x98);
    let reads = Arc::new(FakeReads {
        changes: CalendarChangesPage {
            events: vec![CalendarEventChange {
                event: listing.event.clone(),
                link_id: LINK_ID,
                occurrences: vec![EventOccurrence {
                    occurrence: listing.occurrence.clone(),
                    exception: listing.exception.clone(),
                }],
            }],
            deleted_event_ids: vec![deleted_event],
            calendars: Vec::new(),
            deleted_calendar_ids: vec![deleted_calendar],
            new_watermark: CalendarWatermark::from_links([CalendarLinkWatermark {
                link_id: LINK_ID,
                seq: 12,
            }]),
            has_more: true,
            reset_required: false,
        },
        ..Default::default()
    });

    let response = execute(Arc::clone(&reads), &changes_query()).await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    let changes = &data["calendarChanges"];
    assert_eq!(
        changes["events"][0]["event"]["__typename"],
        "GraphqlCalendarEvent"
    );
    assert_eq!(changes["events"][0]["event"]["id"], EVENT_ID.to_string());
    let occurrence = &changes["events"][0]["occurrences"][0];
    assert_eq!(
        occurrence["id"],
        format!("{EVENT_ID}:2026-10-06T15:00:00+00:00")
    );
    assert_eq!(occurrence["event"]["id"], EVENT_ID.to_string());
    assert_eq!(changes["deletedEventIds"][0], deleted_event.to_string());
    assert_eq!(
        changes["deletedCalendarIds"][0],
        deleted_calendar.to_string()
    );
    assert_eq!(
        changes["newWatermark"],
        serde_json::json!([{ "linkId": LINK_ID.to_string(), "seq": "12" }])
    );
    assert_eq!(changes["hasMore"], true);
    assert_eq!(changes["resetRequired"], false);
    assert_eq!(
        *reads.since.lock().unwrap(),
        vec![CalendarWatermark::from_links([CalendarLinkWatermark {
            link_id: LINK_ID,
            seq: 4,
        }])]
    );
}

#[tokio::test]
async fn a_malformed_watermark_is_a_user_error() {
    for since in [
        r#"[{ linkId: "not-a-uuid", seq: "1" }]"#.to_owned(),
        format!(r#"[{{ linkId: "{LINK_ID}", seq: "-1" }}]"#),
        format!(r#"[{{ linkId: "{LINK_ID}", seq: "one" }}]"#),
    ] {
        let reads = Arc::new(FakeReads::default());
        let response = execute(
            Arc::clone(&reads),
            &format!("{{ calendarChanges(input: {{ since: {since} }}) {{ hasMore }} }}"),
        )
        .await;

        assert_eq!(
            response.errors[0]
                .extensions
                .as_ref()
                .unwrap()
                .get("code")
                .unwrap()
                .to_string(),
            "\"BAD_USER_INPUT\"",
            "{since}"
        );
        assert!(reads.since.lock().unwrap().is_empty());
    }
}

#[tokio::test]
async fn change_failures_are_masked() {
    let reads = Arc::new(FakeReads {
        failure: Failure::Internal,
        ..Default::default()
    });

    let response = execute(reads, &changes_query()).await;

    assert_eq!(
        response.errors[0].message,
        "calendar changes are unavailable"
    );
}