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.

41.8 KB
Raw Blame
use cool_asserts::assert_matches;

use crate::parse::{
    NullXmlFormatter, ParsedAgentSessionMention, ParsedBookingLinkMention, ParsedContactMention,
    ParsedDateMention, ParsedDocumentMention, ParsedGroupMention, ParsedLink,
    ParsedPullRequestMention, ParsedUserMention, ParsedXmlText, PlainTextFormatter, TextSegment,
    XmlFormatter, XmlTag,
};

// =============================================================================
// Basic parsing tests
// =============================================================================

#[test]
fn plain_message() {
    let input = "I'm testing a regular message";
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [TextSegment::Plain("I'm testing a regular message")]);
}

#[test]
fn empty_string() {
    let out = ParsedXmlText::parse("").unwrap();
    assert!(out.0.is_empty());
}

// =============================================================================
// Document mention tests
// =============================================================================

#[test]
fn parse_single_document_mention() {
    let input = r#"<m-document-mention>{"documentName":"My Doc"}</m-document-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name, .. }))
    ] => {
        assert_eq!(document_name.as_ref(), "My Doc");
    });
}

#[test]
fn parse_document_mentions_with_text() {
    let input = r#"I'm testing sending a message with a document  <m-document-mention>{"documentId":"doc-1","blockName":"md","documentName":"Document 1","blockParams":{}}</m-document-mention> mention  <m-document-mention>{"documentId":"doc-2","blockName":"md","documentName":"Document 2","blockParams":{}}</m-document-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();

    assert_matches!(out.0, [
        TextSegment::Plain("I'm testing sending a message with a document  "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name: name1, .. })),
        TextSegment::Plain(" mention  "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name: name2, .. })),
    ] => {
        assert_eq!(name1.as_ref(), "Document 1");
        assert_eq!(name2.as_ref(), "Document 2");
    });
}

#[test]
fn nameless_document_mentions_render_as_their_kind() {
    let input = concat!(
        r#"I made <m-document-mention>{"documentId":"d1","documentName":"","blockName":"md","blockParams":{}}</m-document-mention>"#,
        r#" from <m-document-mention>{"documentId":"d2","documentName":"","blockName":"database","blockParams":{}}</m-document-mention>"#,
        r#", filed <m-document-mention>{"documentId":"t1","documentName":" ","blockName":"task","blockParams":{}}</m-document-mention>"#,
        r#" under <m-document-mention>{"documentId":"i1","documentName":"","blockName":"initiative","blockParams":{}}</m-document-mention>"#,
        r#" in <m-document-mention>{"documentId":"p1","documentName":"","blockName":"project","blockParams":{}}</m-document-mention>"#,
        r#" and replied to <m-document-mention>{"documentId":"c1","documentName":"","blockName":"channel","blockParams":{"channel_message_id":"m1"}}</m-document-mention>"#,
        r#" in <m-document-mention>{"documentId":"c1","documentName":"","blockName":"channel","blockParams":{}}</m-document-mention>"#,
        r#" about <m-document-mention>{"documentId":"x1","documentName":"","blockName":"unheard-of","blockParams":{}}</m-document-mention>."#,
    );
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(
        rendered,
        "I made <document> from <database>, filed <task> under <project> in <folder> and replied to <message> in <channel> about <item>."
    );
}

#[test]
fn document_mention_without_name_or_params_renders_as_its_kind() {
    // Agents omit documentName, and routine mentions carry no blockParams.
    let input = concat!(
        r#"<m-document-mention>{"documentId":"r1","blockName":"routine"}</m-document-mention>"#,
        r#" and <m-document-mention>{"documentId":"x1"}</m-document-mention>"#,
    );
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "<routine> and <item>");
}

#[test]
fn document_mention_with_odd_block_params_still_renders() {
    let input = concat!(
        r#"<m-document-mention>{"documentId":"d1","documentName":"","blockName":"md","blockParams":"x"}</m-document-mention>"#,
        r#" and <m-document-mention>{"documentId":"c1","documentName":"","blockName":"channel","blockParams":{"channel_message_id":null}}</m-document-mention>"#,
    );
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "<document> and <channel>");
}

