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.

23.8 KB
Raw Blame
use reqwest::Method;
use serde_json::json;
use uuid::Uuid;
use wiremock::{
    Mock, MockServer, ResponseTemplate,
    matchers::{header, method, path, query_param},
};

use super::*;
use crate::domain::models::*;
use crate::domain::ports::{
    FolderChangeReader, MailboxActionWriter, MailboxContentReader, MailboxWatchClient,
};

pub(super) async fn setup() -> (MockServer, OutlookApiClientRepository, AccessToken) {
    let server = MockServer::start().await;
    let api = OutlookApiClientRepository::for_test(&format!("{}/v1.0/", server.uri()));
    (server, api, AccessToken::new("test-bearer"))
}

#[tokio::test]
async fn delta_preserves_removals_as_stream_events_and_keeps_opaque_continuations() {
    let (server, api, token) = setup().await;
    let next = format!(
        "{}/v1.0/me/mailFolders/folder/messages/delta?$skiptoken=A%2BB%2F%3D",
        server.uri()
    );
    Mock::given(method("GET"))
        .and(path("/v1.0/me/mailFolders/folder/messages/delta"))
        .and(header("authorization", "Bearer test-bearer"))
        .and(header("prefer", "IdType=\"ImmutableId\""))
        .and(query_param("$select", "id"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "value":[{"id":"m1"},{"id":"m2","@removed":{"reason":"deleted"}}],
            "@odata.nextLink":next
        })))
        .expect(1)
        .mount(&server)
        .await;
    let page = api
        .folder_changes(&token, &ProviderId::new("folder").unwrap(), None)
        .await
        .unwrap();
    assert_eq!(page.changed, vec![ProviderId::new("m1").unwrap()]);
    assert_eq!(page.removed, vec![ProviderId::new("m2").unwrap()]);
    assert_eq!(
        page.position,
        StreamPosition::Continue(StreamToken::new(next))
    );
}

#[tokio::test]
async fn unsafe_cursors_are_rejected_before_sending_credentials() {
    let (server, api, token) = setup().await;
    for unsafe_url in [
        "https://attacker.invalid/v1.0/me/messages/delta".to_owned(),
        format!("{}/v1.0evil/me/messages", server.uri()),
        format!("{}/v1.0/me/messages#fragment", server.uri()),
        format!("{}/v1.0/../outside", server.uri()),
    ] {
        let result = api
            .folder_changes(
                &token,
                &ProviderId::new("inbox").unwrap(),
                Some(&StreamToken::new(unsafe_url)),
            )
            .await;
        assert!(matches!(result, Err(EmailApiError::Permanent { .. })));
    }
    assert!(server.received_requests().await.unwrap().is_empty());
}

#[tokio::test]
async fn redirects_are_not_followed_and_provider_error_content_is_not_leaked() {
    let (server, api, token) = setup().await;
    Mock::given(method("GET"))
        .respond_with(
            ResponseTemplate::new(302)
                .insert_header("Location", "https://attacker.invalid/")
                .set_body_json(json!({"error":{"message":"secret-mail-content"}})),
        )
        .expect(1)
        .mount(&server)
        .await;
    let error = api
        .get::<serde_json::Value>(&token, api.endpoint(&["me"]).unwrap())
        .await
        .unwrap_err();
    assert!(matches!(error, EmailApiError::Permanent { .. }));
    assert!(!format!("{error:?}").contains("secret-mail-content"));
}

#[tokio::test]
async fn send_with_unknown_server_outcome_is_not_retried() {
    let (server, api, token) = setup().await;
    Mock::given(method("POST"))
        .and(path("/v1.0/me/messages/draft/send"))
        .respond_with(ResponseTemplate::new(503))
        .expect(1)
        .mount(&server)
        .await;
    assert_eq!(
        api.submit_draft(&token, &ProviderId::new("draft").unwrap())
            .await
            .unwrap(),
        SubmissionOutcome::Unknown
    );
}

