Skip to main content

websock_tungstenite_mux/
lib.rs

1//! Tokio + tokio-tungstenite based WebSocket multiplexing transport.
2//!
3//! This crate provides a QUIC/WebTransport-like logical stream interface over a single WebSocket.
4
5mod builder;
6mod client;
7mod server;
8mod session;
9pub mod tls;
10
11pub use builder::{ClientBuilder, ServerBuilder};
12pub use client::Client;
13pub use server::{Server, bind};
14pub use session::Limits;
15pub use session::{RecvStream, SendStream, Session};
16pub use tls::{
17    TlsClientConfig, TlsClientConfigBuilder, TlsConfig, TlsServerConfig, TlsServerConfigBuilder,
18};
19
20#[cfg(test)]
21mod tests {
22    use bytes::{Bytes, BytesMut};
23    use tokio::sync::mpsc;
24    use websock_mux_proto::{Frame, StreamDir, StreamId};
25
26    use crate::session::Limits;
27    use crate::session::SessionInner;
28
29    #[test]
30    fn frame_roundtrip() {
31        let id = StreamId(4);
32        let frame = Frame::Stream {
33            id,
34            data: Bytes::from_static(b"hello"),
35            fin: true,
36        };
37        let mut buf = frame.encode();
38        let decoded = Frame::decode(&mut buf).expect("decode");
39        assert_eq!(frame, decoded);
40    }
41
42    #[tokio::test]
43    async fn stream_open_data_fin() {
44        let (outbound_tx, _outbound_rx) = mpsc::channel(4);
45        let (accept_uni_tx, mut accept_uni_rx) = mpsc::channel(4);
46        let (accept_bi_tx, _accept_bi_rx) = mpsc::channel(4);
47        let inner = std::sync::Arc::new(SessionInner::new(
48            false,
49            Limits::default(),
50            outbound_tx,
51            accept_uni_tx,
52            accept_bi_tx,
53        ));
54        let id = StreamId::new(0, true, StreamDir::Uni).expect("stream id");
55        inner
56            .clone()
57            .handle_frame(Frame::OpenUni { id })
58            .await
59            .expect("open");
60        let mut recv = accept_uni_rx.recv().await.expect("recv stream");
61        let data = Bytes::from_static(b"ping");
62        inner
63            .clone()
64            .handle_frame(Frame::Stream {
65                id,
66                data: data.clone(),
67                fin: true,
68            })
69            .await
70            .expect("stream");
71        let mut buf = BytesMut::new();
72        let n = recv.read_buf::<BytesMut>(&mut buf).await.expect("read");
73        assert_eq!(n, Some(4));
74        assert_eq!(buf.as_ref(), data.as_ref());
75        let max_size: usize = 1024;
76        let end = recv.read_chunk(max_size).await.expect("fin");
77        assert!(end.is_none());
78    }
79}