#[test]
fn named_document_mention_renders_its_name() {
    let input = r#"<m-document-mention>{"documentId":"t1","documentName":"Ship it","blockName":"task","blockParams":{}}</m-document-mention>"#;
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "Ship it");
}

#[test]
fn kind_placeholder_is_not_read_back_as_a_tag() {
    let input = r#"see <m-document-mention>{"documentId":"d1","documentName":"","blockName":"md","blockParams":{}}</m-document-mention>"#;
    let once = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    let twice = PlainTextFormatter::format_xml_text(ParsedXmlText::parse_lenient(&once)).0;
    assert_eq!(once, "see <document>");
    assert_eq!(twice, once);
}

#[test]
fn parse_document_mention_invalid_json() {
    let input = r#"<m-document-mention>???</m-document-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

// =============================================================================
// User mention tests
// =============================================================================

#[test]
fn parse_single_user_mention() {
    let input = r#"<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::User(ParsedUserMention { user_id, .. }))
    ] => {
        assert_eq!(user_id.as_ref(), "macro|[email protected]");
    });
}

#[test]
fn parse_multiple_user_mentions() {
    let input = r#"Hello <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> and <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Hello "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention { user_id: uid1, .. })),
        TextSegment::Plain(" and "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention { user_id: uid2, .. })),
    ] => {
        assert_eq!(uid1.as_ref(), "macro|[email protected]");
        assert_eq!(uid2.as_ref(), "macro|[email protected]");
    });
}

#[test]
fn parse_user_mention_invalid_json() {
    let input = r#"<m-user-mention>invalid</m-user-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

// =============================================================================
// Bot mention tests
// =============================================================================

#[test]
fn parse_bare_uuid_bot_mention() {
    let input = r#"<m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000a1a1","email":"Macro"}</m-user-mention> there will come a day when I shall liberate you"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::User(ParsedUserMention { user_id, .. })),
        TextSegment::Plain(" there will come a day when I shall liberate you"),
    ] => {
        assert_eq!(user_id.into_bot().unwrap().as_uuid().to_string(), "00000000-0000-0000-0000-00000000a1a1");
    });
}

#[test]
fn parse_prefixed_bot_mention() {
    let input = r#"<m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000a1a1","email":"Macro"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::User(ParsedUserMention { user_id, .. })),
    ] => {
        assert_eq!(user_id.as_ref(), "bot|00000000-0000-0000-0000-00000000a1a1");
    });
}

#[test]
fn bot_mention_renders_display_name() {
    let input = r#"hi <m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000a1a1","email":"Macro"}</m-user-mention> ok"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "hi Macro ok");
}

#[test]
fn cursor_bot_mention_renders_cursor_not_macro() {
    let input = r#"<m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000c5c5","email":"Cursor","displayName":"Cursor"}</m-user-mention> investigate this"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Cursor investigate this");
}

#[test]
fn bot_mention_prefers_display_name_over_email() {
    let input = r#"<m-user-mention>{"userId":"bot|11111111-1111-1111-1111-111111111111","email":"Helper Bot","displayName":"Helper"}</m-user-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Helper");
}

#[test]
fn team_bot_mention_renders_email_field_as_name() {
    let input = r#"<m-user-mention>{"userId":"bot|11111111-1111-1111-1111-111111111111","email":"Helper Bot"}</m-user-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Helper Bot");
}

#[test]
fn system_bot_mention_without_name_fields_uses_registry() {
    let input =
        r#"<m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000c5c5"}</m-user-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Cursor");
}

#[test]
fn bot_mention_ignores_blank_name_fields() {
    let input = r#"<m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000c5c5","email":"","displayName":" "}</m-user-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Cursor");
}

#[test]
fn unknown_bot_mention_without_name_fields_uses_generic_label() {
    let input =
        r#"<m-user-mention>{"userId":"bot|11111111-1111-1111-1111-111111111111"}</m-user-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Bot");
}

