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.

17.9 KB
Raw Blame
use super::*;
use crate::domain::models::WebhookFilter;
use chrono::Utc;
use entity_access::domain::models::{
    AccessError, AccessLevel, BotAccessScope, BotId, CallChannelInfo, EntityAccessReceipt,
    EntityPermission, RequiredPermission, TeamRole, UserTeamInfo,
};
use futures::StreamExt as _;
use macro_user_id::{lowercased::Lowercase, user_id::MacroUserId};
use std::sync::{Arc, Mutex};
use tokio::sync::broadcast;
use uuid::Uuid;

const SUBSCRIBER_ID: &str = "macro|[email protected]";
const DOCUMENT_ID: &str = "11111111-1111-1111-1111-111111111111";
const OTHER_DOCUMENT_ID: &str = "22222222-2222-2222-2222-222222222222";
const TEAM_WORKSPACE_ID: &str = "33333333-3333-3333-3333-333333333333";
const FOREIGN_WORKSPACE_ID: &str = "44444444-4444-4444-4444-444444444444";

fn subscriber() -> MacroUserIdStr<'static> {
    MacroUserIdStr::try_from(SUBSCRIBER_ID.to_string()).expect("valid user id")
}

fn normalized(event_name: &str, entity_id: &str) -> NormalizedWebhookEvent {
    NormalizedWebhookEvent {
        event_id: Uuid::now_v7().to_string(),
        schema_version: 1,
        event_name: event_name.to_string(),
        entity_type: "document".to_string(),
        entity_id: entity_id.to_string(),
        ordering_key: entity_id.to_string(),
        occurred_at: Utc::now(),
        broker_envelope: serde_json::json!({ "event_type": event_name }),
    }
}

fn document_candidate(event_name: &str, document_id: &str) -> StreamCandidateEvent {
    StreamCandidateEvent {
        event: normalized(event_name, document_id),
        audience: StreamAudience::Entity {
            entity_id: document_id.to_string(),
            entity_type: EntityType::Document,
        },
    }
}

fn workspace_candidate(event_name: &str, workspace_id: &str) -> StreamCandidateEvent {
    let mut candidate = document_candidate(event_name, "wh_test");
    candidate.audience = StreamAudience::Workspace {
        workspace_id: workspace_id.to_string(),
    };
    candidate
}

#[tokio::test]
async fn private_call_event_streams_only_to_the_recipient() {
    let (service, sender) = service(FakeAccessService::allowing(&[]));
    let stream = service
        .open_stream(subscriber(), WebhookScope::User, filter(&["call.invited"]))
        .await
        .unwrap();
    sender
        .send(StreamCandidateEvent {
            event: normalized("call.invited", DOCUMENT_ID),
            audience: StreamAudience::User {
                user_id: "macro|[email protected]".to_string(),
            },
        })
        .unwrap();
    sender
        .send(StreamCandidateEvent {
            event: normalized("call.invited", DOCUMENT_ID),
            audience: StreamAudience::User {
                user_id: SUBSCRIBER_ID.to_string(),
            },
        })
        .unwrap();

    let delivered: Vec<_> = stream.take(1).collect().await;
    assert_eq!(delivered.len(), 1);
    assert_eq!(delivered[0].event_name, "call.invited");
}

fn filter(events: &[&str]) -> WebhookFilters {
    vec![WebhookFilter {
        events: events.iter().map(|event| event.to_string()).collect(),
        ids: None,
    }]
}

/// Access service granting explicit accessor membership to a fixed entity id set.
#[derive(Clone)]
struct FakeAccessService {
    accessor_entity_ids: Vec<String>,
    /// Entity ids `get_access_level` would treat as View (e.g. PUBLIC link-share).
    link_share_entity_ids: Vec<String>,
    users_by_entity_calls: Arc<Mutex<usize>>,
    access_level_calls: Arc<Mutex<usize>>,
}

impl FakeAccessService {
    fn allowing(entity_ids: &[&str]) -> Self {
        Self {
            accessor_entity_ids: entity_ids.iter().map(|id| id.to_string()).collect(),
            link_share_entity_ids: Vec::new(),
            users_by_entity_calls: Arc::default(),
            access_level_calls: Arc::default(),
        }
    }

    fn link_share_only(entity_ids: &[&str]) -> Self {
        Self {
            accessor_entity_ids: Vec::new(),
            link_share_entity_ids: entity_ids.iter().map(|id| id.to_string()).collect(),
            users_by_entity_calls: Arc::default(),
            access_level_calls: Arc::default(),
        }
    }
}

