63 lines
3.4 KiB
Rust
63 lines
3.4 KiB
Rust
// file: crates/common/game-realtime-websocket-lib/tests/loopback.rs
|
|
// version: 1
|
|
|
|
//! Deterministic localhost proof for the Tokio/tokio-tungstenite backend.
|
|
|
|
use game_realtime_transport_lib::RealtimeConnection; // rust-rules: trait-import
|
|
use game_realtime_transport_lib::RealtimeReceiver; // rust-rules: trait-import
|
|
use game_realtime_transport_lib::RealtimeSender; // rust-rules: trait-import
|
|
|
|
const TEST_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(3);
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn binary_round_trip_and_clean_close_work_on_loopback() {
|
|
let bind_address = std::net::SocketAddr::from(([127, 0, 0, 1], 0));
|
|
let listener = match game_realtime_websocket_lib::WebSocketListener::bind(bind_address).await {
|
|
Ok(value) => value,
|
|
Err(error) => panic!("loopback listener bind failed: {error}"),
|
|
};
|
|
let endpoint = format!("ws://{}/", listener.local_addr());
|
|
let pair = tokio::time::timeout(TEST_TIMEOUT, async {
|
|
return tokio::join!(listener.accept(), game_realtime_websocket_lib::connect(endpoint.as_str()));
|
|
})
|
|
.await;
|
|
let (server_connection, client_connection) = match pair {
|
|
Ok((Ok(server), Ok(client))) => (server, client),
|
|
Ok((_server, _client)) => panic!("loopback connection establishment failed"),
|
|
Err(_) => panic!("loopback connection establishment timed out"),
|
|
};
|
|
let (mut server_sender, mut server_receiver) = server_connection.split();
|
|
let (mut client_sender, mut client_receiver) = client_connection.split();
|
|
let client_payload = game_realtime_transport_lib::TransportMessage::new(vec![0, 1, 2, 3, 255]);
|
|
let client_send = tokio::time::timeout(TEST_TIMEOUT, client_sender.send(client_payload)).await;
|
|
assert!(matches!(client_send, Ok(Ok(()))));
|
|
let server_receive = tokio::time::timeout(TEST_TIMEOUT, server_receiver.receive()).await;
|
|
match server_receive {
|
|
Ok(Ok(received)) => assert_eq!(
|
|
received,
|
|
game_realtime_transport_lib::TransportReceive::Message(game_realtime_transport_lib::TransportMessage::new(vec![0, 1, 2, 3, 255]))
|
|
),
|
|
Ok(Err(error)) => panic!("server receive failed: {error}"),
|
|
Err(_) => panic!("server receive timed out"),
|
|
}
|
|
let server_payload = game_realtime_transport_lib::TransportMessage::new(vec![9, 8, 7, 6]);
|
|
let server_send = tokio::time::timeout(TEST_TIMEOUT, server_sender.send(server_payload)).await;
|
|
assert!(matches!(server_send, Ok(Ok(()))));
|
|
let client_receive = tokio::time::timeout(TEST_TIMEOUT, client_receiver.receive()).await;
|
|
match client_receive {
|
|
Ok(Ok(received)) => {
|
|
assert_eq!(received, game_realtime_transport_lib::TransportReceive::Message(game_realtime_transport_lib::TransportMessage::new(vec![9, 8, 7, 6])))
|
|
},
|
|
Ok(Err(error)) => panic!("client receive failed: {error}"),
|
|
Err(_) => panic!("client receive timed out"),
|
|
}
|
|
let client_close = tokio::time::timeout(TEST_TIMEOUT, client_sender.close()).await;
|
|
assert!(matches!(client_close, Ok(Ok(()))));
|
|
let server_close_observation = tokio::time::timeout(TEST_TIMEOUT, server_receiver.receive()).await;
|
|
match server_close_observation {
|
|
Ok(Ok(received)) => assert_eq!(received, game_realtime_transport_lib::TransportReceive::Closed),
|
|
Ok(Err(error)) => panic!("server close observation failed: {error}"),
|
|
Err(_) => panic!("server close observation timed out"),
|
|
};
|
|
}
|