use super::*;
use std::net::SocketAddr;
fn create_test_peer(
download_speed: f64,
upload_speed: f64,
am_choking: bool,
peer_interested: bool,
) -> PeerStats {
let addr: SocketAddr = format!(
"127.0.0.1:{}",
6881u32.saturating_add(download_speed as u32).min(65535)
)
.parse()
.unwrap();
let mut peer_id = [0u8; 20];
peer_id[..8].copy_from_slice(&download_speed.to_bits().to_be_bytes());
let mut peer = PeerStats::new(peer_id, addr);
peer.download_speed = download_speed;
peer.upload_speed = upload_speed;
peer.am_choking = am_choking;
peer.peer_interested = peer_interested;
peer
}
#[test]
fn test_new_algorithm_empty() {
let config = ChokingConfig::default();
let algo = ChokingAlgorithm::new(config);
assert!(algo.is_empty());
assert_eq!(algo.len(), 0);
}
#[test]
fn test_remove_peers_remaps_snubbed_and_optimistic_indices() {
let mut algo = ChokingAlgorithm::new(ChokingConfig::default());
for port in 1..=3 {
algo.add_peer(PeerStats::new(
[port as u8; 20],
format!("127.0.0.1:{port}").parse().unwrap(),
));
}
algo.mark_peer_snubbed(1);
algo.current_optimistic_peer = Some(PeerIdentity {
peer_id: [2u8; 20],
addr: "127.0.0.1:2".parse().unwrap(),
});
algo.remove_peers(&[1]);
assert_eq!(algo.len(), 2);
assert!(!algo.is_explicitly_snubbed(1));
assert_eq!(algo.current_optimistic_peer, None);
}
#[test]
fn test_add_remove_peers() {
let config = ChokingConfig::default();
let mut algo = ChokingAlgorithm::new(config);
assert_eq!(algo.len(), 0);
let addr: SocketAddr = "127.0.0.1:6881".parse().unwrap();
algo.add_peer(PeerStats::new([0u8; 20], addr));
assert_eq!(algo.len(), 1);
algo.add_peer(PeerStats::new([0u8; 20], addr));
assert_eq!(algo.len(), 2);
algo.add_peer(PeerStats::new([0u8; 20], addr));
assert_eq!(algo.len(), 3);
algo.remove_peer(1);
assert_eq!(algo.len(), 2);
algo.remove_peer(0);
assert_eq!(algo.len(), 1);
algo.remove_peer(0);
assert!(algo.is_empty());
}
#[test]
fn test_rotate_choke_selects_top_k() {
let config = ChokingConfig {
max_upload_slots: 3,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(100000.0, 1000.0, true, true));
algo.add_peer(create_test_peer(80000.0, 800.0, true, true));
algo.add_peer(create_test_peer(60000.0, 600.0, true, true));
algo.add_peer(create_test_peer(40000.0, 400.0, true, true));
algo.add_peer(create_test_peer(20000.0, 200.0, true, true));
algo.add_peer(create_test_peer(10000.0, 100.0, true, true));
let actions = algo.rotate_choke();
let unchoke_count = actions
.iter()
.filter(|a| matches!(a, ChokeAction::Unchoke(_)))
.count();
assert_eq!(unchoke_count, 3);
assert_eq!(actions.len(), 6); }
#[test]
fn test_rotate_choke_minimizes_changes() {
let config = ChokingConfig {
max_upload_slots: 2,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(100000.0, 1000.0, false, true)); algo.add_peer(create_test_peer(80000.0, 800.0, false, true)); algo.add_peer(create_test_peer(60000.0, 600.0, true, true)); algo.add_peer(create_test_peer(40000.0, 400.0, true, true));
let actions = algo.rotate_choke();
let no_change_count = actions
.iter()
.filter(|a| matches!(a, ChokeAction::NoChange(_)))
.count();
assert!(
no_change_count >= 2,
"Expected at least 2 NoChange actions, got {}",
no_change_count
);
let actions2 = algo.rotate_choke();
let no_change_count2 = actions2
.iter()
.filter(|a| matches!(a, ChokeAction::NoChange(_)))
.count();
assert_eq!(no_change_count2, 4, "Expected all NoChange on second call");
}
#[test]
fn test_optimistically_unchoke_selects_choked_peer() {
let config = ChokingConfig {
optimistic_unchoke_interval_secs: 0, ..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(1000.0, 100.0, true, true)); algo.add_peer(create_test_peer(2000.0, 200.0, false, true)); algo.add_peer(create_test_peer(3000.0, 300.0, true, false));
let result = algo.optimistically_unchoke();
assert!(
result.is_some(),
"Expected to select a peer for optimistic unchoke"
);
assert_eq!(result.unwrap(), 0);
}
#[test]
fn test_optimistically_avoids_recent() {
let config = ChokingConfig {
optimistic_unchoke_interval_secs: 30,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
let mut peer = create_test_peer(1000.0, 100.0, true, true);
peer.record_optimistic_unchoke(); algo.add_peer(peer);
let result = algo.optimistically_unchoke();
assert!(result.is_none());
}
#[test]
fn test_snubbed_peers_get_lowered_score() {
let normal_peer = create_test_peer(50000.0, 500.0, true, true);
let mut snubbed_peer = create_test_peer(50000.0, 500.0, true, true);
snubbed_peer.is_snubbed = true;
let normal_score = ChokingAlgorithm::calculate_peer_score(&normal_peer, false);
let snubbed_score_stats = ChokingAlgorithm::calculate_peer_score(&snubbed_peer, false);
let snubbed_score_explicit = ChokingAlgorithm::calculate_peer_score(&normal_peer, true);
assert!(snubbed_score_stats < normal_score);
assert!(
(normal_score - snubbed_score_stats) > 900.0,
"Expected large score difference due to PeerStats snubbed penalty"
);
assert!(snubbed_score_explicit < normal_score);
assert!(
(normal_score - snubbed_score_explicit) > 900.0,
"Expected large score difference due to explicit snubbed penalty"
);
}
#[test]
fn test_check_snubbed_returns_timed_out_peers() {
let config = ChokingConfig {
snubbed_timeout_secs: 1, ..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
let _addr: SocketAddr = "127.0.0.1:6881".parse().unwrap();
let peer = PeerStats::new([0u8; 20], "127.0.0.1:6882".parse().unwrap());
algo.add_peer(peer);
std::thread::sleep(std::time::Duration::from_millis(1100));
let snubbed_indices = algo.check_snubbed_peers();
assert_eq!(snubbed_indices.len(), 1);
assert_eq!(snubbed_indices[0], 0);
assert!(algo.get_peer(0).unwrap().is_snubbed);
}
#[test]
fn test_on_data_received_resets_snubbed_status() {
let config = ChokingConfig {
snubbed_timeout_secs: 1,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
let peer = PeerStats::new([0u8; 20], "127.0.0.1:6883".parse().unwrap());
algo.add_peer(peer);
std::thread::sleep(std::time::Duration::from_millis(1100));
let snubbed = algo.check_snubbed_peers();
assert_eq!(snubbed.len(), 1);
assert!(algo.get_peer(0).unwrap().is_snubbed);
algo.on_data_received(0, 1024);
assert!(!algo.get_peer(0).unwrap().is_snubbed);
}
#[test]
fn test_get_peer_accessors() {
let config = ChokingConfig::default();
let mut algo = ChokingAlgorithm::new(config);
let addr: SocketAddr = "127.0.0.1:6881".parse().unwrap();
let peer = PeerStats::new([0u8; 20], addr);
algo.add_peer(peer);
assert!(algo.get_peer(0).is_some());
assert!(algo.get_peer(1).is_none());
{
let p = algo.get_peer_mut(0).unwrap();
p.download_speed = 9999.0;
}
assert!((algo.get_peer(0).unwrap().download_speed - 9999.0).abs() < f64::EPSILON);
}
#[test]
fn test_config_defaults() {
let config = ChokingConfig::default();
assert_eq!(config.max_upload_slots, 4);
assert_eq!(config.optimistic_unchoke_interval_secs, 30);
assert_eq!(config.snubbed_timeout_secs, 60);
assert_eq!(config.choke_rotation_interval_secs, 10);
}
#[test]
fn test_snub_detection_after_timeout() {
let config = ChokingConfig {
snubbed_timeout_secs: 1,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
let peer = PeerStats::new([0u8; 20], "127.0.0.1:6882".parse().unwrap());
algo.add_peer(peer);
std::thread::sleep(std::time::Duration::from_millis(1100));
let snubbed_indices = algo.check_snubbed_peers();
assert_eq!(snubbed_indices.len(), 1);
assert!(algo.get_peer(0).unwrap().is_snubbed);
}
#[test]
fn test_snubbed_peer_always_remains_choked() {
let config = ChokingConfig {
max_upload_slots: 2,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(100000.0, 1000.0, true, true)); algo.add_peer(create_test_peer(50000.0, 500.0, true, true)); algo.add_peer(create_test_peer(30000.0, 300.0, true, true));
algo.mark_peer_snubbed(0);
assert!(algo.is_explicitly_snubbed(0));
assert_eq!(algo.snubbed_count(), 1);
let actions = algo.rotate_choke();
let peer0_action = actions
.iter()
.find(|a| matches!(a, ChokeAction::NoChange(0) | ChokeAction::Choke(0)));
assert!(
peer0_action.is_some(),
"Peer 0 should have an action in results"
);
match peer0_action.unwrap() {
ChokeAction::Choke(_) | ChokeAction::NoChange(_) => {} ChokeAction::Unchoke(_) => panic!("Snubbed peer 0 should NEVER be unchoked"),
}
}
#[test]
fn test_unsnub_on_data_received() {
let config = ChokingConfig::default();
let mut algo = ChokingAlgorithm::new(config);
let peer = PeerStats::new([0u8; 20], "127.0.0.1:6883".parse().unwrap());
algo.add_peer(peer);
algo.mark_peer_snubbed(0);
assert!(algo.is_explicitly_snubbed(0));
assert_eq!(algo.snubbed_count(), 1);
algo.on_data_received(0, 1024);
assert!(
!algo.is_explicitly_snubbed(0),
"Peer should be un-snubbed after data received"
);
assert_eq!(algo.snubbed_count(), 0);
}
#[test]
fn test_identity_api_survives_peer_reordering() {
let mut algo = ChokingAlgorithm::new(ChokingConfig::default());
let first = create_test_peer(1000.0, 100.0, true, true);
let second = create_test_peer(2000.0, 200.0, true, true);
let first_identity = PeerIdentity::from(&first);
let second_identity = PeerIdentity::from(&second);
algo.add_peer(first);
algo.add_peer(second);
algo.mark_peer_snubbed(0);
algo.peers.swap(0, 1);
assert!(algo.is_explicitly_snubbed(1));
algo.on_data_received_by_identity(first_identity, 4096);
assert!(!algo.is_explicitly_snubbed(1));
algo.remove_peers_by_identity(&[second_identity]);
assert_eq!(algo.peers().len(), 1);
assert_eq!(PeerIdentity::from(&algo.peers()[0]), first_identity);
}
#[test]
fn test_identity_actions_match_registered_peers() {
let mut algo = ChokingAlgorithm::new(ChokingConfig {
max_upload_slots: 1,
..Default::default()
});
let first = create_test_peer(3000.0, 0.0, true, true);
let second = create_test_peer(1000.0, 0.0, true, true);
let first_identity = PeerIdentity::from(&first);
let second_identity = PeerIdentity::from(&second);
algo.add_peer(first);
algo.add_peer(second);
let actions = algo.rotate_choke_by_identity();
assert!(actions.iter().any(|action| {
matches!(action, IdentityChokeAction::Unchoke(identity) if *identity == first_identity)
}));
assert!(
actions
.iter()
.any(|action| action.identity() == second_identity)
);
}
#[test]
fn test_opt_unchoking_rotation_changes_peer() {
let config = ChokingConfig {
optimistic_unchoke_interval_secs: 0, ..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(1000.0, 100.0, true, true));
algo.add_peer(create_test_peer(2000.0, 200.0, true, true));
algo.add_peer(create_test_peer(3000.0, 300.0, true, true));
let first = algo.optimistically_unchoke();
assert!(first.is_some());
let first_idx = first.unwrap();
for i in 0..3 {
if let Some(p) = algo.get_peer_mut(i) {
p.last_optimistic_unchoke_at =
std::time::Instant::now() - std::time::Duration::from_secs(1);
}
}
let second = algo.optimistically_unchoke();
assert!(second.is_some());
let second_idx = second.unwrap();
assert_ne!(
first_idx, second_idx,
"Optimistic unchoke should rotate to a different peer"
);
}
#[test]
fn test_opt_unchoking_excludes_snubbed_peers() {
let config = ChokingConfig {
optimistic_unchoke_interval_secs: 0,
..Default::default()
};
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(5000.0, 500.0, true, true));
algo.add_peer(create_test_peer(3000.0, 300.0, true, true));
algo.mark_peer_snubbed(0);
let result = algo.optimistically_unchoke();
assert!(result.is_some());
assert_eq!(
result.unwrap(),
1,
"Should select non-snubbed peer for optimistic unchoke"
);
}
#[test]
fn test_mark_snubbed_idempotent() {
let config = ChokingConfig::default();
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(100.0, 10.0, true, true));
algo.mark_peer_snubbed(0);
assert_eq!(algo.snubbed_count(), 1);
algo.mark_peer_snubbed(0); assert_eq!(
algo.snubbed_count(),
1,
"Duplicate mark should not increase count"
);
}
#[test]
fn test_unsnub_non_snubbed_peer_returns_false() {
let config = ChokingConfig::default();
let mut algo = ChokingAlgorithm::new(config);
algo.add_peer(create_test_peer(100.0, 10.0, true, true));
let result = algo.unsnub_peer(0);
assert!(!result, "Unsnubbing non-snubbed peer should return false");
}