#[tokio::test]
async fn accepted_send_does_not_require_a_response_body() {
    let (server, api, token) = setup().await;
    Mock::given(method("POST"))
        .and(path("/v1.0/me/messages/draft/send"))
        .respond_with(ResponseTemplate::new(202))
        .expect(1)
        .mount(&server)
        .await;
    assert_eq!(
        api.submit_draft(&token, &ProviderId::new("draft").unwrap())
            .await
            .unwrap(),
        SubmissionOutcome::Accepted
    );
}

#[tokio::test]
async fn bodyless_send_declares_zero_content_length() {
    let (server, api, token) = setup().await;
    Mock::given(method("POST"))
        .and(path("/v1.0/me/messages/draft/send"))
        .and(header("content-length", "0"))
        .respond_with(ResponseTemplate::new(202))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/v1.0/me/messages/draft/send"))
        .respond_with(ResponseTemplate::new(411))
        .mount(&server)
        .await;
    assert_eq!(
        api.submit_draft(&token, &ProviderId::new("draft").unwrap())
            .await
            .unwrap(),
        SubmissionOutcome::Accepted
    );
}

#[tokio::test]
async fn throttling_respects_provider_retry_after() {
    let (server, api, token) = setup().await;
    Mock::given(method("GET"))
        .respond_with(ResponseTemplate::new(429).insert_header("Retry-After", "17"))
        .expect(1)
        .mount(&server)
        .await;
    let error = api
        .request(&token, Method::GET, api.endpoint(&["me"]).unwrap(), None)
        .await
        .unwrap_err();
    assert_eq!(
        error,
        EmailApiError::RateLimited {
            retry_after: Some(Duration::from_secs(17)),
            origin: RateLimitOrigin::Provider { concurrency: false }
        }
    );
}

#[tokio::test]
async fn expired_cursor_is_recoverable_without_deleting_existing_mail() {
    let (server, api, token) = setup().await;
    Mock::given(method("GET"))
        .respond_with(ResponseTemplate::new(410))
        .expect(1)
        .mount(&server)
        .await;
    assert_eq!(
        api.folder_changes(&token, &ProviderId::new("inbox").unwrap(), None)
            .await
            .unwrap_err(),
        EmailApiError::OutdatedCursor
    );
}

#[tokio::test]
async fn inline_attachments_are_loaded_even_when_has_attachments_is_false() {
    let (server, api, token) = setup().await;
    Mock::given(method("GET")).and(path("/v1.0/me/messages/m1"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "id":"m1", "conversationId":"conversation", "parentFolderId":"folder",
            "body":{"contentType":"html","content":"<p>Hello<img src=\"cid:logo\"></p><script>bad()</script>"},
            "hasAttachments":false, "isRead":true, "isDraft":false,
            "flag":{"flagStatus":"flagged"}, "inferenceClassification":"focused",
            "categories":["Accounts"], "internetMessageId":"<[email protected]>"
        }))).mount(&server).await;
    Mock::given(method("GET"))
        .and(path("/v1.0/me/messages/m1/attachments"))
        .and(query_param(
            "$select",
            "id,name,contentType,size,microsoft.graph.fileAttachment/contentId",
        ))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"value":[{
            "id":"a1", "name":"logo.png", "contentType":"image/png", "contentId":"logo", "size":12
        }]})))
        .expect(1)
        .mount(&server)
        .await;
    let folder = MailFolder {
        id: ProviderId::new("folder").unwrap(),
        parent_id: None,
        name: "Boîte de réception".into(),
        role: FolderRole::Inbox,
        has_children: false,
    };
    let message = api
        .message(
            &token,
            Uuid::now_v7(),
            &ProviderId::new("m1").unwrap(),
            &[folder],
        )
        .await
        .unwrap()
        .unwrap();
    assert!(message.state.in_inbox);
    assert!(message.state.is_flagged);
    assert_eq!(message.state.attention, Attention::Primary);
    assert_eq!(message.tags, vec!["Accounts"]);
    assert_eq!(message.content.message.attachments.len(), 1);
    assert_eq!(
        message.content.message.attachments[0].content_id.as_deref(),
        Some("logo")
    );
    assert!(
        !message
            .content
            .message
            .body_html_sanitized
            .unwrap()
            .contains("<script")
    );
}

