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::*;
#[test]
fn call_invitation_links_directly_to_guest_join_and_escapes_titles() {
let invitation = CallInvite {
title: "Review <script>alert(1)</script>".to_string(),
share_token: "server-issued-test-token".to_string(),
invited_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
recipient_email: "[email protected]".to_string(),
};
let email = invitation.format_email();
assert!(
email
.body
.contains("/app/meet/join/server-issued-test-token")
);
assert!(email.body.contains("No Macro account needed"));
assert!(!email.body.contains("/signup"));
assert!(!email.body.contains("<script>"));
assert!(email.subject.contains("[email protected]"));
}
fn make_colleague_joined() -> ColleagueJoinedMacro {
ColleagueJoinedMacro {
team_name: "Acme".to_string(),
joined_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
joined_name: Some("Alice Example".to_string()),
recipient_email: EmailStr::try_from("[email protected]".to_string()).unwrap(),
}
}
const COLLEAGUE_SUBJECT: &str = "A team has been created for your organization";
#[test]
fn colleague_joined_is_an_organization_notice_that_links_to_signup() {
let email = make_colleague_joined().format_email();
assert_eq!(email.subject, COLLEAGUE_SUBJECT);
assert!(
email
.body
.contains("Alice Example ([email protected]) set up the")
);
assert!(email.body.contains("<strong>Acme</strong> team on Macro"));
assert!(
email
.body
.contains("Sign up with <strong>[email protected]</strong>")
);
assert!(email.body.contains("one-time notice"));
assert!(
email
.body
.contains("href=\"macro-unsubscribe:colleague_joined_macro\"")
);
assert!(email.body.contains("54 W 21st St, Suite 503, New York, NY"));
assert!(email.body.contains("/app/signup\""));
assert!(email.body.contains(">Join Acme</a"));
assert!(!email.body.contains("referral_code"));
// The notice is not framed as someone signing up.
assert!(!email.body.contains("joined Macro"));
}
#[test]
fn colleague_joined_falls_back_to_the_email_without_a_usable_name() {
for joined_name in [None, Some(" \n\t\u{7} ".to_string())] {
let email = ColleagueJoinedMacro {
joined_name,
..make_colleague_joined()
}
.format_email();
assert_eq!(email.subject, COLLEAGUE_SUBJECT);
assert!(email.body.contains("[email protected] set up the"));
assert!(!email.body.contains("([email protected])"));
}
}
#[test]
fn colleague_joined_puts_long_multiline_names_on_one_capped_line() {
let email = ColleagueJoinedMacro {
joined_name: Some(format!(" Alice\r\nExample\t\u{0}{}", "x".repeat(100))),
..make_colleague_joined()
}
.format_email();
assert_eq!(email.subject, COLLEAGUE_SUBJECT);
assert!(email.body.contains(&format!(
"Alice Example {} ([email protected])",
"x".repeat(50)
)));
}
#[test]
fn colleague_joined_escapes_the_untrusted_name_in_the_body() {
let email = ColleagueJoinedMacro {
joined_name: Some("<b>x</b>".to_string()),
..make_colleague_joined()
}
.format_email();
assert_eq!(email.subject, COLLEAGUE_SUBJECT);
assert!(!email.body.contains("<b>x</b>"));
assert!(
email
.body
.contains("<b>x</b> ([email protected])")
);
}
#[test]
fn colleague_joined_rate_limit_key_is_per_recipient() {
let to_bob = make_colleague_joined();
let to_carol = ColleagueJoinedMacro {
recipient_email: EmailStr::try_from("[email protected]".to_string()).unwrap(),
..make_colleague_joined()
};
assert_eq!(
to_bob.rate_limit_key().as_bytes(),
to_bob.clone().rate_limit_key().as_bytes()
);
assert_ne!(
to_bob.rate_limit_key().as_bytes(),
to_carol.rate_limit_key().as_bytes()
);
}
#[test]
fn team_invite_rate_limit_key_is_per_invite() {
let to_bob = InviteToTeamMetadata {
team_name: "Acme".to_string(),
team_id: Uuid::from_u128(1),
team_invite_id: Uuid::from_u128(10),
invited_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
role: None,
sender_profile_picture_url: None,
invitee_plan: InviteePlan::Free,
reminder: false,
is_agent: false,
inviter_name: None,
};
let to_carol = InviteToTeamMetadata {
team_invite_id: Uuid::from_u128(11),
..to_bob.clone()
};
assert_eq!(
to_bob.rate_limit_key().as_bytes(),
to_bob.clone().rate_limit_key().as_bytes()
);
assert_ne!(
to_bob.rate_limit_key().as_bytes(),
to_carol.rate_limit_key().as_bytes()
);
}
#[test]
fn colleague_joined_serde_round_trip_keeps_the_wire_shape() {
let wire = serde_json::json!({
"team_name": "Acme",
"joined_by": "macro|[email protected]",
"joined_name": "Alice Example",
"recipient_email": "[email protected]",
});
assert_eq!(serde_json::to_value(make_colleague_joined()).unwrap(), wire);
let parsed: ColleagueJoinedMacro = serde_json::from_value(wire).unwrap();
assert_eq!(parsed.team_name, "Acme");
assert_eq!(parsed.joined_by.to_string(), "macro|[email protected]");
assert_eq!(parsed.joined_name.as_deref(), Some("Alice Example"));
assert_eq!(String::from(parsed.recipient_email), "[email protected]");
}
fn make_channel_invite() -> ChannelInviteMetadata {
ChannelInviteMetadata {
invited_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
channel_name: "general".to_string(),
is_direct_message: false,
message_id: None,
email_recipient: None,
message_content: None,
sender_profile_picture_url: None,
}
}
#[test]
fn dm_invite_names_the_sender_not_the_recipient() {
let invite = ChannelInviteMetadata {
channel_name: "julia+scribbington".to_string(),
is_direct_message: true,
message_content: Some("Hey".to_string()),
..make_channel_invite()
};
let email = invite.format_email();
assert_eq!(
email.subject,
"[email protected] sent you a message on Macro"
);
assert!(
email
.body
.contains("[email protected] sent you a message on Macro.")
);
assert!(email.body.contains("Hey"));
assert!(email.body.contains(">View message</a"));
assert!(email.body.contains("/app/signup\""));
assert!(!email.body.contains("julia+scribbington"));
assert!(!email.body.contains("invited"));
assert!(!email.body.contains("Join channel"));
assert_eq!(
invite.format_title(None).unwrap(),
"[email protected] sent you a message"
);
}
#[test]
fn dm_invite_without_message_content_keeps_dm_wording() {
let email = ChannelInviteMetadata {
is_direct_message: true,
..make_channel_invite()
}
.format_email();
assert!(email.body.contains("Sign up to read and reply."));
assert!(!email.body.contains("general"));
assert!(!email.body.contains("A shared space for your team"));
}
#[test]
fn named_channel_invite_keeps_channel_wording_with_or_without_a_message() {
for message_content in [None, Some("Hey".to_string())] {
let invite = ChannelInviteMetadata {
message_content,
..make_channel_invite()
};
let email = invite.format_email();
assert_eq!(
email.subject,
"[email protected] has invited you to join #general"
);
assert!(email.body.contains("<strong>#general</strong> on Macro."));
assert!(email.body.contains(">Join channel</a"));
assert!(!email.body.contains("sent you a message"));
assert_eq!(
invite.format_title(None).unwrap(),
"[email protected] invited you to join #general"
);
}
}
#[test]
fn invite_email_escapes_message_content_and_channel_names() {
for is_direct_message in [false, true] {
let email = ChannelInviteMetadata {
channel_name: "<script>channel</script>".to_string(),
is_direct_message,
message_content: Some("<script>message</script>".to_string()),
..make_channel_invite()
}
.format_email();
assert!(!email.body.contains("<script>"));
assert!(
email
.body
.contains("<script>message</script>")
);
if !is_direct_message {
assert!(
email
.body
.contains("<script>channel</script>")
);
}
}
}
#[test]
fn legacy_channel_invites_default_to_channel_wording() {
for wire in [
serde_json::json!({
"invitedBy": "macro|[email protected]",
"channelName": "general",
}),
serde_json::json!({
"invited_by": "macro|[email protected]",
"channel_name": "general",
}),
] {
let invite: ChannelInviteMetadata = serde_json::from_value(wire).unwrap();
assert!(!invite.is_direct_message);
assert_eq!(
invite.format_email().subject,
"[email protected] has invited you to join #general"
);
}
}
#[test]
fn dm_invite_serde_round_trip_preserves_dm_wording() {
let invite = ChannelInviteMetadata {
is_direct_message: true,
..make_channel_invite()
};
let wire = serde_json::to_value(&invite).unwrap();
assert_eq!(wire["isDirectMessage"], true);
let parsed: ChannelInviteMetadata = serde_json::from_value(wire).unwrap();
assert!(parsed.is_direct_message);
assert_eq!(parsed.format_email().subject, invite.format_email().subject);
}
fn make_invite() -> InviteToMacro {
InviteToMacro {
recipient_email: EmailStr::try_from("[email protected]".to_string()).unwrap(),
referral_code: ReferralCode("ABC123".to_string()),
sender_profile_picture_url: None,
sender_name: Some("Test User".to_string()),
sender_email: Some("[email protected]".to_string()),
}
}
#[test]
fn invitation_logos_keep_the_png_aspect_ratio() {
let team_invite = InviteToTeamMetadata {
team_name: "Acme".to_string(),
team_id: Uuid::nil(),
team_invite_id: Uuid::nil(),
invited_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
role: None,
sender_profile_picture_url: None,
invitee_plan: InviteePlan::Free,
reminder: false,
is_agent: false,
inviter_name: None,
};
for email in [
make_invite().format_email(),
make_channel_invite().format_email(),
team_invite.format_email(),
make_colleague_joined().format_email(),
] {
let body = email.body.split_whitespace().collect::<Vec<_>>().join(" ");
assert!(body.contains(
r#"src="https://static-file-service.macro.com/file/b911aba9-94a6-435c-aa16-8404739f13b0" width="54" height="36""#
));
}
}
#[test]
fn referral_url_does_not_panic() {
let invite = make_invite();
let _url = invite.referral_url();
}
#[test]
fn get_url_all_environments() {
let code = ReferralCode("CODE".to_string());
let cases = [
(Environment::Production, "macro.com"),
(Environment::Develop, "dev.macro.com"),
(Environment::Local, "localhost"),
];
for (env, expected_host) in cases {
let url = get_url(env, &code);
assert_eq!(url.host_str().unwrap(), expected_host);
assert!(url.as_str().contains("referral_code=CODE"));
assert_eq!(url.path(), "/app/signup");
}
}
#[test]
fn format_email_with_sender_name() {
let invite = make_invite();
let referral_url = invite.referral_url().to_string();
let email = invite.format_email();
assert_eq!(email.subject, "Test User has invited you to join Macro");
assert!(
email.body.contains(&referral_url),
"email body should contain the referral URL"
);
}
#[test]
fn format_email_falls_back_to_email_when_no_name() {
let invite = InviteToMacro {
sender_name: None,
..make_invite()
};
let email = invite.format_email();
assert_eq!(
email.subject,
"[email protected] has invited you to join Macro"
);
assert!(email.body.contains("[email protected]"));
}
#[test]
fn format_email_falls_back_to_generic_when_no_name_or_email() {
let invite = InviteToMacro {
sender_name: None,
sender_email: None,
..make_invite()
};
let email = invite.format_email();
assert_eq!(email.subject, "A Macro user has invited you to join Macro");
}
#[test]
fn rate_limit_config_does_not_panic() {
let config = InviteToMacro::rate_limit_config();
assert_eq!(config.max_count, 1);
assert_eq!(config.window, Duration::from_mins(MINUTES_PER_WEEK));
}
#[test]
fn rate_limit_key_does_not_panic() {
let invite = make_invite();
let _key = invite.rate_limit_key();
}
#[test]
fn serialization_roundtrip() {
let invite = make_invite();
let json = serde_json::to_string(&invite).unwrap();
let deserialized: InviteToMacro = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized.referral_code.0, "ABC123");
}
#[test]
fn deserialization_without_sender_email_uses_none() {
let json = r#"{
"recipient_email": "[email protected]",
"referral_code": "ABC123",
"sender_profile_picture_url": null,
"sender_name": "Test User"
}"#;
let deserialized: InviteToMacro = serde_json::from_str(json).unwrap();
assert!(deserialized.sender_email.is_none());
}
#[test]
fn dm_emails_deduplicate_retries_without_suppressing_later_messages() {
let first = ChannelInviteMetadata {
is_direct_message: true,
message_id: Some(Uuid::new_v4()),
..make_channel_invite()
};
let other_recipient = ChannelInviteMetadata {
email_recipient: Some(MacroUserIdStr::try_from_email("[email protected]").unwrap()),
..first.clone()
};
assert_ne!(
first.rate_limit_key().as_bytes(),
other_recipient.rate_limit_key().as_bytes()
);
let next = ChannelInviteMetadata {
message_id: Some(Uuid::new_v4()),
..first.clone()
};
assert_eq!(
first.rate_limit_key().as_bytes(),
first.clone().rate_limit_key().as_bytes()
);
assert_ne!(
first.rate_limit_key().as_bytes(),
next.rate_limit_key().as_bytes()
);
let channel = ChannelInviteMetadata {
is_direct_message: false,
..first
};
let next_channel = ChannelInviteMetadata {
is_direct_message: false,
..next
};
assert_eq!(
channel.rate_limit_key().as_bytes(),
next_channel.rate_limit_key().as_bytes()
);
}
fn make_team_invite(invitee_plan: InviteePlan) -> InviteToTeamMetadata {
InviteToTeamMetadata {
team_name: "Acme".to_string(),
team_id: Uuid::from_u128(1),
team_invite_id: Uuid::from_u128(10),
invited_by: MacroUserIdStr::try_from_email("[email protected]").unwrap(),
role: None,
sender_profile_picture_url: None,
invitee_plan,
reminder: false,
is_agent: false,
inviter_name: Some("Alice Example".to_string()),
}
}
/// The rendered body with whitespace collapsed, so assertions read like the email.
fn team_invite_text(invite: &InviteToTeamMetadata) -> String {
invite
.format_email()
.body
.split_whitespace()
.collect::<Vec<_>>()
.join(" ")
}
#[test]
fn team_invite_names_the_inviter_and_the_team() {
let invite = make_team_invite(InviteePlan::Free);
let text = team_invite_text(&invite);
assert_eq!(
invite.format_email().subject,
"Alice Example invited you to join Acme on Macro"
);
assert!(text.contains("Join Acme on Macro </h1>"));
assert!(text.contains(
r#"<strong style="color: #222222">Alice Example</strong> ([email protected]) invited you to the <strong style="color: #222222">Acme</strong> team."#
));
assert!(text.contains(">Join Acme</a"));
}
#[test]
fn team_invite_falls_back_to_the_inviter_address_without_a_usable_name() {
for inviter_name in [None, Some(" \n\t\u{7} ".to_string())] {
let invite = InviteToTeamMetadata {
inviter_name,
..make_team_invite(InviteePlan::Free)
};
let email = invite.format_email();
assert_eq!(
email.subject,
"[email protected] invited you to join Acme on Macro"
);
assert!(email.from_name.is_none());
assert_eq!(
email.reply_to.map(String::from).as_deref(),
Some("[email protected]")
);
assert!(team_invite_text(&invite).contains(
r#"<strong style="color: #222222">[email protected]</strong> invited you to the"#
));
assert!(!email.body.contains("([email protected])"));
assert!(
email
.text
.unwrap()
.starts_with("[email protected] invited you to the Acme team on Macro.")
);
}
}
#[test]
fn team_invite_is_sent_on_behalf_of_the_inviter() {
let email = make_team_invite(InviteePlan::Free).format_email();
assert_eq!(email.from_name.as_deref(), Some("Alice Example"));
assert_eq!(
email.reply_to.map(String::from).as_deref(),
Some("[email protected]")
);
}
#[test]
fn team_invite_escapes_and_caps_the_inviter_name() {
let invite = InviteToTeamMetadata {
inviter_name: Some(format!(
"<b>Alice</b>\r\nBcc: [email protected] {}",
"x".repeat(100)
)),
..make_team_invite(InviteePlan::Free)
};
let email = invite.format_email();
let name = format!("<b>Alice</b> Bcc: [email protected] {}", "x".repeat(32));
assert_eq!(name.chars().count(), 64);
assert_eq!(
email.subject,
format!("{name} invited you to join Acme on Macro")
);
assert_eq!(email.from_name.as_deref(), Some(name.as_str()));
assert!(!email.body.contains("<b>Alice</b>"));
assert!(email.body.contains("<b>Alice</b> Bcc:"));
}
#[test]
fn team_invite_text_part_names_the_inviter_team_plan_and_link() {
let free = make_team_invite(InviteePlan::Free);
let url = free.invite_url().to_string();
let text = free.format_email().text.unwrap();
assert!(
text.starts_with(
"Alice Example ([email protected]) invited you to the Acme team on Macro."
)
);
assert!(text.contains(
"Free to join: there's nothing to pay. Accept the invite to start working with Acme in Macro."
));
assert!(text.contains(&format!("this email address:\n{url}\n")));
assert!(!text.contains('<'));
let pro = make_team_invite(InviteePlan::Premium)
.format_email()
.text
.unwrap();
assert!(pro.contains(
"Pro is included: Acme covers your seat, so you get every AI model and agent at no cost to you."
));
assert!(!pro.contains("Free to join"));
}
#[test]
fn team_invites_queued_before_inviter_names_fall_back_to_the_address() {
let mut wire = serde_json::to_value(make_team_invite(InviteePlan::Free)).unwrap();
assert_eq!(wire["inviterName"], "Alice Example");
wire.as_object_mut().unwrap().remove("inviterName");
let parsed: InviteToTeamMetadata = serde_json::from_value(wire).unwrap();
assert!(parsed.inviter_name.is_none());
assert_eq!(
parsed.format_email().subject,
"[email protected] invited you to join Acme on Macro"
);
}
#[test]
fn team_invite_promises_pro_only_when_the_team_covers_the_seat() {
let pro = team_invite_text(&make_team_invite(InviteePlan::Premium));
assert!(pro.contains("Pro is included: Acme covers your seat."));
assert!(
pro.contains(
"Acme covers your seat, so you get every AI model and agent at no cost to you."
)
);
assert!(!pro.contains("Free to join"));
let free = team_invite_text(&make_team_invite(InviteePlan::Free));
assert!(free.contains("Free to join"));
assert!(free.contains("Accept the invite to start working with Acme in Macro."));
assert!(!free.contains("Pro is included"));
assert!(!free.contains("covers your seat"));
}
#[test]
fn team_invite_links_the_button_and_a_pasteable_fallback() {
let invite = make_team_invite(InviteePlan::Free);
let url = invite.invite_url().to_string();
let body = invite.format_email().body;
assert!(url.ends_with("/app/team-invite?id=00000000-0000-0000-0000-00000000000a"));
// The button's href, the fallback link's href, and its visible text.
assert_eq!(body.matches(&url).count(), 3);
}
#[test]
fn agent_team_invite_links_to_the_agent_signup_page() {
let invite = InviteToTeamMetadata {
is_agent: true,
..make_team_invite(InviteePlan::Free)
};
let url = invite.invite_url().to_string();
let body = invite.format_email().body;
assert!(url.ends_with("/app/signup/agent?team_invite=00000000-0000-0000-0000-00000000000a"));
assert_eq!(body.matches(&url).count(), 3);
}
#[test]
fn team_invite_escapes_the_team_name() {
let invite = InviteToTeamMetadata {
team_name: "<script>alert(1)</script>".to_string(),
..make_team_invite(InviteePlan::Premium)
};
let body = invite.format_email().body;
assert!(!body.contains("<script>"));
assert!(body.contains("Join <script>alert(1)</script> on Macro"));
}
#[test]
fn team_invite_button_names_the_team_while_it_fits() {
assert_eq!(
make_team_invite(InviteePlan::Free).join_label(),
"Join Acme"
);
let long = InviteToTeamMetadata {
team_name: "Northwind Traders International".to_string(),
..make_team_invite(InviteePlan::Free)
};
assert_eq!(long.join_label(), "Join team");
}
#[test]
fn team_invite_plan_keeps_its_wire_shape() {
let wire = serde_json::to_value(make_team_invite(InviteePlan::Premium)).unwrap();
assert_eq!(wire["inviteePlan"], "premium");
let read: InviteToTeamMetadata = serde_json::from_value(wire).unwrap();
assert_eq!(read.invitee_plan, InviteePlan::Premium);
}
#[test]
fn team_invite_sent_before_plans_were_recorded_reads_as_free() {
let wire = serde_json::json!({
"team_name": "Acme",
"team_id": "00000000-0000-0000-0000-000000000001",
"team_invite_id": "00000000-0000-0000-0000-00000000000a",
"invited_by": "macro|[email protected]",
"role": null,
});
let read: InviteToTeamMetadata = serde_json::from_value(wire).unwrap();
assert_eq!(read.invitee_plan, InviteePlan::Free);
}
#[test]
fn team_invite_reminder_says_so_in_the_subject() {
let reminder = InviteToTeamMetadata {
reminder: true,
is_agent: false,
..make_team_invite(InviteePlan::Free)
};
assert_eq!(
reminder.format_email().subject,
"Reminder: Alice Example invited you to join Acme on Macro"
);
assert_eq!(
make_team_invite(InviteePlan::Free).format_email().subject,
"Alice Example invited you to join Acme on Macro"
);
}
#[test]
fn team_invites_queued_before_reminders_read_as_first_sends() {
let mut wire = serde_json::to_value(make_team_invite(InviteePlan::Free)).unwrap();
wire.as_object_mut().unwrap().remove("reminder");
let parsed: InviteToTeamMetadata = serde_json::from_value(wire).unwrap();
assert!(!parsed.reminder);
}