impl EntityAccessService for FakeAccessService {
    async fn generate_entity_access_receipt<T: RequiredPermission>(
        &self,
        _user_id: &MacroUserId<Lowercase<'_>>,
        _user_org_id: Option<i64>,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> Result<EntityAccessReceipt<T>, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn generate_bot_entity_access_receipt<T: RequiredPermission>(
        &self,
        _bot_id: BotId,
        _scope: BotAccessScope,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> Result<EntityAccessReceipt<T>, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn get_access_level(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        entity_id: &str,
        _entity_type: EntityType,
    ) -> Result<Option<AccessLevel>, AccessError> {
        *self.access_level_calls.lock().unwrap() += 1;
        Ok(self
            .accessor_entity_ids
            .iter()
            .chain(self.link_share_entity_ids.iter())
            .any(|allowed| allowed == entity_id)
            .then_some(AccessLevel::View))
    }

    async fn check_access(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
        _required_level: AccessLevel,
    ) -> Result<AccessLevel, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn check_public_access(
        &self,
        _entity_id: &str,
        _entity_type: EntityType,
        _required_level: AccessLevel,
    ) -> Result<AccessLevel, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn get_entity_permission(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
        _user_org_id: Option<i64>,
    ) -> Result<EntityPermission, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn get_crm_entity_permission_with_team(
        &self,
        _user_id: Option<&MacroUserId<Lowercase<'_>>>,
        _entity_id: &str,
        _entity_type: EntityType,
    ) -> Result<(EntityPermission, Uuid, TeamRole), AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn get_users_by_entity(
        &self,
        entity_id: &str,
        entity_type: EntityType,
    ) -> Result<Vec<MacroUserIdStr<'static>>, AccessError> {
        *self.users_by_entity_calls.lock().unwrap() += 1;
        if entity_type == EntityType::AgentSession {
            return Err(AccessError::BadRequest(
                "get_users_by_entity does not support this entity type",
            ));
        }
        if self
            .accessor_entity_ids
            .iter()
            .any(|allowed| allowed == entity_id)
        {
            Ok(vec![subscriber()])
        } else {
            Ok(vec![])
        }
    }

    async fn get_call_channel(
        &self,
        _call_id: &Uuid,
    ) -> Result<Option<CallChannelInfo>, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn get_call_channel_by_channel_id(
        &self,
        _channel_id: &Uuid,
    ) -> Result<Option<CallChannelInfo>, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }

    async fn get_user_team(
        &self,
        _user_id: &MacroUserId<Lowercase<'_>>,
    ) -> Result<Option<UserTeamInfo>, AccessError> {
        unimplemented!("not used by webhook event streaming")
    }
}

#[derive(Clone)]
struct FakeWorkspaceResolver {
    /// Highest-role team, matching `get_user_team_workspace_id`.
    team_workspace_id: Arc<Mutex<Option<String>>>,
}

impl FakeWorkspaceResolver {
    fn with_team(team_workspace_id: Option<String>) -> Self {
        Self {
            team_workspace_id: Arc::new(Mutex::new(team_workspace_id)),
        }
    }
}

impl WebhookWorkspaceResolver for FakeWorkspaceResolver {
    type Err = anyhow::Error;

    async fn resolve_workspace_ids(
        &self,
        people: Vec<MacroUserIdStr<'static>>,
    ) -> Result<Vec<String>, Self::Err> {
        let mut ids: Vec<String> = people
            .iter()
            .map(|person| person.as_ref().to_string())
            .collect();
        if let Some(team) = self.team_workspace_id.lock().unwrap().clone() {
            ids.push(team);
        }
        Ok(ids)
    }

    async fn get_user_team_workspace_id(
        &self,
        _user_id: MacroUserIdStr<'static>,
    ) -> Result<Option<String>, Self::Err> {
        Ok(self.team_workspace_id.lock().unwrap().clone())
    }
}

type TestService = WebhookEventStreamServiceImpl<FakeAccessService, FakeWorkspaceResolver>;

fn service(access: FakeAccessService) -> (TestService, broadcast::Sender<StreamCandidateEvent>) {
    service_with_team(access, Some(TEAM_WORKSPACE_ID.to_string()))
}

fn service_with_team(
    access: FakeAccessService,
    team_workspace_id: Option<String>,
) -> (TestService, broadcast::Sender<StreamCandidateEvent>) {
    let (sender, _) = broadcast::channel(16);
    let service = WebhookEventStreamServiceImpl::new(
        sender.clone(),
        Arc::new(access),
        FakeWorkspaceResolver::with_team(team_workspace_id),
    );
    (service, sender)
}

