105 lines
5.2 KiB
Rust
105 lines
5.2 KiB
Rust
// file: crates/ksp-onchain-transport-lib/unit_tests/ws_protocol_session.rs
|
|
// version: 3
|
|
|
|
use futures_util::StreamExt; // rust-rules: trait-import
|
|
|
|
fn endpoint(url: &str, protocol: crate::WsProtocolKind) -> crate::WsEndpointSettings {
|
|
return crate::WsEndpointSettings::new(
|
|
"local_protocol_fixture",
|
|
true,
|
|
crate::WsProviderName::new("local-fixture"),
|
|
crate::WsClusterName::new("local"),
|
|
protocol,
|
|
crate::WsEndpointUrl::parse(url).expect("local WebSocket URL must parse"),
|
|
crate::WsSessionSettings::default(),
|
|
);
|
|
}
|
|
|
|
async fn bind_local_listener() -> (tokio::net::TcpListener, std::string::String) {
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("local listener must bind");
|
|
let address = listener.local_addr().expect("local listener must expose address");
|
|
return (listener, format!("ws://{address}"));
|
|
}
|
|
|
|
async fn accept_until_close(listener: tokio::net::TcpListener) {
|
|
let (stream, _) = listener.accept().await.expect("local peer must accept connection");
|
|
let mut websocket = tokio_tungstenite::accept_async(stream).await.expect("local WebSocket handshake must succeed");
|
|
while let std::option::Option::Some(message) = websocket.next().await {
|
|
let message = message.expect("local peer message must decode");
|
|
if message.is_close() {
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn protocol_facades_share_the_existing_physical_session_path() {
|
|
let (standard_listener, standard_url) = bind_local_listener().await;
|
|
let standard_server = tokio::spawn(accept_until_close(standard_listener));
|
|
let standard = crate::SolanaStandardWsSession::connect(endpoint(standard_url.as_str(), crate::WsProtocolKind::SolanaStandard))
|
|
.await
|
|
.expect("standard facade must connect");
|
|
assert_eq!(standard.snapshot().protocol(), crate::WsProtocolKind::SolanaStandard);
|
|
standard.close().await.expect("standard facade must close");
|
|
standard_server.await.expect("standard peer task must finish");
|
|
let (helius_listener, helius_url) = bind_local_listener().await;
|
|
let helius_server = tokio::spawn(accept_until_close(helius_listener));
|
|
let helius_url = format!("{helius_url}/?api-key=SECRET-CANARY");
|
|
let helius = crate::HeliusLaserStreamWsSession::connect(endpoint(helius_url.as_str(), crate::WsProtocolKind::HeliusLaserStream))
|
|
.await
|
|
.expect("Helius facade must connect");
|
|
assert_eq!(helius.snapshot().protocol(), crate::WsProtocolKind::HeliusLaserStream);
|
|
let rendered = format!("{helius:?}");
|
|
assert!(!rendered.contains("SECRET-CANARY"));
|
|
assert!(!rendered.contains(helius_url.as_str()));
|
|
helius.close().await.expect("Helius facade must close");
|
|
helius_server.await.expect("Helius peer task must finish");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn historical_generic_constructor_remains_standard_only_before_network_io() {
|
|
let endpoint = endpoint("ws://127.0.0.1:9", crate::WsProtocolKind::HeliusLaserStream);
|
|
let error = crate::WsSession::connect(endpoint).await.expect_err("generic historical constructor must reject Helius protocol");
|
|
assert_eq!(error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
|
|
assert_eq!(
|
|
error.context().iter().find(|entry| return entry.key() == "expected_protocol").map(|entry| return entry.value()),
|
|
std::option::Option::Some("solana_standard")
|
|
);
|
|
assert_eq!(
|
|
error.context().iter().find(|entry| return entry.key() == "actual_protocol").map(|entry| return entry.value()),
|
|
std::option::Option::Some("helius_laserstream")
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn typed_facades_reject_protocol_mismatch_before_network_io() {
|
|
let helius_error = crate::HeliusLaserStreamWsSession::connect(endpoint("ws://127.0.0.1:9", crate::WsProtocolKind::SolanaStandard))
|
|
.await
|
|
.expect_err("Helius facade must reject standard endpoint");
|
|
assert_eq!(helius_error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
|
|
let standard_error = crate::SolanaStandardWsSession::connect(endpoint("ws://127.0.0.1:9", crate::WsProtocolKind::HeliusLaserStream))
|
|
.await
|
|
.expect_err("standard facade must reject Helius endpoint");
|
|
assert_eq!(standard_error.code(), crate::ERROR_CODE_INVALID_SETTINGS);
|
|
}
|
|
|
|
#[test]
|
|
fn protocol_facades_define_no_second_actor_socket_or_public_inner_escape_hatch() {
|
|
let source = include_str!("../src/ws_protocol_session.rs");
|
|
assert!(!source.contains("tokio::spawn"));
|
|
assert!(!source.contains("tokio_tungstenite"));
|
|
assert!(!source.contains("WsSessionCommand"));
|
|
assert!(!source.contains("pub fn inner("));
|
|
assert!(!source.contains("pub fn into_inner("));
|
|
assert!(!source.contains("pub async fn account_subscribe"));
|
|
assert!(!source.contains("pub async fn block_subscribe"));
|
|
assert!(!source.contains("pub async fn logs_subscribe"));
|
|
assert!(!source.contains("pub async fn program_subscribe"));
|
|
assert!(!source.contains("pub async fn root_subscribe"));
|
|
assert!(!source.contains("pub async fn signature_subscribe"));
|
|
assert!(!source.contains("pub async fn slot_subscribe"));
|
|
assert!(!source.contains("pub async fn slots_updates_subscribe"));
|
|
assert!(!source.contains("pub async fn vote_subscribe"));
|
|
}
|