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.

4.6 KB
Raw Blame
use super::*;

const CUSTOMER_STORAGE_ERROR: &str = "sentinel customer storage error";

fn customer_storage_error() -> CustomerError {
    CustomerError::StorageLayerError(anyhow::anyhow!(CUSTOMER_STORAGE_ERROR))
}

fn assert_preserves_customer_storage_error(error: impl std::fmt::Display) {
    let message = error.to_string();
    assert!(
        message.contains(CUSTOMER_STORAGE_ERROR),
        "customer storage error was missing from: {message}"
    );
}

fn team_with_enterprise_status(enterprise: bool) -> Team {
    Team::new(
        uuid::Uuid::nil(),
        "Test Team".to_string(),
        "TEST_TEAM".to_string(),
        MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),
        false,
        enterprise,
    )
}

#[test]
fn team_enterprise_accessor_preserves_constructor_value() {
    for enterprise in [false, true] {
        assert_eq!(
            team_with_enterprise_status(enterprise).enterprise(),
            enterprise
        );
    }
}

#[test]
fn serialized_team_preserves_enterprise_value() {
    for enterprise in [false, true] {
        let serialized = serde_json::to_value(team_with_enterprise_status(enterprise)).unwrap();

        assert_eq!(serialized["enterprise"], enterprise);
    }
}

#[test]
fn new_team_defaults_link_share_to_team() {
    let team = team_with_enterprise_status(false);
    assert_eq!(team.default_link_share(), Some(LinkShare::Team));

    let serialized = serde_json::to_value(team).unwrap();
    assert_eq!(serialized["default_link_share"], "TEAM");
}

#[test]
fn patch_team_request_distinguishes_omitted_and_null_default_link_share() {
    let omitted: PatchTeamRequest = serde_json::from_str("{}").unwrap();
    assert_eq!(omitted.default_link_share, None);

    let null: PatchTeamRequest = serde_json::from_str(r#"{"default_link_share": null}"#).unwrap();
    assert_eq!(null.default_link_share, Some(None));

    let set: PatchTeamRequest =
        serde_json::from_str(r#"{"default_link_share": "PUBLIC"}"#).unwrap();
    assert_eq!(set.default_link_share, Some(Some(LinkShare::Public)));
}

#[test]
fn invite_users_to_team_error_preserves_customer_storage_error() {
    let error = InviteUsersToTeamError::from(customer_storage_error());
    assert_preserves_customer_storage_error(error);
}

#[test]
fn remove_user_from_team_error_preserves_customer_storage_error() {
    let error = RemoveUserFromTeamError::from(customer_storage_error());
    assert_preserves_customer_storage_error(error);
}

#[test]
fn remove_team_invite_error_preserves_customer_storage_error() {
    let error = RemoveTeamInviteError::from(customer_storage_error());
    assert_preserves_customer_storage_error(error);
}

#[test]
fn delete_team_error_preserves_customer_storage_error() {
    let error = DeleteTeamError::from(customer_storage_error());
    assert_preserves_customer_storage_error(error);
}

#[test]
fn join_team_error_preserves_customer_storage_error() {
    let error = JoinTeamError::from(customer_storage_error());
    assert_preserves_customer_storage_error(error);
}

#[test]
fn team_checkout_error_preserves_customer_storage_error() {
    let error = TeamCheckoutError::from(customer_storage_error());
    assert_preserves_customer_storage_error(error);
}

#[test]
fn generic_email_domains_are_lowercase_and_sorted() {
    // is_generic_email_domain binary searches the list, which is only
    // correct when the entries are sorted (and lowercase, since lookups
    // are lowercased).
    assert!(GENERIC_EMAIL_DOMAINS.is_sorted());
    assert!(
        GENERIC_EMAIL_DOMAINS
            .iter()
            .all(|domain| *domain == domain.to_ascii_lowercase())
    );
}

#[test]
fn is_generic_email_domain_matches_generic_providers() {
    assert!(is_generic_email_domain("gmail.com"));
    assert!(is_generic_email_domain("hotmail.co.uk"));
    assert!(is_generic_email_domain("zoho.com"));
    assert!(is_generic_email_domain("126.com"));
}

#[test]
fn is_generic_email_domain_is_case_insensitive() {
    assert!(is_generic_email_domain("GMAIL.COM"));
    assert!(is_generic_email_domain("Outlook.Com"));
}

#[test]
fn is_generic_email_domain_allows_company_domains() {
    assert!(!is_generic_email_domain("macro.com"));
    assert!(!is_generic_email_domain("example.org"));
    assert!(!is_generic_email_domain("gmail.com.evil.com"));
}

#[test]
fn invite_link_tokens_never_print_their_secret() {
    let secret = uuid::Uuid::from_u128(0x1234_5678_9abc_def0_1234_5678_9abc_def0);
    let token = TeamInviteLinkToken::from_uuid(secret);

    let printed = format!("{token:?} {:?}", Some(token));

    assert!(!printed.contains(&secret.to_string()));
    assert!(!printed.contains(&secret.simple().to_string()));
    assert!(printed.contains("<redacted>"));
}