use aria2_protocol::bittorrent::message::extension::ExtensionHandshake;
use aria2_protocol::bittorrent::message::types::BtMessage;
use crate::engine::bt_peer_interaction::BtPeerInteractive;
use crate::engine::extension_registry::ExtensionUpdate;
use super::make_test_conn;
#[test]
fn test_extension_registry_initial_state() {
let info_hash = [0u8; 20];
let interactive = BtPeerInteractive::new(info_hash, 100);
assert_eq!(interactive.extension_registry().local_ut_metadata_id(), 1);
assert_eq!(interactive.extension_registry().local_ut_pex_id(), 2);
assert!(
interactive
.extension_registry()
.peer_ut_metadata_id()
.is_none()
);
assert!(interactive.extension_registry().peer_ut_pex_id().is_none());
}
#[test]
fn test_dispatch_extended_handshake() {
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
let hs = ExtensionHandshake::new();
let payload = hs.to_bytes();
let msg = BtMessage::Extended { ext_id: 0, payload };
let update = interactive.dispatch_message(msg, &mut conn, |_| false);
assert!(update.extension_update.is_some());
match update.extension_update.unwrap() {
ExtensionUpdate::HandshakeReceived {
ut_metadata_id,
ut_pex_id,
reqq,
} => {
assert_eq!(ut_metadata_id, Some(1));
assert_eq!(ut_pex_id, Some(2));
assert_eq!(reqq, 500);
}
other => panic!("Expected HandshakeReceived, got {:?}", other),
}
assert_eq!(
interactive.extension_registry().peer_ut_metadata_id(),
Some(1)
);
assert_eq!(interactive.extension_registry().peer_ut_pex_id(), Some(2));
assert!(interactive.ut_pex_enabled);
}
#[test]
fn test_dispatch_extended_ut_metadata_request() {
use aria2_protocol::bittorrent::message::extension::UtMetadataMessage;
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
let hs = ExtensionHandshake::new();
let hs_payload = hs.to_bytes();
let _ = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 0,
payload: hs_payload,
},
&mut conn,
|_| false,
);
let msg = UtMetadataMessage::Request { piece: 0 };
let payload = msg.to_payload();
let update = interactive.dispatch_message(
BtMessage::Extended { ext_id: 1, payload },
&mut conn,
|_| false,
);
assert!(update.extension_update.is_some());
match update.extension_update.unwrap() {
ExtensionUpdate::MetadataRequest { piece } => {
assert_eq!(piece, 0);
}
other => panic!("Expected MetadataRequest, got {:?}", other),
}
}
#[test]
fn test_dispatch_extended_ut_metadata_data() {
use aria2_protocol::bittorrent::message::extension::UtMetadataMessage;
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
let hs = ExtensionHandshake::new();
let hs_payload = hs.to_bytes();
let _ = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 0,
payload: hs_payload,
},
&mut conn,
|_| false,
);
let msg = UtMetadataMessage::Data {
piece: 2,
total_size: 50000,
data: b"test metadata".to_vec(),
};
let payload = msg.to_payload();
let update = interactive.dispatch_message(
BtMessage::Extended { ext_id: 1, payload },
&mut conn,
|_| false,
);
assert!(update.extension_update.is_some());
match update.extension_update.unwrap() {
ExtensionUpdate::MetadataPiece {
piece,
total_size,
data,
} => {
assert_eq!(piece, 2);
assert_eq!(total_size, 50000);
assert_eq!(data, b"test metadata");
}
other => panic!("Expected MetadataPiece, got {:?}", other),
}
}
#[test]
fn test_dispatch_extended_ut_pex() {
use aria2_protocol::bittorrent::message::extension::{CompactPeerV4, UtPexMessage};
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
let hs = ExtensionHandshake::new();
let hs_payload = hs.to_bytes();
let _ = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 0,
payload: hs_payload,
},
&mut conn,
|_| false,
);
let mut pex = UtPexMessage::new();
let mut peer_bytes = [0u8; 6];
peer_bytes[..4].copy_from_slice(&[10, 0, 0, 1]);
peer_bytes[4..6].copy_from_slice(&6881u16.to_be_bytes());
pex.added.push(CompactPeerV4(peer_bytes));
let payload = pex.to_payload();
let update = interactive.dispatch_message(
BtMessage::Extended { ext_id: 2, payload },
&mut conn,
|_| false,
);
assert!(update.extension_update.is_some());
match update.extension_update.unwrap() {
ExtensionUpdate::PeerExchange {
added_v4,
added_v6,
dropped_v4,
dropped_v6,
} => {
assert_eq!(added_v4.len(), 1);
assert!(added_v6.is_empty());
assert!(dropped_v4.is_empty());
assert!(dropped_v6.is_empty());
assert_eq!(added_v4[0], CompactPeerV4(peer_bytes));
}
other => panic!("Expected PeerExchange, got {:?}", other),
}
}
#[test]
fn test_dispatch_extended_unknown_ext_id() {
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
let hs = ExtensionHandshake::new();
let hs_payload = hs.to_bytes();
let _ = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 0,
payload: hs_payload,
},
&mut conn,
|_| false,
);
let update = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 99,
payload: vec![],
},
&mut conn,
|_| false,
);
assert!(update.extension_update.is_none());
}
#[test]
fn test_dispatch_extended_handshake_enables_pex() {
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
assert!(!interactive.ut_pex_enabled);
let hs = ExtensionHandshake::new();
let hs_payload = hs.to_bytes();
let _ = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 0,
payload: hs_payload,
},
&mut conn,
|_| false,
);
assert!(interactive.ut_pex_enabled);
}
#[test]
fn test_dispatch_extended_handshake_without_pex() {
use aria2_protocol::bittorrent::bencode::codec::BencodeValue;
use std::collections::BTreeMap;
let info_hash = [0u8; 20];
let mut interactive = BtPeerInteractive::new(info_hash, 100);
let mut conn = make_test_conn();
let mut m_dict = BTreeMap::new();
m_dict.insert(b"ut_metadata".to_vec(), BencodeValue::Int(1));
let mut root = BTreeMap::new();
root.insert(b"m".to_vec(), BencodeValue::Dict(m_dict));
root.insert(b"reqq".to_vec(), BencodeValue::Int(500));
let bytes = BencodeValue::Dict(root).encode();
let _ = interactive.dispatch_message(
BtMessage::Extended {
ext_id: 0,
payload: bytes,
},
&mut conn,
|_| false,
);
assert!(!interactive.ut_pex_enabled);
assert!(interactive.extension_registry().supports_ut_metadata());
}