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.7 KB
Raw Blame
use super::*;
use feature_flags::{FlagSnapshot, FlagValue, outbound::fake::FakeFeatureFlags};
use token::MockMicrosoftTokenCipher;

type Service = MicrosoftAuthService<
    MockMicrosoftGrantRepository,
    MockMicrosoftIdentityProvider,
    FakeFeatureFlags,
>;

fn attempt() -> LinkAttempt {
    LinkAttempt {
        id: macro_uuid::generate_uuid_v7(),
        owner: macro_uuid::generate_uuid_v7(),
        identity_provider_id: "microsoft".into(),
        redirect_uri: "https://auth.example.com/callback".into(),
        return_uri: Some("https://app.example.com".into()),
        verifier: Zeroizing::new("verifier".into()),
        nonce: "nonce".into(),
        calendar_requested: false,
        expires_at: Utc::now() + Duration::minutes(10),
    }
}

fn envelope() -> EncryptedMicrosoftToken {
    EncryptedMicrosoftToken {
        refresh_token_ciphertext: vec![1; 32],
        encrypted_data_key: vec![2; 32],
        nonce: vec![3; 12],
        encryption_version: 1,
        kms_key_id: "key".into(),
    }
}

fn scopes() -> Vec<String> {
    [
        "User.Read",
        "Mail.ReadWrite",
        "Mail.Send",
        "MailboxSettings.ReadWrite",
        "Contacts.ReadWrite",
        "Calendars.ReadWrite",
    ]
    .map(str::to_owned)
    .to_vec()
}

#[tokio::test]
async fn mismatched_provider_is_rejected_before_code_exchange() {
    let pending = attempt();
    let id = pending.id;
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_claim_link()
        .once()
        .return_once(move |_| Ok(pending));
    repo.expect_abandon_link().once().returning(|_| Ok(()));
    let service = Service::new(
        repo,
        MockMicrosoftIdentityProvider::new(),
        Arc::new(MockMicrosoftTokenCipher::new()),
    );
    assert_eq!(
        service.complete_link(id, "google", "code").await,
        Err(MicrosoftAuthError::InvalidAttempt)
    );
}

#[tokio::test]
async fn verified_mailbox_never_changes_the_initiating_owner() {
    let pending = attempt();
    let id = pending.id;
    let owner = pending.owner;
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_claim_link()
        .once()
        .return_once(move |_| Ok(pending));
    repo.expect_complete_link()
        .once()
        .withf(move |attempt, identity, _, _| {
            attempt.owner == owner && identity.email == "[email protected]"
        })
        .returning(|_, _, _, _| Ok(()));
    let mut provider = MockMicrosoftIdentityProvider::new();
    provider.expect_exchange().once().returning(|_, _| {
        Ok(VerifiedGrant {
            tenant_id: "tenant".into(),
            subject_id: "subject".into(),
            mailbox_id: "mailbox".into(),
            email: "[email protected]".into(),
            scopes: scopes(),
            refresh_token: MicrosoftRefreshToken::new("refresh".into()),
        })
    });
    let mut cipher = MockMicrosoftTokenCipher::new();
    cipher
        .expect_encrypt()
        .once()
        .withf(move |actual, email, _| {
            actual == &owner.to_string() && email == "[email protected]"
        })
        .returning(|_, _, _| Ok(envelope()));
    let service = Service::new(repo, provider, Arc::new(cipher));
    assert_eq!(
        service
            .complete_link(id, "microsoft", "code")
            .await
            .unwrap(),
        Some("https://app.example.com".into())
    );
}

#[tokio::test]
async fn partial_consent_is_not_persisted_as_full_parity_grant() {
    let pending = attempt();
    let id = pending.id;
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_claim_link()
        .once()
        .return_once(move |_| Ok(pending));
    repo.expect_abandon_link().once().returning(|_| Ok(()));
    let mut provider = MockMicrosoftIdentityProvider::new();
    provider.expect_exchange().once().returning(|_, _| {
        Ok(VerifiedGrant {
            tenant_id: "tenant".into(),
            subject_id: "subject".into(),
            mailbox_id: "mailbox".into(),
            email: "[email protected]".into(),
            scopes: vec!["Mail.ReadWrite".into()],
            refresh_token: MicrosoftRefreshToken::new("refresh".into()),
        })
    });
    let service = Service::new(repo, provider, Arc::new(MockMicrosoftTokenCipher::new()));
    assert_eq!(
        service.complete_link(id, "microsoft", "code").await,
        Err(MicrosoftAuthError::MissingPermissions)
    );
}

