as-market-binance-okx-spot/tests/binance_ws_test.rs

use tungstenite::client::connect_with_proxy;
use tungstenite::protocol::WebSocketConfig;
use tungstenite::Message;
use std::net::{SocketAddr, IpAddr, Ipv4Addr};
use serde_json::json;
use url::Url;

#[tokio::test]
async fn test() {
    let request_url = Url::parse("wss://stream.binance.com:443/ws/btcusdt@depth10@100ms").unwrap();
    let proxy_address = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 9080);
    let websocket_config = Some(WebSocketConfig {
        max_send_queue: Some(16),
        max_message_size: Some(16 * 1024 * 1024),
        max_frame_size: Some(16 * 1024 * 1024),
        accept_unmasked_frames: false,
    });
    let max_redirects = 5;

    let (mut socket, response) =
        connect_with_proxy(request_url, proxy_address, websocket_config, max_redirects)
            .expect("Can't connect");

    // println!("connected：{}", response.status());

    let j = json!({
        "method": "SUBSCRIBE",
        "params":
        [
            "btcusdt@depth1@100ms"
        ],
        "id": 1
    });

    println!("{}", j.to_string());

    socket
        .write_message(Message::Text(j.to_string().into()))
        .unwrap();

    loop {
        if !socket.can_read() {
            continue;
        }

        let msg = socket.read_message();

        println!("Received msg");

        match msg {
            Ok(Message::Text(text)) => {
                println!("Received text: {}", text);
            }
            Ok(Message::Binary(bin)) => {
                println!("Received binary: {:?}", bin);
            }
            Ok(Message::Ping(_)) | Ok(Message::Pong(_)) | Ok(Message::Close(_)) => {
                socket.write_message(Message::Pong(vec![]))
                    .unwrap();
                println!("ping");
            }
            Err(error) => {
                println!("Error receiving message: {}", error);
                break;
            }
        }
    }

    socket.close(None).unwrap();
}