lernie 0.1.67

lernie: the operator seat — the window and wire client for a yog 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
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

//! Every rung falling through, and the sentence each leaves; and the stated
//! defaults.

use super::*;

#[test]
fn a_dark_commons_is_said_after_the_direct_refusal() {
    let mut node = FakeNode::bind(NodeId([2u8; 20]));
    node.serve(vec![], Mood::Silent, vec![]);
    let b = Bench::new(dead(), None);
    let channel = b.channel().tuned(
        Roving {
            bootstrap: vec![node.addr.to_string()],
            // The one node is silent: its deadline is waited out, a floor.
            dht: quick(),
            ..b.roving()
        },
        b.clock.arc(),
    );
    let Err(Reach::Unsent(said)) = channel.ask(&request(1)) else {
        panic!("nothing crossed");
    };
    assert!(said.starts_with("connect 127.0.0.1:"), "{said}");
    assert!(
        said.contains("; rendezvous: no DHT node answered get"),
        "{said}"
    );
}

#[test]
fn every_way_the_rendezvous_can_disappoint_is_a_sentence() {
    let sealed_elsewhere = Keypair::from_seed([1u8; 32])
        .unwrap()
        .sign(
            pairing().presence_salt(),
            1,
            Presence { endpoints: vec![] }.seal(&[8u8; 32]).unwrap(),
        )
        .unwrap();
    for (held, expect) in [
        (None, "no presence is published under this pairing"),
        (
            Some(sealed_elsewhere),
            "will not open under this pairing salt",
        ),
        (
            Some(presence(dead())),
            "nothing answered the punch inside its window",
        ),
    ] {
        let b = Bench::new(dead(), held);
        let channel = b.channel().tuned(
            Roving {
                window: Duration::from_millis(300),
                ..b.roving()
            },
            b.clock.arc(),
        );
        let said = channel.ask(&request(1)).unwrap_err().said();
        assert!(said.ends_with(expect), "{said}");
    }
    let b = Bench::new(dead(), None);
    let channel = b.channel().tuned(
        Roving {
            bootstrap: vec![String::new()],
            ..b.roving()
        },
        b.clock.arc(),
    );
    let said = channel.ask(&request(1)).unwrap_err().said();
    assert!(said.ends_with("no bootstrap node resolved"), "{said}");
}

#[test]
fn the_defaults_are_the_stated_ones() {
    let r = Roving::default();
    assert_eq!(r.direct, Duration::from_secs(5));
    assert_eq!(r.window, Duration::from_secs(40));
    assert_eq!(
        r.bootstrap,
        [
            "router.bittorrent.com:6881",
            "dht.transmissionbt.com:6881",
            "router.utorrent.com:6881",
            "dht.aelitis.com:6881",
        ]
    );
    assert_eq!(r.advertise, None);
    assert_eq!(r.dht.k, 8);
}

/// **A stand-in asked past its script hangs up**, so a test that asks more
/// than it scripted fails on the ask rather than reading an answer nobody
/// wrote.
#[test]
fn a_stand_in_asked_past_its_script_hangs_up() {
    let (listener, at) = listener();
    let b = Bench::new(at, None);
    let engine = Engine::listen(b.scratch.path(), listener, Vec::new());
    assert!(b.channel().ask(&request(1)).is_err());
    assert_eq!(engine.connections(), 1);
    assert_eq!(
        ops(&engine.heard()),
        vec![1],
        "the ask was heard, not answered"
    );
}