#[tokio::test]
async fn moves_return_the_provider_identity_with_immutable_id_preference() {
    let (server, api, token) = setup().await;
    Mock::given(method("POST"))
        .and(path("/v1.0/me/messages/m1/move"))
        .and(header("prefer", "IdType=\"ImmutableId\""))
        .respond_with(ResponseTemplate::new(201).set_body_json(json!({"id":"m1"})))
        .expect(1)
        .mount(&server)
        .await;
    let id = ProviderId::new("m1").unwrap();
    assert_eq!(
        api.apply_message_action(
            &token,
            &id,
            &MessageAction::MoveToFolder(ProviderId::new("archive").unwrap()),
            None,
        )
        .await
        .unwrap()
        .id,
        id
    );
}

#[tokio::test]
async fn deleting_a_missing_subscription_is_idempotent() {
    let (server, api, token) = setup().await;
    Mock::given(method("DELETE"))
        .respond_with(ResponseTemplate::new(404))
        .mount(&server)
        .await;
    api.remove_watch(&token, &ProviderId::new("subscription").unwrap())
        .await
        .unwrap();
}

#[tokio::test]
async fn categories_use_assignment_names_and_never_become_folder_roles() {
    use crate::domain::ports::MailboxLabelClient;
    let (server, api, token) = setup().await;
    Mock::given(method("GET"))
        .and(path("/v1.0/me/outlook/masterCategories"))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_json(json!({"value":[{"id":"opaque-catalog-id","displayName":"TRASH"}]})),
        )
        .mount(&server)
        .await;
    let labels = api.list_labels(&token, Uuid::now_v7()).await.unwrap();
    assert_eq!(labels[0].provider_label_id, "TRASH");
    assert!(matches!(
        labels[0].type_,
        Some(models_email::service::label::LabelType::User)
    ));
    Mock::given(method("DELETE"))
        .and(path("/v1.0/me/outlook/masterCategories/opaque-catalog-id"))
        .respond_with(ResponseTemplate::new(204))
        .expect(1)
        .mount(&server)
        .await;
    api.delete_label(&token, "TRASH").await.unwrap();
}

#[tokio::test]
async fn invitation_mime_parts_are_decoded_for_the_existing_calendar_parser() {
    use crate::domain::ports::MailboxCalendarClient;
    let (server, api, token) = setup().await;
    let mime = "MIME-Version: 1.0\r\nContent-Type: multipart/alternative; boundary=meeting\r\n\r\n--meeting\r\nContent-Type: text/plain\r\n\r\nMeeting\r\n--meeting\r\nContent-Type: text/calendar; method=REQUEST\r\nContent-Transfer-Encoding: quoted-printable\r\n\r\nBEGIN:VCALENDAR\r\nSUMMARY:Test=20meeting\r\nEND:VCALENDAR\r\n--meeting--\r\n";
    Mock::given(method("GET"))
        .and(path("/v1.0/me/messages/invitation/$value"))
        .respond_with(ResponseTemplate::new(200).set_body_string(mime))
        .expect(1)
        .mount(&server)
        .await;
    let parts = api.get_calendar_parts(&token, "invitation").await.unwrap();
    assert_eq!(parts.len(), 1);
    assert!(
        String::from_utf8(parts[0].inline_data.clone().unwrap())
            .unwrap()
            .contains("SUMMARY:Test meeting")
    );
}