#[test]
fn bot_mention_null_formatter_strips_mention() {
    let input = r#"hi <m-user-mention>{"userId":"bot|00000000-0000-0000-0000-00000000a1a1","email":"Macro"}</m-user-mention> ok"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = NullXmlFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "hi  ok");
}

#[test]
fn user_mention_renders_email() {
    let input = r#"<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "[email protected]");
}

// =============================================================================
// Contact mention tests
// =============================================================================

#[test]
fn parse_contact_mention() {
    let input = r#"asdf <m-contact-mention>{"contactId":"[email protected]","name":"Ness Chu","emailOrDomain":"[email protected]","isCompany":false}</m-contact-mention> asdf"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("asdf "),
        TextSegment::Xml(XmlTag::Contact(ParsedContactMention { name })),
        TextSegment::Plain(" asdf"),
    ] => {
        assert_eq!(name.as_ref(), "Ness Chu");
    });
}

#[test]
fn parse_contact_mention_missing_name() {
    // Missing "name" field - should fail to parse
    let input = r#"<m-contact-mention>{"contactId":"[email protected]","emailOrDomain":"[email protected]"}</m-contact-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_contact_mention_invalid_json() {
    let input = r#"<m-contact-mention>not-json</m-contact-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

// =============================================================================
// Date mention tests
// =============================================================================

#[test]
fn parse_date_mention() {
    let input = r#"asdf <m-date-mention>{"date":"2025-12-01T05:00:00.000Z","displayFormat":"Mon, Dec 1, 2025"}</m-date-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("asdf "),
        TextSegment::Xml(XmlTag::Date(ParsedDateMention { display_format })),
    ] => {
        assert_eq!(display_format.as_ref(), "Mon, Dec 1, 2025");
    });
}

#[test]
fn parse_date_mention_missing_display_format() {
    // Missing "displayFormat" field - should fail to parse
    let input = r#"<m-date-mention>{"date":"2025-12-01T05:00:00.000Z"}</m-date-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_date_mention_invalid_json() {
    let input = r#"<m-date-mention>{broken</m-date-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

// =============================================================================
// Link tests
// =============================================================================

#[test]
fn parse_link_different_text_and_url() {
    let input = r#"Visit <m-link>{"text":"Example Website","url":"https://www.example.com"}</m-link> today"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Visit "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
        TextSegment::Plain(" today"),
    ] => {
        assert_eq!(text.as_ref(), "Example Website");
        assert_eq!(url.as_ref(), "https://www.example.com");
    });
}

#[test]
fn parse_link_same_text_and_url() {
    let input = r#"<m-link>{"url":"https://example.com","text":"https://example.com"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "https://example.com");
        assert_eq!(url.as_ref(), "https://example.com");
    });
}

#[test]
fn parse_multiple_links() {
    let input = r#"Check out <m-link>{"text":"Google","url":"https://google.com"}</m-link> and also <m-link>{"text":"https://github.com","url":"https://github.com"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Check out "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text: t1, url: u1 })),
        TextSegment::Plain(" and also "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text: t2, url: u2 })),
    ] => {
        assert_eq!(t1.as_ref(), "Google");
        assert_eq!(u1.as_ref(), "https://google.com");
        assert_eq!(t2.as_ref(), "https://github.com");
        assert_eq!(u2.as_ref(), "https://github.com");
    });
}

#[test]
fn parse_link_empty_text() {
    let input = r#"<m-link>{"text":"","url":"https://www.example.com"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "");
        assert_eq!(url.as_ref(), "https://www.example.com");
    });
}

#[test]
fn parse_link_with_special_characters() {
    let input = r#"<m-link>{"text":"Search: \"hello world\"","url":"https://example.com?q=hello%20world&sort=date"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "Search: \"hello world\"");
        assert_eq!(url.as_ref(), "https://example.com?q=hello%20world&sort=date");
    });
}

