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.

7.2 KB
Raw Blame
use super::*;
use bots::domain::models::BotId;

use macro_user_id::cowlike::CowLike;
use serde_json::json;

fn owner() -> MacroUserIdStr<'static> {
    MacroUserIdStr::parse_from_str("macro|[email protected]")
        .expect("valid user id")
        .into_owned()
}

fn identity() -> SessionIdentity {
    SessionIdentity {
        session_id: AgentSessionId::TEST_A,
        session_name: "Fix the flaky test".to_owned(),
        bot_id: BotId::TEST_A,
        bot_name: "Macro Coder".to_owned(),
        owner_id: owner(),
        origin: Some(ThreadOrigin::new(
            messages::domain::models::MessageParent::Channel(Uuid::from_u128(1)),
            Uuid::from_u128(2),
            Uuid::from_u128(3),
        )),
        audience: vec![owner()],
        source: crate::domain::model::SessionSource::User,
    }
}

fn action_id() -> AgentActionId {
    AgentActionId::mint()
}

fn one_of_each() -> Vec<AgentSessionLifecycleEvent> {
    vec![
        AgentSessionLifecycleEvent::Opened(SessionOpenedMetadata {
            identity: identity(),
            model: "claude".to_owned(),
            harness: "claude_code".to_owned(),
        }),
        AgentSessionLifecycleEvent::TurnStarted(TurnStartedMetadata {
            identity: identity(),
            turn: TurnId(0),
            action_id: action_id(),
            actor: Some(owner()),
            announcement_message_id: Some(Uuid::from_u128(4)),
        }),
        AgentSessionLifecycleEvent::TurnEnded(TurnEndedMetadata {
            identity: identity(),
            turn: TurnId(0),
            action_id: action_id(),
            actor: Some(owner()),
            announcement_message_id: Some(Uuid::from_u128(4)),
            stop_reason: "end_turn".to_owned(),
            queued_remaining: 0,
        }),
        AgentSessionLifecycleEvent::CommandRejected(CommandRejectedMetadata {
            identity: identity(),
            action_id: action_id(),
            actor: Some(owner()),
            announcement_message_id: Some(Uuid::from_u128(4)),
            failure: CommandFailure {
                code: "ai_billing_unavailable".into(),
                message: "AI usage validation is temporarily unavailable. Please try again.".into(),
                retryable: true,
            },
        }),
        AgentSessionLifecycleEvent::Settled(SessionSettledMetadata {
            identity: identity(),
            last_turn: Some(TurnSummary {
                turn: TurnId(0),
                action_id: action_id(),
                actor: Some(owner()),
                announcement_message_id: Some(Uuid::from_u128(4)),
                stop_reason: "end_turn".to_owned(),
                excerpt: Some("Done.".to_owned()),
            }),
        }),
        AgentSessionLifecycleEvent::WaitingForInput(WaitingForInputMetadata {
            identity: identity(),
            turn: TurnId(1),
            action_id: action_id(),
            announcement_message_id: None,
            question: "Which approach?".to_owned(),
        }),
        AgentSessionLifecycleEvent::InputReceived(InputReceivedMetadata {
            identity: identity(),
            turn: TurnId(1),
            action_id: action_id(),
        }),
        AgentSessionLifecycleEvent::Mentioned(SessionMentionedMetadata {
            identity: identity(),
            action_id: action_id(),
            mentioned_by: Some(owner()),
            mentioned: vec![
                MacroUserIdStr::parse_from_str("macro|[email protected]")
                    .expect("valid user id")
                    .into_owned(),
            ],
            origin_message_id: None,
        }),
        AgentSessionLifecycleEvent::Stopped(SessionStoppedMetadata {
            identity: identity(),
            reason: "transport closed".to_owned(),
            turn_in_flight: None,
        }),
        AgentSessionLifecycleEvent::Renamed(SessionRenamedMetadata {
            identity: identity(),
        }),
        AgentSessionLifecycleEvent::Deleted(SessionDeletedMetadata {
            identity: identity(),
        }),
    ]
}

#[cfg(feature = "admission")]
#[test]
fn admission_failures_have_only_sanitized_public_fields() {
    use ai_billing::{AiAdmissionError, DenyReason};
    for error in [
        AiAdmissionError::Denied(DenyReason::AllowanceExhausted),
        AiAdmissionError::Denied(DenyReason::OverageLimitReached),
        AiAdmissionError::Denied(DenyReason::OveragePaymentFailed),
        AiAdmissionError::Unavailable,
    ] {
        let failure = CommandFailure::from(error);
        assert_eq!(failure.code, error.code());
        assert_eq!(failure.message, error.to_string());
        assert_eq!(failure.retryable, error.is_retryable());
        assert_eq!(
            serde_json::to_value(failure)
                .unwrap()
                .as_object()
                .unwrap()
                .len(),
            3
        );
    }
}

#[test]
fn event_names_match_the_wire() {
    use strum::IntoEnumIterator as _;

    // Subscribers filter on these names, so the serde tag is the contract and
    // `AgentSessionLifecycleEventName` must agree with it variant for variant.
    let wire_names: Vec<String> = one_of_each()
        .into_iter()
        .map(|event| {
            serde_json::to_value(event).expect("serialize event")["event_type"].to_string()
        })
        .collect();
    let names: Vec<String> = AgentSessionLifecycleEventName::iter()
        .map(|name| serde_json::Value::String(name.to_string()).to_string())
        .collect();

    assert_eq!(names, wire_names);
}

#[test]
fn name_is_the_wire_name() {
    for event in one_of_each() {
        let value = serde_json::to_value(&event).expect("serialize event");
        assert_eq!(value["event_type"], json!(event.name()));
    }
}

#[test]
fn every_variant_round_trips() {
    for event in one_of_each() {
        let value = serde_json::to_value(&event).expect("serialize event");
        assert_eq!(
            value["metadata"]["identity"]["session_id"],
            json!(AgentSessionId::TEST_A)
        );
        let parsed: AgentSessionLifecycleEvent =
            serde_json::from_value(value).expect("deserialize event");
        assert_eq!(parsed, event);
    }
}

#[test]
fn identity_without_audience_still_decodes() {
    // Events published before the audience existed have no such field; a
    // consumer reading a retained record must not choke on them.
    let mut value = serde_json::to_value(AgentSessionLifecycleEvent::Renamed(
        SessionRenamedMetadata {
            identity: identity(),
        },
    ))
    .expect("serialize event");
    value["metadata"]["identity"]
        .as_object_mut()
        .expect("identity object")
        .remove("audience");

    let parsed: AgentSessionLifecycleEvent =
        serde_json::from_value(value).expect("deserialize event");
    assert!(parsed.identity().audience.is_empty());
}

#[test]
fn macro_event_is_keyed_by_session_id() {
    let event = AgentSessionLifecycleMacroEvent::new(AgentSessionLifecycleEvent::Renamed(
        SessionRenamedMetadata {
            identity: identity(),
        },
    ));

    assert_eq!(event.key(), AgentSessionId::TEST_A.to_string());
    assert_eq!(event.event().schema_version, 1);
    assert_eq!(event.event().event.session_id(), AgentSessionId::TEST_A);
}