#[tokio::test]
async fn read_authentication_retry_keeps_the_same_mailbox_generation() {
    use crate::domain::{
        ports::{AlwaysAllowRateLimiter, MailboxTokenSource},
        service::mailbox::MailboxApiService,
    };
    struct Tokens;
    impl MailboxTokenSource for Tokens {
        async fn access_token(
            &self,
            mailbox: MailboxAccess,
            freshness: TokenFreshness,
        ) -> Result<AccessToken, TokenError> {
            assert_eq!(mailbox.grant_generation, 7);
            Ok(AccessToken::new(match freshness {
                TokenFreshness::Cached => "expired",
                TokenFreshness::Fresh => "fresh",
            }))
        }
    }
    let (server, api, _) = setup().await;
    Mock::given(method("GET"))
        .and(header("authorization", "Bearer expired"))
        .respond_with(ResponseTemplate::new(401))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("GET")).and(header("authorization","Bearer fresh"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"value":[],"@odata.deltaLink":format!("{}/v1.0/me/mailFolders/folder/messages/delta?$deltatoken=opaque",server.uri())})))
        .expect(1).mount(&server).await;
    let service = MailboxApiService::new(api, Tokens, AlwaysAllowRateLimiter);
    service
        .changes(
            MailboxAccess {
                sync_generation: 1,
                link_id: Uuid::now_v7(),
                grant_generation: 7,
            },
            &ProviderId::new("folder").unwrap(),
            None,
        )
        .await
        .unwrap();
}

#[tokio::test]
async fn request_gate_covers_nested_pages_and_receives_provider_retry_after() {
    use crate::domain::ports::{MailboxLabelClient, MailboxRequestGate, ScopedMailboxRepository};
    use std::{
        future::Future,
        pin::Pin,
        sync::{Arc, Mutex},
        time::Duration,
    };
    struct Gate {
        mailbox: MailboxAccess,
        finished: Mutex<Vec<Option<Duration>>>,
    }
    impl MailboxRequestGate for Gate {
        fn acquire(
            &self,
            mailbox: MailboxAccess,
        ) -> Pin<Box<dyn Future<Output = Result<Uuid, EmailApiError>> + Send + '_>> {
            assert_eq!(mailbox, self.mailbox);
            Box::pin(async { Ok(Uuid::now_v7()) })
        }
        fn finish(
            &self,
            mailbox: MailboxAccess,
            _: Uuid,
            retry_after: Option<Duration>,
        ) -> Pin<Box<dyn Future<Output = ()> + Send + '_>> {
            assert_eq!(mailbox, self.mailbox);
            self.finished.lock().unwrap().push(retry_after);
            Box::pin(async {})
        }
        fn admitted(
            &self,
            _: MailboxAccess,
        ) -> Pin<Box<dyn Future<Output = Option<u64>> + Send + '_>> {
            Box::pin(async { None })
        }
    }
    let (server, mut api, token) = setup().await;
    let mailbox = MailboxAccess {
        sync_generation: 1,
        link_id: Uuid::now_v7(),
        grant_generation: 7,
    };
    let gate = Arc::new(Gate {
        mailbox,
        finished: Mutex::new(Vec::new()),
    });
    api.gate = Some(gate.clone());
    let api = api.for_mailbox(mailbox);
    Mock::given(method("GET")).and(path("/v1.0/me/outlook/masterCategories"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"value":[],"@odata.nextLink":format!("{}/v1.0/me/outlook/nextCategories",server.uri())})))
        .expect(1).mount(&server).await;
    Mock::given(method("GET"))
        .and(path("/v1.0/me/outlook/nextCategories"))
        .respond_with(ResponseTemplate::new(429).insert_header("Retry-After", "90"))
        .expect(1)
        .mount(&server)
        .await;
    assert!(matches!(
        api.list_labels(&token, mailbox.link_id).await,
        Err(EmailApiError::RateLimited { .. })
    ));
    assert_eq!(
        *gate.finished.lock().unwrap(),
        vec![None, Some(Duration::from_secs(90))]
    );
}

