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.

3.5 KB
Raw Blame
use super::*;

#[test]
fn storage_string_round_trips() {
    let uuid = Uuid::new_v4();
    let bot_id = BotId::new_from_uuid(uuid);

    assert_eq!(
        BotIdStr::parse_from_str(bot_id.into_storage_id().as_ref())
            .unwrap()
            .bot_id(),
        bot_id
    );
}

#[test]
fn bot_id_str_parses_storage_string() {
    let uuid = Uuid::new_v4();
    let bot_id = BotId::new_from_uuid(uuid);
    let storage = format!("bot|{uuid}");

    let parsed = BotIdStr::parse_from_str(&storage).unwrap();

    assert_eq!(parsed.bot_id(), bot_id);
    assert_eq!(parsed.as_uuid(), uuid);
    assert_eq!(parsed.bot_id().as_uuid().to_string(), uuid.to_string());
    assert_eq!(parsed.as_ref(), storage);
}

#[test]
fn bot_id_str_from_bot_id_creates_storage_string() {
    let bot_id = BotId::new_from_uuid(Uuid::new_v4());
    let storage = BotIdStr::from(bot_id);

    assert_eq!(storage.bot_id(), bot_id);
    assert_eq!(storage.to_string(), format!("bot|{bot_id}"));
}

#[test]
fn system_bot_id_is_stable_and_distinct_from_ai_personas() {
    assert_eq!(
        MACRO_SYSTEM_BOT_ID.into_storage_id().as_ref(),
        "bot|00000000-0000-0000-0000-000000005759"
    );
    assert_ne!(MACRO_SYSTEM_BOT_ID, MACRO_AI_BOT_ID);
    assert_ne!(MACRO_SYSTEM_BOT_ID, MACRO_CODER_BOT_ID);
}

#[test]
fn macro_new_id_is_stable_and_distinct_from_macro() {
    assert_eq!(
        MACRO_NEW_BOT_ID.into_storage_id().as_ref(),
        "bot|00000000-0000-0000-0000-00000000a2a2"
    );
    assert_ne!(MACRO_NEW_BOT_ID, MACRO_AI_BOT_ID);
    // The classic bot answers in channel; only its replacement opens sessions.
    assert!(!system_bot(MACRO_AI_BOT_ID).unwrap().has_agent);
    assert!(system_bot(MACRO_NEW_BOT_ID).unwrap().has_agent);
    // Two ids, one persona: both present as "Macro" wherever a person reads a
    // sender, a mention, or an agent list.
    assert_eq!(
        system_bot(MACRO_NEW_BOT_ID).unwrap().name,
        system_bot(MACRO_AI_BOT_ID).unwrap().name
    );
}

#[test]
fn rejects_non_bot_storage_string() {
    assert!(BotIdStr::parse_from_str("macro|[email protected]").is_err());
}

#[test]
fn non_system_bot_id_rejects_every_system_bot() {
    for bot in SYSTEM_BOTS {
        assert_eq!(NonSystemBotId::new(bot.id), None, "{}", bot.handle);
    }
}

#[test]
fn non_system_bot_id_accepts_a_row_bot() {
    let bot = NonSystemBotId::new(BotId::TEST_A).unwrap();

    assert_eq!(bot.get(), BotId::TEST_A);
}

#[test]
fn rejects_trailing_storage_content() {
    let uuid = Uuid::new_v4();

    assert!(BotIdStr::parse_from_str(&format!("bot|{uuid}|extra")).is_err());
}

#[test]
fn rejects_non_canonical_storage_uuid() {
    let uuid = Uuid::new_v4().simple().to_string();

    assert!(BotIdStr::parse_from_str(&format!("bot|{uuid}")).is_err());
}

#[test]
fn equality_and_hash_ignore_uuid_case() {
    let lowercase = "bot|0a0b0c0d-0000-0000-0000-00000000a1a1".to_string();
    let uppercase = "bot|0A0B0C0D-0000-0000-0000-00000000A1A1".to_string();

    let lower = BotIdStr::parse_from_str(&lowercase).unwrap();
    let upper = BotIdStr::parse_from_str(&uppercase).unwrap();

    // Different original strings, same bot: equal and hash-compatible.
    assert_eq!(lower, upper);
    assert_eq!(lower.bot_id(), upper.bot_id());

    let set: std::collections::HashSet<BotIdStr<'_>> =
        [lower.clone(), upper.clone()].into_iter().collect();
    assert_eq!(set.len(), 1);
}

#[test]
fn macro_agent_session_bot_is_mentioned_as_macro() {
    assert_eq!(mention_handle(MACRO_NEW_BOT_ID, MACRO_NEW_HANDLE), "macro");
    assert_eq!(mention_handle(CURSOR_BOT_ID, CURSOR_HANDLE), "cursor");
}