tauri_plugin_tauribun/
models.rs

1use serde::{Deserialize, Serialize};
2
3#[derive(Debug, Deserialize, Serialize)]
4#[serde(rename_all = "camelCase")]
5pub struct PingRequest {
6    pub value: Option<String>,
7}
8
9#[derive(Debug, Clone, Default, Deserialize, Serialize)]
10#[serde(rename_all = "camelCase")]
11pub struct PingResponse {
12    pub value: Option<String>,
13}
14
15#[derive(Debug, Deserialize, Serialize)]
16#[serde(rename_all = "camelCase")]
17pub struct SpawnServerRequest {
18    /// The name/identifier for this server instance
19    pub name: String,
20    /// The path to the sidecar binary (relative to the app's binary directory)
21    pub binary_path: String,
22}
23
24#[derive(Debug, Clone, Deserialize, Serialize)]
25#[serde(rename_all = "camelCase")]
26pub struct SpawnServerResponse {
27    /// Whether the server was successfully spawned
28    pub success: bool,
29    /// The name of the spawned server
30    pub name: String,
31}
32
33#[derive(Debug, Deserialize, Serialize)]
34#[serde(rename_all = "camelCase")]
35pub struct SendMessageRequest {
36    /// The name of the server to send the message to
37    pub name: String,
38    /// The message to send (will be written to stdin)
39    pub message: String,
40}
41
42#[derive(Debug, Clone, Deserialize, Serialize)]
43#[serde(rename_all = "camelCase")]
44pub struct SendMessageResponse {
45    /// Whether the message was successfully sent
46    pub success: bool,
47}
48
49#[derive(Debug, Deserialize, Serialize)]
50#[serde(rename_all = "camelCase")]
51pub struct KillServerRequest {
52    /// The name of the server to kill
53    pub name: String,
54}
55
56#[derive(Debug, Clone, Deserialize, Serialize)]
57#[serde(rename_all = "camelCase")]
58pub struct KillServerResponse {
59    /// Whether the server was successfully killed
60    pub success: bool,
61}
62
63#[cfg(test)]
64mod tests {
65    use super::*;
66
67    // Test that SpawnServerRequest serializes with camelCase
68    #[test]
69    fn spawn_request_serializes_camel_case() {
70        let req = SpawnServerRequest {
71            name: "test".to_string(),
72            binary_path: "path/to/bin".to_string(),
73        };
74        let json = serde_json::to_string(&req).unwrap();
75        assert!(json.contains("binaryPath"));
76        assert!(json.contains("\"name\""));
77    }
78
79    // Test deserialization from camelCase JSON
80    #[test]
81    fn spawn_request_deserializes_from_camel_case() {
82        let json = r#"{"name":"test","binaryPath":"path/to/bin"}"#;
83        let req: SpawnServerRequest = serde_json::from_str(json).unwrap();
84        assert_eq!(req.name, "test");
85        assert_eq!(req.binary_path, "path/to/bin");
86    }
87
88    // Test SpawnServerResponse
89    #[test]
90    fn spawn_response_roundtrip() {
91        let resp = SpawnServerResponse {
92            success: true,
93            name: "my-server".to_string(),
94        };
95        let json = serde_json::to_string(&resp).unwrap();
96        let parsed: SpawnServerResponse = serde_json::from_str(&json).unwrap();
97        assert_eq!(parsed.success, resp.success);
98        assert_eq!(parsed.name, resp.name);
99    }
100
101    // Test SendMessageRequest/Response
102    #[test]
103    fn send_message_roundtrip() {
104        let req = SendMessageRequest {
105            name: "server".to_string(),
106            message: "hello".to_string(),
107        };
108        let json = serde_json::to_string(&req).unwrap();
109        let parsed: SendMessageRequest = serde_json::from_str(&json).unwrap();
110        assert_eq!(parsed.name, req.name);
111        assert_eq!(parsed.message, req.message);
112
113        let resp = SendMessageResponse { success: true };
114        let json = serde_json::to_string(&resp).unwrap();
115        assert!(json.contains("\"success\":true"));
116    }
117
118    // Test KillServerRequest/Response
119    #[test]
120    fn kill_server_roundtrip() {
121        let req = KillServerRequest {
122            name: "server".to_string(),
123        };
124        let json = serde_json::to_string(&req).unwrap();
125        let parsed: KillServerRequest = serde_json::from_str(&json).unwrap();
126        assert_eq!(parsed.name, req.name);
127
128        let resp = KillServerResponse { success: true };
129        let json = serde_json::to_string(&resp).unwrap();
130        assert!(json.contains("\"success\":true"));
131    }
132
133    // Test PingRequest/Response with optional value
134    #[test]
135    fn ping_with_value() {
136        let req = PingRequest {
137            value: Some("hello".to_string()),
138        };
139        let json = serde_json::to_string(&req).unwrap();
140        assert!(json.contains("\"value\":\"hello\""));
141
142        let resp = PingResponse {
143            value: Some("pong".to_string()),
144        };
145        let json = serde_json::to_string(&resp).unwrap();
146        assert!(json.contains("\"value\":\"pong\""));
147    }
148
149    #[test]
150    fn ping_without_value() {
151        let req = PingRequest { value: None };
152        let json = serde_json::to_string(&req).unwrap();
153        assert!(json.contains("\"value\":null"));
154    }
155}
tauri_plugin_tauribun/models.rs

tauri_plugin_tauribun/
models.rs
