services/mctp/server/tests/echo.rs

// Licensed under the Apache-2.0 license
// SPDX-License-Identifier: Apache-2.0

//! MCTP echo integration test.
//!
//! This test exercises the full MCTP server stack with a mock transport,
//! replicating a production echo task behavior:
//!
//! 1. Server A (echo responder): listens for MCTP type-1 messages, echoes payload back
//! 2. Server B (requester): sends a request to A and verifies the echo response
//!
//! The test uses a **client/server partition**: the echo application logic
//! interacts exclusively through the `MctpClient` trait (client side), while
//! the `Server` + transport plumbing is the server side.

mod common;

use std::cell::RefCell;

use mctp::Eid;
use openprot_mctp_api::{Handle, MctpClient};
use openprot_mctp_server::Server;

use common::{transfer, BufferSender, DirectClient};


// ---------------------------------------------------------------------------
// Echo application logic (client side)
// ---------------------------------------------------------------------------

/// Echo one message: receive on the listener, send the payload back.
///
/// This is the same shape as production echo logic:
/// ```ignore
/// let (_, _, msg, mut resp) = listener.recv(&mut recv_buf).unwrap_lite();
/// resp.send(msg).unwrap();
/// ```
/// but expressed through the `MctpClient` trait.
fn echo_once(client: &impl MctpClient, listener_handle: Handle) {
    let mut recv_buf = [0u8; 255];
    let meta = client
        .recv(listener_handle, 0, &mut recv_buf)
        .expect("echo: should receive a message");

    let payload = &recv_buf[..meta.payload_size];
    client
        .send(
            None,
            meta.msg_type,
            Some(meta.remote_eid),
            Some(meta.msg_tag),
            false,
            payload,
        )
        .expect("echo: should send response");
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

/// MCTP echo: send a request, receive it on a listener, echo back, verify.
///
/// This replicates a production echo task behavior:
/// - EID 8 listens for MsgType(1) and echoes the payload
/// - EID 42 sends a request and checks the response matches
#[test]
fn mctp_echo_roundtrip() {
    // -- Server side: set up two MCTP server instances with mock transport --
    let buf_a = RefCell::new(Vec::new());
    let sender_a = BufferSender { packets: &buf_a };
    let server_a: RefCell<Server<_, 16>> =
        RefCell::new(Server::new(Eid(8), 0, sender_a));

    let buf_b = RefCell::new(Vec::new());
    let sender_b = BufferSender { packets: &buf_b };
    let server_b: RefCell<Server<_, 16>> =
        RefCell::new(Server::new(Eid(42), 0, sender_b));

    // -- Client side: wrap servers in DirectClient to use MctpClient trait --
    let client_a = DirectClient::new(&server_a);
    let client_b = DirectClient::new(&server_b);

    // Client A: register listener for MsgType(1) — same as echo task
    let listener_handle = client_a.listener(1).unwrap();

    // Client B: get a request handle targeting EID 8
    let req_handle = client_b.req(8).unwrap();

    // Client B: send a request with MsgType(1)
    let payload = b"Hello MCTP echo!";
    let _tag = client_b
        .send(Some(req_handle), 1, None, None, false, payload)
        .unwrap();

    // Server side: transfer B's outbound packets to A
    transfer(&buf_b, &mut server_a.borrow_mut());

    // Client A: echo the message back (uses MctpClient trait)
    echo_once(&client_a, listener_handle);

    // Server side: transfer A's outbound packets to B
    transfer(&buf_a, &mut server_b.borrow_mut());

    // Client B: receive the echo response (uses MctpClient trait)
    let mut resp_buf = [0u8; 255];
    let resp_meta = client_b
        .recv(req_handle, 0, &mut resp_buf)
        .expect("Client B should have received the echo response");

    let response = &resp_buf[..resp_meta.payload_size];
    assert_eq!(response, payload, "Echo response should match original payload");
    assert_eq!(resp_meta.msg_type, 1);
    assert_eq!(resp_meta.remote_eid, 8);

    // Clean up
    client_a.drop_handle(listener_handle);
    client_b.drop_handle(req_handle);
}

/// Test that multiple messages can be echoed in sequence.
#[test]
fn mctp_echo_multiple() {
    let buf_a = RefCell::new(Vec::new());
    let sender_a = BufferSender { packets: &buf_a };
    let server_a: RefCell<Server<_, 16>> =
        RefCell::new(Server::new(Eid(8), 0, sender_a));

    let buf_b = RefCell::new(Vec::new());
    let sender_b = BufferSender { packets: &buf_b };
    let server_b: RefCell<Server<_, 16>> =
        RefCell::new(Server::new(Eid(42), 0, sender_b));

    let client_a = DirectClient::new(&server_a);
    let client_b = DirectClient::new(&server_b);

    let listener = client_a.listener(1).unwrap();
    let req = client_b.req(8).unwrap();

    for i in 0..5u8 {
        let msg = [i; 32];

        // Client B: send request
        client_b
            .send(Some(req), 1, None, None, false, &msg)
            .unwrap();
        transfer(&buf_b, &mut server_a.borrow_mut());
        buf_b.borrow_mut().clear();

        // Client A: echo (uses MctpClient trait)
        echo_once(&client_a, listener);
        transfer(&buf_a, &mut server_b.borrow_mut());
        buf_a.borrow_mut().clear();

        // Client B: verify echo response
        let mut resp_buf = [0u8; 255];
        let resp = client_b
            .recv(req, 0, &mut resp_buf)
            .expect("echo response should be available");
        assert_eq!(&resp_buf[..resp.payload_size], &msg);
    }

    client_a.drop_handle(listener);
    client_b.drop_handle(req);
}