#[test]
fn filter_accepts_its_events_and_optional_entity_ids() {
    let document_filter = WebhookFilter {
        events: vec!["document.updated".to_string()],
        ids: Some(vec![DOCUMENT_ID.to_string()]),
    };
    let message_filter = WebhookFilter {
        events: vec!["message.posted".to_string()],
        ids: None,
    };

    assert!(document_filter.accepts("document.updated", DOCUMENT_ID));
    assert!(!document_filter.accepts("document.updated", OTHER_DOCUMENT_ID));
    assert!(!document_filter.accepts("document.created", DOCUMENT_ID));
    assert!(message_filter.accepts("message.posted", "any-channel-id"));
}

#[tokio::test]
async fn open_stream_delivers_only_matching_accessible_events() {
    let candidates = vec![
        document_candidate("document.updated", DOCUMENT_ID),
        // Filter matches but the subscriber has no access: skipped.
        document_candidate("document.updated", OTHER_DOCUMENT_ID),
        // Access would pass but the filter does not match: skipped.
        document_candidate("document.created", DOCUMENT_ID),
        workspace_candidate("document.updated", SUBSCRIBER_ID),
        workspace_candidate("document.updated", TEAM_WORKSPACE_ID),
        workspace_candidate("document.updated", FOREIGN_WORKSPACE_ID),
    ];
    let (service, sender) = service(FakeAccessService::allowing(&[DOCUMENT_ID]));

    let stream = service
        .open_stream(
            subscriber(),
            WebhookScope::Team,
            filter(&["document.updated"]),
        )
        .await
        .expect("stream opens");
    for candidate in candidates {
        sender.send(candidate).unwrap();
    }
    let delivered: Vec<NormalizedWebhookEvent> = stream.take(2).collect().await;

    let delivered_entities: Vec<&str> = delivered
        .iter()
        .map(|event| event.entity_id.as_str())
        .collect();
    assert_eq!(delivered_entities, vec![DOCUMENT_ID, "wh_test"]);
}

#[tokio::test]
async fn team_scope_requires_team_membership() {
    let (service, _) = service_with_team(FakeAccessService::allowing(&[]), None);

    let Err(error) = service
        .open_stream(
            subscriber(),
            WebhookScope::Team,
            filter(&["webhook.updated"]),
        )
        .await
    else {
        panic!("team scope without team membership must be rejected");
    };

    assert!(matches!(error, WebhookStreamError::BadRequest(_)));
}

#[tokio::test]
async fn open_stream_checks_access_for_each_matching_event() {
    let candidates = vec![
        document_candidate("document.updated", DOCUMENT_ID),
        document_candidate("document.updated", DOCUMENT_ID),
        document_candidate("document.updated", DOCUMENT_ID),
    ];
    let access = FakeAccessService::allowing(&[DOCUMENT_ID]);
    let call_count = access.users_by_entity_calls.clone();
    let (service, sender) = service(access);

    let stream = service
        .open_stream(
            subscriber(),
            WebhookScope::Team,
            filter(&["document.updated"]),
        )
        .await
        .expect("stream opens");
    for candidate in candidates {
        sender.send(candidate).unwrap();
    }
    let delivered: Vec<NormalizedWebhookEvent> = stream.take(3).collect().await;

    assert_eq!(delivered.len(), 3);
    assert_eq!(*call_count.lock().unwrap(), 3);
}

#[tokio::test]
async fn open_stream_rejects_empty_or_degenerate_filters() {
    let (service, _) = service(FakeAccessService::allowing(&[]));

    for filters in [
        vec![],
        vec![WebhookFilter {
            events: vec![],
            ids: None,
        }],
        vec![WebhookFilter {
            events: vec![String::new()],
            ids: None,
        }],
        vec![WebhookFilter {
            events: vec!["document.updated".to_string()],
            ids: Some(vec![]),
        }],
    ] {
        let Err(error) = service
            .open_stream(subscriber(), WebhookScope::Team, filters)
            .await
        else {
            panic!("degenerate filters must be rejected");
        };
        assert!(matches!(error, WebhookStreamError::BadRequest(_)));
    }
}

