cloudiful-server 0.2.5

Rust web server bootstrap crate with Actix and Axum adapters
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use axum::{
    Router,
    body::Body,
    http::{Request, StatusCode},
};
use rmcp::ServiceExt;
use tower::ServiceExt as TowerServiceExt;

use crate::{
    ServerConfig as HttpServerConfig,
    mcp::{Server, serve, tool, tool_router},
};

#[derive(Clone)]
struct PingServer;

#[tool_router(server_handler)]
impl PingServer {
    #[tool(description = "Ping the server")]
    fn ping(&self) -> String {
        "pong".to_string()
    }
}

#[tokio::test]
async fn serve_over_async_rw_transport_exposes_tools() {
    let (server_io, client_io) = tokio::io::duplex(1024);
    let (server_read, server_write) = tokio::io::split(server_io);
    let (client_read, client_write) = tokio::io::split(client_io);

    let server_task =
        tokio::spawn(async move { serve(PingServer, (server_read, server_write)).await });

    let client = ().serve((client_read, client_write)).await.unwrap();
    let tools = client.peer().list_tools(Default::default()).await.unwrap();

    assert_eq!(tools.tools.len(), 1);
    assert_eq!(tools.tools[0].name, "ping");

    client.cancel().await.unwrap();
    server_task.await.unwrap().unwrap().cancel().await.unwrap();
}

#[tokio::test]
async fn streamable_http_server_binds_on_loopback() {
    let config = HttpServerConfig::new()
        .with_listen_addr("127.0.0.1:0")
        .build()
        .unwrap();

    let bound = Server::new(config, || PingServer)
        .with_server_config(crate::mcp::ServerConfig::new().with_service_path("/mcp"))
        .bind()
        .unwrap();

    assert!(bound.addrs().iter().all(|addr| addr.ip().is_loopback()));
}

#[tokio::test]
async fn service_path_is_normalized_for_http_router() {
    let response = crate::mcp::router(
        crate::mcp::ServerConfig::new().with_service_path("mcp/"),
        || PingServer,
    )
    .unwrap()
    .oneshot(
        Request::builder()
            .uri("/mcp")
            .header("host", "not-loopback.example")
            .body(Body::empty())
            .unwrap(),
    )
    .await
    .unwrap();

    assert_ne!(response.status(), StatusCode::NOT_FOUND);
    assert_ne!(response.status(), StatusCode::FORBIDDEN);
}

#[tokio::test]
async fn root_service_path_is_accepted() {
    let response = crate::mcp::router(
        crate::mcp::ServerConfig::new().with_service_path("/"),
        || PingServer,
    )
    .unwrap()
    .oneshot(
        Request::builder()
            .uri("/")
            .header("host", "not-loopback.example")
            .body(Body::empty())
            .unwrap(),
    )
    .await
    .unwrap();

    assert_ne!(response.status(), StatusCode::NOT_FOUND);
    assert_ne!(response.status(), StatusCode::FORBIDDEN);
}

#[tokio::test]
async fn service_can_be_nested_in_existing_router() {
    let service = crate::mcp::service(crate::mcp::ServerConfig::new(), || PingServer).unwrap();
    let app = Router::new().nest_service("/mcp", service);

    let response = app
        .oneshot(
            Request::builder()
                .uri("/mcp")
                .header("host", "not-loopback.example")
                .body(Body::empty())
                .unwrap(),
        )
        .await
        .unwrap();

    assert_ne!(response.status(), StatusCode::NOT_FOUND);
    assert_ne!(response.status(), StatusCode::FORBIDDEN);
}

#[tokio::test]
async fn empty_service_path_is_rejected() {
    let config = HttpServerConfig::new()
        .with_listen_addr("127.0.0.1:0")
        .build()
        .unwrap();

    let err = Server::new(config, || PingServer)
        .with_server_config(crate::mcp::ServerConfig::new().with_service_path(" "))
        .bind()
        .unwrap_err();

    assert!(matches!(
        err,
        crate::mcp::McpServerError::InvalidServicePath(_)
    ));
}