do-memory-mcp 0.1.31

Model Context Protocol (MCP) server for AI agents
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

//! Test to verify all server responses are valid JSON
//!
//! This test validates that the MCP server always produces valid JSON-RPC responses
//! that can be parsed by clients, addressing issue #143.

use do_memory_mcp::jsonrpc::{JsonRpcError, JsonRpcResponse};

#[test]
fn test_valid_jsonrpc_response() {
    // Test that a valid success response serializes to valid JSON
    let response = JsonRpcResponse {
        jsonrpc: "2.0".to_string(),
        id: Some(serde_json::json!(1)),
        result: Some(serde_json::json!({"success": true})),
        error: None,
    };

    let json_str = serde_json::to_string(&response).expect("Should serialize to JSON");

    // Verify it's valid JSON that can be parsed
    let parsed: serde_json::Value =
        serde_json::from_str(&json_str).expect("Response should be valid JSON");

    assert_eq!(parsed["jsonrpc"], "2.0");
    assert_eq!(parsed["id"], 1);
    assert_eq!(parsed["result"]["success"], true);
}

#[test]
fn test_valid_jsonrpc_error_response() {
    // Test that error responses serialize to valid JSON
    let response = JsonRpcResponse {
        jsonrpc: "2.0".to_string(),
        id: Some(serde_json::json!(2)),
        result: None,
        error: Some(JsonRpcError {
            code: -32603,
            message: "Internal error".to_string(),
            data: Some(serde_json::json!({"details": "Test error"})),
        }),
    };

    let json_str = serde_json::to_string(&response).expect("Should serialize to JSON");

    // Verify it's valid JSON that can be parsed
    let parsed: serde_json::Value =
        serde_json::from_str(&json_str).expect("Error response should be valid JSON");

    assert_eq!(parsed["jsonrpc"], "2.0");
    assert_eq!(parsed["id"], 2);
    assert!(parsed["error"].is_object());
    assert_eq!(parsed["error"]["code"], -32603);
    assert_eq!(parsed["error"]["message"], "Internal error");
}

#[test]
fn test_parse_error_response_serialization() {
    // Test that parse error responses are valid JSON
    let response = JsonRpcResponse {
        jsonrpc: "2.0".to_string(),
        id: None,
        result: None,
        error: Some(JsonRpcError {
            code: -32700,
            message: "Parse error".to_string(),
            data: Some(serde_json::json!({"details": "Invalid JSON"})),
        }),
    };

    let json_str = serde_json::to_string(&response).expect("Should serialize to JSON");

    // Verify it's valid JSON that can be parsed
    let parsed: serde_json::Value =
        serde_json::from_str(&json_str).expect("Parse error response should be valid JSON");

    assert_eq!(parsed["jsonrpc"], "2.0");
    assert!(parsed["id"].is_null());
    assert!(parsed["error"].is_object());
    assert_eq!(parsed["error"]["code"], -32700);
}

#[test]
fn test_response_roundtrip() {
    // Test that response can be serialized and deserialized correctly
    let original = JsonRpcResponse {
        jsonrpc: "2.0".to_string(),
        id: Some(serde_json::json!(123)),
        result: Some(serde_json::json!({"data": [1, 2, 3]})),
        error: None,
    };

    let json_str = serde_json::to_string(&original).expect("Should serialize");
    let parsed: JsonRpcResponse = serde_json::from_str(&json_str).expect("Should deserialize");

    assert_eq!(parsed.jsonrpc, original.jsonrpc);
    assert_eq!(parsed.id, original.id);
    assert_eq!(parsed.result, original.result);
}

#[test]
fn test_complex_result_serialization() {
    // Test that complex result structures serialize correctly
    let result = serde_json::json!({
        "episodes": [
            {
                "id": "ep1",
                "content": "Test content",
                "timestamp": 1234567890
            }
        ],
        "patterns": {
            "count": 5,
            "domains": ["web", "data"]
        }
    });

    let response = JsonRpcResponse {
        jsonrpc: "2.0".to_string(),
        id: Some(serde_json::json!(10)),
        result: Some(result),
        error: None,
    };

    let json_str = serde_json::to_string(&response).expect("Should serialize to JSON");

    // Verify it's valid JSON
    let parsed: serde_json::Value =
        serde_json::from_str(&json_str).expect("Complex response should be valid JSON");

    assert_eq!(parsed["result"]["episodes"][0]["id"], "ep1");
    assert_eq!(parsed["result"]["patterns"]["count"], 5);
}