#[test]
fn parse_link_missing_text() {
    // Missing "text" field - should fail to parse
    let input = r#"<m-link>{"url":"https://www.example.com"}</m-link>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_link_missing_url() {
    // Missing "url" field - should fail to parse
    let input = r#"<m-link>{"text":"Example Link"}</m-link>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_link_invalid_json() {
    let input = r#"<m-link>{"text":"Example","url":INVALID}</m-link>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_link_with_title_field() {
    // Title field should be ignored, only text and url matter
    let input =
        r#"<m-link>{"url":"https://example.com","text":"Example","title":"A title"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "Example");
        assert_eq!(url.as_ref(), "https://example.com");
    });
}

#[test]
fn parse_link_unicode_characters() {
    let input = r#"<m-link>{"text":"测试链接 🔗","url":"https://example.com/测试"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "测试链接 🔗");
        assert_eq!(url.as_ref(), "https://example.com/测试");
    });
}

// =============================================================================
// Mixed mention tests
// =============================================================================

#[test]
fn parse_mixed_mentions() {
    let input = r#"Hi <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>, let's discuss <m-document-mention>{"documentId":"6e01eaf5-f497-4b2e-96d0-ea3d527ef47d","blockName":"md","documentName":"Test Doc 34","blockParams":{},"collapsed":false}</m-document-mention> with <m-contact-mention>{"contactId":"[email protected]","name":"Ness Chu","emailOrDomain":"[email protected]","isCompany":false}</m-contact-mention> on <m-date-mention>{"date":"2025-12-01T05:00:00.000Z","displayFormat":"Mon, Dec 1, 2025"}</m-date-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Hi "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
        TextSegment::Plain(", let's discuss "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name, .. })),
        TextSegment::Plain(" with "),
        TextSegment::Xml(XmlTag::Contact(ParsedContactMention { name })),
        TextSegment::Plain(" on "),
        TextSegment::Xml(XmlTag::Date(ParsedDateMention { display_format })),
    ] => {
        assert_eq!(document_name.as_ref(), "Test Doc 34");
        assert_eq!(name.as_ref(), "Ness Chu");
        assert_eq!(display_format.as_ref(), "Mon, Dec 1, 2025");
    });
}

#[test]
fn parse_mixed_mentions_with_links() {
    let input = r#"Hi <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>, check out <m-link>{"text":"Our Docs","url":"https://docs.example.com"}</m-link> and <m-document-mention>{"documentId":"6e01eaf5-f497-4b2e-96d0-ea3d527ef47d","blockName":"md","documentName":"Test Doc 34","blockParams":{},"collapsed":false}</m-document-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Hi "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention {  .. })),
        TextSegment::Plain(", check out "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
        TextSegment::Plain(" and "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name, .. })),
    ] => {
        assert_eq!(text.as_ref(), "Our Docs");
        assert_eq!(url.as_ref(), "https://docs.example.com");
        assert_eq!(document_name.as_ref(), "Test Doc 34");
    });
}

#[test]
fn parse_content_with_multiple_document_and_user_mentions() {
    let input = r#"<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> I'm testing sending a message with a document  <m-document-mention>{"documentId":"doc-1","blockName":"md","documentName":"Document 1","blockParams":{}}</m-document-mention> mention  <m-document-mention>{"documentId":"doc-2","blockName":"md","documentName":"Document 2","blockParams":{}}</m-document-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::User(ParsedUserMention {  .. })),
        TextSegment::Plain(" I'm testing sending a message with a document  "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name: name1, .. })),
        TextSegment::Plain(" mention  "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name: name2, .. })),
    ] => {
        assert_eq!(name1.as_ref(), "Document 1");
        assert_eq!(name2.as_ref(), "Document 2");
    });
}

// =============================================================================
// Edge cases
// =============================================================================

#[test]
fn parse_text_with_angle_brackets_but_no_mentions() {
    // Text with < that isn't a valid tag should fail since we can't parse it
    let input = "5 < 10 and 10 > 5";
    let result = ParsedXmlText::parse(input);
    // This will fail because < starts something that isn't a valid tag
    assert!(result.is_err());
}

