use crate::engine::bt_message_receiver::{BtMessageReceiver, HandshakeResult};
use aria2_protocol::bittorrent::message::handshake::Handshake;
use aria2_protocol::bittorrent::message::types::HANDSHAKE_LENGTH;
fn make_handshake_bytes(info_hash: &[u8; 20], peer_id: &[u8; 20]) -> [u8; HANDSHAKE_LENGTH] {
Handshake::new(info_hash, peer_id).to_bytes()
}
#[test]
fn test_new_receiver_initial_state() {
let info_hash = [0xAA; 20];
let receiver = BtMessageReceiver::new(info_hash);
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_full_handshake_success() {
let info_hash = [0x11; 20];
let peer_id = [0x22; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let data = make_handshake_bytes(&info_hash, &peer_id);
let result = receiver.receive_handshake(&data);
match result {
HandshakeResult::Completed {
peer_id: pid,
reserved_bytes,
} => {
assert_eq!(pid, peer_id);
assert_ne!(reserved_bytes, [0u8; 8]);
}
_ => panic!("Expected Completed, got {:?}", result),
}
assert!(receiver.is_handshake_sent());
}
#[test]
fn test_info_hash_mismatch() {
let expected_hash = [0x11; 20];
let wrong_hash = [0xFF; 20];
let peer_id = [0x22; 20];
let mut receiver = BtMessageReceiver::new(expected_hash);
let data = make_handshake_bytes(&wrong_hash, &peer_id);
let result = receiver.receive_handshake(&data);
match result {
HandshakeResult::InfoHashMismatch { received } => {
assert_eq!(received, wrong_hash);
}
_ => panic!("Expected InfoHashMismatch, got {:?}", result),
}
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_incomplete_data_too_short() {
let info_hash = [0x11; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let result = receiver.receive_handshake(&[]);
assert_eq!(result, HandshakeResult::NeedMoreData);
let partial = vec![0u8; 67];
let result = receiver.receive_handshake(&partial);
assert_eq!(result, HandshakeResult::NeedMoreData);
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_quick_reply_valid_info_hash_partial() {
let info_hash = [0x33; 20];
let peer_id = [0x44; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let full_data = make_handshake_bytes(&info_hash, &peer_id);
let partial = &full_data[..48];
let result = receiver.receive_handshake_with_quick_reply(partial);
assert_eq!(result, HandshakeResult::NeedMoreData);
assert!(receiver.is_handshake_sent());
}
#[test]
fn test_quick_reply_invalid_info_hash() {
let expected_hash = [0x33; 20];
let wrong_hash = [0xFF; 20];
let peer_id = [0x44; 20];
let mut receiver = BtMessageReceiver::new(expected_hash);
let full_data = make_handshake_bytes(&wrong_hash, &peer_id);
let partial = &full_data[..48];
let result = receiver.receive_handshake_with_quick_reply(partial);
match result {
HandshakeResult::InfoHashMismatch { received } => {
assert_eq!(received, wrong_hash);
}
_ => panic!("Expected InfoHashMismatch, got {:?}", result),
}
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_handshake_sent_flag_transitions() {
let info_hash = [0x11; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
assert!(!receiver.is_handshake_sent());
receiver.set_handshake_sent(true);
assert!(receiver.is_handshake_sent());
receiver.set_handshake_sent(false);
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_roundtrip_with_handshake_parse() {
let info_hash = [0xAB; 20];
let peer_id = [0xCD; 20];
let handshake = Handshake::new(&info_hash, &peer_id);
let bytes = handshake.to_bytes();
let parsed = Handshake::parse(&bytes).unwrap();
assert_eq!(parsed.info_hash, info_hash);
assert_eq!(parsed.peer_id, peer_id);
let mut receiver = BtMessageReceiver::new(info_hash);
let result = receiver.receive_handshake(&bytes);
match result {
HandshakeResult::Completed {
peer_id: pid,
reserved_bytes,
} => {
assert_eq!(pid, peer_id);
assert_eq!(reserved_bytes, handshake.reserved);
}
_ => panic!("Expected Completed, got {:?}", result),
}
}
#[test]
fn test_quick_reply_full_68_bytes() {
let info_hash = [0x55; 20];
let peer_id = [0x66; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let data = make_handshake_bytes(&info_hash, &peer_id);
let result = receiver.receive_handshake_with_quick_reply(&data);
match result {
HandshakeResult::Completed { peer_id: pid, .. } => {
assert_eq!(pid, peer_id);
}
_ => panic!("Expected Completed, got {:?}", result),
}
assert!(receiver.is_handshake_sent());
}
#[test]
fn test_quick_reply_not_triggered_when_already_sent() {
let info_hash = [0x55; 20];
let peer_id = [0x66; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
receiver.set_handshake_sent(true);
let data = make_handshake_bytes(&info_hash, &peer_id);
let result = receiver.receive_handshake_with_quick_reply(&data);
match result {
HandshakeResult::Completed { peer_id: pid, .. } => {
assert_eq!(pid, peer_id);
}
_ => panic!("Expected Completed, got {:?}", result),
}
}
#[test]
fn test_quick_reply_not_triggered_with_less_than_48_bytes() {
let info_hash = [0x55; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let data = vec![0u8; 47];
let result = receiver.receive_handshake_with_quick_reply(&data);
assert_eq!(result, HandshakeResult::NeedMoreData);
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_parse_error_bad_protocol() {
let info_hash = [0x11; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let mut bad_data = [0u8; HANDSHAKE_LENGTH];
bad_data[0] = 19;
bad_data[1..20].copy_from_slice(b"Invalid protocol!!!");
let result = receiver.receive_handshake(&bad_data);
match result {
HandshakeResult::ParseError { reason } => {
assert!(!reason.is_empty());
}
_ => panic!("Expected ParseError, got {:?}", result),
}
assert!(!receiver.is_handshake_sent());
}
#[test]
fn test_quick_reply_then_full_data() {
let info_hash = [0x77; 20];
let peer_id = [0x88; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
let full_data = make_handshake_bytes(&info_hash, &peer_id);
let partial = &full_data[..48];
let result1 = receiver.receive_handshake_with_quick_reply(partial);
assert_eq!(result1, HandshakeResult::NeedMoreData);
assert!(receiver.is_handshake_sent());
let result2 = receiver.receive_handshake_with_quick_reply(&full_data);
match result2 {
HandshakeResult::Completed { peer_id: pid, .. } => {
assert_eq!(pid, peer_id);
}
_ => panic!("Expected Completed, got {:?}", result2),
}
}
#[test]
fn test_reserved_bytes_preserved() {
let info_hash = [0x99; 20];
let peer_id = [0xAA; 20];
let handshake = Handshake::new(&info_hash, &peer_id).with_dht(true);
let bytes = handshake.to_bytes();
let mut receiver = BtMessageReceiver::new(info_hash);
let result = receiver.receive_handshake(&bytes);
match result {
HandshakeResult::Completed { reserved_bytes, .. } => {
assert_ne!(reserved_bytes[7] & 0x04, 0);
assert_ne!(reserved_bytes[5] & 0x10, 0);
assert_ne!(reserved_bytes[7] & 0x01, 0);
}
_ => panic!("Expected Completed, got {:?}", result),
}
}
#[test]
fn test_handshake_sent_set_after_successful_receive() {
let info_hash = [0xBB; 20];
let peer_id = [0xCC; 20];
let mut receiver = BtMessageReceiver::new(info_hash);
assert!(!receiver.is_handshake_sent());
let data = make_handshake_bytes(&info_hash, &peer_id);
let _ = receiver.receive_handshake(&data);
assert!(receiver.is_handshake_sent());
let _ = receiver.receive_handshake(&data);
assert!(receiver.is_handshake_sent());
}
#[test]
fn test_quick_reply_data_between_48_and_67() {
let info_hash = [0xDD; 20];
let peer_id = [0xEE; 20];
let full_data = make_handshake_bytes(&info_hash, &peer_id);
let mut receiver = BtMessageReceiver::new(info_hash);
let result48 = receiver.receive_handshake_with_quick_reply(&full_data[..48]);
assert_eq!(result48, HandshakeResult::NeedMoreData);
assert!(receiver.is_handshake_sent());
let mut receiver = BtMessageReceiver::new(info_hash);
let result60 = receiver.receive_handshake_with_quick_reply(&full_data[..60]);
assert_eq!(result60, HandshakeResult::NeedMoreData);
assert!(receiver.is_handshake_sent());
let mut receiver = BtMessageReceiver::new(info_hash);
let result67 = receiver.receive_handshake_with_quick_reply(&full_data[..67]);
assert_eq!(result67, HandshakeResult::NeedMoreData);
assert!(receiver.is_handshake_sent());
}