decdn-node 0.1.0

The deCDN node daemon (decdn-node): runtime, request handlers, payment settlement, and the admin RPC server
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

use super::*;

fn addr(byte: u8) -> Address {
    Address::from([byte; 20])
}

fn content(origins: &[Address]) -> ResolvedContent {
    ResolvedContent {
        denied_origins: origins.iter().copied().collect(),
        ..ResolvedContent::default()
    }
}

#[test]
fn empty_denies_nothing() {
    assert!(!ContentDenylist::empty().is_origin_denied(&addr(1)));
}

#[test]
fn local_origins_are_denied() {
    let deny = ContentDenylist::new(&content(&[addr(9)]));
    assert!(deny.is_origin_denied(&addr(9)));
    assert!(!deny.is_origin_denied(&addr(10)));
}

/// The reload path must not clobber what the chain watcher learned, and the
/// watcher must not clobber the operator's local list. This is the whole
/// reason the two live in separate slots.
#[test]
fn local_reload_and_chain_updates_are_independent() {
    let deny = ContentDenylist::new(&content(&[addr(1)]));
    deny.apply_chain_origin(addr(2), true);
    assert!(deny.is_origin_denied(&addr(1)));
    assert!(deny.is_origin_denied(&addr(2)));

    // A reload that drops the local entry leaves the chain entry standing.
    deny.set_local_origins(&content(&[]));
    assert!(!deny.is_origin_denied(&addr(1)));
    assert!(deny.is_origin_denied(&addr(2)));

    // ...and a chain removal leaves a re-added local entry standing.
    deny.set_local_origins(&content(&[addr(1)]));
    deny.apply_chain_origin(addr(2), false);
    assert!(deny.is_origin_denied(&addr(1)));
    assert!(!deny.is_origin_denied(&addr(2)));
}

/// An address on BOTH lists must survive removal from one. A naive single
/// set would drop it and silently resume serving a blacklisted origin.
#[test]
fn origin_on_both_lists_survives_removal_from_one() {
    let deny = ContentDenylist::new(&content(&[addr(3)]));
    deny.apply_chain_origin(addr(3), true);
    deny.apply_chain_origin(addr(3), false);
    assert!(deny.is_origin_denied(&addr(3)), "local entry still stands");
}

#[test]
fn apply_chain_origin_reports_whether_it_changed_anything() {
    let deny = ContentDenylist::empty();
    assert!(deny.apply_chain_origin(addr(4), true));
    assert!(!deny.apply_chain_origin(addr(4), true), "replay is a no-op");
    assert!(deny.apply_chain_origin(addr(4), false));
    assert!(!deny.apply_chain_origin(addr(4), false));
}

#[test]
fn set_chain_origins_replaces_wholesale() {
    let deny = ContentDenylist::empty();
    deny.apply_chain_origin(addr(5), true);
    deny.set_chain_origins([addr(6)].into_iter().collect());
    assert!(!deny.is_origin_denied(&addr(5)));
    assert!(deny.is_origin_denied(&addr(6)));
    assert_eq!(deny.chain_origin_count(), 1);
}