quicburn-shared 0.1.0

A blazing fast QUIC implementation in Rust
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

//! Integration tests for quicburn-shared

use quicburn_shared::{
    ALPN_PROTOCOL, PROTOCOL_VERSION, is_compatible_version, parse_protocol_version, protocol_info,
};

#[test]
fn test_protocol_compatibility_full_cycle() {
    let info = protocol_info();
    assert!(info.starts_with("quicburn/"));
    assert!(info.contains(PROTOCOL_VERSION));
}

#[test]
fn test_alpn_protocol_handshake() {
    // Simulate ALPN negotiation
    let server_protocols = quicburn_shared::supported_alpn_protocols();
    let client_protocol = ALPN_PROTOCOL;

    // Server should accept client's protocol
    let accepted = server_protocols.iter().any(|&p| p == client_protocol);
    assert!(accepted);
}

#[test]
fn test_version_parsing_comprehensive() {
    // Test valid versions
    assert_eq!(parse_protocol_version("0.1.0"), Some((0, 1, 0)));
    assert_eq!(parse_protocol_version("1.0.0"), Some((1, 0, 0)));
    assert_eq!(parse_protocol_version("2.3.4"), Some((2, 3, 4)));
    assert_eq!(parse_protocol_version("255.255.255"), Some((255, 255, 255)));

    // Test invalid versions
    assert_eq!(parse_protocol_version(""), None);
    assert_eq!(parse_protocol_version("1"), None);
    assert_eq!(parse_protocol_version("1.2"), None);
    assert_eq!(parse_protocol_version("1.2.3.4"), None);
    assert_eq!(parse_protocol_version("a.b.c"), None);
    assert_eq!(parse_protocol_version("1.2.3a"), None);
}

#[test]
fn test_version_compatibility_edges() {
    // Current version should always be compatible
    assert!(is_compatible_version(PROTOCOL_VERSION));

    // Same major, different minor/patch should be compatible
    if let Some((major, _, _)) = parse_protocol_version(PROTOCOL_VERSION) {
        assert!(is_compatible_version(&format!("{}.0.0", major)));
        assert!(is_compatible_version(&format!("{}.999.999", major)));
        assert!(is_compatible_version(&format!("{}.0.999", major)));
        assert!(is_compatible_version(&format!("{}.999.0", major)));
    }

    // Different major should be incompatible
    let current_major = parse_protocol_version(PROTOCOL_VERSION)
        .map(|(m, _, _)| m)
        .unwrap_or(0);

    assert!(!is_compatible_version(&format!(
        "{}.0.0",
        current_major + 1
    )));
    if current_major > 0 {
        assert!(!is_compatible_version(&format!(
            "{}.0.0",
            current_major - 1
        )));
    }
}