#[tokio::test]
async fn lost_rotation_fence_never_returns_or_caches_the_access_token() {
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_active_grant().once().returning(|_, _, _| {
        Ok(StoredGrant {
            scopes: vec![
                "User.Read".into(),
                "Mail.ReadWrite".into(),
                "Mail.Send".into(),
            ],
            id: macro_uuid::generate_uuid_v7(),
            generation: 1,
            revision: 0,
            owner: "owner".into(),
            email: "[email protected]".into(),
            envelope: envelope(),
        })
    });
    repo.expect_acquire_refresh()
        .once()
        .returning(|_, _| Ok(true));
    repo.expect_finish_refresh()
        .once()
        .returning(|_, _, _, _| Ok(false));
    repo.expect_release_refresh()
        .once()
        .withf(|_, _, revoke| !revoke)
        .returning(|_, _, _| Ok(()));
    let mut provider = MockMicrosoftIdentityProvider::new();
    provider.expect_refresh().once().returning(|_| {
        Ok(RefreshedGrant {
            access_token: Zeroizing::new("must-not-escape".into()),
            refresh_token: None,
            expires_in: 3600,
            scopes: scopes(),
        })
    });
    let mut cipher = MockMicrosoftTokenCipher::new();
    cipher
        .expect_decrypt()
        .once()
        .returning(|_, _, _| Ok(MicrosoftRefreshToken::new("refresh".into())));
    let service = Service::new(repo, provider, Arc::new(cipher));
    assert!(matches!(
        service
            .access_token(macro_uuid::generate_uuid_v7(), 1, 1, false)
            .await,
        Err(MicrosoftAuthError::Busy)
    ));
    assert!(service.cache.lock().unwrap().is_empty());
}

#[tokio::test]
async fn revoked_grants_are_checked_before_cache_hits() {
    let grant_id = macro_uuid::generate_uuid_v7();
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_active_grant()
        .once()
        .returning(|_, _, _| Err(MicrosoftAuthError::ReauthorizationRequired));
    let service = Service::new(
        repo,
        MockMicrosoftIdentityProvider::new(),
        Arc::new(MockMicrosoftTokenCipher::new()),
    );
    service.cache.lock().unwrap().insert(
        (grant_id, 1),
        CachedToken {
            scopes: scopes(),
            value: Zeroizing::new("revoked".into()),
            expires_at: Utc::now() + Duration::hours(1),
        },
    );
    assert!(matches!(
        service
            .access_token(macro_uuid::generate_uuid_v7(), 1, 1, false)
            .await,
        Err(MicrosoftAuthError::ReauthorizationRequired)
    ));
}

#[test]
fn optional_permissions_never_revoke_a_working_mail_grant() {
    let core = vec![
        "User.Read".into(),
        "Mail.ReadWrite".into(),
        "Mail.Send".into(),
    ];
    assert!(has_required_scopes(&core));
    assert!(!has_required_scopes(&core[..2]));
    assert!(has_required_scopes(
        &core
            .iter()
            .map(|scope| format!("https://graph.microsoft.com/{scope}"))
            .collect::<Vec<_>>()
    ));
}

#[test]
fn graph_scope_spellings_have_one_persisted_representation() {
    assert_eq!(
        normalize_scopes(vec![
            "https://graph.microsoft.com/calendars.readwrite".into(),
            "Calendars.ReadWrite".into(),
            "MAIL.SEND".into()
        ]),
        vec!["Calendars.ReadWrite", "Mail.Send"]
    );
}