#[test]
fn parse_consecutive_mentions_no_space() {
    let input = r#"<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention><m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [
            TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
            TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
        ]
    );
}

#[test]
fn parse_mention_at_start() {
    let input =
        r#"<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> hello"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [
            TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
            TextSegment::Plain(" hello"),
        ]
    );
}

#[test]
fn parse_mention_at_end() {
    let input =
        r#"hello <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [
            TextSegment::Plain("hello "),
            TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
        ]
    );
}

// =============================================================================
// Additional tests to match original test coverage
// =============================================================================

#[test]
fn parse_user_mention_with_surrounding_text() {
    let input = r#"asdf <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> asdf"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [
            TextSegment::Plain("asdf "),
            TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
            TextSegment::Plain(" asdf"),
        ]
    );
}

#[test]
fn parse_document_mention_with_surrounding_text() {
    let input = r#"asdf <m-document-mention>{"documentId":"6e01eaf5-f497-4b2e-96d0-ea3d527ef47d","blockName":"md","documentName":"Test Doc 34","blockParams":{},"collapsed":false}</m-document-mention> asdf"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("asdf "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name, .. })),
        TextSegment::Plain(" asdf"),
    ] => {
        assert_eq!(document_name.as_ref(), "Test Doc 34");
    });
}

#[test]
fn parse_plain_message_no_mentions() {
    let input = "Just a regular message with no mentions";
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [TextSegment::Plain(
            "Just a regular message with no mentions"
        )]
    );
}

#[test]
fn parse_user_mention_invalid_json_with_suffix() {
    let input =
        r#"<m-user-mention>{"userId":"macro|[email protected]",INVALID}</m-user-mention> asdf"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_link_same_text_url_with_surrounding_text() {
    let input = r#"Check out this link <m-link>{"text":"https://www.example.com","url":"https://www.example.com"}</m-link> for more info"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Check out this link "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
        TextSegment::Plain(" for more info"),
    ] => {
        assert_eq!(text.as_ref(), "https://www.example.com");
        assert_eq!(url.as_ref(), "https://www.example.com");
    });
}

#[test]
fn parse_link_empty_text_with_prefix() {
    let input = r#"Link: <m-link>{"text":"","url":"https://www.example.com"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Link: "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "");
        assert_eq!(url.as_ref(), "https://www.example.com");
    });
}

#[test]
fn parse_link_special_chars_with_prefix() {
    let input = r#"Complex link <m-link>{"text":"Search: \"hello world\"","url":"https://example.com?q=hello%20world&sort=date"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Complex link "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "Search: \"hello world\"");
        assert_eq!(url.as_ref(), "https://example.com?q=hello%20world&sort=date");
    });
}

#[test]
fn parse_link_missing_text_with_suffix() {
    let input = r#"<m-link>{"url":"https://www.example.com"}</m-link> missing text field"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_link_missing_url_with_suffix() {
    let input = r#"<m-link>{"text":"Example Link"}</m-link> missing url field"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_link_invalid_json_with_suffix() {
    let input = r#"<m-link>{"text":"Example","url":INVALID}</m-link> invalid json"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_mixed_mentions_with_multiple_links() {
    let input = r#"Hi <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>, check out <m-link>{"text":"Our Docs","url":"https://docs.example.com"}</m-link> and <m-document-mention>{"documentId":"6e01eaf5-f497-4b2e-96d0-ea3d527ef47d","blockName":"md","documentName":"Test Doc 34","blockParams":{},"collapsed":false}</m-document-mention> on <m-date-mention>{"date":"2025-12-01T05:00:00.000Z","displayFormat":"Mon, Dec 1, 2025"}</m-date-mention> or visit <m-link>{"text":"https://example.com","url":"https://example.com"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Hi "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
        TextSegment::Plain(", check out "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text: t1, .. })),
        TextSegment::Plain(" and "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name, .. })),
        TextSegment::Plain(" on "),
        TextSegment::Xml(XmlTag::Date(ParsedDateMention { display_format })),
        TextSegment::Plain(" or visit "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text: t2, url: u2 })),
    ] => {
        assert_eq!(t1.as_ref(), "Our Docs");
        assert_eq!(document_name.as_ref(), "Test Doc 34");
        assert_eq!(display_format.as_ref(), "Mon, Dec 1, 2025");
        assert_eq!(t2.as_ref(), "https://example.com");
        assert_eq!(u2.as_ref(), "https://example.com");
    });
}

