liburlx 0.2.2

A memory-safe URL transfer library — idiomatic Rust reimplementation of libcurl
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

//! Property-based tests for the WebSocket frame codec.

#![allow(clippy::unwrap_used, clippy::expect_used)]

use proptest::prelude::*;

use liburlx::protocol::ws::{read_frame, Frame, Opcode};

proptest! {
    /// Any text frame roundtrips through encode → decode.
    #[test]
    fn text_frame_roundtrip(text in "[a-zA-Z0-9 ]{0,200}") {
        let frame = Frame::text(&text);
        let encoded = frame.encode(false);
        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
        let decoded = rt.block_on(async {
            let mut cursor = std::io::Cursor::new(encoded);
            read_frame(&mut cursor).await.unwrap()
        });
        prop_assert_eq!(decoded.as_text().unwrap(), text.as_str());
        prop_assert_eq!(decoded.opcode, Opcode::Text);
        prop_assert!(decoded.fin);
    }

    /// Any binary frame roundtrips through encode → decode.
    #[test]
    fn binary_frame_roundtrip(data in proptest::collection::vec(any::<u8>(), 0..500)) {
        let frame = Frame::binary(&data);
        let encoded = frame.encode(false);
        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
        let decoded = rt.block_on(async {
            let mut cursor = std::io::Cursor::new(encoded);
            read_frame(&mut cursor).await.unwrap()
        });
        prop_assert_eq!(&decoded.payload, &data);
        prop_assert_eq!(decoded.opcode, Opcode::Binary);
    }

    /// Masked frames decode to the same payload as unmasked.
    #[test]
    fn masked_unmasked_same_payload(text in "[a-zA-Z0-9]{1,100}") {
        let frame = Frame::text(&text);
        let unmasked = frame.encode(false);
        let masked = frame.encode(true);

        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
        let (d_un, d_ma) = rt.block_on(async {
            let mut c1 = std::io::Cursor::new(unmasked);
            let mut c2 = std::io::Cursor::new(masked);
            let d1 = read_frame(&mut c1).await.unwrap();
            let d2 = read_frame(&mut c2).await.unwrap();
            (d1, d2)
        });

        prop_assert_eq!(d_un.as_text().unwrap(), d_ma.as_text().unwrap());
    }

    /// Frame length encoding always matches the payload size.
    #[test]
    fn encoded_length_consistent(len in 0usize..2000) {
        let data = vec![0x41u8; len];
        let frame = Frame::binary(&data);
        let encoded = frame.encode(false);

        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
        let decoded = rt.block_on(async {
            let mut cursor = std::io::Cursor::new(encoded);
            read_frame(&mut cursor).await.unwrap()
        });
        prop_assert_eq!(decoded.payload.len(), len);
    }

    /// Ping frames preserve arbitrary payload.
    #[test]
    fn ping_payload_preserved(data in proptest::collection::vec(any::<u8>(), 0..125)) {
        let frame = Frame::ping(&data);
        let encoded = frame.encode(false);
        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
        let decoded = rt.block_on(async {
            let mut cursor = std::io::Cursor::new(encoded);
            read_frame(&mut cursor).await.unwrap()
        });
        prop_assert_eq!(&decoded.payload, &data);
        prop_assert_eq!(decoded.opcode, Opcode::Ping);
    }

    /// Pong frames preserve arbitrary payload.
    #[test]
    fn pong_payload_preserved(data in proptest::collection::vec(any::<u8>(), 0..125)) {
        let frame = Frame::pong(&data);
        let encoded = frame.encode(false);
        let rt = tokio::runtime::Builder::new_current_thread().enable_all().build().unwrap();
        let decoded = rt.block_on(async {
            let mut cursor = std::io::Cursor::new(encoded);
            read_frame(&mut cursor).await.unwrap()
        });
        prop_assert_eq!(&decoded.payload, &data);
        prop_assert_eq!(decoded.opcode, Opcode::Pong);
    }
}