#[tokio::test]
async fn free_account_at_mixed_provider_limit_cannot_start_a_new_connection() {
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_connection_facts().once().returning(|_, _| {
        Ok(email::domain::inbox_entitlement::InboxConnectionFacts {
            professional: false,
            accessible_inboxes: 2,
            reconnecting: false,
        })
    });
    let service = Service::new(
        repo,
        MockMicrosoftIdentityProvider::new(),
        Arc::new(MockMicrosoftTokenCipher::new()),
    );
    assert!(matches!(
        service
            .start_link(
                Uuid::now_v7(),
                &MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),
                "https://macro.test/callback".into(),
                None,
                false,
                None
            )
            .await,
        Err(MicrosoftAuthError::PaymentRequired)
    ));
}

#[tokio::test]
async fn new_connections_need_the_switch_and_the_users_flag() {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let cases = [
        // (switch, flags configured, the user's flag load, admitted)
        (
            true,
            true,
            Ok(FlagSnapshot::new([(
                OUTLOOK_FLAG.into(),
                FlagValue::Boolean(true),
            )])),
            true,
        ),
        (
            true,
            true,
            Ok(FlagSnapshot::new([(
                OUTLOOK_FLAG.into(),
                FlagValue::Boolean(false),
            )])),
            false,
        ),
        (true, true, Ok(FlagSnapshot::default()), false),
        (true, true, Err("PostHog unreachable".to_owned()), false),
        (true, false, Err("never loaded".to_owned()), true),
        (
            false,
            true,
            Ok(FlagSnapshot::new([(
                OUTLOOK_FLAG.into(),
                FlagValue::Boolean(true),
            )])),
            false,
        ),
        (false, false, Err("never loaded".to_owned()), false),
    ];
    for (switch, configured, load, admitted) in cases {
        let mut flags = FakeFeatureFlags::default();
        flags.set(user.clone(), load.clone());
        let service = Service::new(
            MockMicrosoftGrantRepository::new(),
            MockMicrosoftIdentityProvider::new(),
            Arc::new(MockMicrosoftTokenCipher::new()),
        )
        .with_connections_enabled(switch)
        .with_feature_flags(configured.then_some(flags));
        assert_eq!(
            service.new_connections_enabled(&user).await,
            admitted,
            "switch {switch}, configured {configured}, load {load:?}"
        );
    }
}

#[tokio::test]
async fn flagged_off_user_cannot_start_a_new_connection() {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    for load in [
        Ok(FlagSnapshot::new([(
            OUTLOOK_FLAG.into(),
            FlagValue::Boolean(false),
        )])),
        Err("PostHog unreachable".to_owned()),
    ] {
        let mut repo = MockMicrosoftGrantRepository::new();
        repo.expect_connection_facts().once().returning(|_, _| {
            Ok(email::domain::inbox_entitlement::InboxConnectionFacts {
                professional: true,
                accessible_inboxes: 0,
                reconnecting: false,
            })
        });
        let mut flags = FakeFeatureFlags::default();
        flags.set(user.clone(), load);
        // No begin_link expectation: a refused start records no attempt.
        let service = Service::new(
            repo,
            MockMicrosoftIdentityProvider::new(),
            Arc::new(MockMicrosoftTokenCipher::new()),
        )
        .with_feature_flags(Some(flags));
        assert!(matches!(
            service
                .start_link(
                    Uuid::now_v7(),
                    &user,
                    "https://macro.test/callback".into(),
                    None,
                    false,
                    None
                )
                .await,
            Err(MicrosoftAuthError::NotConfigured)
        ));
    }
}

