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.7 KB
Raw Blame
use super::{mark_message_as_sent, set_flags_from_labels};
use crate::messages::get::fetch_messages_metadata;
use crate::threads::get::get_thread_by_id_and_link_id;
use crate::threads::update::update_thread_metadata;
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use models_email::service::message::Message;
use sqlx::{PgConnection, PgPool, types::Uuid};

const LINK: Uuid = Uuid::from_u128(0x019a0000_0000_7000_8000_000000000001);
const OTHER_LINK: Uuid = Uuid::from_u128(0x019a0000_0000_7000_8000_000000000002);
const THREAD: Uuid = Uuid::from_u128(0x019a0000_0000_7000_8000_000000000101);
const PROVIDER_THREAD: Uuid = Uuid::from_u128(0x019a0000_0000_7000_8000_000000000102);
const MESSAGE: Uuid = Uuid::from_u128(0x019a0000_0000_7000_8000_000000000201);
const PROVIDER_MESSAGE: Uuid = Uuid::from_u128(0x019a0000_0000_7000_8000_000000000202);

async fn message(conn: &mut PgConnection, thread: Uuid) -> anyhow::Result<Message> {
    let messages = fetch_messages_metadata(conn, thread).await?;
    assert_eq!(messages.len(), 1);
    Ok(messages.into_iter().next().unwrap())
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(path = "../../../fixtures", scripts("mark_message_as_sent"))
)]
async fn sent_message_has_recency_before_provider_sync(pool: PgPool) -> anyhow::Result<()> {
    let mut tx = pool.begin().await?;
    let pending = message(tx.as_mut(), THREAD).await?;
    assert!(!pending.is_sent);
    assert!(pending.internal_date_ts.is_none());

    // These are the same two steps used by scheduled-delivery finalization,
    // before its transaction commits and the message_sent event is published.
    mark_message_as_sent(tx.as_mut(), "sent-message", "sent-thread", LINK, MESSAGE).await?;
    update_thread_metadata(tx.as_mut(), THREAD, LINK).await?;
    let sent = message(tx.as_mut(), THREAD).await?;
    assert!(sent.is_sent);
    assert!(!sent.is_draft);
    assert_eq!(sent.provider_id.as_deref(), Some("sent-message"));
    assert_eq!(sent.provider_thread_id.as_deref(), Some("sent-thread"));
    assert_eq!(sent.internal_date_ts, Some(sent.updated_at));
    assert!(sent.internal_date_ts > pending.sent_at);
    tx.commit().await?;

    // The Mail cache capsule and server Sent membership both use this field.
    // It must already exist without a subsequent Gmail inbox-sync pass.
    let thread = get_thread_by_id_and_link_id(&pool, THREAD, LINK)
        .await?
        .unwrap();
    assert_eq!(thread.latest_outbound_message_ts, sent.internal_date_ts);
    assert_eq!(thread.latest_non_spam_message_ts, sent.internal_date_ts);
    assert!(thread.latest_inbound_message_ts.is_none());
    assert!(!thread.inbox_visible);

    let mut retry = pool.begin().await?;
    mark_message_as_sent(retry.as_mut(), "sent-message", "sent-thread", LINK, MESSAGE).await?;
    assert_eq!(
        message(retry.as_mut(), THREAD).await?.internal_date_ts,
        sent.internal_date_ts,
        "replaying finalization must not move the message in Sent"
    );
    retry.commit().await?;
    Ok(())
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(path = "../../../fixtures", scripts("mark_message_as_sent"))
)]
async fn sent_message_preserves_provider_timestamp(pool: PgPool) -> anyhow::Result<()> {
    let mut tx = pool.begin().await?;
    let before = message(tx.as_mut(), PROVIDER_THREAD).await?;
    assert!(before.internal_date_ts.is_some());
    mark_message_as_sent(
        tx.as_mut(),
        "provider-message",
        "provider-thread",
        LINK,
        PROVIDER_MESSAGE,
    )
    .await?;
    update_thread_metadata(tx.as_mut(), PROVIDER_THREAD, LINK).await?;
    let sent = message(tx.as_mut(), PROVIDER_THREAD).await?;
    assert!(sent.is_sent);
    assert_eq!(sent.internal_date_ts, before.internal_date_ts);
    tx.commit().await?;

    let thread = get_thread_by_id_and_link_id(&pool, PROVIDER_THREAD, LINK)
        .await?
        .unwrap();
    assert_eq!(thread.latest_outbound_message_ts, before.internal_date_ts);
    Ok(())
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(path = "../../../fixtures", scripts("mark_message_as_sent"))
)]
async fn sent_message_update_is_scoped_to_its_inbox(pool: PgPool) -> anyhow::Result<()> {
    let mut tx = pool.begin().await?;
    mark_message_as_sent(
        tx.as_mut(),
        "wrong-message",
        "wrong-thread",
        OTHER_LINK,
        MESSAGE,
    )
    .await?;
    let unchanged = message(tx.as_mut(), THREAD).await?;
    assert!(!unchanged.is_sent);
    assert!(unchanged.internal_date_ts.is_none());
    assert!(unchanged.provider_id.is_none());
    tx.commit().await?;
    Ok(())
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(path = "../../../fixtures", scripts("mark_message_as_sent"))
)]
async fn failed_finalization_rolls_back_sent_recency(pool: PgPool) -> anyhow::Result<()> {
    let mut tx = pool.begin().await?;
    mark_message_as_sent(tx.as_mut(), "sent-message", "sent-thread", LINK, MESSAGE).await?;
    update_thread_metadata(tx.as_mut(), THREAD, LINK).await?;
    tx.rollback().await?;

    let mut conn = pool.acquire().await?;
    let unchanged = message(&mut conn, THREAD).await?;
    assert!(!unchanged.is_sent);
    assert!(unchanged.internal_date_ts.is_none());
    let thread = get_thread_by_id_and_link_id(&pool, THREAD, LINK)
        .await?
        .unwrap();
    assert!(thread.latest_outbound_message_ts.is_none());
    Ok(())
}

async fn row_version(pool: &PgPool) -> anyhow::Result<String> {
    Ok(sqlx::query_scalar!(
        r#"SELECT xmin::text AS "xmin!" FROM email_messages WHERE id = $1"#,
        MESSAGE
    )
    .fetch_one(pool)
    .await?)
}

#[sqlx::test(
    migrator = "MACRO_DB_MIGRATIONS",
    fixtures(path = "../../../fixtures", scripts("mark_message_as_sent"))
)]
async fn flags_that_already_match_their_labels_are_not_rewritten(
    pool: PgPool,
) -> anyhow::Result<()> {
    // The message has neither UNREAD nor STARRED: it is read and not starred.
    sqlx::query!(
        "UPDATE email_messages SET is_read = true, is_starred = false WHERE id = $1",
        MESSAGE
    )
    .execute(&pool)
    .await?;
    let before = row_version(&pool).await?;

    let mut tx = pool.begin().await?;
    set_flags_from_labels(tx.as_mut(), MESSAGE, true, true).await?;
    tx.commit().await?;
    assert_eq!(row_version(&pool).await?, before);

    sqlx::query!(
        "UPDATE email_messages SET is_read = false WHERE id = $1",
        MESSAGE
    )
    .execute(&pool)
    .await?;
    let mut tx = pool.begin().await?;
    set_flags_from_labels(tx.as_mut(), MESSAGE, true, false).await?;
    tx.commit().await?;
    let is_read = sqlx::query_scalar!("SELECT is_read FROM email_messages WHERE id = $1", MESSAGE)
        .fetch_one(&pool)
        .await?;
    assert!(is_read);
    Ok(())
}