#[tokio::test]
async fn first_archive_provisions_a_marked_folder_then_recovers_it_on_retry() {
    use wiremock::matchers::body_partial_json;
    let (server, api, token) = setup().await;
    Mock::given(method("GET"))
        .and(path("/v1.0/me/mailFolders/archive"))
        .respond_with(ResponseTemplate::new(404))
        .mount(&server)
        .await;
    let listed = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
    let count = listed.clone();
    Mock::given(method("GET"))
        .and(path("/v1.0/me/mailFolders"))
        .respond_with(move |_: &wiremock::Request| {
            let value = if count.fetch_add(1, std::sync::atomic::Ordering::SeqCst) == 0 {
                json!([])
            } else {
                json!([{"id":"archive-created","displayName":"Macro Archive"}])
            };
            ResponseTemplate::new(200).set_body_json(json!({"value":value}))
        })
        .expect(2)
        .mount(&server)
        .await;
    Mock::given(method("POST")).and(path("/v1.0/me/mailFolders"))
        .and(body_partial_json(json!({"singleValueExtendedProperties":[{"id":"String {81f532e3-7ace-4e0b-bae9-312ce0d50c8c} Name MacroFolderRole","value":"archive"}]})))
        .respond_with(ResponseTemplate::new(201).set_body_json(json!({"id":"archive-created","displayName":"Macro Archive"}))).expect(1).mount(&server).await;
    Mock::given(method("POST"))
        .and(path("/v1.0/me/messages/m1/move"))
        .and(body_partial_json(
            json!({"destinationId":"archive-created"}),
        ))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"id":"m1"})))
        .expect(2)
        .mount(&server)
        .await;
    for _ in 0..2 {
        api.apply_message_action(
            &token,
            &ProviderId::new("m1").unwrap(),
            &MessageAction::Archive,
            None,
        )
        .await
        .unwrap();
    }
}

struct FreshToken;
impl crate::domain::ports::MailboxRejectedTokenRefresh for FreshToken {
    fn refresh(
        &self,
        _: MailboxAccess,
    ) -> std::pin::Pin<
        Box<dyn std::future::Future<Output = Result<AccessToken, EmailApiError>> + Send + '_>,
    > {
        Box::pin(async { Ok(AccessToken::new("fresh")) })
    }
}
#[tokio::test]
async fn rejected_token_retries_only_a_definitive_401_and_reuses_the_fresh_token() {
    let (server, api, token) = setup().await;
    let api = api
        .with_rejected_token_refresh(std::sync::Arc::new(FreshToken))
        .for_mailbox(MailboxAccess {
            link_id: Uuid::now_v7(),
            grant_generation: 1,
            sync_generation: 1,
        });
    Mock::given(method("PATCH"))
        .and(header("authorization", "Bearer test-bearer"))
        .respond_with(ResponseTemplate::new(401))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("PATCH"))
        .and(header("authorization", "Bearer fresh"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"id":"m1"})))
        .expect(2)
        .mount(&server)
        .await;
    for _ in 0..2 {
        api.apply_message_action(
            &token,
            &ProviderId::new("m1").unwrap(),
            &MessageAction::SetRead(true),
            None,
        )
        .await
        .unwrap();
    }
    server.reset().await;
    Mock::given(method("PATCH"))
        .respond_with(ResponseTemplate::new(503))
        .expect(1)
        .mount(&server)
        .await;
    assert!(
        api.apply_message_action(
            &token,
            &ProviderId::new("m1").unwrap(),
            &MessageAction::SetRead(true),
            None
        )
        .await
        .is_err()
    );
}

#[tokio::test]
async fn organization_patch_returns_the_exact_conditional_response_version() {
    let (server, api, token) = setup().await;
    Mock::given(method("PATCH"))
        .and(path("/v1.0/me/messages/m1"))
        .and(header("if-match", "W/\"before\""))
        .respond_with(
            ResponseTemplate::new(200)
                .set_body_json(json!({"id":"m1","@odata.etag":"W/\"after\""})),
        )
        .expect(1)
        .mount(&server)
        .await;
    let receipt = api
        .apply_message_action(
            &token,
            &ProviderId::new("m1").unwrap(),
            &MessageAction::SetFlagged(true),
            Some("W/\"before\""),
        )
        .await
        .unwrap();
    assert_eq!(receipt.id.as_str(), "m1");
    assert_eq!(receipt.version.as_deref(), Some("W/\"after\""));
}

