initial commit

interfaces/websocket/server/tests/timeout_integration_test.rs

@@ -0,0 +1,119 @@
+use circle_ws_lib::{spawn_circle_server, ServerConfig};
+use futures_util::{sink::SinkExt, stream::StreamExt};
+use std::time::Duration;
+use tokio::time::sleep;
+use tokio_tungstenite::{connect_async, tungstenite::protocol::Message};
+
+// Define a simple JSON-RPC request structure for sending scripts
+#[derive(serde::Serialize, Debug)]
+struct JsonRpcRequest {
+    jsonrpc: String,
+    method: String,
+    params: ScriptParams,
+    id: u64,
+}
+
+#[derive(serde::Serialize, Debug)]
+struct ScriptParams {
+    script: String,
+}
+
+// Define a simple JSON-RPC error response structure for assertion
+#[derive(serde::Deserialize, Debug)]
+#[allow(dead_code)]
+struct JsonRpcErrorResponse {
+    jsonrpc: String,
+    error: JsonRpcErrorDetails,
+    id: Option<serde_json::Value>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct JsonRpcErrorDetails {
+    code: i32,
+    message: String,
+}
+
+const SERVER_ADDRESS: &str = "ws://127.0.0.1:8088/test_pub_key_timeout";
+const TEST_CIRCLE_NAME: &str = "test_timeout_circle";
+const RHAI_TIMEOUT_SECONDS: u64 = 30; // Match server's default timeout
+
+#[tokio::test]
+async fn test_rhai_script_timeout() {
+    let server_config = ServerConfig::new(
+        "127.0.0.1".to_string(),
+        8088,
+        "redis://127.0.0.1:6379".to_string(),
+    );
+
+    let (server_handle, _server_stop_handle) = spawn_circle_server(server_config).unwrap();
+    sleep(Duration::from_secs(2)).await; // Give server time to start
+
+    let (mut ws_stream, _response) = connect_async(SERVER_ADDRESS)
+        .await
+        .expect("Failed to connect to WebSocket server");
+
+    let long_running_script = "
+        let mut x = 0;
+        for i in 0..999999999 {
+            x = x + i;
+        }
+        print(x);
+    "
+    .to_string();
+
+    let request = JsonRpcRequest {
+        jsonrpc: "2.0".to_string(),
+        method: "play".to_string(),
+        params: ScriptParams {
+            script: long_running_script,
+        },
+        id: 1,
+    };
+
+    let request_json = serde_json::to_string(&request).expect("Failed to serialize request");
+    ws_stream
+        .send(Message::Text(request_json))
+        .await
+        .expect("Failed to send message");
+
+    match tokio::time::timeout(
+        Duration::from_secs(RHAI_TIMEOUT_SECONDS + 10),
+        ws_stream.next(),
+    )
+    .await
+    {
+        Ok(Some(Ok(Message::Text(text)))) => {
+            let response: Result<JsonRpcErrorResponse, _> = serde_json::from_str(&text);
+            match response {
+                Ok(err_resp) => {
+                    assert_eq!(
+                        err_resp.error.code, -32002,
+                        "Error code should indicate timeout."
+                    );
+                    assert!(
+                        err_resp.error.message.contains("Timeout"),
+                        "Error message should indicate timeout."
+                    );
+                }
+                Err(e) => {
+                    panic!("Failed to deserialize error response: {}. Raw: {}", e, text);
+                }
+            }
+        }
+        Ok(Some(Ok(other_msg))) => {
+            panic!("Received unexpected message type: {:?}", other_msg);
+        }
+        Ok(Some(Err(e))) => {
+            panic!("WebSocket error: {}", e);
+        }
+        Ok(None) => {
+            panic!("WebSocket stream closed unexpectedly.");
+        }
+        Err(_) => {
+            panic!("Test timed out waiting for server response.");
+        }
+    }
+
+    ws_stream.close(None).await.ok();
+    server_handle.abort();
+}