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.

16.8 KB
Raw Blame
use super::*;
use macro_db_migrator::MACRO_DB_MIGRATIONS;

#[derive(Clone)]
struct Grants(VerifiedMailboxGrant);
impl CompletedMailboxGrantSource for Grants {
    async fn completed_grant(
        &self,
        _: Uuid,
        owner: Uuid,
    ) -> Result<VerifiedMailboxGrant, InitializationError> {
        if owner != self.0.owner {
            return Err(InitializationError::InvalidAttempt);
        }
        Ok(self.0.clone())
    }
}

async fn actor(db: &PgPool, email: &str) -> (Uuid, MacroUserIdStr<'static>) {
    let id = macro_uuid::generate_uuid_v7();
    let macro_id = MacroUserIdStr::try_from(format!("macro|{email}")).unwrap();
    sqlx::query!(
        "INSERT INTO macro_user (id,username,email,stripe_customer_id) VALUES ($1,$2,$3,$4)",
        id,
        macro_id.as_ref(),
        email,
        format!("cus_{id}")
    )
    .execute(db)
    .await
    .unwrap();
    sqlx::query!(
        r#"INSERT INTO "User" (id,email,macro_user_id) VALUES ($1,$2,$3)"#,
        macro_id.as_ref(),
        email,
        id
    )
    .execute(db)
    .await
    .unwrap();
    (id, macro_id)
}

