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.

6.8 KB
Raw Blame
use base64::Engine;
use base64::engine::general_purpose::URL_SAFE_NO_PAD;
use gmail_client::GmailClient;
use models_email::email::service::address::ContactInfo;
use models_email::email::service::message::MessageToSend;
use serde_json::Value;
use uuid::Uuid;
use wiremock::matchers::{header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};

use crate::domain::models::{AccessToken, SendRequest};
use crate::domain::ports::MailboxSendClient;
use crate::outbound::gmail::GmailApiClientRepository;

fn repository(server: &MockServer) -> GmailApiClientRepository {
    GmailApiClientRepository::new(GmailClient::new_with_urls(
        "projects/p/topics/mail".to_string(),
        server.uri(),
        server.uri(),
        server.uri(),
        "audience".to_string(),
    ))
}

#[tokio::test]
async fn builds_posts_and_returns_provider_ids() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/users/me/messages/send"))
        .and(header("authorization", "Bearer access-token"))
        .respond_with(ResponseTemplate::new(200).set_body_raw(
            include_str!("fixtures/sent_message.json"),
            "application/json",
        ))
        .mount(&server)
        .await;

    let request = SendRequest {
        message_id: None,
        message: MessageToSend {
            db_id: None,
            provider_id: None,
            replying_to_id: None,
            provider_thread_id: None,
            thread_db_id: None,
            link_id: Uuid::nil(),
            subject: "Adapter subject".to_string(),
            to: Some(vec![ContactInfo {
                email: "[email protected]".to_string(),
                name: Some("Recipient".to_string()),
                photo_url: None,
            }]),
            cc: None,
            bcc: None,
            body_text: Some("Adapter body".to_string()),
            body_html: None,
            body_macro: None,
            attachments: None,
            headers_json: None,
            send_time: None,
        },
        from: ContactInfo {
            email: "[email protected]".to_string(),
            name: Some("Sender".to_string()),
            photo_url: None,
        },
        parent_message_id: Some("[email protected]".to_string()),
        references: Some(vec!["[email protected]".to_string()]),
    };

    let sent = repository(&server)
        .send_message(
            &AccessToken::new("access-token"),
            &request,
            Some("thread-1"),
        )
        .await
        .unwrap();

    assert_eq!(sent.provider_message_id, "gmail-message-123");
    assert_eq!(sent.provider_thread_id, "gmail-thread-456");

    let requests = server.received_requests().await.unwrap();
    let payload: Value = serde_json::from_slice(&requests[0].body).unwrap();
    assert_eq!(payload["threadId"], "thread-1");
    let mime = URL_SAFE_NO_PAD
        .decode(payload["raw"].as_str().unwrap())
        .unwrap();
    let mime = String::from_utf8(mime).unwrap();
    assert!(mime.contains("Subject: Adapter subject"));
    assert!(mime.contains("Adapter body"));
    assert!(mime.contains("In-Reply-To:"));
    assert!(mime.contains("[email protected]"));
}

#[tokio::test]
async fn prepared_dispatch_does_not_retry_provider_failure() {
    use crate::domain::ports::MailboxSendRecoveryClient;
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/users/me/messages/send"))
        .respond_with(ResponseTemplate::new(503))
        .expect(1)
        .mount(&server)
        .await;
    let error = repository(&server)
        .send_prepared(
            &AccessToken::new("access-token"),
            b"Message-ID: <[email protected]>\r\n\r\nbody",
            None,
        )
        .await
        .unwrap_err();
    assert!(matches!(
        error,
        crate::domain::models::EmailApiError::Transient { .. }
    ));
    assert_eq!(server.received_requests().await.unwrap().len(), 1);
}

#[tokio::test]
async fn prepared_dispatch_preserves_explicit_validation_rejection() {
    use crate::domain::models::EmailApiError;
    use crate::domain::ports::MailboxSendRecoveryClient;
    for status in [400, 413, 422] {
        let server = MockServer::start().await;
        Mock::given(method("POST"))
            .and(path("/users/me/messages/send"))
            .respond_with(ResponseTemplate::new(status).set_body_string("invalid message"))
            .expect(1)
            .mount(&server)
            .await;
        let error = repository(&server)
            .send_prepared(&AccessToken::new("token"), b"message", None)
            .await
            .unwrap_err();
        assert!(matches!(error, EmailApiError::SendRejected { .. }));
        assert_eq!(server.received_requests().await.unwrap().len(), 1);
    }
}

#[tokio::test]
async fn timeout_and_malformed_success_do_not_establish_rejection() {
    use crate::domain::models::EmailApiError;
    use crate::domain::ports::MailboxSendRecoveryClient;
    for (status, body) in [
        (408, "request timeout"),
        (200, "not JSON"),
        (200, "{}"),
        (302, "redirect"),
    ] {
        let server = MockServer::start().await;
        Mock::given(method("POST"))
            .and(path("/users/me/messages/send"))
            .respond_with(ResponseTemplate::new(status).set_body_raw(body, "application/json"))
            .expect(1)
            .mount(&server)
            .await;
        let error = repository(&server)
            .send_prepared(&AccessToken::new("token"), b"message", None)
            .await
            .unwrap_err();
        assert!(matches!(error, EmailApiError::Permanent { .. }));
        assert_eq!(server.received_requests().await.unwrap().len(), 1);
    }
}

#[tokio::test]
async fn recovery_maps_ids_and_search_errors_without_sending() {
    use crate::domain::ports::MailboxSendRecoveryClient;
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/users/me/messages"))
        .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
            "messages": [{"id":"sent-message","threadId":"sent-thread"}]
        })))
        .expect(1)
        .mount(&server)
        .await;
    let found = repository(&server)
        .find_sent_message(&AccessToken::new("token"), "[email protected]")
        .await
        .unwrap()
        .unwrap();
    assert_eq!(found.provider_message_id, "sent-message");
    assert_eq!(found.provider_thread_id, "sent-thread");
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/users/me/messages"))
        .respond_with(ResponseTemplate::new(429))
        .expect(1)
        .mount(&server)
        .await;
    assert!(matches!(
        repository(&server)
            .find_sent_message(&AccessToken::new("token"), "[email protected]")
            .await,
        Err(crate::domain::models::EmailApiError::RateLimited { .. })
    ));
}