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.

8.0 KB
Raw Blame
use std::sync::Mutex;

use async_graphql::{EmptyMutation, EmptySubscription, Object, Schema};
use chrono::{NaiveDate, TimeZone, Utc};

use super::*;

struct FakeReader {
    stored: HashMap<Uuid, ThreadFocus>,
    ordered: Vec<Uuid>,
    calls: Mutex<Vec<(String, Vec<Uuid>)>>,
    /// Fail every classification lookup, as when the database is down.
    failing: bool,
}

impl EmailFocusReader for FakeReader {
    fn focus_thread_ids<'a>(
        &'a self,
        user: &'a MacroUserIdStr<'static>,
        window_days: u16,
    ) -> BoxFuture<'a, Result<Vec<Uuid>, rootcause::Report>> {
        self.calls
            .lock()
            .unwrap()
            .push((format!("{user}:{window_days}"), Vec::new()));
        Box::pin(async { Ok(self.ordered.clone()) })
    }

    fn focus_for_threads<'a>(
        &'a self,
        user: &'a MacroUserIdStr<'static>,
        thread_ids: Vec<Uuid>,
    ) -> BoxFuture<'a, Result<HashMap<Uuid, ThreadFocus>, rootcause::Report>> {
        self.calls
            .lock()
            .unwrap()
            .push((user.to_string(), thread_ids.clone()));
        Box::pin(async move {
            if self.failing {
                return Err(rootcause::report!("database unavailable"));
            }
            Ok(thread_ids
                .into_iter()
                .filter_map(|id| self.stored.get(&id).map(|focus| (id, focus.clone())))
                .collect())
        })
    }
}

fn user() -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from_email("[email protected]").unwrap()
}

fn focus(importance: u8) -> ThreadFocus {
    ThreadFocus {
        is_focus: true,
        category: FocusCategory::Outreach,
        importance,
        needs_reply: true,
        needs_follow_up: false,
        classified_at: Utc.with_ymd_and_hms(2026, 10, 9, 12, 0, 0).unwrap(),
        importance_trend: ImportanceTrend::Flat,
        due_on: None,
    }
}

struct Query {
    threads: Vec<Uuid>,
}

#[Object]
impl Query {
    async fn focus(
        &self,
        ctx: &Context<'_>,
    ) -> async_graphql::Result<Vec<Option<GraphqlEmailThreadFocus>>> {
        // Fields resolve concurrently in a real query; load the same way so they batch.
        futures::future::try_join_all(
            self.threads
                .iter()
                .map(|thread_id| load_email_thread_focus(ctx, *thread_id)),
        )
        .await
    }

    async fn ids(&self, ctx: &Context<'_>) -> async_graphql::Result<Vec<String>> {
        Ok(load_email_focus_thread_ids(ctx, &user(), 30)
            .await?
            .into_iter()
            .map(|id| id.to_string())
            .collect())
    }
}

#[tokio::test]
async fn focus_edge_maps_stored_classifications() {
    let (known, unknown) = (Uuid::new_v4(), Uuid::new_v4());
    let reader = Arc::new(FakeReader {
        stored: HashMap::from([(known, focus(87))]),
        ordered: vec![known],
        calls: Mutex::default(),
        failing: false,
    });
    let schema = Schema::build(
        Query {
            threads: vec![known, unknown],
        },
        EmptyMutation,
        EmptySubscription,
    )
    .data(email_thread_focus_loader(user(), reader.clone()))
    .data(EmailFocusContext(reader.clone()))
    .finish();

    let response = schema
        .execute(
            "{ focus { isFocus category importance needsReply needsFollowUp classifiedAt } ids }",
        )
        .await;
    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(data["focus"][0]["category"], "OUTREACH");
    assert_eq!(data["focus"][0]["importance"], 87);
    assert_eq!(data["focus"][0]["needsReply"], true);
    assert_eq!(
        data["focus"][0]["classifiedAt"],
        "2026-10-09T12:00:00+00:00"
    );
    assert!(data["focus"][1].is_null());
    assert_eq!(data["ids"][0], known.to_string());
    // Both edge lookups were batched into one read for the viewer.
    let calls = reader.calls.lock().unwrap();
    assert!(
        calls
            .iter()
            .any(|(who, ids)| who == "macro|[email protected]" && ids.len() == 2)
    );
    // The list is read for the viewer over the requested window.
    assert!(
        calls
            .iter()
            .any(|(who, _)| who == "macro|[email protected]:30")
    );
}