async fn attempt(db: &PgPool, actor: (Uuid, MacroUserIdStr<'static>)) -> InitializeMailbox {
    let id = macro_uuid::generate_uuid_v7();
    sqlx::query!("INSERT INTO in_progress_user_link (id,macro_user_id,email_provider,linked_email) VALUES ($1,$2,'OUTLOOK','[email protected]')",id,actor.0)
        .execute(db).await.unwrap();
    InitializeMailbox {
        attempt: id,
        actor: actor.1,
        actor_fusion_id: actor.0,
        force_share: false,
    }
}

fn grant(owner: Uuid) -> VerifiedMailboxGrant {
    VerifiedMailboxGrant {
        scopes: vec![
            "User.Read".into(),
            "Mail.ReadWrite".into(),
            "Mail.Send".into(),
        ],
        calendar_requested: false,
        id: macro_uuid::generate_uuid_v7(),
        generation: 1,
        owner,
        email: "[email protected]".into(),
        tenant_id: "tenant".into(),
        mailbox_id: "mailbox".into(),
    }
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn initialization_is_atomic_idempotent_and_seeds_independent_provider_streams(db: PgPool) {
    let actor = actor(&db, "[email protected]").await;
    let request = attempt(&db, actor.clone()).await;
    let service = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(actor.0)),
    );
    let link = service.initialize(request.clone()).await.unwrap();
    assert!(service.recognizes(&request).await.unwrap());
    assert_eq!(service.initialize(request.clone()).await.unwrap(), link);
    let row = sqlx::query!("SELECT provider::text AS provider,grant_generation,provider_mailbox_id FROM email_links WHERE id = $1",link).fetch_one(&db).await.unwrap();
    assert_eq!(row.provider.as_deref(), Some("OUTLOOK"));
    assert_eq!(row.grant_generation, 1);
    assert_eq!(row.provider_mailbox_id.as_deref(), Some("mailbox"));
    let streams = sqlx::query!(
        "SELECT kind FROM email_sync_streams WHERE link_id = $1 ORDER BY kind",
        link
    )
    .fetch_all(&db)
    .await
    .unwrap();
    assert_eq!(
        streams
            .iter()
            .map(|stream| stream.kind.as_str())
            .collect::<Vec<_>>(),
        vec!["contacts_catalog", "contacts_profile", "folder_catalog"]
    );
    assert_eq!(
        sqlx::query_scalar!(
            "SELECT count(*) FROM email_projection_outbox WHERE link_id = $1",
            link
        )
        .fetch_one(&db)
        .await
        .unwrap(),
        Some(1)
    );
    assert_eq!(
        sqlx::query_scalar!(
            "SELECT count(*) FROM in_progress_user_link WHERE id = $1",
            request.attempt
        )
        .fetch_one(&db)
        .await
        .unwrap(),
        Some(0)
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn shared_promotion_keeps_one_inbox_and_both_scoped_access_edges(db: PgPool) {
    let first = actor(&db, "[email protected]").await;
    let second = actor(&db, "[email protected]").await;
    let service = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(first.0)),
    );
    let link = service
        .initialize(attempt(&db, first.clone()).await)
        .await
        .unwrap();
    let service = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(second.0)),
    );
    let mut request = attempt(&db, second.clone()).await;
    assert!(matches!(
        service.initialize(request.clone()).await,
        Err(InitializationError::SharingConfirmation { .. })
    ));
    request.force_share = true;
    assert_eq!(service.initialize(request).await.unwrap(), link);
    let row = sqlx::query!(
        "SELECT macro_id,fusionauth_user_id,sync_generation FROM email_links WHERE id = $1",
        link
    )
    .fetch_one(&db)
    .await
    .unwrap();
    assert_eq!(row.macro_id, "macro|[email protected]");
    assert_eq!(row.fusionauth_user_id, second.0.to_string());
    assert_eq!(row.sync_generation, 2);
    assert_eq!(
        sqlx::query_scalar!("SELECT count(*) FROM email_links")
            .fetch_one(&db)
            .await
            .unwrap(),
        Some(1)
    );
    assert_eq!(
        sqlx::query_scalar!(
            "SELECT count(*) FROM macro_user_links WHERE link_id = $1",
            link
        )
        .fetch_one(&db)
        .await
        .unwrap(),
        Some(2)
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn wrong_actor_and_changed_snapshot_cannot_consume_an_attempt(db: PgPool) {
    let owner = actor(&db, "[email protected]").await;
    let other = actor(&db, "[email protected]").await;
    let mut request = attempt(&db, owner.clone()).await;
    let grants = grant(owner.0);
    let repo = PgMailboxInitialization(db.clone());
    let before = repo.inspect(&request, &grants).await.unwrap();
    request.actor = other.1;
    request.actor_fusion_id = other.0;
    assert!(matches!(
        repo.commit(
            &request,
            &grants,
            &before,
            InitializationDecision::Create {
                owner: owner.1.clone()
            }
        )
        .await,
        Err(InitializationError::Changed)
    ));
    assert_eq!(
        sqlx::query_scalar!("SELECT count(*) FROM email_links")
            .fetch_one(&db)
            .await
            .unwrap(),
        Some(0)
    );
    assert_eq!(
        sqlx::query_scalar!(
            "SELECT count(*) FROM in_progress_user_link WHERE id = $1",
            request.attempt
        )
        .fetch_one(&db)
        .await
        .unwrap(),
        Some(1)
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn mixed_provider_connection_limit_is_rechecked_without_blocking_reconnect(db: PgPool) {
    let owner = actor(&db, "[email protected]").await;
    let req = attempt(&db, owner.clone()).await;
    let service = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(owner.0)),
    );
    let outlook = service.initialize(req.clone()).await.unwrap();
    let gmail = Uuid::now_v7();
    sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,'[email protected]','GMAIL')",gmail,owner.1.as_ref(),owner.0.to_string()).execute(&db).await.unwrap();
    let reconnect = attempt(&db, owner.clone()).await;
    assert_eq!(service.initialize(reconnect).await.unwrap(), outlook);
    let req = attempt(&db, owner.clone()).await;
    let mut third = grant(owner.0);
    third.email = "[email protected]".into();
    third.mailbox_id = "third".into();
    let service =
        MailboxInitializationService::new(PgMailboxInitialization(db.clone()), Grants(third));
    assert!(matches!(
        service.initialize(req).await,
        Err(InitializationError::PaymentRequired)
    ));
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn gmail_reservation_counts_outlook_and_allows_only_verified_reconnect(db: PgPool) {
    let owner = actor(&db, "[email protected]").await;
    for (address, provider) in [
        ("[email protected]", "GMAIL"),
        ("[email protected]", "OUTLOOK"),
    ] {
        sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,$4,$5::text::email_user_provider_enum)",Uuid::now_v7(),owner.1.as_ref(),owner.0.to_string(),address,provider).execute(&db).await.unwrap();
    }
    let admission = email::domain::inbox_entitlement::InboxConnectionService(
        email::outbound::EmailPgRepo::new(db.clone()),
    );
    let gmail =
        sqlx::query_scalar!("SELECT id FROM email_links WHERE email_address='[email protected]'")
            .fetch_one(&db)
            .await
            .unwrap();
    assert!(
        admission
            .permits_connection(
                owner.1.clone(),
                false,
                email::domain::models::UserProvider::Gmail,
                Some(gmail)
            )
            .await
            .unwrap()
    );
    assert!(
        !admission
            .permits_connection(
                owner.1.clone(),
                false,
                email::domain::models::UserProvider::Outlook,
                Some(gmail)
            )
            .await
            .unwrap()
    );
    assert!(
        !admission
            .permits_connection(
                owner.1.clone(),
                false,
                email::domain::models::UserProvider::Gmail,
                Some(Uuid::now_v7())
            )
            .await
            .unwrap()
    );
    let mut tx = db.begin().await.unwrap();
    assert!(matches!(
        lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]").await,
        Err(InitializationError::PaymentRequired)
    ));
    assert!(matches!(
        lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]").await,
        Err(InitializationError::PaymentRequired)
    ));
    lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]")
        .await
        .unwrap();
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn admission_pause_rejects_new_mailbox_but_preserves_reconnect(db: PgPool) {
    let owner = actor(&db, "[email protected]").await;
    let request = attempt(&db, owner.clone()).await;
    let service = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(owner.0)),
    )
    .with_connections_enabled(false);
    assert!(matches!(
        service.initialize(request.clone()).await,
        Err(InitializationError::Unavailable)
    ));
    let enabled = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(owner.0)),
    );
    let link = enabled.initialize(request).await.unwrap();
    assert_eq!(
        service
            .initialize(attempt(&db, owner.clone()).await)
            .await
            .unwrap(),
        link
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn reconnect_resumes_organization_commands_under_the_new_grant(db: PgPool) {
    use email::domain::{
        mailbox::commands::MailboxCommandRepository,
        models::mailbox_action::{MailboxAction, MailboxActionTarget, PendingMailboxState},
        ports::EmailRepo,
    };
    let owner = actor(&db, "[email protected]").await;
    let link = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(owner.0)),
    )
    .initialize(attempt(&db, owner.clone()).await)
    .await
    .unwrap();
    let (thread, message, other) = (Uuid::now_v7(), Uuid::now_v7(), Uuid::now_v7());
    sqlx::query!(
        "INSERT INTO email_threads(id,link_id) VALUES($1,$2)",
        thread,
        link
    )
    .execute(&db)
    .await
    .unwrap();
    for (id, provider_id) in [(message, "outlook-message"), (other, "outlook-other")] {
        sqlx::query!(
            "INSERT INTO email_messages(id,link_id,thread_id,provider_id) VALUES($1,$2,$3,$4)",
            id,
            link,
            thread,
            provider_id
        )
        .execute(&db)
        .await
        .unwrap();
    }
    let target_for = |message_id, provider_id: &str, is_read| MailboxActionTarget {
        message_id,
        provider_id: Some(provider_id.into()),
        pending: PendingMailboxState {
            is_read: Some(is_read),
            ..Default::default()
        },
    };
    let target = |is_read| target_for(message, "outlook-message", is_read);
    let repo = email::outbound::EmailPgRepo::new(db.clone());
    let retrying = repo
        .enqueue_mailbox_action(
            link,
            owner.1.clone(),
            &MailboxAction::Read(true),
            &[target(true)],
        )
        .await
        .unwrap();
    let queued = repo
        .enqueue_mailbox_action(
            link,
            owner.1.clone(),
            &MailboxAction::Read(false),
            &[target(false)],
        )
        .await
        .unwrap();
    let sync = email::outbound::mailbox_pg::PgMailboxSync::new(db.clone());
    let lease = sync.claim_command(Uuid::now_v7()).await.unwrap().unwrap();
    assert_eq!(lease.id, retrying);
    // An authorization failure releases the lease for a later retry.
    sync.release_command(&lease, 300).await.unwrap();
    let confirming = repo
        .enqueue_mailbox_action(
            link,
            owner.1.clone(),
            &MailboxAction::Read(true),
            &[target_for(other, "outlook-other", true)],
        )
        .await
        .unwrap();
    sqlx::query!(
        "UPDATE email_mailbox_commands SET status = 'confirming' WHERE id = $1",
        confirming
    )
    .execute(&db)
    .await
    .unwrap();

    MailboxInitializationService::new(PgMailboxInitialization(db.clone()), Grants(grant(owner.0)))
        .initialize(attempt(&db, owner.clone()).await)
        .await
        .unwrap();
    let generation = sqlx::query_scalar!(
        "SELECT sync_generation FROM email_links WHERE id = $1",
        link
    )
    .fetch_one(&db)
    .await
    .unwrap();
    assert_eq!(generation, lease.mailbox.sync_generation + 1);
    let commands = sqlx::query!(
        "SELECT id,status,generation FROM email_mailbox_commands WHERE link_id = $1 ORDER BY accepted_order",
        link
    )
    .fetch_all(&db)
    .await
    .unwrap();
    assert_eq!(
        commands
            .iter()
            .map(|c| (c.id, c.status.as_str(), c.generation))
            .collect::<Vec<_>>(),
        vec![
            (retrying, "pending", generation),
            (queued, "pending", generation),
            (confirming, "pending", generation)
        ]
    );
    assert_eq!(
        sqlx::query_scalar!(
            "SELECT command_id FROM email_pending_mailbox_state WHERE message_id = $1",
            message
        )
        .fetch_one(&db)
        .await
        .unwrap(),
        queued,
        "the newest accepted intent stays visible across the reconnect"
    );
    let mut resumed = Vec::new();
    for _ in 0..2 {
        let lease = sync.claim_command(Uuid::now_v7()).await.unwrap().unwrap();
        resumed.push((lease.id, lease.mailbox.sync_generation));
    }
    resumed.sort();
    let mut expected = vec![(retrying, generation), (confirming, generation)];
    expected.sort();
    assert_eq!(
        resumed, expected,
        "a confirming command resumes instead of blocking later commands"
    );
}