#[test]
fn parse_link_user_document_mixed() {
    let input = r#"Check out <m-link>{"text":"Example","url":"https://example.com"}</m-link> and <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> this doc <m-document-mention>{"documentId":"doc-1","blockName":"md","documentName":"Document 1","blockParams":{}}</m-document-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Check out "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
        TextSegment::Plain(" and "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
        TextSegment::Plain(" this doc "),
        TextSegment::Xml(XmlTag::Document(ParsedDocumentMention { document_name, .. })),
    ] => {
        assert_eq!(text.as_ref(), "Example");
        assert_eq!(url.as_ref(), "https://example.com");
        assert_eq!(document_name.as_ref(), "Document 1");
    });
}

#[test]
fn parse_link_markdown_characters_in_text() {
    let input = r#"Link with special chars <m-link>{"text":"[Already] (Markdown) *Format*","url":"https://example.com"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Link with special chars "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "[Already] (Markdown) *Format*");
        assert_eq!(url.as_ref(), "https://example.com");
    });
}

#[test]
fn parse_link_unicode_with_prefix() {
    let input =
        r#"Unicode link <m-link>{"text":"测试链接 🔗","url":"https://example.com/测试"}</m-link>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Unicode link "),
        TextSegment::Xml(XmlTag::Link(ParsedLink { text, url })),
    ] => {
        assert_eq!(text.as_ref(), "测试链接 🔗");
        assert_eq!(url.as_ref(), "https://example.com/测试");
    });
}

#[test]
fn parse_contact_mention_missing_name_with_suffix() {
    let input = r#"<m-contact-mention>{"contactId":"[email protected]","emailOrDomain":"[email protected]","isCompany":false}</m-contact-mention> asdf"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_document_mention_missing_name_with_suffix() {
    let input = r#"<m-document-mention>{"documentId":"6e01eaf5-f497-4b2e-96d0-ea3d527ef47d","blockName":"md","blockParams":{},"collapsed":false}</m-document-mention> asdf"#;
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "<document> asdf");
}

// =============================================================================
// Group mention tests
// =============================================================================

#[test]
fn parse_single_group_mention() {
    let input = r#"<m-group-mention>{"groupAlias":"here"}</m-group-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Group(ParsedGroupMention { group_alias }))
    ] => {
        assert_eq!(group_alias.as_ref(), "here");
    });
}

#[test]
fn parse_group_mention_with_surrounding_text() {
    let input = r#"Hey <m-group-mention>{"groupAlias":"here"}</m-group-mention> check this out"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("Hey "),
        TextSegment::Xml(XmlTag::Group(ParsedGroupMention { group_alias })),
        TextSegment::Plain(" check this out"),
    ] => {
        assert_eq!(group_alias.as_ref(), "here");
    });
}

#[test]
fn parse_group_mention_missing_alias() {
    let input = r#"<m-group-mention>{}</m-group-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_group_mention_invalid_json() {
    let input = r#"<m-group-mention>invalid</m-group-mention>"#;
    let result = ParsedXmlText::parse(input);
    assert!(result.is_err());
}

#[test]
fn parse_group_mention_with_user_mention() {
    let input = r#"<m-group-mention>{"groupAlias":"here"}</m-group-mention> and <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::Group(ParsedGroupMention { group_alias })),
        TextSegment::Plain(" and "),
        TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
    ] => {
        assert_eq!(group_alias.as_ref(), "here");
    });
}

