Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use crate::messages::delete::MessageDeletion;
use crate::messages::get::{draft_exists_with_id, filter_existing_provider_message_ids};
use crate::messages::scheduled::get::get_scheduled_db_messages_by_link_id;
use macro_db_migrator::MACRO_DB_MIGRATIONS;
use sqlx::types::Uuid;
use sqlx::{Pool, Postgres};
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("draft_exists_with_id"))
)]
async fn draft_exists_with_id_returns_true_for_existing_draft(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
const _: &sqlx::migrate::Migrator = &MACRO_DB_MIGRATIONS;
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000e01")?;
let draft_id = Uuid::parse_str("00000000-0000-0000-0000-00000000e501")?;
let exists = draft_exists_with_id(&pool, link_id, draft_id).await?;
assert!(exists);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("draft_exists_with_id"))
)]
async fn draft_exists_with_id_returns_false_for_non_draft_message(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000e01")?;
let non_draft_id = Uuid::parse_str("00000000-0000-0000-0000-00000000e502")?;
let exists = draft_exists_with_id(&pool, link_id, non_draft_id).await?;
assert!(!exists);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("draft_exists_with_id"))
)]
async fn draft_exists_with_id_returns_false_for_wrong_link_id(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let wrong_link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000e02")?;
let draft_id = Uuid::parse_str("00000000-0000-0000-0000-00000000e501")?;
let exists = draft_exists_with_id(&pool, wrong_link_id, draft_id).await?;
assert!(!exists);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("draft_exists_with_id"))
)]
async fn draft_exists_with_id_returns_false_for_nonexistent_message(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000e01")?;
let nonexistent_id = Uuid::parse_str("00000000-0000-0000-0000-00000000efff")?;
let exists = draft_exists_with_id(&pool, link_id, nonexistent_id).await?;
assert!(!exists);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_returns_unsent_only(pool: Pool<Postgres>) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 100).await?;
// Should return 3 unsent scheduled messages
assert_eq!(result.len(), 3);
// Verify all returned messages are unsent scheduled messages
let returned_ids: Vec<Uuid> = result.iter().map(|m| m.id).collect();
let unsent_1 = Uuid::parse_str("00000000-0000-0000-0000-0000000d0001")?;
let unsent_2 = Uuid::parse_str("00000000-0000-0000-0000-0000000d0002")?;
let unsent_3 = Uuid::parse_str("00000000-0000-0000-0000-0000000d0003")?;
assert!(
returned_ids.contains(&unsent_1),
"Should include unsent message 1"
);
assert!(
returned_ids.contains(&unsent_2),
"Should include unsent message 2"
);
assert!(
returned_ids.contains(&unsent_3),
"Should include unsent message 3"
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_excludes_sent_messages(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 100).await?;
let returned_ids: Vec<Uuid> = result.iter().map(|m| m.id).collect();
// Already sent scheduled message should NOT be included
let sent_msg = Uuid::parse_str("00000000-0000-0000-0000-0000000d0004")?;
assert!(
!returned_ids.contains(&sent_msg),
"Should not include already sent message"
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_excludes_non_scheduled_messages(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 100).await?;
let returned_ids: Vec<Uuid> = result.iter().map(|m| m.id).collect();
// Regular non-scheduled message should NOT be included
let regular_msg = Uuid::parse_str("00000000-0000-0000-0000-0000000d0005")?;
assert!(
!returned_ids.contains(®ular_msg),
"Should not include non-scheduled message"
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_excludes_immediate_send_undo_rows(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
let immediate_send_id = Uuid::parse_str("00000000-0000-0000-0000-0000000d0001")?;
sqlx::query!(
"UPDATE email_messages SET is_draft = false WHERE id = $1",
immediate_send_id
)
.execute(&pool)
.await?;
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 100).await?;
assert!(
result.iter().all(|message| message.id != immediate_send_id),
"Immediate-send undo rows are not user-created scheduled drafts"
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_isolates_by_link_id(pool: Pool<Postgres>) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 100).await?;
let returned_ids: Vec<Uuid> = result.iter().map(|m| m.id).collect();
// Message from other link should NOT be included
let other_link_msg = Uuid::parse_str("00000000-0000-0000-0000-0000000d0006")?;
assert!(
!returned_ids.contains(&other_link_msg),
"Should not include messages from other links"
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_orders_by_created_at_desc(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 100).await?;
// Should be ordered by created_at DESC (newest first)
assert_eq!(
result[0].subject,
Some("Newest scheduled message".to_string())
);
assert_eq!(
result[1].subject,
Some("Middle scheduled message".to_string())
);
assert_eq!(
result[2].subject,
Some("Oldest scheduled message".to_string())
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_respects_limit(pool: Pool<Postgres>) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
// Request only 2 messages
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 2).await?;
assert_eq!(result.len(), 2);
// Should return the 2 newest (ordered by created_at DESC)
assert_eq!(
result[0].subject,
Some("Newest scheduled message".to_string())
);
assert_eq!(
result[1].subject,
Some("Middle scheduled message".to_string())
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_respects_offset(pool: Pool<Postgres>) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
// Skip first 2 messages
let result = get_scheduled_db_messages_by_link_id(&pool, link_id, 2, 100).await?;
assert_eq!(result.len(), 1);
// Should return only the oldest message
assert_eq!(
result[0].subject,
Some("Oldest scheduled message".to_string())
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_pagination_works(pool: Pool<Postgres>) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001")?;
// Page 1: limit 1, offset 0
let page1 = get_scheduled_db_messages_by_link_id(&pool, link_id, 0, 1).await?;
assert_eq!(page1.len(), 1);
assert_eq!(
page1[0].subject,
Some("Newest scheduled message".to_string())
);
// Page 2: limit 1, offset 1
let page2 = get_scheduled_db_messages_by_link_id(&pool, link_id, 1, 1).await?;
assert_eq!(page2.len(), 1);
assert_eq!(
page2[0].subject,
Some("Middle scheduled message".to_string())
);
// Page 3: limit 1, offset 2
let page3 = get_scheduled_db_messages_by_link_id(&pool, link_id, 2, 1).await?;
assert_eq!(page3.len(), 1);
assert_eq!(
page3[0].subject,
Some("Oldest scheduled message".to_string())
);
// Page 4: limit 1, offset 3 (no more results)
let page4 = get_scheduled_db_messages_by_link_id(&pool, link_id, 3, 1).await?;
assert!(page4.is_empty());
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_scheduled_db_messages"))
)]
async fn get_scheduled_db_messages_returns_empty_for_nonexistent_link(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let nonexistent_link_id = Uuid::parse_str("00000000-0000-0000-0000-999999999999")?;
let result = get_scheduled_db_messages_by_link_id(&pool, nonexistent_link_id, 0, 100).await?;
assert!(result.is_empty());
Ok(())
}
async fn fetch_calendar_flag(pool: &Pool<Postgres>, thread_id: Uuid) -> anyhow::Result<bool> {
Ok(sqlx::query_scalar!(
"SELECT has_calendar_attachment FROM email_threads WHERE id = $1",
thread_id
)
.fetch_one(pool)
.await?)
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("sync_thread_calendar_flag"))
)]
async fn delete_message_clears_calendar_flag_when_last_ics_message_removed(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let thread_id = Uuid::parse_str("00000000-0000-0000-0000-00000000b201")?;
let ics_message_id = Uuid::parse_str("00000000-0000-0000-0000-00000000b501")?;
let fusionauth_user_id = "00000000-0000-0000-0000-000000000b01";
// Establish the flag from the fixture's .ics attachment.
let mut conn = pool.acquire().await?;
crate::threads::update::sync_thread_calendar_flag(&mut conn, thread_id).await?;
drop(conn);
assert!(fetch_calendar_flag(&pool, thread_id).await?);
let message = crate::messages::get_simple_messages::get_simple_message(
&pool,
&ics_message_id,
fusionauth_user_id,
)
.await?
.expect("fixture message present");
let mut tx = pool.begin().await?;
let deletion = crate::messages::delete::delete_message_with_tx(&mut tx, &message).await?;
tx.commit().await?;
// The thread survives (a second message remains) and the flag flips off
// because its attachments cascaded away with the message.
assert_eq!(
deletion,
MessageDeletion::Deleted {
deleted_thread: None
}
);
assert!(!fetch_calendar_flag(&pool, thread_id).await?);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("sync_thread_calendar_flag"))
)]
async fn delete_message_reports_already_deleted_message(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let ics_message_id = Uuid::parse_str("00000000-0000-0000-0000-00000000b501")?;
let fusionauth_user_id = "00000000-0000-0000-0000-000000000b01";
let message = crate::messages::get_simple_messages::get_simple_message(
&pool,
&ics_message_id,
fusionauth_user_id,
)
.await?
.expect("fixture message present");
let mut conn = pool.acquire().await?;
let first = crate::messages::delete::delete_message_with_tx(&mut conn, &message).await?;
let second = crate::messages::delete::delete_message_with_tx(&mut conn, &message).await?;
assert!(matches!(first, MessageDeletion::Deleted { .. }));
assert_eq!(second, MessageDeletion::AlreadyDeleted);
Ok(())
}
const READ_STATUS_LINK: &str = "00000000-0000-0000-0000-000000000e11";
const READ_STATUS_OTHER_LINK: &str = "00000000-0000-0000-0000-000000000e12";
const READ_STATUS_MSG_A: &str = "00000000-0000-0000-0000-00000000e611";
const READ_STATUS_MSG_B: &str = "00000000-0000-0000-0000-00000000e612";
const READ_STATUS_OTHER_MSG: &str = "00000000-0000-0000-0000-00000000e613";
async fn fetch_is_read(pool: &Pool<Postgres>, message_id: Uuid) -> anyhow::Result<bool> {
Ok(sqlx::query_scalar!(
"SELECT is_read FROM email_messages WHERE id = $1",
message_id
)
.fetch_one(pool)
.await?)
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("message_read_status"))
)]
async fn update_message_read_status_batch_marks_messages_read(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str(READ_STATUS_LINK)?;
let message_ids = vec![
Uuid::parse_str(READ_STATUS_MSG_A)?,
Uuid::parse_str(READ_STATUS_MSG_B)?,
];
let updated = crate::messages::update::update_message_read_status_batch(
&pool,
message_ids.clone(),
link_id,
true,
)
.await?;
assert_eq!(updated, 2);
for id in message_ids {
assert!(fetch_is_read(&pool, id).await?);
}
Ok(())
}
/// The inbox that owns a thread is not always owned by the macro user acting on it:
/// shared and delegated inboxes are owned by a separate fusion user. Scoping this
/// update by anything other than the link silently matched zero rows, leaving
/// `is_read` diverged from the labels and the denormalized thread flag.
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("message_read_status"))
)]
async fn update_message_read_status_batch_scopes_to_owning_link(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let other_link_id = Uuid::parse_str(READ_STATUS_OTHER_LINK)?;
let message_id = Uuid::parse_str(READ_STATUS_MSG_A)?;
// Ids that belong to a different link than the one supplied must not be updated,
// and the mismatch is loud rather than silently absorbed.
let result = crate::messages::update::update_message_read_status_batch(
&pool,
vec![message_id],
other_link_id,
true,
)
.await;
assert!(result.is_err());
assert!(!fetch_is_read(&pool, message_id).await?);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("message_read_status"))
)]
async fn update_message_read_status_batch_leaves_other_inboxes_untouched(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str(READ_STATUS_LINK)?;
let other_message_id = Uuid::parse_str(READ_STATUS_OTHER_MSG)?;
let updated = crate::messages::update::update_message_read_status_batch(
&pool,
vec![Uuid::parse_str(READ_STATUS_MSG_A)?],
link_id,
true,
)
.await?;
assert_eq!(updated, 1);
assert!(!fetch_is_read(&pool, other_message_id).await?);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("message_read_status"))
)]
async fn update_message_read_status_ignores_wrong_link(pool: Pool<Postgres>) -> anyhow::Result<()> {
let other_link_id = Uuid::parse_str(READ_STATUS_OTHER_LINK)?;
let message_id = Uuid::parse_str(READ_STATUS_MSG_A)?;
let mut conn = pool.acquire().await?;
let updated = crate::messages::update::update_message_read_status(
&mut conn,
message_id,
other_link_id,
true,
)
.await?;
assert!(updated.is_none());
assert!(!fetch_is_read(&pool, message_id).await?);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("draft_exists_with_id"))
)]
async fn filter_existing_provider_message_ids_partitions_known_and_missing(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
let link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000e01")?;
let other_link_id = Uuid::parse_str("00000000-0000-0000-0000-000000000e02")?;
let requested = vec![
"provider-msg-e501".to_string(),
"provider-msg-e502".to_string(),
"provider-msg-missing".to_string(),
];
let existing = filter_existing_provider_message_ids(&pool, link_id, &requested).await?;
assert!(existing.contains("provider-msg-e501"));
assert!(existing.contains("provider-msg-e502"));
assert!(!existing.contains("provider-msg-missing"));
assert_eq!(existing.len(), 2);
// Messages belong to the first link only.
let cross_link = filter_existing_provider_message_ids(&pool, other_link_id, &requested).await?;
assert!(cross_link.is_empty());
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("draft_exists_with_id"))
)]
async fn parsed_reads_preserve_restored_draft_generation(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
use crate::messages::get_parsed::{
get_paginated_parsed_messages_by_thread_id, get_parsed_message_by_id,
get_parsed_messages_by_id_batch,
};
let draft_id = Uuid::parse_str("00000000-0000-0000-0000-00000000e501")?;
sqlx::query!(
"UPDATE email_messages SET draft_generation = 2 WHERE id = $1",
draft_id
)
.execute(&pool)
.await?;
let single = get_parsed_message_by_id(&pool, &draft_id).await?.unwrap();
assert_eq!(single.draft_generation, 2);
assert_eq!(serde_json::to_value(&single)?["draft_generation"], 2);
let batch = get_parsed_messages_by_id_batch(&pool, &[draft_id]).await?;
assert_eq!(batch[0].draft_generation, 2);
let page =
get_paginated_parsed_messages_by_thread_id(&pool, single.thread_db_id, 0, 100).await?;
assert_eq!(
page.iter()
.find(|message| message.db_id == draft_id)
.unwrap()
.draft_generation,
2
);
Ok(())
}
#[sqlx::test(
migrator = "MACRO_DB_MIGRATIONS",
fixtures(path = "../../fixtures", scripts("get_thread_summary_info"))
)]
async fn get_message_sender_and_pretty_sender_skips_messages_without_sender_contact(
pool: Pool<Postgres>,
) -> anyhow::Result<()> {
const _: &sqlx::migrate::Migrator = &MACRO_DB_MIGRATIONS;
let link_id = Uuid::parse_str("00000000-0000-0000-0000-00000000001c")?;
let thread_id = Uuid::parse_str("00000000-0000-0000-0000-000000000301")?;
let with_contact_id = Uuid::parse_str("00000000-0000-0000-0000-0000000e0601")?;
let without_contact_id = Uuid::parse_str("00000000-0000-0000-0000-0000000e0626")?;
sqlx::query!(
r#"
INSERT INTO email_messages (id, thread_id, link_id, is_draft, is_sent, from_contact_id)
VALUES ($1, $2, $3, false, false, NULL)
"#,
without_contact_id,
thread_id,
link_id
)
.execute(&pool)
.await?;
let senders = crate::messages::get::get_message_sender_and_pretty_sender(
&pool,
&[link_id],
&[with_contact_id, without_contact_id],
)
.await?;
assert_eq!(senders.len(), 1);
assert!(!senders.contains_key(&without_contact_id));
let sender = senders.get(&with_contact_id).unwrap();
assert_eq!(sender.sender, "[email protected]");
assert_eq!(sender.pretty_sender, "Alice Smith");
Ok(())
}