0.3.5-alpha.9

crates/common/game-realtime-webtransport-lib/tests/datagrams.rs

@@ -0,0 +1,109 @@
+// file: crates/common/game-realtime-webtransport-lib/tests/datagrams.rs
+// version: 1
+
+#![cfg(not(target_arch = "wasm32"))]
+
+const CLIENT_DATAGRAM: &[u8] = b"client-datagram";
+const RECEIVE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(1);
+const SERVER_DATAGRAM: &[u8] = b"server-datagram";
+
+#[tokio::test(flavor = "current_thread")]
+async fn backend_specific_datagrams_round_trip_without_entering_the_common_contract() {
+    let identity_result = game_realtime_webtransport_lib::WebTransportServerIdentity::generate_loopback();
+    assert!(identity_result.is_ok());
+    let identity = match identity_result {
+        Ok(value) => value,
+        Err(error) => panic!("identity generation failed unexpectedly: {error}"),
+    };
+    let certificate_hash = identity.certificate_hash().clone();
+    let server_config = game_realtime_webtransport_lib::WebTransportServerConfig::new(std::net::SocketAddr::from(([127, 0, 0, 1], 0)), identity);
+    let listener_result = game_realtime_webtransport_lib::WebTransportListener::bind(server_config);
+    assert!(listener_result.is_ok());
+    let mut listener = match listener_result {
+        Ok(value) => value,
+        Err(error) => panic!("listener bind failed unexpectedly: {error}"),
+    };
+    let endpoint = format!("https://{}/datagrams", listener.local_addr());
+    let client_config_result = game_realtime_webtransport_lib::WebTransportClientConfig::new(endpoint.as_str(), certificate_hash);
+    assert!(client_config_result.is_ok());
+    let client_config = match client_config_result {
+        Ok(value) => value,
+        Err(error) => panic!("client config failed unexpectedly: {error}"),
+    };
+    let (server_result, client_result) = tokio::join!(listener.accept(), game_realtime_webtransport_lib::connect(&client_config));
+    assert!(server_result.is_ok());
+    assert!(client_result.is_ok());
+    let server_session = match server_result {
+        Ok(value) => value,
+        Err(error) => panic!("server accept failed unexpectedly: {error}"),
+    };
+    let client_session = match client_result {
+        Ok(value) => value,
+        Err(error) => panic!("client connect failed unexpectedly: {error}"),
+    };
+    assert!(client_session.max_datagram_size() >= CLIENT_DATAGRAM.len());
+    assert!(server_session.max_datagram_size() >= SERVER_DATAGRAM.len());
+    assert!(client_session.send_datagram(CLIENT_DATAGRAM).is_ok());
+    let server_receive = tokio::time::timeout(RECEIVE_TIMEOUT, server_session.receive_datagram()).await;
+    assert!(server_receive.is_ok());
+    let server_payload = match server_receive {
+        Ok(Ok(value)) => value,
+        Ok(Err(error)) => panic!("server datagram receive failed unexpectedly: {error}"),
+        Err(_) => panic!("server datagram receive timed out"),
+    };
+    assert_eq!(server_payload.as_slice(), CLIENT_DATAGRAM);
+    assert!(server_session.send_datagram(SERVER_DATAGRAM).is_ok());
+    let client_receive = tokio::time::timeout(RECEIVE_TIMEOUT, client_session.receive_datagram()).await;
+    assert!(client_receive.is_ok());
+    let client_payload = match client_receive {
+        Ok(Ok(value)) => value,
+        Ok(Err(error)) => panic!("client datagram receive failed unexpectedly: {error}"),
+        Err(_) => panic!("client datagram receive timed out"),
+    };
+    assert_eq!(client_payload.as_slice(), SERVER_DATAGRAM);
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn oversized_datagram_is_rejected_before_backend_send() {
+    let identity_result = game_realtime_webtransport_lib::WebTransportServerIdentity::generate_loopback();
+    assert!(identity_result.is_ok());
+    let identity = match identity_result {
+        Ok(value) => value,
+        Err(error) => panic!("identity generation failed unexpectedly: {error}"),
+    };
+    let certificate_hash = identity.certificate_hash().clone();
+    let server_config = game_realtime_webtransport_lib::WebTransportServerConfig::new(std::net::SocketAddr::from(([127, 0, 0, 1], 0)), identity);
+    let listener_result = game_realtime_webtransport_lib::WebTransportListener::bind(server_config);
+    assert!(listener_result.is_ok());
+    let mut listener = match listener_result {
+        Ok(value) => value,
+        Err(error) => panic!("listener bind failed unexpectedly: {error}"),
+    };
+    let endpoint = format!("https://{}/datagrams-limit", listener.local_addr());
+    let client_config_result = game_realtime_webtransport_lib::WebTransportClientConfig::new(endpoint.as_str(), certificate_hash);
+    assert!(client_config_result.is_ok());
+    let client_config = match client_config_result {
+        Ok(value) => value,
+        Err(error) => panic!("client config failed unexpectedly: {error}"),
+    };
+    let (server_result, client_result) = tokio::join!(listener.accept(), game_realtime_webtransport_lib::connect(&client_config));
+    assert!(server_result.is_ok());
+    assert!(client_result.is_ok());
+    let client_session = match client_result {
+        Ok(value) => value,
+        Err(error) => panic!("client connect failed unexpectedly: {error}"),
+    };
+    let oversized_len = match client_session.max_datagram_size().checked_add(1) {
+        Some(value) => value,
+        None => panic!("datagram maximum unexpectedly reached usize::MAX"),
+    };
+    assert!(oversized_len <= 1024 * 1024);
+    let payload = vec![0_u8; oversized_len];
+    let error_result = client_session.send_datagram(payload.as_slice());
+    assert!(error_result.is_err());
+    let error = match error_result {
+        Ok(()) => panic!("oversized datagram unexpectedly succeeded"),
+        Err(value) => value,
+    };
+    assert_eq!(error.kind(), game_realtime_transport_lib::TransportErrorKind::MessageTooLarge);
+}