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.3 KB
Raw Blame
use std::collections::VecDeque;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};

use chrono::Utc;
use model_entity::EntityType;
use rootcause::Report;
use uuid::Uuid;

use super::*;
use crate::domain::events::ActivityWireRow;

struct FakeConsumer {
    messages: Mutex<VecDeque<Result<ActivityTopicEvent, Report>>>,
    calls: Arc<AtomicUsize>,
}

impl ActivityTopicEventConsumer for FakeConsumer {
    async fn recv(&self) -> Result<ActivityTopicEvent, Report> {
        self.calls.fetch_add(1, Ordering::SeqCst);
        self.messages
            .lock()
            .expect("consumer messages lock")
            .pop_front()
            .unwrap_or_else(|| Err(rootcause::report!("consumer stopped")))
    }
}

fn user(local: &str) -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from(format!("macro|{local}@example.com")).expect("valid user ID")
}

fn wire_row(subject: &MacroUserIdStr<'static>, entity_id: &str) -> ActivityWireRow {
    ActivityWireRow {
        agent_correlation_id: None,
        id: Uuid::new_v4(),
        actor_id: subject.as_ref().to_owned(),
        subject_id: subject.as_ref().to_owned(),
        entity_type: EntityType::Document,
        entity_id: entity_id.to_string(),
        action: "edited".to_string(),
        action_payload: None,
        occurred_at: Utc::now(),
    }
}

fn recorded(recipient: &str, activities: Vec<ActivityWireRow>) -> ActivityTopicEvent {
    ActivityTopicEvent::Recorded {
        recipient_id: recipient.to_string(),
        activities,
    }
}

#[tokio::test(start_paused = true)]
async fn distributes_activities_to_recipient_subscriptions() {
    let one = user("one");
    let two = user("two");
    let receive_calls = Arc::new(AtomicUsize::new(0));
    let consumer = FakeConsumer {
        messages: Mutex::new(VecDeque::from([
            Err(rootcause::report!("transient receive failure")),
            Ok(recorded(one.as_ref(), vec![wire_row(&one, "doc-1")])),
            Ok(recorded(two.as_ref(), vec![wire_row(&two, "doc-2")])),
        ])),
        calls: Arc::clone(&receive_calls),
    };
    let service = Arc::new(ActivityRealtimeConsumerService::new(consumer));
    let mut one_first = service.subscribe(one.clone());
    let mut one_second = service.subscribe(one);
    let mut two_receiver = service.subscribe(two);

    let run_error = tokio::spawn({
        let service = Arc::clone(&service);
        async move { service.run().await }
    })
    .await
    .expect("consumer task joins")
    .expect_err("fake consumer eventually stops");

    assert!(run_error.to_string().contains("failed to receive"));
    assert_eq!(
        receive_calls.load(Ordering::SeqCst),
        3 + MAX_RECEIVE_ATTEMPTS,
        "a successful event resets the receive retry strategy"
    );
    let ActivitySubscriptionUpdate::Updated(one_first) =
        one_first.recv().await.expect("first subscriber receives")
    else {
        panic!("expected activity update");
    };
    let ActivitySubscriptionUpdate::Updated(one_second) =
        one_second.recv().await.expect("second subscriber receives")
    else {
        panic!("expected activity update");
    };
    let ActivitySubscriptionUpdate::Updated(two) =
        two_receiver.recv().await.expect("other user receives")
    else {
        panic!("expected activity update");
    };
    assert_eq!(one_first.entity_id, "doc-1");
    assert_eq!(two.entity_id, "doc-2");
    assert!(Arc::ptr_eq(&one_first, &one_second));
}