#[tokio::test]
async fn flagged_on_user_starts_a_new_connection() {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_connection_facts().once().returning(|_, _| {
        Ok(email::domain::inbox_entitlement::InboxConnectionFacts {
            professional: true,
            accessible_inboxes: 0,
            reconnecting: false,
        })
    });
    repo.expect_begin_link().once().returning(|_| Ok(()));
    let mut provider = MockMicrosoftIdentityProvider::new();
    provider
        .expect_identity_provider_id()
        .once()
        .returning(|| Ok("microsoft".into()));
    provider
        .expect_authorize()
        .once()
        .returning(|_| Ok("https://login.example.com/authorize".into()));
    let mut flags = FakeFeatureFlags::default();
    flags.set(
        user.clone(),
        Ok(FlagSnapshot::new([(
            OUTLOOK_FLAG.into(),
            FlagValue::Boolean(true),
        )])),
    );
    let service = Service::new(repo, provider, Arc::new(MockMicrosoftTokenCipher::new()))
        .with_feature_flags(Some(flags));
    let started = service
        .start_link(
            Uuid::now_v7(),
            &user,
            "https://macro.test/callback".into(),
            None,
            false,
            None,
        )
        .await
        .unwrap();
    assert_eq!(
        started.authorization_url,
        "https://login.example.com/authorize"
    );
}

#[tokio::test]
async fn reconnecting_an_inbox_never_depends_on_the_flag_or_the_switch() {
    let user = MacroUserIdStr::try_from("macro|[email protected]".to_string()).unwrap();
    let reconnect = Uuid::now_v7();
    for load in [
        Ok(FlagSnapshot::new([(
            OUTLOOK_FLAG.into(),
            FlagValue::Boolean(false),
        )])),
        Err("PostHog unreachable".to_owned()),
    ] {
        let mut repo = MockMicrosoftGrantRepository::new();
        repo.expect_connection_facts()
            .once()
            .withf(move |_, id| *id == Some(reconnect))
            .returning(|_, _| {
                Ok(email::domain::inbox_entitlement::InboxConnectionFacts {
                    professional: false,
                    accessible_inboxes: 2,
                    reconnecting: true,
                })
            });
        repo.expect_begin_link().once().returning(|_| Ok(()));
        let mut provider = MockMicrosoftIdentityProvider::new();
        provider
            .expect_identity_provider_id()
            .once()
            .returning(|| Ok("microsoft".into()));
        provider
            .expect_authorize()
            .once()
            .returning(|_| Ok("https://login.example.com/authorize".into()));
        let mut flags = FakeFeatureFlags::default();
        flags.set(user.clone(), load);
        let service = Service::new(repo, provider, Arc::new(MockMicrosoftTokenCipher::new()))
            .with_connections_enabled(false)
            .with_feature_flags(Some(flags));
        assert!(
            service
                .start_link(
                    Uuid::now_v7(),
                    &user,
                    "https://macro.test/callback".into(),
                    None,
                    false,
                    Some(reconnect),
                )
                .await
                .is_ok()
        );
    }
}

#[tokio::test]
async fn tokens_report_whether_the_cache_served_them() {
    let grant_id = macro_uuid::generate_uuid_v7();
    let mut repo = MockMicrosoftGrantRepository::new();
    repo.expect_active_grant()
        .times(2)
        .returning(move |_, _, _| {
            Ok(StoredGrant {
                scopes: scopes(),
                id: grant_id,
                generation: 1,
                revision: 0,
                owner: "owner".into(),
                email: "[email protected]".into(),
                envelope: envelope(),
            })
        });
    repo.expect_acquire_refresh()
        .once()
        .returning(|_, _| Ok(true));
    repo.expect_finish_refresh()
        .once()
        .returning(|_, _, _, _| Ok(true));
    let mut provider = MockMicrosoftIdentityProvider::new();
    provider.expect_refresh().once().returning(|_| {
        Ok(RefreshedGrant {
            access_token: Zeroizing::new("fresh".into()),
            refresh_token: None,
            expires_in: 3600,
            scopes: scopes(),
        })
    });
    let mut cipher = MockMicrosoftTokenCipher::new();
    cipher
        .expect_decrypt()
        .once()
        .returning(|_, _, _| Ok(MicrosoftRefreshToken::new("refresh".into())));
    let service = Service::new(repo, provider, Arc::new(cipher));
    let link = macro_uuid::generate_uuid_v7();

    let refreshed = service.access_token(link, 1, 1, false).await.unwrap();
    let cached = service.access_token(link, 1, 1, false).await.unwrap();

    assert!(!refreshed.cached);
    assert!(cached.cached);
    assert_eq!(cached.as_str(), "fresh");
}