rbit 0.2.2

A BitTorrent library implementing BEP specifications
Documentation 
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

use std::net::{IpAddr, Ipv4Addr, SocketAddr};

use super::*;

#[test]
fn test_node_id_generate() {
    let id1 = NodeId::generate();
    let id2 = NodeId::generate();
    assert_ne!(id1.0, id2.0);
}

#[test]
fn test_node_id_from_bytes() {
    let bytes = [1u8; 20];
    let id = NodeId::from_bytes(&bytes).unwrap();
    assert_eq!(id.0, bytes);
}

#[test]
fn test_node_id_from_bytes_invalid() {
    let bytes = [1u8; 10];
    assert!(NodeId::from_bytes(&bytes).is_err());
}

#[test]
fn test_node_id_distance() {
    let id1 = NodeId([0u8; 20]);
    let id2 = NodeId([0xFF; 20]);

    let dist = id1.distance(&id2);
    assert_eq!(dist, [0xFF; 20]);

    let dist_self = id1.distance(&id1);
    assert_eq!(dist_self, [0u8; 20]);
}

#[test]
fn test_node_id_bucket_index() {
    let id1 = NodeId([0u8; 20]);
    let mut id2_bytes = [0u8; 20];
    id2_bytes[0] = 0x80;
    let id2 = NodeId(id2_bytes);

    assert_eq!(id1.bucket_index(&id2), 0);
}

#[test]
fn test_node_compact() {
    let id = NodeId([1u8; 20]);
    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 6881);
    let node = Node::new(id, addr);

    let compact = node.to_compact().unwrap();
    assert_eq!(compact.len(), 26);

    let parsed = Node::from_compact(&compact).unwrap();
    assert_eq!(parsed.id.0, id.0);
    assert_eq!(parsed.addr, addr);
}

#[test]
fn test_node_state() {
    let id = NodeId::generate();
    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 6881);
    let mut node = Node::new(id, addr);

    assert!(node.is_good());
    assert!(!node.is_bad());

    node.fail();
    node.fail();
    node.fail();
    assert!(node.is_bad());
}

#[test]
fn test_routing_table_add() {
    let our_id = NodeId::generate();
    let table = RoutingTable::new(our_id);

    for _ in 0..10 {
        let id = NodeId::generate();
        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 6881);
        table.add_node(Node::new(id, addr));
    }

    assert!(table.node_count() > 0);
}

#[test]
fn test_routing_table_find_closest() {
    let our_id = NodeId::generate();
    let table = RoutingTable::new(our_id);

    for i in 0..20 {
        let mut id_bytes = [0u8; 20];
        id_bytes[0] = i;
        let id = NodeId(id_bytes);
        let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(192, 168, 1, i)), 6881);
        table.add_node(Node::new(id, addr));
    }

    let target = NodeId([0u8; 20]);
    let closest = table.find_closest(&target, 8);
    assert!(closest.len() <= 8);
}

#[test]
fn test_dht_message_ping() {
    let our_id = NodeId::generate();
    let tid = bytes::Bytes::from_static(b"aa");

    let msg = DhtMessage::ping(tid.clone(), &our_id);
    let encoded = msg.encode().unwrap();

    let parsed = DhtMessage::parse(&encoded).unwrap();
    assert_eq!(parsed.transaction_id, tid);
    assert!(parsed.query.is_some());
}

#[test]
fn test_dht_message_find_node() {
    let our_id = NodeId::generate();
    let target = NodeId::generate();
    let tid = bytes::Bytes::from_static(b"bb");

    let msg = DhtMessage::find_node(tid.clone(), &our_id, target);
    let encoded = msg.encode().unwrap();

    let parsed = DhtMessage::parse(&encoded).unwrap();
    assert_eq!(parsed.transaction_id, tid);

    if let Some((name, query)) = parsed.query {
        assert_eq!(name, "find_node");
        match query {
            DhtQuery::FindNode { target: t } => {
                assert_eq!(t.0, target.0);
            }
            _ => panic!("wrong query type"),
        }
    } else {
        panic!("missing query");
    }
}

#[test]
fn test_dht_message_get_peers() {
    let our_id = NodeId::generate();
    let info_hash = [0xAB; 20];
    let tid = bytes::Bytes::from_static(b"cc");

    let msg = DhtMessage::get_peers(tid.clone(), &our_id, info_hash);
    let encoded = msg.encode().unwrap();

    let parsed = DhtMessage::parse(&encoded).unwrap();
    assert_eq!(parsed.transaction_id, tid);

    if let Some((name, query)) = parsed.query {
        assert_eq!(name, "get_peers");
        match query {
            DhtQuery::GetPeers { info_hash: h } => {
                assert_eq!(h, info_hash);
            }
            _ => panic!("wrong query type"),
        }
    } else {
        panic!("missing query");
    }
}