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.6 KB
Raw Blame
use agent_client_protocol::RawJsonRpcMessage;
use agent_client_protocol::schema::v1::RequestId;
use serde_json::json;

use super::*;

#[test]
fn event_names_are_opaque_wire_strings() {
    let event_names = [
        SystemEvent::Unknown("runtime/ready".to_owned()),
        SystemEvent::Unknown("agent/started".to_owned()),
        SystemEvent::Unknown("vendor/custom-event".to_owned()),
    ];
    for name in event_names {
        let wire_name = name.as_str();
        assert_eq!(serde_json::to_value(&name).unwrap(), json!(wire_name));
        assert_eq!(
            serde_json::from_value::<SystemEvent>(json!(wire_name)).unwrap(),
            name
        );
    }
}

#[test]
fn acp_ready_round_trips_as_a_typed_variant() {
    assert_eq!(
        serde_json::to_value(SystemEvent::AcpReady).unwrap(),
        json!("acp_ready")
    );
    assert_eq!(
        serde_json::from_value::<SystemEvent>(json!("acp_ready")).unwrap(),
        SystemEvent::AcpReady
    );
}

#[test]
fn disconnected_round_trips_as_a_typed_variant() {
    assert_eq!(
        serde_json::to_value(SystemEvent::Disconnected).unwrap(),
        json!("disconnected")
    );
    assert_eq!(
        serde_json::from_value::<SystemEvent>(json!("disconnected")).unwrap(),
        SystemEvent::Disconnected
    );
}

#[test]
fn unknown_event_names_round_trip_losslessly() {
    let event = serde_json::from_value::<SystemEvent>(json!("vendor/custom-event")).unwrap();
    assert_eq!(
        event,
        SystemEvent::Unknown("vendor/custom-event".to_owned())
    );
    assert_eq!(
        serde_json::to_value(event).unwrap(),
        json!("vendor/custom-event")
    );
}

#[test]
fn to_server_message_event_has_the_specified_wire_shape() {
    let event = ToServerMessage::Event {
        event: SystemEvent::Unknown("agent/stopped".to_owned()),
    };

    assert_eq!(
        serde_json::to_value(event).unwrap(),
        json!({
            "type": "event",
            "event": "agent/stopped",
        })
    );
}

#[test]
fn acp_message_contains_an_acp_raw_jsonrpc_message() {
    let nested = RawJsonRpcMessage::request(
        "initialize".to_owned(),
        json!({ "protocolVersion": 1 }),
        RequestId::Number(1),
    )
    .unwrap();
    let delivery = ToRuntimeMessage::Acp(AcpMessage(nested));

    let message = serde_json::to_value(delivery).unwrap();
    assert_eq!(
        message,
        json!({
            "type": "acp",
            "jsonrpc": "2.0",
            "id": 1,
            "method": "initialize",
            "params": {
                "protocolVersion": 1,
            },
        })
    );

    let ToRuntimeMessage::Acp(AcpMessage(parsed)) =
        serde_json::from_value::<ToRuntimeMessage>(message).unwrap()
    else {
        panic!("expected ACP message")
    };
    assert_eq!(
        serde_json::to_value(parsed).unwrap(),
        json!({
            "jsonrpc": "2.0",
            "id": 1,
            "method": "initialize",
            "params": {
                "protocolVersion": 1,
            },
        })
    );
}

#[test]
fn model_probe_messages_carry_no_session_id_and_no_correlation() {
    let request = ToRuntimeMessage::ModelProbeRequest;
    let response = ToServerMessage::ModelProbeResponse {
        result: ModelProbeResult::Available {
            config_options: Vec::new(),
        },
    };

    assert_eq!(
        serde_json::to_value(request).unwrap(),
        json!({ "type": "modelProbeRequest" })
    );
    assert_eq!(
        serde_json::to_value(response).unwrap(),
        json!({
            "type": "modelProbeResponse",
            "result": {
                "status": "available",
                "configOptions": [],
            },
        })
    );
}