#[sqlx::test(migrator = "MACRO_DB_MIGRATIONS")]
async fn concurrent_gmail_and_outlook_connections_share_one_remaining_free_slot(db: PgPool) {
    let owner = actor(&db, "[email protected]").await;
    sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,'[email protected]','GMAIL')",Uuid::new_v4(),owner.1.as_ref(),owner.0.to_string()).execute(&db).await.unwrap();
    let request = attempt(&db, owner.clone()).await;
    let service = MailboxInitializationService::new(
        PgMailboxInitialization(db.clone()),
        Grants(grant(owner.0)),
    );
    let gmail = async {
        let mut tx = db.begin().await.map_err(unavailable)?;
        lock_gmail_connection(&mut tx, owner.1.as_ref(), "[email protected]").await?;
        let id = Uuid::new_v4();
        sqlx::query!("INSERT INTO email_links(id,macro_id,fusionauth_user_id,email_address,provider) VALUES($1,$2,$3,'[email protected]','GMAIL')",id,owner.1.as_ref(),owner.0.to_string()).execute(&mut *tx).await.map_err(unavailable)?;
        tx.commit().await.map_err(unavailable)?;
        Ok::<_, InitializationError>(id)
    };
    let (gmail, outlook) = tokio::join!(gmail, service.initialize(request));
    assert_ne!(gmail.is_ok(), outlook.is_ok());
    let failure = gmail.err().or(outlook.err()).unwrap();
    assert!(matches!(failure, InitializationError::PaymentRequired));
    let count=sqlx::query_scalar!("SELECT count(*) FROM email_links l WHERE l.macro_id=$1 OR EXISTS(SELECT 1 FROM macro_user_links a WHERE a.link_id=l.id AND a.primary_macro_id=$1)",owner.1.as_ref()).fetch_one(&db).await.unwrap();
    assert_eq!(count, Some(2));
}