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 super::*;
use email_api_client::domain::models::FolderRole;
use macro_db_migrator::MACRO_DB_MIGRATIONS;
pub(super) async fn fixture(db: &PgPool) -> (PgMailboxSync, Uuid) {
let link = macro_uuid::generate_uuid_v7();
sqlx::query!(r#"
INSERT INTO email_links (id,macro_id,fusionauth_user_id,email_address,provider,grant_generation)
VALUES ($1,'macro|[email protected]','outlook-owner','[email protected]','OUTLOOK',1)
"#,link).execute(db).await.unwrap();
sqlx::query!(
r#"
INSERT INTO email_sync_streams (id,link_id,generation,kind,scope_id)
VALUES ($1,$2,1,'mail_folder','folder')
"#,
macro_uuid::generate_uuid_v7(),
link
)
.execute(db)
.await
.unwrap();
(PgMailboxSync::new(db.clone()), link)
}
pub(super) fn page() -> MailboxChangePage {
MailboxChangePage {
changed: vec![ProviderId::new("a").unwrap(), ProviderId::new("b").unwrap()],
removed: vec![
ProviderId::new("b").unwrap(),
ProviderId::new("moved").unwrap(),
],
position: StreamPosition::Checkpoint(StreamToken::new("opaque-checkpoint".into())),
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn checkpoint_commits_with_deduplicated_changes_and_folder_removals(db: PgPool) {
let (repo, link) = fixture(&db).await;
let lease = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&lease, &page()).await.unwrap();
let row = sqlx::query!(
"SELECT position,initial_complete,lease_id FROM email_sync_streams WHERE id = $1",
lease.id
)
.fetch_one(&db)
.await
.unwrap();
assert_eq!(row.position.as_deref(), Some("opaque-checkpoint"));
assert!(row.initial_complete);
assert!(row.lease_id.is_none());
let jobs = sqlx::query!("SELECT provider_id,is_import FROM email_message_reconciliation WHERE link_id = $1 ORDER BY provider_id",link).fetch_all(&db).await.unwrap();
assert_eq!(
jobs.iter()
.map(|row| row.provider_id.as_str())
.collect::<Vec<_>>(),
vec!["a", "b", "moved"]
);
assert!(jobs.iter().all(|row| row.is_import));
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn stale_worker_cannot_advance_cursor_or_enqueue_work(db: PgPool) {
let (repo, link) = fixture(&db).await;
let stale = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
sqlx::query!(
"UPDATE email_sync_streams SET lease_until = now() - interval '1 second' WHERE id = $1",
stale.id
)
.execute(&db)
.await
.unwrap();
let current = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
assert!(current.fence > stale.fence);
assert!(matches!(
repo.commit_page(&stale, &page()).await,
Err(MailboxError::Stale)
));
let count = sqlx::query_scalar!(
"SELECT count(*) FROM email_message_reconciliation WHERE link_id = $1",
link
)
.fetch_one(&db)
.await
.unwrap();
assert_eq!(count, Some(0));
repo.commit_page(¤t, &page()).await.unwrap();
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn wakeup_arriving_during_reconciliation_survives_old_acknowledgement(db: PgPool) {
let (repo, _) = fixture(&db).await;
let stream = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&stream, &page()).await.unwrap();
let work = repo
.claim_message(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
sqlx::query!(
"UPDATE email_sync_streams SET next_run_at = now() WHERE id = $1",
stream.id
)
.execute(&db)
.await
.unwrap();
let stream = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&stream, &page()).await.unwrap();
repo.complete_message(&work).await.unwrap();
let row = sqlx::query!("SELECT revision,lease_id,is_import FROM email_message_reconciliation WHERE link_id = $1 AND provider_id = $2",work.mailbox.link_id,work.provider_id.as_str()).fetch_one(&db).await.unwrap();
assert_eq!(row.revision, work.revision + 1);
assert!(row.lease_id.is_none());
assert!(!row.is_import);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn expired_stream_reset_preserves_other_streams_and_pending_work(db: PgPool) {
let (repo, link) = fixture(&db).await;
let stream = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&stream, &page()).await.unwrap();
let known = repo
.claim_message(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.ingest(
&known,
snapshot(link, known.provider_id.as_str(), Default::default(), "v1"),
)
.await
.unwrap();
repo.complete_message(&known).await.unwrap();
sqlx::query!(
"UPDATE email_sync_streams SET next_run_at = now(),attachments_rechecked=true WHERE id = $1",
stream.id
)
.execute(&db)
.await
.unwrap();
let lease = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.reset_stream(&lease).await.unwrap();
let row = sqlx::query!(
"SELECT position,initial_complete,attachments_rechecked FROM email_sync_streams WHERE id = $1",
stream.id
)
.fetch_one(&db)
.await
.unwrap();
assert!(row.position.is_none());
assert!(!row.initial_complete);
assert!(!row.attachments_rechecked);
let recheck = sqlx::query_scalar!("SELECT is_import FROM email_message_reconciliation WHERE link_id = $1 AND provider_id = $2",link,known.provider_id.as_str()).fetch_one(&db).await.unwrap();
assert!(recheck);
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM email_message_reconciliation WHERE link_id = $1",
link
)
.fetch_one(&db)
.await
.unwrap(),
Some(3)
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn complete_catalog_resolves_roles_and_creates_folder_streams(db: PgPool) {
let (repo, link) = fixture(&db).await;
sqlx::query!("INSERT INTO email_sync_streams (id,link_id,generation,kind,scope_id) VALUES ($1,$2,1,'folder_catalog','mail')",macro_uuid::generate_uuid_v7(),link).execute(&db).await.unwrap();
let lease = repo
.claim_catalog(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_catalog(
&lease,
&[MailFolder {
id: ProviderId::new("inbox-id").unwrap(),
parent_id: None,
name: "Boîte de réception".into(),
role: FolderRole::Inbox,
has_children: false,
}],
)
.await
.unwrap();
let folders = repo.folders(lease.mailbox).await.unwrap();
assert_eq!(folders.len(), 1);
assert_eq!(folders[0].role, FolderRole::Inbox);
let count = sqlx::query_scalar!("SELECT count(*) FROM email_sync_streams WHERE link_id = $1 AND kind = 'mail_folder' AND scope_id = 'inbox-id'",link).fetch_one(&db).await.unwrap();
assert_eq!(count, Some(1));
assert!(matches!(
repo.commit_catalog(&lease, &[]).await,
Err(MailboxError::Stale)
));
assert_eq!(repo.folders(lease.mailbox).await.unwrap().len(), 1);
}
pub(super) fn snapshot(
link_id: Uuid,
provider_id: &str,
state: email_api_client::domain::models::MailboxState,
version: &str,
) -> email_api_client::domain::models::MailboxMessage {
use email_api_client::domain::models::{MailboxMessage, MessageWithCalendarParts};
let message = serde_json::from_value(serde_json::json!({
"db_id":macro_uuid::generate_uuid_v7(),"thread_db_id":macro_uuid::generate_uuid_v7(),"link_id":link_id,
"provider_id":provider_id,"provider_thread_id":"conversation","subject":"Outlook message",
"internal_date_ts":"2026-10-01T12:00:00Z","body_text":"retained content",
"is_read":state.is_read,"is_starred":state.is_flagged,"is_draft":state.is_draft,"is_sent":false,"has_attachments":false,
"to":[],"cc":[],"bcc":[],"labels":[],"attachments":[],"attachments_draft":[],"attachments_forwarded":[],
"created_at":"2026-10-01T12:00:00Z","updated_at":"2026-10-01T12:00:00Z"
})).unwrap();
MailboxMessage {
draft_correlation: None,
content: MessageWithCalendarParts {
message,
calendar_parts: Vec::new(),
},
state,
folder_id: Some(ProviderId::new("folder").unwrap()),
tags: vec!["TRASH".into()],
version: Some(version.into()),
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn ingestion_commits_content_state_and_outbox_without_treating_categories_as_folders(
db: PgPool,
) {
use email_api_client::domain::models::{Attention, MailboxState};
let (repo, link) = fixture(&db).await;
let stream = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&stream, &page()).await.unwrap();
let work = repo
.claim_message(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
let state = MailboxState {
in_inbox: true,
attention: Attention::Primary,
..Default::default()
};
repo.ingest(
&work,
snapshot(link, work.provider_id.as_str(), state.clone(), "v1"),
)
.await
.unwrap();
repo.ingest(
&work,
snapshot(link, work.provider_id.as_str(), state, "v1"),
)
.await
.unwrap();
let row = sqlx::query!("SELECT m.body_text,t.inbox_visible,t.is_signal FROM email_messages m JOIN email_threads t ON t.id = m.thread_id WHERE m.link_id = $1 AND m.provider_id = $2",link,work.provider_id.as_str()).fetch_one(&db).await.unwrap();
assert_eq!(row.body_text.as_deref(), Some("retained content"));
assert!(row.inbox_visible);
assert!(row.is_signal);
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM email_projection_outbox WHERE link_id = $1",
link
)
.fetch_one(&db)
.await
.unwrap(),
Some(1)
);
repo.absent(&work).await.unwrap();
let row = sqlx::query!("SELECT m.body_text,t.inbox_visible FROM email_messages m JOIN email_threads t ON t.id = m.thread_id WHERE m.link_id = $1 AND m.provider_id = $2",link,work.provider_id.as_str()).fetch_one(&db).await.unwrap();
assert_eq!(row.body_text.as_deref(), Some("retained content"));
assert!(!row.inbox_visible);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn stale_ingestion_cannot_overwrite_a_reconnected_mailbox(db: PgPool) {
let (repo, link) = fixture(&db).await;
let stream = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&stream, &page()).await.unwrap();
let work = repo
.claim_message(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
sqlx::query!(
"UPDATE email_links SET sync_generation = sync_generation + 1 WHERE id = $1",
link
)
.execute(&db)
.await
.unwrap();
assert!(matches!(
repo.ingest(
&work,
snapshot(link, work.provider_id.as_str(), Default::default(), "v1")
)
.await,
Err(MailboxError::Stale)
));
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM email_messages WHERE link_id = $1",
link
)
.fetch_one(&db)
.await
.unwrap(),
Some(0)
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn projection_ack_keeps_version_watermark_and_exposes_normalized_state(db: PgPool) {
use crate::domain::mailbox::projection::MailboxProjectionRepository;
let (repo, link) = fixture(&db).await;
let stream = repo
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
repo.commit_page(&stream, &page()).await.unwrap();
let work = repo
.claim_message(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
let state = email_api_client::domain::models::MailboxState {
in_inbox: true,
..Default::default()
};
repo.ingest(
&work,
snapshot(link, work.provider_id.as_str(), state.clone(), "v1"),
)
.await
.unwrap();
let event = repo
.claim_projection(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
let context = repo.projection_context(&event).await.unwrap().unwrap();
let message = context.message.unwrap();
assert!(message.in_inbox);
assert!(
!message.in_trash,
"user category TRASH is not a physical trash folder"
);
assert!(message.is_present);
repo.renew_projection(&event).await.unwrap();
repo.finish_projection(&event, None).await.unwrap();
repo.ingest(
&work,
snapshot(link, work.provider_id.as_str(), state, "v1"),
)
.await
.unwrap();
assert!(
repo.claim_projection(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.is_none()
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn projection_crash_reclaims_work_and_old_worker_cannot_ack_successor(db: PgPool) {
use crate::domain::mailbox::projection::MailboxProjectionRepository;
let (repo, link) = fixture(&db).await;
let payload = serde_json::json!({"kind":"link_connected","actor_id":"macro|[email protected]","is_new":true});
sqlx::query!(
"INSERT INTO email_projection_outbox (id,link_id,generation,payload) VALUES ($1,$2,1,$3)",
macro_uuid::generate_uuid_v7(),
link,
payload
)
.execute(&db)
.await
.unwrap();
let old = repo
.claim_projection(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
sqlx::query!("UPDATE email_projection_outbox SET lease_until = now() - interval '1 second' WHERE id = $1",old.id).execute(&db).await.unwrap();
let successor = repo
.claim_projection(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
assert!(matches!(
repo.renew_projection(&old).await,
Err(MailboxError::Stale)
));
repo.finish_projection(&old, None).await.unwrap();
assert_eq!(
sqlx::query_scalar!(
"SELECT count(*) FROM email_projection_outbox WHERE id = $1",
old.id
)
.fetch_one(&db)
.await
.unwrap(),
Some(1)
);
repo.finish_projection(&successor, None).await.unwrap();
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn mailbox_previews_distinguish_categories_trash_and_imported_drafts(db: PgPool) {
use crate::domain::{
models::{PreviewCursorQuery, PreviewView, PreviewViewStandardLabel},
ports::EmailRepo,
};
use macro_user_id::user_id::MacroUserIdStr;
use models_pagination::{Query, SimpleSortMethod};
let (sync, link) = fixture(&db).await;
let stream = sync
.claim_stream(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
sync.commit_page(&stream, &page()).await.unwrap();
let work = sync
.claim_message(macro_uuid::generate_uuid_v7())
.await
.unwrap()
.unwrap();
let repo = crate::outbound::EmailPgRepo::new(db.clone());
let state = email_api_client::domain::models::MailboxState {
in_inbox: true,
..Default::default()
};
sync.ingest(
&work,
snapshot(link, work.provider_id.as_str(), state, "one"),
)
.await
.unwrap();
let read = |view| {
repo.previews_for_view_cursor(
PreviewCursorQuery {
view: PreviewView::StandardLabel(view),
link_ids: vec![link],
limit: 50,
query: Query::new(None, SimpleSortMethod::UpdatedAt, None),
team_id: None,
},
MacroUserIdStr::try_from_email("[email protected]").unwrap(),
)
};
assert_eq!(
read(PreviewViewStandardLabel::Inbox).await.unwrap().len(),
1,
"a TRASH category is still inbox mail"
);
assert_eq!(read(PreviewViewStandardLabel::All).await.unwrap().len(), 1);
sync.ingest(
&work,
snapshot(
link,
work.provider_id.as_str(),
email_api_client::domain::models::MailboxState {
in_trash: true,
..Default::default()
},
"two",
),
)
.await
.unwrap();
assert!(
read(PreviewViewStandardLabel::Inbox)
.await
.unwrap()
.is_empty()
);
assert!(
read(PreviewViewStandardLabel::All)
.await
.unwrap()
.is_empty()
);
sync.ingest(
&work,
snapshot(
link,
work.provider_id.as_str(),
email_api_client::domain::models::MailboxState {
is_draft: true,
..Default::default()
},
"three",
),
)
.await
.unwrap();
assert_eq!(
read(PreviewViewStandardLabel::Drafts).await.unwrap().len(),
1,
"imported drafts have provider timestamps"
);
sync.absent(&work).await.unwrap();
assert!(
read(PreviewViewStandardLabel::Drafts)
.await
.unwrap()
.is_empty(),
"a deleted remote draft must disappear unless a local edit needs recovery"
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn folder_delete_and_restore_reprojects_unchanged_message_etags(db: PgPool) {
use email_api_client::domain::models::MailboxState;
let (repo, link) = fixture(&db).await;
sqlx::query!("INSERT INTO email_sync_streams(id,link_id,generation,kind,scope_id) VALUES($1,$2,1,'folder_catalog','mail')",Uuid::new_v4(),link).execute(&db).await.unwrap();
let mut 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: None,
name: "Projects".into(),
role: FolderRole::Other,
has_children: true,
},
MailFolder {
id: ProviderId::new("folder").unwrap(),
parent_id: Some(ProviderId::new("parent").unwrap()),
name: "Invoices".into(),
role: FolderRole::Other,
has_children: false,
},
];
let catalog = repo.claim_catalog(Uuid::new_v4()).await.unwrap().unwrap();
repo.commit_catalog(&catalog, &folders).await.unwrap();
sqlx::query!("INSERT INTO email_message_reconciliation(link_id,generation,provider_id,is_import) VALUES($1,1,'same-message',true)",link).execute(&db).await.unwrap();
let initial = repo.claim_message(Uuid::new_v4()).await.unwrap().unwrap();
repo.ingest(
&initial,
snapshot(
link,
"same-message",
MailboxState::default(),
"unchanged-etag",
),
)
.await
.unwrap();
repo.complete_message(&initial).await.unwrap();
for deleted in [true, false] {
folders[1].parent_id = deleted.then(|| ProviderId::new("trash").unwrap());
sqlx::query!("UPDATE email_sync_streams SET next_run_at=now() WHERE link_id=$1 AND kind='folder_catalog'",link).execute(&db).await.unwrap();
let catalog = repo.claim_catalog(Uuid::new_v4()).await.unwrap().unwrap();
repo.commit_catalog(&catalog, &folders).await.unwrap();
let work = repo.claim_message(Uuid::new_v4()).await.unwrap().unwrap();
assert_eq!(work.provider_id.as_str(), "same-message");
repo.ingest(
&work,
snapshot(
link,
"same-message",
MailboxState {
in_trash: deleted,
..Default::default()
},
"unchanged-etag",
),
)
.await
.unwrap();
repo.complete_message(&work).await.unwrap();
let state=sqlx::query_scalar!("SELECT (mailbox_state->>'in_trash')::boolean FROM email_messages WHERE link_id=$1 AND provider_id='same-message'",link).fetch_one(&db).await.unwrap();
assert_eq!(state, Some(deleted));
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn completed_import_rechecks_attachments_after_later_sent_correspondence(db: PgPool) {
use email_api_client::domain::models::MailboxState;
use models_email::service::address::ContactInfo;
let (repo, link) = fixture(&db).await;
sqlx::query!("INSERT INTO email_sync_streams(id,link_id,generation,kind,scope_id,initial_complete) VALUES($1,$2,1,'folder_catalog','mail',true)",Uuid::new_v4(),link).execute(&db).await.unwrap();
let stream = repo.claim_stream(Uuid::new_v4()).await.unwrap().unwrap();
repo.commit_page(
&stream,
&MailboxChangePage {
changed: vec![
ProviderId::new("a-incoming").unwrap(),
ProviderId::new("z-sent").unwrap(),
],
removed: vec![],
position: StreamPosition::Checkpoint(StreamToken::new("finished".into())),
},
)
.await
.unwrap();
let incoming = repo.claim_message(Uuid::new_v4()).await.unwrap().unwrap();
assert_eq!(incoming.provider_id.as_str(), "a-incoming");
let mut received = snapshot(link, "a-incoming", MailboxState::default(), "received-v1");
received.content.message.from = Some(ContactInfo {
email: "[email protected]".into(),
name: None,
photo_url: None,
});
received.content.message.attachments=vec![serde_json::from_value(serde_json::json!({"db_id":Uuid::new_v4(),"provider_id":"pdf","filename":"contract.pdf","mime_type":"application/pdf","size_bytes":10})).unwrap()];
received.content.message.has_attachments = true;
repo.ingest(&incoming, received).await.unwrap();
repo.complete_message(&incoming).await.unwrap();
assert!(
email_db_client::attachments::provider::upload::new_email_document_atts(
&db,
link,
"a-incoming"
)
.await
.unwrap()
.is_empty()
);
let sent = repo.claim_message(Uuid::new_v4()).await.unwrap().unwrap();
let mut sent_message = snapshot(link, "z-sent", MailboxState::default(), "sent-v1");
sent_message.content.message.provider_thread_id = Some("different-conversation".into());
sent_message.content.message.is_sent = true;
sent_message.content.message.from = Some(ContactInfo {
email: "[email protected]".into(),
name: None,
photo_url: None,
});
sent_message.content.message.to = vec![ContactInfo {
email: "[email protected]".into(),
name: None,
photo_url: None,
}];
repo.ingest(&sent, sent_message).await.unwrap();
repo.complete_message(&sent).await.unwrap();
repo.complete_message(&sent).await.unwrap();
let queued=sqlx::query!("SELECT generation,payload FROM email_projection_outbox WHERE link_id=$1 AND payload->>'kind'='attachment_recheck'",link).fetch_all(&db).await.unwrap();
assert_eq!(queued.len(), 1);
assert_eq!(queued[0].generation, 1);
let eligible = email_db_client::attachments::provider::upload::new_email_document_atts(
&db,
link,
"a-incoming",
)
.await
.unwrap();
assert_eq!(eligible.len(), 1);
assert_eq!(
queued[0].payload["message_id"],
eligible[0].message_db_id.to_string()
);
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn native_outlook_attachment_identity_survives_metadata_collisions_and_empty_snapshots(
db: PgPool,
) {
use email_api_client::domain::models::MailboxState;
let (repo, link) = fixture(&db).await;
let mut retained = None;
for (revision, ids) in [
(1, vec!["file-a", "file-b"]),
(2, vec!["file-b"]),
(3, vec!["replacement"]),
(4, vec![]),
] {
sqlx::query!("INSERT INTO email_message_reconciliation(link_id,generation,provider_id,is_import) VALUES($1,1,'native-draft',false)",link).execute(&db).await.unwrap();
let work = repo.claim_message(Uuid::new_v4()).await.unwrap().unwrap();
let mut message = snapshot(
link,
"native-draft",
MailboxState {
is_draft: true,
..Default::default()
},
&format!("v{revision}"),
);
message.content.message.attachments=ids.iter().map(|id|serde_json::from_value(serde_json::json!({"db_id":Uuid::new_v4(),"provider_id":id,"filename":"same.pdf","mime_type":"application/pdf","size_bytes":8})).unwrap()).collect();
message.content.message.has_attachments = !ids.is_empty();
repo.ingest(&work, message).await.unwrap();
repo.complete_message(&work).await.unwrap();
let attachments=sqlx::query!("SELECT a.id,a.provider_attachment_id FROM email_attachments a JOIN email_messages m ON m.id=a.message_id WHERE m.link_id=$1 ORDER BY a.provider_attachment_id",link).fetch_all(&db).await.unwrap();
assert_eq!(
attachments
.iter()
.map(|a| a.provider_attachment_id.as_deref().unwrap())
.collect::<Vec<_>>(),
ids
);
if revision == 1 {
retained = Some(attachments[1].id);
}
if revision == 2 {
assert_eq!(Some(attachments[0].id), retained);
}
if revision == 3 {
assert_ne!(Some(attachments[0].id), retained);
}
}
}
#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn message_claims_take_due_live_changes_before_imports_and_skip_backed_off_rows(db: PgPool) {
let (repo, link) = fixture(&db).await;
sqlx::query!(r#"
INSERT INTO email_message_reconciliation(link_id,generation,provider_id,is_import,available_at) VALUES
($1,1,'live-later',false,now() + interval '1 hour'),
($1,1,'import-due',true,now() - interval '2 minutes'),
($1,1,'live-due',false,now() - interval '1 minute')
"#,link).execute(&db).await.unwrap();
let mut claimed = Vec::new();
while let Some(work) = repo.claim_message(Uuid::new_v4()).await.unwrap() {
claimed.push(work.provider_id.as_str().to_owned());
}
assert_eq!(claimed, ["live-due", "import-due"]);
}