Struct WebSocketTestClient 

pub struct WebSocketTestClient { /* private fields */ }

WebSocket test client for integration testing

Provides high-level API for WebSocket connection management, message sending/receiving, and authentication.

Implementations

impl WebSocketTestClient

pub async fn connect(url: &str) -> Result<Self, WsError>

Connect to WebSocket server

Example

use reinhardt_test::websocket::WebSocketTestClient;

#[tokio::test]
async fn test_connect() {
    let client = WebSocketTestClient::connect("ws://localhost:8080/ws")
        .await
        .unwrap();
}

pub async fn connect_with_token(url: &str, token: &str) -> Result<Self, WsError>

Connect to WebSocket server with Bearer token authentication

Adds Authorization: Bearer <token> header to the WebSocket handshake request.

Example

use reinhardt_test::websocket::WebSocketTestClient;

#[tokio::test]
async fn test_auth() {
    let client = WebSocketTestClient::connect_with_token(
        "ws://localhost:8080/ws",
        "my-secret-token"
    )
    .await
    .unwrap();
}

pub async fn connect_with_query_token( url: &str, token: &str, ) -> Result<Self, WsError>

Connect to WebSocket server with query parameter authentication

Appends ?token=<token> to the URL.

Example

use reinhardt_test::websocket::WebSocketTestClient;

#[tokio::test]
async fn test_query_auth() {
    let client = WebSocketTestClient::connect_with_query_token(
        "ws://localhost:8080/ws",
        "my-token"
    )
    .await
    .unwrap();
}

pub async fn connect_with_cookie( url: &str, cookie_name: &str, cookie_value: &str, ) -> Result<Self, WsError>

Connect to WebSocket server with cookie authentication

Adds Cookie: <cookie_name>=<cookie_value> header to the WebSocket handshake request.

Example

use reinhardt_test::websocket::WebSocketTestClient;

#[tokio::test]
async fn test_cookie_auth() {
    let client = WebSocketTestClient::connect_with_cookie(
        "ws://localhost:8080/ws",
        "session_id",
        "abc123"
    )
    .await
    .unwrap();
}

pub async fn send_text(&mut self, text: &str) -> Result<(), WsError>

Send text message to WebSocket server

Example

use reinhardt_test::websocket::WebSocketTestClient;

#[tokio::test]
async fn test_send() {
    let mut client = WebSocketTestClient::connect("ws://localhost:8080/ws")
        .await
        .unwrap();
    client.send_text("Hello").await.unwrap();
}

pub async fn send_binary(&mut self, data: &[u8]) -> Result<(), WsError>

Send binary message to WebSocket server

pub async fn send_ping(&mut self, payload: &[u8]) -> Result<(), WsError>

Send ping message to WebSocket server

pub async fn send_pong(&mut self, payload: &[u8]) -> Result<(), WsError>

Send pong message to WebSocket server

pub async fn receive(&mut self) -> Option<Result<Message, WsError>>

Receive next message from WebSocket server

Returns None if connection is closed.

pub async fn receive_text(&mut self) -> Result<String, WsError>

Receive text message from WebSocket server with timeout

Example

use reinhardt_test::websocket::WebSocketTestClient;

#[tokio::test]
async fn test_receive() {
    let mut client = WebSocketTestClient::connect("ws://localhost:8080/ws")
        .await
        .unwrap();
    let text = client.receive_text().await.unwrap();
    assert_eq!(text, "Welcome");
}

pub async fn receive_text_with_timeout( &mut self, duration: Duration, ) -> Result<String, WsError>

Receive text message with custom timeout

pub async fn receive_binary(&mut self) -> Result<Vec<u8>, WsError>

Receive binary message from WebSocket server with timeout

pub async fn receive_binary_with_timeout( &mut self, duration: Duration, ) -> Result<Vec<u8>, WsError>

Receive binary message with custom timeout

pub async fn close(self) -> Result<(), WsError>

Close WebSocket connection

pub fn url(&self) -> &str

Get WebSocket URL