use axum::Router;
use base64::{engine::general_purpose, Engine};
use socket_io_client::{ClientApp, Socket, Data as ClientData};
use socketioxide::{
extract::{Data as ServerData, SocketRef},
SocketIo,
};
use std::sync::{Arc, Mutex};
use tokio::net::TcpListener;
use tokio::sync::oneshot;
use tokio::time::{sleep, Duration};
pub async fn start_test_server_on_port(port: u16) -> (SocketIo, tokio::task::JoinHandle<()>) {
let (layer, io) = SocketIo::new_layer();
io.ns("/", |socket: SocketRef| async move {
socket.on("echo", |socket: SocketRef, ServerData::<serde_json::Value>(data)| async move {
socket.emit("echo_reply", &data).ok();
});
});
let app = Router::new().layer(layer);
let addr = format!("127.0.0.1:{}", port);
let listener = TcpListener::bind(addr).await.unwrap();
let handle = tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
(io, handle)
}
pub async fn start_test_server() -> (u16, SocketIo, tokio::task::JoinHandle<()>) {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let (io, handle) = start_test_server_on_port(port).await;
(port, io, handle)
}
#[tokio::test]
async fn test_basic_connection_and_disconnect() {
let _ = tracing_subscriber::fmt::try_init();
let (port, _io, _server_handle) = start_test_server().await;
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let (disconnect_tx, disconnect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let disconnect_tx = Arc::new(Mutex::new(Some(disconnect_tx)));
let mut app = ClientApp::new(());
let ctx = connect_tx.clone();
let dtx = disconnect_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
let dtx = dtx.clone();
async move {
socket.on_connect({
let ctx = ctx.clone();
move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
tokio::spawn(async move {
sleep(Duration::from_millis(50)).await;
let _ = socket.0.disconnect().await;
});
}
}
});
socket.on_disconnect({
let dtx = dtx.clone();
move |_: Socket<()>, _: ClientData<serde_json::Value>| {
let dtx = dtx.clone();
async move {
if let Some(tx) = dtx.lock().unwrap().take() {
tx.send(()).ok();
}
}
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect");
let disconnect_res = tokio::time::timeout(Duration::from_secs(5), disconnect_rx).await;
assert!(disconnect_res.is_ok(), "Timeout waiting for disconnect");
}
#[tokio::test]
async fn test_polling_only() {
let _ = tracing_subscriber::fmt::try_init();
let (port, _io, _server_handle) = start_test_server().await;
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let mut app = ClientApp::new(());
app.set_allow_upgrade(false);
let ctx = connect_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
async move {
socket.on_connect(move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
tokio::spawn(async move {
sleep(Duration::from_millis(50)).await;
let _ = socket.0.disconnect().await;
});
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect in polling mode");
}
#[tokio::test]
async fn test_polling_to_websocket_upgrade() {
let _ = tracing_subscriber::fmt::try_init();
let (port, _io, _server_handle) = start_test_server().await;
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let mut app = ClientApp::new(());
let ctx = connect_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
async move {
socket.on_connect(move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
tokio::spawn(async move {
sleep(Duration::from_millis(50)).await;
let _ = socket.0.disconnect().await;
});
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect in upgrade mode");
}
#[tokio::test]
async fn test_ping_pong() {
let _ = tracing_subscriber::fmt::try_init();
let (layer, io) = socketioxide::SocketIo::builder()
.ping_interval(Duration::from_millis(300))
.ping_timeout(Duration::from_millis(300))
.build_layer();
io.ns("/", |socket: SocketRef| async move {
socket.on("echo", |socket: SocketRef, ServerData::<serde_json::Value>(data)| async move {
socket.emit("echo_reply", &data).ok();
});
});
let app = Router::new().layer(layer);
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let (echo_tx, echo_rx) = oneshot::channel();
let echo_tx = Arc::new(Mutex::new(Some(echo_tx)));
let mut app = ClientApp::new(());
let ctx = connect_tx.clone();
let etx = echo_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
let etx = etx.clone();
async move {
socket.on_connect({
let ctx = ctx.clone();
move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
tokio::spawn(async move {
sleep(Duration::from_millis(1200)).await;
let _ = socket.0.emit("echo", serde_json::json!("still_alive")).await;
});
}
}
});
socket.on("echo_reply", {
let etx = etx.clone();
move |socket: Socket<()>, _: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| {
let etx = etx.clone();
async move {
if let Some(tx) = etx.lock().unwrap().take() {
tx.send(()).ok();
}
let _ = socket.0.disconnect().await;
}
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect in ping pong test");
let echo_res = tokio::time::timeout(Duration::from_secs(5), echo_rx).await;
assert!(echo_res.is_ok(), "Timeout waiting for echo reply, ping pong failed or client disconnected");
}
#[tokio::test]
async fn test_auto_reconnection() {
let _ = tracing_subscriber::fmt::try_init();
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
drop(listener);
let (_io, server_handle) = start_test_server_on_port(port).await;
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let (reconnect_tx, reconnect_rx) = oneshot::channel();
let reconnect_tx = Arc::new(Mutex::new(Some(reconnect_tx)));
let mut app = ClientApp::new(());
app.set_reconnect_interval(1);
app.set_pong_timeout(1);
let ctx = connect_tx.clone();
let rtx = reconnect_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
let rtx = rtx.clone();
async move {
socket.on_connect({
let ctx = ctx.clone();
move |_: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
}
}
});
socket.on_disconnect(move |_: Socket<()>, _: ClientData<serde_json::Value>| {
async move {
println!("Client detected disconnect!");
}
});
socket.on_reconnect({
let rtx = rtx.clone();
move |_: Socket<()>, _: ClientData<serde_json::Value>, attempts: u64| {
let rtx = rtx.clone();
async move {
println!("Reconnected after {} attempts", attempts);
if let Some(tx) = rtx.lock().unwrap().take() {
tx.send(()).ok();
}
}
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for first connect");
_io.close().await;
server_handle.abort();
sleep(Duration::from_millis(2500)).await;
let _new_server = start_test_server_on_port(port).await;
println!("Server restarted");
let reconnect_res = tokio::time::timeout(Duration::from_secs(10), reconnect_rx).await;
assert!(reconnect_res.is_ok(), "Timeout waiting for reconnect");
}
#[tokio::test]
async fn test_event_emission() {
let _ = tracing_subscriber::fmt::try_init();
let (port, _io, _server_handle) = start_test_server().await;
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let (echo_tx, echo_rx) = oneshot::channel::<serde_json::Value>();
let echo_tx = Arc::new(Mutex::new(Some(echo_tx)));
let (multi_tx, multi_rx) = oneshot::channel::<serde_json::Value>();
let multi_tx = Arc::new(Mutex::new(Some(multi_tx)));
let mut app = ClientApp::new(());
let ctx = connect_tx.clone();
let etx = echo_tx.clone();
let mtx = multi_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
let etx = etx.clone();
let mtx = mtx.clone();
async move {
socket.on_connect(move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
let _ = socket.0.emit("echo", serde_json::json!({"hello": "world"})).await;
let _ = socket.0.emit("echo", serde_json::json!(["arg1", "arg2"])).await;
}
});
socket.on("echo_reply", move |_: Socket<()>, data: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| {
let etx = etx.clone();
let mtx = mtx.clone();
async move {
let val = data.0;
println!("Received echo_reply: {:?}", val);
if val.is_array() && !val.as_array().unwrap().is_empty() {
let arg0 = &val[0];
if arg0.is_object() && arg0.get("hello") == Some(&serde_json::json!("world")) {
if let Some(tx) = etx.lock().unwrap().take() {
tx.send(arg0.clone()).ok();
}
} else if arg0.is_array() && arg0[0] == "arg1" {
if let Some(tx) = mtx.lock().unwrap().take() {
tx.send(arg0.clone()).ok();
}
}
}
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect");
let echo_res = tokio::time::timeout(Duration::from_secs(5), echo_rx).await;
assert!(echo_res.is_ok(), "Timeout waiting for echo reply");
assert_eq!(echo_res.unwrap().unwrap(), serde_json::json!({"hello": "world"}));
let multi_res = tokio::time::timeout(Duration::from_secs(5), multi_rx).await;
assert!(multi_res.is_ok(), "Timeout waiting for multi-arg echo reply");
assert_eq!(multi_res.unwrap().unwrap(), serde_json::json!(["arg1", "arg2"]));
}
#[tokio::test]
async fn test_acknowledgements() {
let _ = tracing_subscriber::fmt::try_init();
let (layer, io) = socketioxide::SocketIo::new_layer();
io.ns("/", |socket: SocketRef| async move {
socket.on("get_user", |_socket: SocketRef, ServerData::<serde_json::Value>(data), ack: socketioxide::extract::AckSender| async move {
let id = data.as_u64().unwrap_or(0);
if id == 123 {
ack.send(&serde_json::json!({ "name": "Alice" })).ok();
} else {
ack.send(&serde_json::json!({ "error": "not found" })).ok();
}
});
socket.on("ping_client", |socket: SocketRef| async move {
let stream = socket.emit_with_ack::<_, serde_json::Value>("client_echo", &serde_json::json!("ping_from_server")).unwrap();
if let Ok(res) = stream.await {
socket.emit("client_echo_result", &res).ok();
}
});
});
let app = Router::new().layer(layer);
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let (tc7_tx, tc7_rx) = oneshot::channel::<serde_json::Value>();
let tc7_tx = Arc::new(Mutex::new(Some(tc7_tx)));
let (tc8_tx, tc8_rx) = oneshot::channel::<serde_json::Value>();
let tc8_tx = Arc::new(Mutex::new(Some(tc8_tx)));
let mut app = ClientApp::new(());
let ctx = connect_tx.clone();
let tc7_tx_clone = tc7_tx.clone();
let tc8_tx_clone = tc8_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
let tc7_tx = tc7_tx_clone.clone();
let tc8_tx = tc8_tx_clone.clone();
async move {
socket.on_connect(move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
let tc7_tx = tc7_tx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
tokio::spawn(async move {
let res = socket.0.emit_with_ack("get_user", serde_json::json!(123), Duration::from_secs(2)).await;
if let Ok(data) = res {
if let Some(tx) = tc7_tx.lock().unwrap().take() {
tx.send(data).ok();
}
}
let _ = socket.0.emit("ping_client", serde_json::json!(null)).await;
});
}
});
socket.on("client_echo", |_: Socket<()>, data: ClientData<serde_json::Value>, ack: socket_io_client::Ack<()>| async move {
let _ = ack.send(data.0).await;
});
socket.on("client_echo_result", move |_: Socket<()>, data: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| {
let tc8_tx = tc8_tx.clone();
async move {
if let Some(tx) = tc8_tx.lock().unwrap().take() {
tx.send(data.0).ok();
}
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect");
let tc7_res = tokio::time::timeout(Duration::from_secs(5), tc7_rx).await;
assert!(tc7_res.is_ok(), "Timeout waiting for TC 7 reply");
let tc7_res = tc7_res.unwrap().unwrap();
assert!(tc7_res.is_array());
let arr = tc7_res.as_array().unwrap();
assert_eq!(arr[0], serde_json::json!({ "name": "Alice" }));
let tc8_res = tokio::time::timeout(Duration::from_secs(5), tc8_rx).await;
assert!(tc8_res.is_ok(), "Timeout waiting for TC 8 reply");
let tc8_res = tc8_res.unwrap().unwrap();
assert!(tc8_res.is_array());
let arr2 = tc8_res.as_array().unwrap();
assert_eq!(arr2[0], serde_json::json!("ping_from_server"));
}
#[tokio::test]
async fn test_namespaces_multiplexing() {
let _ = tracing_subscriber::fmt::try_init();
let (layer, io) = socketioxide::SocketIo::new_layer();
io.ns("/", |socket: SocketRef| async move {
socket.on("broadcast_root", |socket: SocketRef, ServerData::<serde_json::Value>(data)| async move {
socket.broadcast().emit("from_root", &data).await.ok();
});
});
io.ns("/admin", |socket: SocketRef| async move {
socket.on("broadcast_admin", |socket: SocketRef, ServerData::<serde_json::Value>(data)| async move {
socket.broadcast().emit("from_admin", &data).await.ok();
});
});
let app = Router::new().layer(layer);
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
let url = format!("http://127.0.0.1:{}", port);
let mut app1 = ClientApp::new(());
let mut app2 = ClientApp::new(());
app1.ns("/", |_| async move {});
app1.ns("/admin", |_| async move {});
let (root_rx_tx, root_rx_rx) = oneshot::channel::<serde_json::Value>();
let root_rx_tx = Arc::new(Mutex::new(Some(root_rx_tx)));
let (admin_rx_tx, admin_rx_rx) = oneshot::channel::<serde_json::Value>();
let admin_rx_tx = Arc::new(Mutex::new(Some(admin_rx_tx)));
let (connect2_root_tx, connect2_root_rx) = oneshot::channel();
let connect2_root_tx = Arc::new(Mutex::new(Some(connect2_root_tx)));
let (connect2_admin_tx, connect2_admin_rx) = oneshot::channel();
let connect2_admin_tx = Arc::new(Mutex::new(Some(connect2_admin_tx)));
let root_tx = root_rx_tx.clone();
let admin_tx = admin_rx_tx.clone();
app2.ns("/", move |socket| {
let root_tx = root_tx.clone();
let connect_tx = connect2_root_tx.clone();
async move {
socket.on_connect(move |_: Socket<()>, _: ClientData<serde_json::Value>| {
let connect_tx = connect_tx.clone();
async move {
if let Some(tx) = connect_tx.lock().unwrap().take() {
tx.send(()).ok();
}
}
});
socket.on("from_root", move |_: Socket<()>, data: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| {
let root_tx = root_tx.clone();
async move {
if let Some(tx) = root_tx.lock().unwrap().take() {
tx.send(data.0).ok();
}
}
});
socket.on("from_admin", |_: Socket<()>, _: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| async move {
panic!("Root namespace received admin event!");
});
}
});
app2.ns("/admin", move |socket| {
let admin_tx = admin_tx.clone();
let connect_tx = connect2_admin_tx.clone();
async move {
socket.on_connect(move |_: Socket<()>, _: ClientData<serde_json::Value>| {
let connect_tx = connect_tx.clone();
async move {
if let Some(tx) = connect_tx.lock().unwrap().take() {
tx.send(()).ok();
}
}
});
socket.on("from_admin", move |_: Socket<()>, data: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| {
let admin_tx = admin_tx.clone();
async move {
if let Some(tx) = admin_tx.lock().unwrap().take() {
tx.send(data.0).ok();
}
}
});
socket.on("from_root", |_: Socket<()>, _: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| async move {
panic!("Admin namespace received root event!");
});
}
});
let url_clone = url.clone();
tokio::spawn(async move {
app1.run(&url_clone).await;
});
let url_clone2 = url.clone();
tokio::spawn(async move {
app2.run(&url_clone2).await;
});
let connect2_root_res = tokio::time::timeout(Duration::from_secs(5), connect2_root_rx).await;
assert!(connect2_root_res.is_ok(), "Timeout waiting for root connect");
let connect2_admin_res = tokio::time::timeout(Duration::from_secs(5), connect2_admin_rx).await;
assert!(connect2_admin_res.is_ok(), "Timeout waiting for admin connect");
let mut client1 = socket_io_client::SocketIOClient::new(&url);
client1.set_namespace("/");
client1.register_namespace("/admin");
assert!(client1.connect().await.is_ok(), "Client1 failed to connect");
assert!(client1.connect_additional_ns("/admin", None).await.is_ok(), "Client1 failed to connect admin ns");
sleep(Duration::from_millis(50)).await;
assert!(client1.emit_ns("/", "broadcast_root", serde_json::json!("msg_root")).await.is_ok(), "Failed to emit on root");
assert!(client1.emit_ns("/admin", "broadcast_admin", serde_json::json!("msg_admin")).await.is_ok(), "Failed to emit on admin");
let r1 = tokio::time::timeout(Duration::from_secs(5), root_rx_rx).await;
assert!(r1.is_ok(), "Timeout waiting for root broadcast");
let r1 = r1.unwrap().unwrap();
let arr = r1.as_array().unwrap();
assert_eq!(arr[0], serde_json::json!("msg_root"));
let r2 = tokio::time::timeout(Duration::from_secs(5), admin_rx_rx).await;
assert!(r2.is_ok(), "Timeout waiting for admin broadcast");
let r2 = r2.unwrap().unwrap();
let arr2 = r2.as_array().unwrap();
assert_eq!(arr2[0], serde_json::json!("msg_admin"));
sleep(Duration::from_millis(500)).await;
}
#[tokio::test]
async fn test_binary_payloads() {
let _ = tracing_subscriber::fmt::try_init();
let (layer, io) = socketioxide::SocketIo::new_layer();
io.ns("/", |socket: SocketRef| async move {
socket.on("binary_echo", |socket: SocketRef, ServerData::<(serde_json::Value, bytes::Bytes, bytes::Bytes)>((data, bin1, bin2))| async move {
println!("Server received binary_echo: {:?} with bin1: {:?}, bin2: {:?}", data, bin1, bin2);
socket.emit("binary_echo_reply", &(data, bin1, bin2)).ok();
});
});
let app = Router::new().layer(layer);
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let port = listener.local_addr().unwrap().port();
tokio::spawn(async move {
axum::serve(listener, app).await.unwrap();
});
let url = format!("http://127.0.0.1:{}", port);
let (connect_tx, connect_rx) = oneshot::channel();
let connect_tx = Arc::new(Mutex::new(Some(connect_tx)));
let (binary_tx, binary_rx) = oneshot::channel::<(serde_json::Value, Vec<Vec<u8>>)>();
let binary_tx = Arc::new(Mutex::new(Some(binary_tx)));
let mut app = ClientApp::new(());
let ctx = connect_tx.clone();
let btx = binary_tx.clone();
app.ns("/", move |socket| {
let ctx = ctx.clone();
let btx = btx.clone();
async move {
socket.on_connect(move |socket: Socket<()>, _: ClientData<serde_json::Value>| {
let ctx = ctx.clone();
async move {
if let Some(tx) = ctx.lock().unwrap().take() {
tx.send(()).ok();
}
let bin_data = vec![vec![1, 2, 3, 4], vec![5, 6, 7, 8]];
let _ = socket.0.emit_binary("binary_echo", vec![serde_json::json!({"file": "test.bin"})], bin_data).await;
}
});
socket.on("binary_echo_reply", move |_: Socket<()>, data: ClientData<serde_json::Value>, _: socket_io_client::Ack<()>| {
let btx = btx.clone();
async move {
if let Some(tx) = btx.lock().unwrap().take() {
tx.send((data.0, vec![])).ok(); }
}
});
}
});
tokio::spawn(async move {
app.run(&url).await;
});
let connect_res = tokio::time::timeout(Duration::from_secs(5), connect_rx).await;
assert!(connect_res.is_ok(), "Timeout waiting for connect");
let reply_res = tokio::time::timeout(Duration::from_secs(5), binary_rx).await;
assert!(reply_res.is_ok(), "Timeout waiting for binary echo");
let (reply, _) = reply_res.unwrap().unwrap();
println!("Client received: {:?}", reply);
assert!(reply.is_array());
let arr = reply.as_array().unwrap();
let b1 = arr[1].get("binary").unwrap().as_str().unwrap();
let b2 = arr[2].get("binary").unwrap().as_str().unwrap();
assert_eq!(general_purpose::STANDARD.decode(b1).unwrap(), vec![1, 2, 3, 4]);
assert_eq!(general_purpose::STANDARD.decode(b2).unwrap(), vec![5, 6, 7, 8]);
}