oxur_repl/
protocol.rs

1//! REPL Protocol
2//!
3//! Defines the communication protocol between REPL client and server.
4
5use serde::{Deserialize, Serialize};
6
7/// Request from client to server
8#[derive(Debug, Clone, Serialize, Deserialize)]
9pub enum ReplRequest {
10    /// Evaluate an expression
11    Eval { source: String },
12
13    /// Load a file
14    Load { path: String },
15
16    /// Reset the REPL state
17    Reset,
18
19    /// Get REPL status
20    Status,
21
22    /// Shutdown the server
23    Shutdown,
24}
25
26/// Response from server to client
27#[derive(Debug, Clone, Serialize, Deserialize)]
28pub enum ReplResponse {
29    /// Successful evaluation result
30    Value { value: String },
31
32    /// Evaluation error
33    Error { message: String },
34
35    /// Status information
36    Status { tier1_count: usize, tier2_count: usize, tier3_count: usize },
37
38    /// Acknowledgment
39    Ok,
40}
41
42#[cfg(test)]
43mod tests {
44    use super::*;
45
46    #[test]
47    fn test_request_serialization() {
48        let req = ReplRequest::Eval { source: "(+ 1 2)".to_string() };
49        let json = serde_json::to_string(&req).unwrap();
50        let parsed: ReplRequest = serde_json::from_str(&json).unwrap();
51
52        match parsed {
53            ReplRequest::Eval { source } => assert_eq!(source, "(+ 1 2)"),
54            _ => panic!("Wrong variant"),
55        }
56    }
57
58    #[test]
59    fn test_request_load() {
60        let req = ReplRequest::Load { path: "test.ox".to_string() };
61        match req {
62            ReplRequest::Load { path } => assert_eq!(path, "test.ox"),
63            _ => panic!("Wrong variant"),
64        }
65    }
66
67    #[test]
68    fn test_request_reset() {
69        let req = ReplRequest::Reset;
70        match req {
71            ReplRequest::Reset => (),
72            _ => panic!("Wrong variant"),
73        }
74    }
75
76    #[test]
77    fn test_request_status() {
78        let req = ReplRequest::Status;
79        match req {
80            ReplRequest::Status => (),
81            _ => panic!("Wrong variant"),
82        }
83    }
84
85    #[test]
86    fn test_request_shutdown() {
87        let req = ReplRequest::Shutdown;
88        match req {
89            ReplRequest::Shutdown => (),
90            _ => panic!("Wrong variant"),
91        }
92    }
93
94    #[test]
95    fn test_response_value() {
96        let resp = ReplResponse::Value { value: "42".to_string() };
97        match resp {
98            ReplResponse::Value { value } => assert_eq!(value, "42"),
99            _ => panic!("Wrong variant"),
100        }
101    }
102
103    #[test]
104    fn test_response_error() {
105        let resp = ReplResponse::Error { message: "error".to_string() };
106        match resp {
107            ReplResponse::Error { message } => assert_eq!(message, "error"),
108            _ => panic!("Wrong variant"),
109        }
110    }
111
112    #[test]
113    fn test_response_status() {
114        let resp = ReplResponse::Status { tier1_count: 1, tier2_count: 2, tier3_count: 3 };
115        match resp {
116            ReplResponse::Status { tier1_count, tier2_count, tier3_count } => {
117                assert_eq!(tier1_count, 1);
118                assert_eq!(tier2_count, 2);
119                assert_eq!(tier3_count, 3);
120            }
121            _ => panic!("Wrong variant"),
122        }
123    }
124
125    #[test]
126    fn test_response_ok() {
127        let resp = ReplResponse::Ok;
128        match resp {
129            ReplResponse::Ok => (),
130            _ => panic!("Wrong variant"),
131        }
132    }
133
134    #[test]
135    fn test_request_clone() {
136        let req = ReplRequest::Eval { source: "test".to_string() };
137        let cloned = req.clone();
138        match cloned {
139            ReplRequest::Eval { source } => assert_eq!(source, "test"),
140            _ => panic!("Wrong variant"),
141        }
142    }
143
144    #[test]
145    fn test_response_clone() {
146        let resp = ReplResponse::Value { value: "test".to_string() };
147        let cloned = resp.clone();
148        match cloned {
149            ReplResponse::Value { value } => assert_eq!(value, "test"),
150            _ => panic!("Wrong variant"),
151        }
152    }
153}
oxur_repl/protocol.rs

oxur_repl/
protocol.rs