#[tokio::test]
async fn lagged_stream_skips_missed_events_and_continues() {
    let (sender, _) = broadcast::channel(2);
    let service = WebhookEventStreamServiceImpl::new(
        sender.clone(),
        Arc::new(FakeAccessService::allowing(&[DOCUMENT_ID])),
        FakeWorkspaceResolver::with_team(Some(TEAM_WORKSPACE_ID.to_string())),
    );
    let mut stream = service
        .open_stream(
            subscriber(),
            WebhookScope::Team,
            filter(&["document.updated"]),
        )
        .await
        .expect("stream opens");

    sender
        .send(document_candidate("document.updated", DOCUMENT_ID))
        .unwrap();
    sender
        .send(document_candidate("document.updated", DOCUMENT_ID))
        .unwrap();
    let latest = document_candidate("document.updated", DOCUMENT_ID);
    let latest_id = latest.event.event_id.clone();
    sender.send(latest).unwrap();

    let delivered = stream.next().await.expect("stream continues after lag");
    assert_ne!(delivered.event_id, latest_id);
    assert_eq!(stream.next().await.unwrap().event_id, latest_id);
}

#[tokio::test]
async fn open_stream_does_not_deliver_link_share_only_entities() {
    let (service, sender) = service(FakeAccessService::link_share_only(&[DOCUMENT_ID]));

    let stream = service
        .open_stream(
            subscriber(),
            WebhookScope::User,
            filter(&["document.updated"]),
        )
        .await
        .expect("stream opens");
    sender
        .send(document_candidate("document.updated", DOCUMENT_ID))
        .unwrap();
    sender
        .send(workspace_candidate("document.updated", SUBSCRIBER_ID))
        .unwrap();

    let delivered: Vec<NormalizedWebhookEvent> = stream.take(1).collect().await;
    assert_eq!(
        delivered
            .iter()
            .map(|event| event.entity_id.as_str())
            .collect::<Vec<_>>(),
        vec!["wh_test"]
    );
}

#[tokio::test]
async fn team_scope_uses_highest_role_team_not_first_resolved_workspace() {
    // Highest-role team is FOREIGN; TEAM would sort first by team_id text.
    let (service, sender) = service_with_team(
        FakeAccessService::allowing(&[]),
        Some(FOREIGN_WORKSPACE_ID.to_string()),
    );

    let stream = service
        .open_stream(
            subscriber(),
            WebhookScope::Team,
            filter(&["webhook.created"]),
        )
        .await
        .expect("stream opens");
    sender
        .send(workspace_candidate("webhook.created", TEAM_WORKSPACE_ID))
        .unwrap();
    sender
        .send(workspace_candidate("webhook.created", FOREIGN_WORKSPACE_ID))
        .unwrap();

    let delivered: Vec<NormalizedWebhookEvent> = stream.take(1).collect().await;
    assert_eq!(delivered.len(), 1);
}

#[tokio::test]
async fn team_membership_revocation_ends_the_stream() {
    let resolver = FakeWorkspaceResolver::with_team(Some(TEAM_WORKSPACE_ID.to_string()));
    let (sender, _) = broadcast::channel(16);
    let service = WebhookEventStreamServiceImpl::new(
        sender.clone(),
        Arc::new(FakeAccessService::allowing(&[])),
        resolver.clone(),
    );
    let mut stream = service
        .open_stream(
            subscriber(),
            WebhookScope::Team,
            filter(&["webhook.created"]),
        )
        .await
        .expect("stream opens");

    *resolver.team_workspace_id.lock().unwrap() = None;
    sender
        .send(workspace_candidate("webhook.created", TEAM_WORKSPACE_ID))
        .unwrap();

    assert!(stream.next().await.is_none());
}

#[tokio::test]
async fn agent_session_events_fall_back_to_access_level() {
    const SESSION_ID: &str = "55555555-5555-5555-5555-555555555555";
    let access = FakeAccessService::allowing(&[SESSION_ID]);
    let access_level_calls = access.access_level_calls.clone();
    let (service, sender) = service(access);

    let stream = service
        .open_stream(
            subscriber(),
            WebhookScope::User,
            filter(&["agent_trigger.existing"]),
        )
        .await
        .expect("stream opens");
    sender
        .send(StreamCandidateEvent {
            event: normalized("agent_trigger.existing", SESSION_ID),
            audience: StreamAudience::Entity {
                entity_id: SESSION_ID.to_string(),
                entity_type: EntityType::AgentSession,
            },
        })
        .unwrap();

    let delivered: Vec<NormalizedWebhookEvent> = stream.take(1).collect().await;
    assert_eq!(delivered[0].entity_id, SESSION_ID);
    assert_eq!(*access_level_calls.lock().unwrap(), 1);
}