rudof_mcp 0.3.21

RDF and Knowledge Graphs processing tool
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
138
139
140

//! Tests for MCP server capabilities.
//!
//! These tests verify that the server correctly advertises its capabilities

#[cfg(not(target_family = "wasm"))]
use rmcp::{ServerHandler, model::ProtocolVersion};
#[cfg(not(target_family = "wasm"))]
use rudof_mcp::service::RudofMcpService;

/// Test that the server can be created successfully
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_service_creation() {
    let service = RudofMcpService::try_new();
    assert!(service.is_ok(), "Service should be created successfully");
}

/// Test that the server can be created with default
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_service_default() {
    let _service = RudofMcpService::default();
    // If we get here without panic, the test passes
}

/// Test server info contains required fields per MCP spec
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_server_info_has_required_fields() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    // Protocol version should be the latest
    assert_eq!(
        info.protocol_version,
        ProtocolVersion::LATEST,
        "Protocol version should be the latest MCP version"
    );

    // Server info (implementation) must be present
    assert!(
        !info.server_info.name.is_empty(),
        "Server implementation name should not be empty"
    );

    // Instructions should be provided for LLMs
    assert!(
        info.instructions.is_some(),
        "Instructions should be provided for LLM context"
    );
}

/// Test that tools capability is advertised
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_tools_capability_advertised() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    assert!(
        info.capabilities.tools.is_some(),
        "Tools capability should be advertised"
    );
}

/// Test that prompts capability is advertised
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_prompts_capability_advertised() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    assert!(
        info.capabilities.prompts.is_some(),
        "Prompts capability should be advertised"
    );
}

/// Test that resources capability is advertised
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_resources_capability_advertised() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    let resources_cap = info
        .capabilities
        .resources
        .expect("Resources capability should be advertised");

    assert_eq!(
        resources_cap.subscribe,
        Some(false),
        "Resource subscription is not yet implemented"
    );
    assert_eq!(
        resources_cap.list_changed,
        Some(false),
        "Resource list_changed notifications are not yet implemented"
    );
}

/// Test that logging capability is enabled
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_logging_capability_advertised() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    let logging = info
        .capabilities
        .logging
        .expect("Logging capability should be advertised");
    assert!(logging.is_empty(), "Logging capability should be declared as an object");
}

/// Test that completions capability is advertised
#[cfg(not(target_family = "wasm"))]
#[test]
fn test_completions_capability_advertised() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    assert!(
        info.capabilities.completions.is_some(),
        "Completions capability should be advertised"
    );
}

#[cfg(not(target_family = "wasm"))]
#[test]
fn test_no_experimental_capabilities() {
    let service = RudofMcpService::new();
    let info = service.get_info();

    assert!(
        info.capabilities.experimental.is_none(),
        "Experimental capabilities should not be set unless needed"
    );
}