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.9 KB
Raw Blame
use std::sync::{Arc, Mutex};

use models_email::email::service::label::Label;
use models_email::service::contact::Contact;
use uuid::Uuid;

use super::super::models::{
    AccessToken, ApiOperationKind, ChangePage, ContactPage, EmailApiError, ProviderSubscription,
    RateLimitRefusal, RequestPermit, SendRequest, SentIds, SyncCursor, ThreadListPage, TokenError,
    TokenFreshness,
};
use super::super::ports::{
    MailboxAttachmentClient, MailboxBlocklistClient, MailboxContactsClient, MailboxLabelClient,
    MailboxMessageClient, MailboxSendClient, MailboxSubscriptionClient, MailboxSyncClient,
    ProviderRequestGate, ProviderTokenSource,
};

#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) enum Call {
    Token(Uuid, TokenFreshness),
    HealthNeutralToken(Uuid, TokenFreshness),
    Acquire(Uuid, ApiOperationKind),
    Finish(Uuid, Option<EmailApiError>),
    Abandon(Uuid),
    Repository(&'static str),
}

pub(super) type CallLog = Arc<Mutex<Vec<Call>>>;

pub(super) fn call_log() -> CallLog {
    Arc::new(Mutex::new(Vec::new()))
}

#[derive(Clone)]
pub(super) struct FakeTokenSource {
    calls: CallLog,
    result: Result<AccessToken, TokenError>,
    fresh_result: Option<Result<AccessToken, TokenError>>,
}

impl FakeTokenSource {
    pub(super) fn new(calls: CallLog, result: Result<AccessToken, TokenError>) -> Self {
        Self {
            calls,
            result,
            fresh_result: None,
        }
    }

    /// Answers fresh link-id fetches with `result` instead.
    pub(super) fn with_fresh(mut self, result: Result<AccessToken, TokenError>) -> Self {
        self.fresh_result = Some(result);
        self
    }
}

impl ProviderTokenSource for FakeTokenSource {
    async fn get_access_token(
        &self,
        link_id: Uuid,
        freshness: TokenFreshness,
    ) -> Result<AccessToken, TokenError> {
        self.calls
            .lock()
            .unwrap()
            .push(Call::Token(link_id, freshness));
        match (&self.fresh_result, freshness) {
            (Some(fresh), TokenFreshness::Fresh) => fresh.clone(),
            _ => self.result.clone(),
        }
    }

    async fn get_access_token_for_link(
        &self,
        link: &models_email::service::link::Link,
        freshness: TokenFreshness,
    ) -> Result<AccessToken, TokenError> {
        self.calls
            .lock()
            .unwrap()
            .push(Call::Token(link.id, freshness));
        self.result.clone()
    }

    async fn get_access_token_health_neutral(
        &self,
        link: &models_email::service::link::Link,
        freshness: TokenFreshness,
    ) -> Result<AccessToken, TokenError> {
        self.calls
            .lock()
            .unwrap()
            .push(Call::HealthNeutralToken(link.id, freshness));
        self.result.clone()
    }
}

#[derive(Clone)]
pub(super) struct FakeGate {
    calls: CallLog,
    result: Result<(), RateLimitRefusal>,
}

impl FakeGate {
    pub(super) fn new(calls: CallLog, result: Result<(), RateLimitRefusal>) -> Self {
        Self { calls, result }
    }
}

impl ProviderRequestGate for FakeGate {
    async fn acquire(
        &self,
        link_id: Uuid,
        operation: ApiOperationKind,
    ) -> Result<RequestPermit, RateLimitRefusal> {
        self.calls
            .lock()
            .unwrap()
            .push(Call::Acquire(link_id, operation));
        let calls = self.calls.clone();
        self.result.clone().map(|()| {
            RequestPermit::new(link_id, Uuid::nil(), move |link_id, _| {
                calls.lock().unwrap().push(Call::Abandon(link_id));
            })
        })
    }

    async fn finish(&self, permit: RequestPermit, error: Option<&EmailApiError>) {
        self.calls
            .lock()
            .unwrap()
            .push(Call::Finish(permit.link_id(), error.cloned()));
        permit.disarm();
    }
}

#[derive(Clone)]
pub(super) struct FakeRepository {
    calls: CallLog,
}

impl FakeRepository {
    pub(super) fn new(calls: CallLog) -> Self {
        Self { calls }
    }

    fn unavailable<T>(&self, method: &'static str) -> Result<T, EmailApiError> {
        self.calls.lock().unwrap().push(Call::Repository(method));
        Err(EmailApiError::Permanent {
            message: "fake repository response is not configured".to_string(),
        })
    }
}

impl MailboxSyncClient for FakeRepository {
    async fn get_thread_count(&self, _: &AccessToken) -> Result<u64, EmailApiError> {
        self.unavailable("get_thread_count")
    }

