use super::*;
use std::net::SocketAddr;
fn make_local_node() -> DhtNode {
DhtNode::new([0u8; 20], "127.0.0.1:6881".parse::<SocketAddr>().unwrap())
}
#[test]
fn test_bucket_creation_full_range() {
let local = make_local_node();
let bucket = Bucket::new(&local);
assert_eq!(bucket.prefix_length(), 0);
assert_eq!(bucket.min_id(), &[0u8; 20]);
assert_eq!(bucket.max_id(), &[0xFFu8; 20]);
assert_eq!(bucket.count_node(), 0);
assert!(!bucket.is_full());
}
#[test]
fn test_bucket_is_in_range() {
let local = make_local_node();
let bucket = Bucket::new(&local);
assert!(bucket.is_in_range(&[0u8; 20]));
assert!(bucket.is_in_range(&[0xFFu8; 20]));
assert!(bucket.is_in_range(&[0x80u8; 20]));
}
#[test]
fn test_add_node() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let node = DhtNode::new([1u8; 20], "127.0.0.1:6882".parse().unwrap());
assert!(bucket.add_node(node));
assert_eq!(bucket.count_node(), 1);
}
#[test]
fn unverified_duplicate_cannot_replace_verified_node_endpoint() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let node_id = [0x21; 20];
let verified_addr: SocketAddr = "192.0.2.1:6881".parse().unwrap();
let advertised_addr: SocketAddr = "198.51.100.9:6881".parse().unwrap();
bucket.add_node(DhtNode::new(node_id, verified_addr));
bucket.add_node(DhtNode::unverified(node_id, advertised_addr));
assert_eq!(bucket.count_node(), 1);
assert_eq!(bucket.nodes()[0].addr(), verified_addr);
assert!(bucket.nodes()[0].is_good());
}
#[test]
fn test_add_node_full_bucket_replaces_bad() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
for i in 0..K {
let mut node = DhtNode::new(
[i as u8; 20],
format!("127.0.0.1:{}", 6882 + i).parse().unwrap(),
);
for _ in 0..5 {
node.record_failure();
}
bucket.add_node(node);
}
assert!(bucket.is_full());
let new_node = DhtNode::new([0xFFu8; 20], "127.0.0.1:9999".parse().unwrap());
assert!(bucket.add_node(new_node));
assert_eq!(bucket.count_node(), K);
}
#[test]
fn test_add_node_full_bucket_rejects() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
for i in 0..K {
let node = DhtNode::new(
[(i + 1) as u8; 20],
format!("127.0.0.1:{}", 6882 + i).parse().unwrap(),
);
bucket.add_node(node);
}
assert!(bucket.is_full());
let previous_update = std::time::Instant::now() - std::time::Duration::from_secs(1_800);
bucket.last_updated = previous_update;
let new_node = DhtNode::new([0xFFu8; 20], "127.0.0.1:9999".parse().unwrap());
assert!(!bucket.add_node(new_node));
assert_eq!(bucket.last_updated, previous_update);
}
#[test]
fn test_split_allowed() {
let local = make_local_node();
let bucket = Bucket::new(&local);
assert!(bucket.split_allowed());
}
#[test]
fn test_split_not_allowed_if_local_id_out_of_range() {
let local = DhtNode::new([0xFFu8; 20], "127.0.0.1:6881".parse().unwrap());
let bucket = Bucket::new_for_range(
1,
[0u8; 20], [0x7Fu8; 20], local.id,
);
assert!(!bucket.split_allowed());
}
#[test]
fn test_split() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
for i in 0..4u8 {
let node = DhtNode::new(
[i; 20],
format!("127.0.0.1:{}", 6882 + i as u16).parse().unwrap(),
);
bucket.add_node(node);
}
for i in 0..4u8 {
let mut id = [0u8; 20];
id[0] = 0x80 | i;
let node = DhtNode::new(
id,
format!("127.0.0.2:{}", 6882 + i as u16).parse().unwrap(),
);
bucket.add_node(node);
}
assert_eq!(bucket.count_node(), 8);
let right_bucket = bucket.split();
assert_eq!(bucket.prefix_length(), 1);
assert_eq!(bucket.count_node(), 4);
assert_eq!(right_bucket.prefix_length(), 1);
assert_eq!(right_bucket.count_node(), 4);
}
#[test]
fn test_cache_node() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let node = DhtNode::new([1u8; 20], "127.0.0.1:6882".parse().unwrap());
bucket.cache_node(node);
assert_eq!(bucket.cached_nodes().len(), 1);
}
#[test]
fn test_cache_node_limit() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
for i in 0..5u8 {
let node = DhtNode::new(
[i; 20],
format!("127.0.0.1:{}", 6882 + i as u16).parse().unwrap(),
);
bucket.cache_node(node);
}
assert_eq!(bucket.cached_nodes().len(), CACHE_SIZE);
}
#[test]
fn replacement_cache_deduplicates_ids_and_active_nodes() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let active_id = [1; 20];
let candidate_id = [2; 20];
bucket.add_node(DhtNode::new(active_id, "127.0.0.1:6882".parse().unwrap()));
bucket.cache_node(DhtNode::new(active_id, "127.0.0.1:6999".parse().unwrap()));
bucket.cache_node(DhtNode::new(
candidate_id,
"127.0.0.1:6883".parse().unwrap(),
));
bucket.cache_node(DhtNode::new(
candidate_id,
"127.0.0.1:6884".parse().unwrap(),
));
assert_eq!(bucket.cached_nodes().len(), 1);
assert_eq!(bucket.cached_nodes()[0].id(), &candidate_id);
assert_eq!(bucket.cached_nodes()[0].addr().port(), 6884);
assert!(bucket.nodes().iter().any(|node| node.id() == &active_id));
}
#[test]
fn test_drop_node_promotes_cached() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let node_id = [1u8; 20];
let node = DhtNode::new(node_id, "127.0.0.1:6882".parse().unwrap());
bucket.add_node(node);
let replacement = DhtNode::new([2u8; 20], "127.0.0.1:6883".parse().unwrap());
bucket.cache_node(replacement);
assert!(bucket.drop_node(&node_id));
assert_eq!(bucket.count_node(), 1);
assert!(bucket.nodes().iter().any(|n| n.id == [2u8; 20]));
}
#[test]
fn test_replace_node_consumes_cached_candidate() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let node_id = [1u8; 20];
let replacement_id = [2u8; 20];
bucket.add_node(DhtNode::new(node_id, "127.0.0.1:6882".parse().unwrap()));
bucket.cache_node(DhtNode::new(
replacement_id,
"127.0.0.1:6883".parse().unwrap(),
));
assert!(bucket.remove_cached_node(&replacement_id));
assert!(bucket.replace_node(
&node_id,
DhtNode::new(replacement_id, "127.0.0.1:6883".parse().unwrap())
));
assert!(!bucket.nodes().iter().any(|node| node.id == node_id));
assert!(bucket.nodes().iter().any(|node| node.id == replacement_id));
assert!(bucket.cached_nodes().is_empty());
}
#[test]
fn test_get_random_node_id() {
let local = make_local_node();
let bucket = Bucket::new(&local);
let id = bucket.get_random_node_id();
assert!(bucket.is_in_range(&id));
}
#[test]
fn random_bucket_target_preserves_only_non_random_prefix_bits() {
let local_id = [0x80; 20];
let mut min_id = [0; 20];
min_id[..2].copy_from_slice(&[0x80, 0x80]);
let bucket = Bucket::new_for_range(9, min_id, [0xFF; 20], local_id);
let mut random_id = [0xFF; 20];
bucket.apply_fixed_prefix(&mut random_id);
assert_eq!(random_id[0], 0x80);
assert_eq!(random_id[1], 0xFF);
assert!(bucket.is_in_range(&random_id));
}
#[test]
fn test_needs_refresh_empty() {
let local = make_local_node();
let bucket = Bucket::new(&local);
assert!(bucket.needs_refresh());
}
#[test]
fn test_contains_questionable_node() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let node = DhtNode::new([1u8; 20], "127.0.0.1:6882".parse().unwrap());
bucket.add_node(node);
assert!(!bucket.contains_questionable_node());
}
#[test]
fn test_move_to_tail() {
let local = make_local_node();
let mut bucket = Bucket::new(&local);
let n1 = DhtNode::new([1u8; 20], "127.0.0.1:6882".parse().unwrap());
let n2 = DhtNode::new([2u8; 20], "127.0.0.1:6883".parse().unwrap());
bucket.add_node(n1);
bucket.add_node(n2);
bucket.move_to_tail(&[1u8; 20]);
assert_eq!(bucket.nodes()[1].id, [1u8; 20]);
}