async_socket/
lib.rs

1//! This crate implements a general-purpose asynchronous socket.
2//! 
3//! The `Socket` implements [AsyncRead], [AsyncWrite], [Stream] and [Clone]
4//! traits and thus mimics the functionality and the behaviour of the
5//! [TcpStream] and [UnixStream] objects. These propertis makes it a perfect
6//! tool for testing network activities and events.
7//! 
8//! [![Documentation](https://img.shields.io/badge/-Documentation-blue?style=for-the-badge&logo=Rust)](https://docs.rs/async-socket)
9//! [![Source](https://img.shields.io/badge/-Source-lightgrey?style=for-the-badge&logo=GitHub)](https://github.com/xpepermint/async-socket-rs)
10//! 
11//! ### Usage
12//! 
13//! **Example:**
14//! 
15//! ```rust
16//! use async_socket::Socket;
17//! use async_std::task::spawn;
18//! use futures::io::AsyncWriteExt;
19//! use futures::stream::StreamExt;
20//! 
21//! async fn example() {
22//!     let mut stream = Socket::default();
23//!     let mut writer = stream.clone();
24//! 
25//!     spawn(async move {
26//!         writer.write(b"Hello").await.unwrap();
27//!     });
28//! 
29//!     while let Some(bytes) = stream.next().await {
30//!         // ...
31//!     }
32//! }
33//! ```
34//! 
35//! [AsyncRead]: https://docs.rs/futures/latest/futures/prelude/trait.AsyncRead.html
36//! [AsyncWrite]: https://docs.rs/futures/latest/futures/prelude/trait.AsyncWrite.html
37//! [Stream]: https://docs.rs/futures/latest/futures/prelude/trait.Stream.html
38//! [Clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html
39//! [TcpStream]: https://docs.rs/async-std/latest/async_std/net/struct.TcpStream.html 
40//! [UnixStream]: https://docs.rs/async-std/latest/async_std/os/unix/net/struct.UnixStream.html
41mod socket;
42mod state;
43
44pub use socket::*;
45pub use state::*;
46
47#[cfg(test)]
48mod tests {
49    use super::*;
50    use async_std::task::spawn;
51    use futures::io::{AsyncWriteExt, AsyncReadExt};
52    use futures::stream::StreamExt;
53
54    #[async_std::test]
55    async fn writes_and_streams() {
56        let mut stream = Socket::default();
57        let mut writer = stream.clone();
58
59        spawn(async move {
60            writer.write(b"Hello").await.unwrap();
61            writer.write(b" ").await.unwrap();
62            writer.write(b"World!").await.unwrap();
63        });
64
65        let mut data = vec![];
66        while let Some(mut chunk) = stream.next().await {
67            data.append(&mut chunk);
68
69            if data.len() >= 12 {
70                break;
71            }
72        }
73
74        assert_eq!(data, b"Hello World!");
75    }
76
77    #[async_std::test]
78    async fn writes_and_reads() {
79        let mut stream = Socket::default();
80
81        stream.write(b"Hello").await.unwrap();
82
83        let mut buf = vec![0u8; 2];
84        let size = stream.read(&mut buf).await.unwrap();
85
86        assert_eq!(buf, b"He");
87        assert_eq!(size, 2);
88    }
89}