#[tokio::test(start_paused = true)]
async fn routes_by_recipient_and_drops_non_user_recipients() {
    let subscribed = user("subscribed");
    let other = user("other");
    // A row about someone else's action still reaches its addressed
    // recipient — that is how entity watchers hear about other principals.
    let mut foreign_subject_row = wire_row(&other, "doc-watched");
    foreign_subject_row.subject_id = "bot|automation".to_string();
    let consumer = FakeConsumer {
        messages: Mutex::new(VecDeque::from([
            // Addressed to a non-user principal: dropped whole.
            Ok(recorded(
                "bot|automation",
                vec![wire_row(&subscribed, "ignored")],
            )),
            Ok(recorded(
                subscribed.as_ref(),
                vec![foreign_subject_row, wire_row(&subscribed, "doc-1")],
            )),
        ])),
        calls: Arc::new(AtomicUsize::new(0)),
    };
    let service = Arc::new(ActivityRealtimeConsumerService::new(consumer));
    let mut receiver = service.subscribe(subscribed);

    let _ = tokio::spawn({
        let service = Arc::clone(&service);
        async move { service.run().await }
    })
    .await
    .expect("consumer task joins")
    .expect_err("fake consumer eventually stops");

    // The dropped event preceded these, so the first deliveries being the
    // addressed rows proves the non-user recipient was dropped whole.
    let ActivitySubscriptionUpdate::Updated(first) =
        receiver.recv().await.expect("subscriber receives")
    else {
        panic!("expected activity update");
    };
    assert_eq!(first.entity_id, "doc-watched");
    assert_eq!(first.subject_id, "bot|automation");
    let ActivitySubscriptionUpdate::Updated(second) =
        receiver.recv().await.expect("subscriber receives")
    else {
        panic!("expected activity update");
    };
    assert_eq!(second.entity_id, "doc-1");
}

#[tokio::test(start_paused = true)]
async fn reports_slow_consumer_subscription_exit() {
    let subscribed = user("subscribed");
    let consumer = FakeConsumer {
        messages: Mutex::new(VecDeque::new()),
        calls: Arc::new(AtomicUsize::new(0)),
    };
    let service = ActivityRealtimeConsumerService::new(consumer);
    let subscription = service.subscribe(subscribed.clone());

    for _ in 0..=SUBSCRIBER_BUFFER_CAPACITY.get() {
        let row = wire_row(&subscribed, "doc-1");
        let record = row.into_record().expect("decodes");
        service
            .broadcasts
            .publish(
                &subscribed,
                ActivitySubscriptionUpdate::Updated(Arc::new(record)),
            )
            .expect("subscriber remains until its buffer fills");
        tokio::task::yield_now().await;
    }

    assert_eq!(
        subscription.exit_reason().await,
        ActivitySubscriptionExit::SlowConsumer
    );
}

#[tokio::test(start_paused = true)]
async fn purge_invalidates_unrelated_subscribers_without_entity_access_data() {
    let consumer = FakeConsumer {
        messages: Mutex::new(VecDeque::from([
            Ok(ActivityTopicEvent::Invalidated),
            Ok(ActivityTopicEvent::Invalidated),
        ])),
        calls: Arc::new(AtomicUsize::new(0)),
    };
    let service = Arc::new(ActivityRealtimeConsumerService::new(consumer));
    let mut one = service.subscribe(user("former-viewer"));
    let mut two = service.subscribe(user("other-viewer"));
    let task = tokio::spawn({
        let service = service.clone();
        async move { service.run().await }
    });
    task.await.unwrap().expect_err("test consumer stops");
    assert!(matches!(
        one.recv().await,
        Some(ActivitySubscriptionUpdate::Invalidated)
    ));
    assert!(matches!(
        two.recv().await,
        Some(ActivitySubscriptionUpdate::Invalidated)
    ));
    assert!(
        tokio::time::timeout(Duration::from_millis(1), one.recv())
            .await
            .is_err(),
        "bursts coalesce"
    );
}

#[tokio::test(start_paused = true)]
async fn large_recorded_batch_refreshes_without_disconnect() {
    let viewer = user("viewer");
    let consumer = FakeConsumer {
        messages: Mutex::new(VecDeque::from([Ok(recorded(
            viewer.as_ref(),
            (0..100).map(|_| wire_row(&viewer, "doc-1")).collect(),
        ))])),
        calls: Arc::new(AtomicUsize::new(0)),
    };
    let service = Arc::new(ActivityRealtimeConsumerService::new(consumer));
    let mut receiver = service.subscribe(viewer);
    let task = tokio::spawn({
        let service = service.clone();
        async move { service.run().await }
    });
    task.await.unwrap().expect_err("test consumer stops");
    assert!(matches!(
        receiver.recv().await,
        Some(ActivitySubscriptionUpdate::Invalidated)
    ));
    assert!(
        tokio::time::timeout(Duration::from_millis(1), receiver.recv())
            .await
            .is_err(),
        "subscription remains open"
    );
}