systemd-resolved-rs 0.1.1

A compatibility-oriented reimplementation of systemd-resolved
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

#[cfg(test)]
mod test_22_logical_server_identity {
    use super::*;

    fn spec(
        address: SocketAddr,
        interface: &str,
        server_name: &str,
    ) -> crate::config::DnsServerSpec {
        crate::config::DnsServerSpec {
            address,
            interface: Some(interface.to_owned()),
            server_name: Some(server_name.to_owned()),
        }
    }

    #[test]
    fn same_address_metadata_expands_into_distinct_server_keys() {
        let address = "192.0.2.53:853".parse().expect("DNS server");
        let config = Config {
            upstreams: vec![address],
            upstream_specs: vec![
                spec(address, "eth0", "one.example"),
                spec(address, "eth1", "two.example"),
            ],
            fallback_upstreams: Vec::new(),
            fallback_upstream_specs: Vec::new(),
            ..Config::default()
        };
        let resolver = Resolver::new(config);

        let specs = resolver.server_specs_for_scope(ScopeKind::Global, &[address]);
        assert_eq!(specs.len(), 2);
        let keys = server_keys_for_specs(ScopeKind::Global, &specs);
        assert_eq!(keys.len(), 2);
        assert_eq!(keys[0].server(), address);
        assert_eq!(keys[1].server(), address);
        assert_ne!(keys[0], keys[1]);
    }

    #[test]
    fn attempted_identity_does_not_suppress_same_address_peer() {
        let address = "192.0.2.53:853".parse().expect("DNS server");
        let config = Config {
            upstreams: vec![address],
            upstream_specs: vec![
                spec(address, "eth0", "one.example"),
                spec(address, "eth1", "two.example"),
            ],
            ..Config::default()
        };
        let resolver = Resolver::new(config);
        let specs = resolver.server_specs_for_scope(ScopeKind::Global, &[address]);
        let keys = server_keys_for_specs(ScopeKind::Global, &specs);
        let mut attempted = HashSet::new();

        let first = resolver
            .select_server(&keys, &attempted)
            .expect("first identity");
        attempted.insert(first);
        let second = resolver
            .select_server(&keys, &attempted)
            .expect("second identity");

        assert_ne!(first, second);
        assert_eq!(first.server(), second.server());
    }
}