azalea_protocol/
lib.rs

1#![doc = include_str!("../README.md")]
2// this is necessary for thiserror backtraces
3#![feature(error_generic_member_access)]
4
5pub mod address;
6pub mod common;
7#[cfg(feature = "connecting")]
8pub mod connect;
9pub mod packets;
10pub mod read;
11pub mod resolve;
12pub mod write;
13
14#[doc(hidden)]
15#[deprecated(note = "renamed to `resolve`.")]
16pub mod resolver {
17    pub use super::resolve::*;
18}
19
20#[doc(hidden)]
21#[deprecated(note = "moved to `address::ServerAddr`.")]
22pub type ServerAddress = address::ServerAddr;
23
24#[cfg(test)]
25mod tests {
26    use std::io::Cursor;
27
28    use uuid::Uuid;
29
30    use crate::{
31        packets::{
32            Packet,
33            game::s_chat::{LastSeenMessagesUpdate, ServerboundChat},
34            login::{ServerboundLoginPacket, s_hello::ServerboundHello},
35        },
36        read::{compression_decoder, read_packet},
37        write::{compression_encoder, serialize_packet, write_packet},
38    };
39
40    #[tokio::test]
41    async fn test_hello_packet() {
42        let packet = ServerboundHello {
43            name: "test".to_owned(),
44            profile_id: Uuid::nil(),
45        };
46        let mut stream = Vec::new();
47        write_packet(&packet.into_variant(), &mut stream, None, &mut None)
48            .await
49            .unwrap();
50
51        assert_eq!(
52            stream,
53            [
54                22, 0, 4, 116, 101, 115, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
55            ]
56        );
57
58        let mut stream = Cursor::new(stream);
59
60        let _ = read_packet::<ServerboundLoginPacket, _>(
61            &mut stream,
62            &mut Cursor::new(Vec::new()),
63            None,
64            &mut None,
65        )
66        .await
67        .unwrap();
68    }
69
70    #[tokio::test]
71    async fn test_double_hello_packet() {
72        let packet = ServerboundHello {
73            name: "test".to_owned(),
74            profile_id: Uuid::nil(),
75        }
76        .into_variant();
77        let mut stream = Vec::new();
78        write_packet(&packet, &mut stream, None, &mut None)
79            .await
80            .unwrap();
81        write_packet(&packet, &mut stream, None, &mut None)
82            .await
83            .unwrap();
84        let mut stream = Cursor::new(stream);
85
86        let mut buffer = Cursor::new(Vec::new());
87
88        let _ = read_packet::<ServerboundLoginPacket, _>(&mut stream, &mut buffer, None, &mut None)
89            .await
90            .unwrap();
91        let _ = read_packet::<ServerboundLoginPacket, _>(&mut stream, &mut buffer, None, &mut None)
92            .await
93            .unwrap();
94    }
95
96    #[tokio::test]
97    async fn test_read_long_compressed_chat() {
98        let compression_threshold = 256;
99
100        let buf = serialize_packet(
101            &ServerboundChat {
102                message: "a".repeat(256),
103                timestamp: 0,
104                salt: 0,
105                signature: None,
106                last_seen_messages: LastSeenMessagesUpdate::default(),
107            }
108            .into_variant(),
109        )
110        .unwrap();
111
112        let buf = compression_encoder(&buf, compression_threshold).unwrap();
113
114        println!("{buf:?}");
115
116        compression_decoder(&mut Cursor::new(&buf), compression_threshold).unwrap();
117    }
118}