120 lines
3.4 KiB
Rust
120 lines
3.4 KiB
Rust
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();
|
|
}
|