// =============================================================================
// Agent session and pull request mention tests
// =============================================================================

#[test]
fn parse_agent_session_mention() {
    let input = r#"see <m-agent-session-mention>{"id":"sess-1","label":"Fix login"}</m-agent-session-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Plain("see "),
        TextSegment::Xml(XmlTag::AgentSession(ParsedAgentSessionMention { id, label })),
    ] => {
        assert_eq!(id.as_ref(), "sess-1");
        assert_eq!(label.as_deref(), Some("Fix login"));
    });
}

#[test]
fn parse_agent_session_mention_without_label() {
    let input = r#"<m-agent-session-mention>{"id":"sess-1"}</m-agent-session-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Agent session");
}

#[test]
fn parse_agent_session_mention_missing_id() {
    let input = r#"<m-agent-session-mention>{"label":"Fix login"}</m-agent-session-mention>"#;
    assert!(ParsedXmlText::parse(input).is_err());
}

#[test]
fn parse_pull_request_mention() {
    let input = r#"<m-pr-mention>{"id":"foreign-1","label":"macro/macro#123"}</m-pr-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "macro/macro#123");
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [
        TextSegment::Xml(XmlTag::PullRequest(ParsedPullRequestMention { id, label, .. })),
    ] => {
        assert_eq!(id.as_ref(), "foreign-1");
        assert_eq!(label.as_deref(), Some("macro/macro#123"));
    });
}

#[test]
fn parse_pull_request_mention_without_label() {
    let input = r#"<m-pr-mention>{"id":"foreign-1"}</m-pr-mention>"#;
    let parsed = ParsedXmlText::parse(input).unwrap();
    let rendered = PlainTextFormatter::format_xml_text(parsed).0;
    assert_eq!(rendered, "Pull request");
}

#[test]
fn parse_pull_request_mention_by_github_url() {
    let input = r#"See <m-pr-mention>{"url":"https://github.com/macro-inc/macro/pull/7945","label":""}</m-pr-mention>."#;
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "See macro-inc/macro#7945.");
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(&out.0[..], [
        TextSegment::Plain("See "),
        TextSegment::Xml(XmlTag::PullRequest(ParsedPullRequestMention { id, url, .. })),
        TextSegment::Plain("."),
    ] => {
        assert!(id.is_empty());
        assert_eq!(url.as_deref(), Some("https://github.com/macro-inc/macro/pull/7945"));
    });
}

#[test]
fn pull_request_github_ref_reads_a_url_written_as_the_id() {
    let input = r#"<m-pr-mention>{"id":"https://github.com/macro-inc/macro/pull/7945","url":null}</m-pr-mention>"#;
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "macro-inc/macro#7945");
}

#[test]
fn pull_request_github_ref_ignores_non_pull_urls() {
    for url in [
        "https://github.com/macro-inc/macro/issues/7945",
        "https://example.com/macro-inc/macro/pull/7945",
        "https://github.com/macro-inc/macro/pull/79x",
    ] {
        let input = format!(r#"<m-pr-mention>{{"url":"{url}"}}</m-pr-mention>"#);
        let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(&input).unwrap()).0;
        assert_eq!(rendered, "Pull request", "{url}");
    }
    let input =
        r#"<m-pr-mention>{"url":"https://www.github.com/a/b/pull/12/files#x"}</m-pr-mention>"#;
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "a/b#12");
}

#[test]
fn parse_booking_link_mention() {
    let input = r#"Book here: <m-booking-link-mention>{"profileId":"profile-1","slug":"intro","url":"https://macro.com/app/book/profile-1/intro","label":""}</m-booking-link-mention>"#;
    let rendered = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(rendered, "Book here: intro");
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(&out.0[..], [
        TextSegment::Plain("Book here: "),
        TextSegment::Xml(XmlTag::BookingLink(ParsedBookingLinkMention {
            profile_id,
            slug,
            url,
            ..
        })),
    ] => {
        assert_eq!(profile_id.as_ref(), "profile-1");
        assert_eq!(slug.as_deref(), Some("intro"));
        assert_eq!(url.as_ref(), "https://macro.com/app/book/profile-1/intro");
    });
}

