nexora 0.0.1

Single-threaded io_uring HTTP/1.1, HTTP/2, WebSocket, and TLS proactor client and server SDK
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
101
102
103
104
105
106
107
108
109
110

//! Public DNS cache and static-override precedence contracts.
use std::{
    net::{IpAddr, Ipv4Addr, SocketAddr},
    time::{Duration, Instant},
};

use nexora::{DnsCache, HostResolver, Result, SubsystemId};

fn address(port: u16) -> Vec<SocketAddr> {
    vec![SocketAddr::new(
        IpAddr::V4(Ipv4Addr::new(192, 0, 2, 1)),
        port,
    )]
}

#[test]
fn cache_serves_live_entries_and_drops_expired_ones() {
    let now = Instant::now();
    let mut cache = DnsCache::new(4);
    cache.insert(
        "Example.COM.",
        443,
        address(443),
        Duration::from_secs(30),
        now,
    );
    assert_eq!(
        cache.lookup("example.com", 443, now + Duration::from_secs(10)),
        Some(address(443))
    );
    assert!(
        cache
            .lookup("example.com", 443, now + Duration::from_secs(30))
            .is_none()
    );
    assert!(cache.is_empty());
}

#[test]
fn cache_rejects_zero_ttl_and_empty_address_lists() {
    let now = Instant::now();
    let mut cache = DnsCache::new(4);
    cache.insert("a.test", 80, address(80), Duration::ZERO, now);
    cache.insert("b.test", 80, Vec::new(), Duration::from_secs(30), now);
    assert!(cache.is_empty());
}

#[test]
fn cache_evicts_the_earliest_expiring_entry() {
    let now = Instant::now();
    let mut cache = DnsCache::new(1);
    cache.insert("short.test", 80, address(80), Duration::from_secs(5), now);
    cache.insert("long.test", 80, address(80), Duration::from_secs(60), now);
    assert_eq!(cache.len(), 1);
    assert!(
        cache
            .lookup("short.test", 80, now + Duration::from_secs(1))
            .is_none()
    );
    assert!(
        cache
            .lookup("long.test", 80, now + Duration::from_secs(1))
            .is_some()
    );
}

#[test]
fn overrides_win_over_cached_answers_and_ip_literals() -> Result<()> {
    let options = cares::ResolverOptions::builder().build()?;
    let mut resolver =
        HostResolver::new(SubsystemId::new_unchecked(9), options, "127.0.0.1:53", 1)?;
    let now = Instant::now();
    let override_address = vec![SocketAddr::from(([192, 0, 2, 7], 443))];
    resolver.resolve_host(
        "Static.Example.",
        443,
        vec![IpAddr::V4(Ipv4Addr::new(192, 0, 2, 7))],
    );
    assert_eq!(
        resolver.lookup_static_or_cache("static.example", 443, now),
        Some(override_address.clone())
    );
    assert_eq!(
        resolver.lookup_static_or_cache("127.0.0.1", 8080, now),
        Some(vec![SocketAddr::from(([127, 0, 0, 1], 8080))])
    );
    resolver.store_cache(
        "static.example",
        443,
        address(443),
        Duration::from_secs(60),
        now,
    );
    assert_eq!(
        resolver.lookup_static_or_cache("static.example", 443, now),
        Some(override_address)
    );
    resolver.resolve_host("static.example", 443, Vec::new());
    assert_eq!(
        resolver.lookup_static_or_cache("static.example", 443, now),
        Some(address(443))
    );
    resolver.clear_static("static.example", 443);
    assert!(
        resolver
            .lookup_static_or_cache("static.example", 443, now)
            .is_none()
    );
    Ok(())
}