#[tokio::test]
async fn focus_edge_says_which_way_importance_is_moving() {
    let threads = [Uuid::new_v4(), Uuid::new_v4(), Uuid::new_v4()];
    let trends = [
        ImportanceTrend::Up,
        ImportanceTrend::Down,
        ImportanceTrend::Flat,
    ];
    let reader = Arc::new(FakeReader {
        stored: threads
            .into_iter()
            .zip(trends)
            .map(|(thread, importance_trend)| {
                (
                    thread,
                    ThreadFocus {
                        importance_trend,
                        ..focus(50)
                    },
                )
            })
            .collect(),
        ordered: Vec::new(),
        calls: Mutex::default(),
        failing: false,
    });
    let schema = Schema::build(
        Query {
            threads: threads.to_vec(),
        },
        EmptyMutation,
        EmptySubscription,
    )
    .data(email_thread_focus_loader(user(), reader))
    .finish();

    let response = schema.execute("{ focus { importanceTrend } }").await;
    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(data["focus"][0]["importanceTrend"], "UP");
    assert_eq!(data["focus"][1]["importanceTrend"], "DOWN");
    assert_eq!(data["focus"][2]["importanceTrend"], "FLAT");
}

#[tokio::test]
async fn a_failed_lookup_errors_only_the_focus_field() {
    let thread = Uuid::new_v4();
    let reader = Arc::new(FakeReader {
        stored: HashMap::new(),
        ordered: vec![thread],
        calls: Mutex::default(),
        failing: true,
    });
    let schema = Schema::build(
        Query {
            threads: vec![thread],
        },
        EmptyMutation,
        EmptySubscription,
    )
    .data(email_thread_focus_loader(user(), reader.clone()))
    .data(EmailFocusContext(reader))
    .finish();

    let response = schema.execute("{ focus { importance } ids }").await;
    assert_eq!(response.errors.len(), 1, "{:?}", response.errors);
    assert_eq!(
        response.errors[0].message,
        "email thread focus is unavailable"
    );
    let data = response.data.into_json().unwrap();
    assert!(data["focus"].is_null());
    assert_eq!(data["ids"][0], thread.to_string());
}

#[tokio::test]
async fn focus_is_absent_where_it_is_not_served() {
    let schema = Schema::build(
        Query {
            threads: vec![Uuid::new_v4()],
        },
        EmptyMutation,
        EmptySubscription,
    )
    .finish();
    let response = schema.execute("{ focus { importance } ids }").await;
    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert!(data["focus"][0].is_null());
    assert_eq!(data["ids"], serde_json::json!([]));
}

#[tokio::test]
async fn due_on_reads_as_a_plain_date_or_null() {
    let due = Uuid::now_v7();
    let open_ended = Uuid::now_v7();
    let reader = Arc::new(FakeReader {
        stored: HashMap::from([
            (
                due,
                ThreadFocus {
                    due_on: NaiveDate::from_ymd_opt(2026, 11, 6),
                    ..focus(50)
                },
            ),
            (open_ended, focus(50)),
        ]),
        ordered: vec![],
        calls: Mutex::default(),
        failing: false,
    });
    let schema = Schema::build(
        Query {
            threads: vec![due, open_ended],
        },
        EmptyMutation,
        EmptySubscription,
    )
    .data(email_thread_focus_loader(user(), reader.clone()))
    .data(EmailFocusContext(reader))
    .finish();

    let response = schema.execute("{ focus { dueOn } }").await;

    assert!(response.errors.is_empty(), "{:?}", response.errors);
    let data = response.data.into_json().unwrap();
    assert_eq!(data["focus"][0]["dueOn"], "2026-11-06");
    assert!(data["focus"][1]["dueOn"].is_null());
}