// =============================================================================
// Unknown / unrecognized tag tests
// =============================================================================

#[test]
fn parse_await_tag_is_skipped() {
    let input = r#"<m-await>{"awaitId":"a1","text":"Macro is thinking…","inline":true}</m-await>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert!(out.0.is_empty());
}

#[test]
fn parse_await_tag_with_surrounding_text() {
    let input = r#"before <m-await>{"text":"Macro is thinking…","inline":true}</m-await> after"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [TextSegment::Plain("before "), TextSegment::Plain(" after"),]
    );
}

#[test]
fn parse_empty_await_tag_is_skipped() {
    let input = r#"hi <m-await></m-await>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(out.0, [TextSegment::Plain("hi ")]);
}

#[test]
fn parse_arbitrary_unknown_tag_is_skipped() {
    let input = r#"hello <m-foo>{"bar":1}</m-foo> world"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [TextSegment::Plain("hello "), TextSegment::Plain(" world"),]
    );
}

#[test]
fn parse_self_closing_unknown_tag_is_skipped() {
    let input = r#"hello <m-foo/> world"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [TextSegment::Plain("hello "), TextSegment::Plain(" world"),]
    );
}

#[test]
fn parse_self_closing_unknown_tag_alone_is_skipped() {
    let input = r#"<m-await/>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert!(out.0.is_empty());
}

#[test]
fn parse_unknown_tag_mixed_with_recognized() {
    let input = r#"<m-await>{"text":"thinking"}</m-await> Hi <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention>"#;
    let out = ParsedXmlText::parse(input).unwrap();
    assert_matches!(
        out.0,
        [
            TextSegment::Plain(" Hi "),
            TextSegment::Xml(XmlTag::User(ParsedUserMention { .. })),
        ]
    );
}

// =============================================================================
// Lenient parsing (prose that need not be valid markup)
// =============================================================================

fn lenient_plain_text(input: &str) -> String {
    PlainTextFormatter::format_xml_text(ParsedXmlText::parse_lenient(input)).0
}

#[test]
fn lenient_parse_unwraps_mentions_beside_stray_angle_brackets() {
    let input = r#"Fixed Vec<String> for <m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> when 5 < 10 in <m-document-mention>{"documentId":"doc-1","documentName":"the request","blockName":"channel","blockParams":{}}</m-document-mention>"#;
    assert!(ParsedXmlText::parse(input).is_err());
    assert_eq!(
        lenient_plain_text(input),
        "Fixed Vec<String> for [email protected] when 5 < 10 in the request"
    );
}

#[test]
fn lenient_parse_drops_unknown_tags_like_strict_parse() {
    let input = r#"<m-await>{"text":"thinking"}</m-await>Done <m-await/>"#;
    assert_eq!(lenient_plain_text(input), "Done ");
}

#[test]
fn lenient_parse_keeps_a_malformed_mention_as_text() {
    let input = r#"Hi <m-user-mention>invalid</m-user-mention>"#;
    assert_eq!(lenient_plain_text(input), input);
}

#[test]
fn lenient_parse_keeps_text_after_an_unclosed_tag_as_written() {
    // One scan per unclosed tag would make this input quadratic to parse.
    let input = "<m-link>x ".repeat(16 * 1024);
    assert_eq!(lenient_plain_text(&input), input);
}

#[test]
fn lenient_parse_of_valid_markup_matches_strict_parse() {
    let input = r#"<m-user-mention>{"userId":"macro|[email protected]","email":"[email protected]"}</m-user-mention> see <m-link>{"text":"docs","url":"https://example.com"}</m-link>"#;
    let strict = PlainTextFormatter::format_xml_text(ParsedXmlText::parse(input).unwrap()).0;
    assert_eq!(lenient_plain_text(input), strict);
}