#[test]
fn folder_subtrees_inherit_trash_without_becoming_move_destinations() {
    let folders = vec![
        MailFolder {
            id: ProviderId::new("trash").unwrap(),
            parent_id: None,
            name: "Trash".into(),
            role: FolderRole::Trash,
            has_children: true,
        },
        MailFolder {
            id: ProviderId::new("parent").unwrap(),
            parent_id: Some(ProviderId::new("trash").unwrap()),
            name: "Deleted project".into(),
            role: FolderRole::Other,
            has_children: true,
        },
        MailFolder {
            id: ProviderId::new("child").unwrap(),
            parent_id: Some(ProviderId::new("parent").unwrap()),
            name: "Invoices".into(),
            role: FolderRole::Other,
            has_children: false,
        },
    ];
    let source =
        serde_json::from_value(json!({"id":"m","conversationId":"c","parentFolderId":"child"}))
            .unwrap();
    let message = super::messages::normalize(source, Vec::new(), Uuid::new_v4(), &folders).unwrap();
    assert!(message.state.in_trash);
    assert_eq!(
        folders
            .iter()
            .filter(|folder| folder.role == FolderRole::Trash)
            .count(),
        1
    );
    let mut restored = folders;
    restored[1].parent_id = None;
    assert_eq!(
        MailFolder::effective_role(&restored, Some(&restored[2].id)),
        FolderRole::Other
    );
}

#[test]
fn reply_snippets_leave_out_the_quoted_message() {
    let snippet = |body: serde_json::Value| {
        let source = serde_json::from_value(json!({
            "id":"m","conversationId":"c","subject":"RE: Hello",
            "bodyPreview":"Preview with quoted history","body":body
        }))
        .unwrap();
        super::messages::normalize(source, Vec::new(), Uuid::new_v4(), &[])
            .unwrap()
            .content
            .message
            .snippet
    };
    assert_eq!(
        snippet(json!({"contentType":"html","content":concat!(
            "<html><body><div>Tell gab   I said\nhello</div>",
            "<div id=\"appendonsend\"></div><hr><div id=\"divRplyFwdMsg\">",
            "<b>From:</b> Teo<br><b>Sent:</b> Tuesday<br><b>To:</b> Gab<br>",
            "<b>Subject:</b> Hello</div><div>Original message</div></body></html>"
        )}))
        .as_deref(),
        Some("Tell gab I said hello")
    );
    assert_eq!(
        snippet(json!({"contentType":"text","content":
            "Me too\n\nOn Tue, Oct 20, 2026 at 3:00 PM Teo <[email protected]> wrote:\n> God I love outlook"
        }))
        .as_deref(),
        Some("Me too")
    );
}

#[tokio::test]
async fn cloud_reference_attachments_preserve_provider_open_without_download_bytes() {
    let (server, api, token) = setup().await;
    Mock::given(method("GET")).and(path("/v1.0/me/messages/m1"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"id":"m1","conversationId":"c","webLink":"https://outlook.live.com/mail/0/deeplink/read/message"}))).expect(1).mount(&server).await;
    Mock::given(method("GET")).and(path("/v1.0/me/messages/m1/attachments"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"value":[{"@odata.type":"#microsoft.graph.referenceAttachment","id":"cloud","name":"shared.pdf","contentType":"application/pdf","size":0,"isInline":false}]}))).expect(1).mount(&server).await;
    let message = api
        .message(&token, Uuid::new_v4(), &ProviderId::new("m1").unwrap(), &[])
        .await
        .unwrap()
        .unwrap();
    let attachment = &message.content.message.attachments[0];
    assert_eq!(
        attachment.reference_url.as_deref(),
        Some("https://outlook.live.com/mail/0/deeplink/read/message")
    );
    assert_eq!(attachment.filename.as_deref(), Some("shared.pdf"));
    assert!(attachment.data_url.is_none());
    assert_eq!(server.received_requests().await.unwrap().len(), 2);
}

#[tokio::test]
async fn message_mime_returns_the_original_bytes() {
    let (server, api, token) = setup().await;
    let mime = b"Subject: hi\r\n\r\nbody";
    Mock::given(method("GET"))
        .and(path("/v1.0/me/messages/message-1/$value"))
        .and(header("authorization", "Bearer test-bearer"))
        .respond_with(ResponseTemplate::new(200).set_body_bytes(&mime[..]))
        .expect(1)
        .mount(&server)
        .await;
    let bytes = api
        .mime(&token, &ProviderId::new("message-1").unwrap())
        .await
        .unwrap();
    assert_eq!(bytes, mime);
}