pulseengine-mcp-protocol 0.17.1

[DEPRECATED] Use rmcp instead. MCP protocol types for PulseEngine.
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

//! Tests for lib.rs functionality

#[cfg(test)]
mod tests {
    use crate::error::ErrorCode;
    use crate::*;

    #[test]
    fn test_mcp_version_constant() {
        assert_eq!(MCP_VERSION, "2025-11-25");
    }

    #[test]
    fn test_supported_protocol_versions() {
        assert_eq!(SUPPORTED_PROTOCOL_VERSIONS.len(), 4);
        assert_eq!(SUPPORTED_PROTOCOL_VERSIONS[0], "2025-11-25");
        assert_eq!(SUPPORTED_PROTOCOL_VERSIONS[1], "2025-06-18");
        assert_eq!(SUPPORTED_PROTOCOL_VERSIONS[2], "2025-03-26");
        assert_eq!(SUPPORTED_PROTOCOL_VERSIONS[3], "2024-11-05");
    }

    #[test]
    fn test_is_protocol_version_supported() {
        assert!(is_protocol_version_supported("2025-11-25"));
        assert!(is_protocol_version_supported("2025-06-18"));
        assert!(is_protocol_version_supported("2025-03-26"));
        assert!(!is_protocol_version_supported("2024-01-01"));
        assert!(!is_protocol_version_supported("invalid"));
        assert!(!is_protocol_version_supported(""));
    }

    #[test]
    fn test_validate_protocol_version_success() {
        let result = validate_protocol_version("2025-11-25");
        assert!(result.is_ok());

        let result = validate_protocol_version("2025-06-18");
        assert!(result.is_ok());

        let result = validate_protocol_version("2025-03-26");
        assert!(result.is_ok());
    }

    #[test]
    fn test_validate_protocol_version_failure() {
        let result = validate_protocol_version("2024-01-01");
        assert!(result.is_err());

        let error = result.unwrap_err();
        assert_eq!(error.code, ErrorCode::InvalidRequest);
        assert!(error.message.contains("Protocol version mismatch"));
        assert!(error.message.contains("2024-01-01"));
        assert!(error.message.contains("2025-11-25"));
    }

    #[test]
    fn test_validate_protocol_version_empty() {
        let result = validate_protocol_version("");
        assert!(result.is_err());
    }

    #[test]
    fn test_reexports() {
        // Test that core types are properly re-exported
        let _error: Error = Error::invalid_request("test");
        let _result: Result<()> = Ok(());
        let _validator = Validator;

        // Test model types are accessible
        let _request = Request {
            jsonrpc: "2.0".to_string(),
            method: "test".to_string(),
            params: serde_json::Value::Null,
            id: Some(NumberOrString::Number(1)),
        };
    }

    #[test]
    fn test_error_result_interop() {
        fn returns_result() -> Result<String> {
            Ok("success".to_string())
        }

        fn returns_error() -> Result<String> {
            Err(Error::method_not_found("test"))
        }

        assert!(returns_result().is_ok());
        assert!(returns_error().is_err());
    }
}