    async fn list_changes_page(
        &self,
        _: &AccessToken,
        _: &SyncCursor,
        _: Option<&str>,
    ) -> Result<ChangePage, EmailApiError> {
        self.unavailable("list_changes_page")
    }
}

impl MailboxSubscriptionClient for FakeRepository {
    async fn subscribe(&self, _: &AccessToken) -> Result<ProviderSubscription, EmailApiError> {
        self.unavailable("subscribe")
    }

    async fn unsubscribe(&self, _: &AccessToken) -> Result<(), EmailApiError> {
        self.unavailable("unsubscribe")
    }
}

impl MailboxMessageClient for FakeRepository {
    async fn get_message(
        &self,
        _: &AccessToken,
        _: Uuid,
        _: &str,
    ) -> Result<Option<crate::domain::models::MessageWithCalendarParts>, EmailApiError> {
        self.unavailable("get_message")
    }

    async fn get_message_label_ids(
        &self,
        _: &AccessToken,
        _: &str,
    ) -> Result<Option<Vec<String>>, EmailApiError> {
        self.unavailable("get_message_label_ids")
    }

    async fn list_messages(
        &self,
        _: &AccessToken,
        _: u32,
        _: &[&str],
    ) -> Result<Vec<String>, EmailApiError> {
        self.unavailable("list_messages")
    }

    async fn get_message_ids_for_thread(
        &self,
        _: &AccessToken,
        _: &str,
    ) -> Result<Vec<String>, EmailApiError> {
        self.unavailable("get_message_ids_for_thread")
    }

    async fn get_thread(
        &self,
        _: &AccessToken,
        _: Uuid,
        _: &str,
    ) -> Result<Vec<crate::domain::models::MessageWithCalendarParts>, EmailApiError> {
        self.unavailable("get_thread")
    }

    async fn list_threads(
        &self,
        _: &AccessToken,
        _: u32,
        _: Option<&str>,
        _: &[&str],
    ) -> Result<ThreadListPage, EmailApiError> {
        self.unavailable("list_threads")
    }

    async fn modify_message_labels(
        &self,
        _: &AccessToken,
        _: &str,
        _: &[String],
        _: &[String],
    ) -> Result<(), EmailApiError> {
        self.unavailable("modify_message_labels")
    }

    async fn batch_modify_message_labels(
        &self,
        _: &AccessToken,
        _: &[String],
        _: &[String],
        _: &[String],
    ) -> Result<(), EmailApiError> {
        self.unavailable("batch_modify_message_labels")
    }
}

impl MailboxSendClient for FakeRepository {
    async fn send_message(
        &self,
        _: &AccessToken,
        _: &SendRequest,
        _: Option<&str>,
    ) -> Result<SentIds, EmailApiError> {
        self.unavailable("send_message")
    }
}

impl MailboxLabelClient for FakeRepository {
    async fn list_labels(&self, _: &AccessToken, _: Uuid) -> Result<Vec<Label>, EmailApiError> {
        self.unavailable("list_labels")
    }

    async fn create_label(
        &self,
        _: &AccessToken,
        _: Uuid,
        _: &str,
    ) -> Result<Label, EmailApiError> {
        self.unavailable("create_label")
    }

    async fn delete_label(&self, _: &AccessToken, _: &str) -> Result<(), EmailApiError> {
        self.unavailable("delete_label")
    }
}

impl MailboxAttachmentClient for FakeRepository {
    async fn get_attachment(
        &self,
        _: &AccessToken,
        _: &str,
        _: &str,
    ) -> Result<Vec<u8>, EmailApiError> {
        self.unavailable("get_attachment")
    }
}

impl MailboxContactsClient for FakeRepository {
    async fn get_self_contact(&self, _: &AccessToken, _: Uuid) -> Result<Contact, EmailApiError> {
        self.unavailable("get_self_contact")
    }

    async fn list_contacts_page(
        &self,
        _: &AccessToken,
        _: Uuid,
        _: Option<&str>,
        _: Option<&str>,
    ) -> Result<ContactPage, EmailApiError> {
        self.unavailable("list_contacts_page")
    }

    async fn list_other_contacts_page(
        &self,
        _: &AccessToken,
        _: Uuid,
        _: Option<&str>,
        _: Option<&str>,
    ) -> Result<ContactPage, EmailApiError> {
        self.unavailable("list_other_contacts_page")
    }
}

impl MailboxBlocklistClient for FakeRepository {
    async fn block_sender(&self, _: &AccessToken, _: &str) -> Result<(), EmailApiError> {
        self.unavailable("block_sender")
    }

    async fn unblock_sender(&self, _: &AccessToken, _: &str) -> Result<(), EmailApiError> {
        self.unavailable("unblock_sender")
    }

    async fn list_blocked_senders(&self, _: &AccessToken) -> Result<Vec<String>, EmailApiError> {
        self.unavailable("list_blocked_senders")
    }
}