use super::super::*;
use std::sync::Arc;
use crate::download::DownloadContext;
use crate::engine::bittorrent::peer::storage::PeerStorage;
use crate::engine::bittorrent::tracker::communication::BtAnnounce;
use crate::request::request_group::DownloadOptions;
use crate::segment::piece_storage::PieceStorage;
#[test]
fn dht_engine_configuration_uses_process_options_over_task_overrides() {
let mut registry = BtRegistry::new();
let process_options = DownloadOptions {
dht_message_timeout: 17,
dht_listen_port: Some("49000-49001".to_string()),
dht_file_path: Some("process-dht.dat".to_string()),
..Default::default()
};
registry.set_global_dht_options(Arc::new(
crate::engine::bittorrent::dht::config::DhtEngineOptions::from(&process_options),
));
let task_options = DownloadOptions {
dht_message_timeout: 3,
dht_listen_port: Some("50000".to_string()),
dht_file_path: Some("task-dht.dat".to_string()),
..Default::default()
};
let options = registry.global_dht_options();
assert_eq!(options.dht_message_timeout, 17);
assert_eq!(options.dht_listen_port.as_deref(), Some("49000-49001"));
assert_eq!(options.dht_file_path.as_deref(), Some("process-dht.dat"));
assert_ne!(
options.dht_message_timeout,
task_options.dht_message_timeout
);
}
#[test]
fn registry_default_dht_configuration_does_not_inherit_task_overrides() {
let registry = BtRegistry::new();
let task_options = DownloadOptions {
dht_message_timeout: 3,
dht_listen_port: Some("50000".to_string()),
dht_file_path: Some("task-dht.dat".to_string()),
..Default::default()
};
let options = registry.global_dht_options();
let defaults = crate::engine::bittorrent::dht::config::DhtEngineOptions::default();
assert_eq!(options.dht_message_timeout, defaults.dht_message_timeout);
assert_eq!(options.dht_listen_port, defaults.dht_listen_port);
assert_eq!(options.dht_file_path, defaults.dht_file_path);
assert_ne!(
options.dht_message_timeout,
task_options.dht_message_timeout
);
}
#[tokio::test]
async fn global_dht_start_applies_process_peer_storage_limits() {
let registry = Arc::new(std::sync::RwLock::new(BtRegistry::new()));
let engine = BtRegistry::get_or_start_global_dht_engine_with_storage_config(
®istry,
91,
aria2_protocol::bittorrent::dht::engine::DhtEngineConfig::local(),
aria2_protocol::bittorrent::dht::DhtPeerStorageConfig {
max_info_hashes: 7,
max_peers_per_info_hash: 5,
},
)
.await
.expect("process DHT engine should start with configured peer-storage limits");
assert_eq!(engine.stats().await.max_peer_info_hashes, 7);
registry
.write()
.unwrap()
.set_global_dht_peer_storage_config(
aria2_protocol::bittorrent::dht::DhtPeerStorageConfig {
max_info_hashes: 3,
max_peers_per_info_hash: 2,
},
);
assert_eq!(engine.stats().await.max_peer_info_hashes, 3);
let options = registry.read().unwrap().global_dht_options();
assert_eq!(options.dht_max_peer_info_hashes, 3);
assert_eq!(options.dht_max_peers_per_info_hash, 2);
engine.shutdown_async().await;
}
fn make_bt_object_with_info_hash(
piece_length: u32,
total_length: u64,
path: &str,
info_hash: &str,
private: bool,
) -> BtObject {
use crate::download::download_context::{ContextAttributeType, TorrentAttribute};
let mut ctx = DownloadContext::new(piece_length, total_length, path.to_string());
let mut ta = TorrentAttribute::new(info_hash.to_string());
ta.private_torrent = private;
ta.name = format!("torrent_{}", info_hash);
ctx.set_attribute(ContextAttributeType::BitTorrent, Box::new(ta));
let ctx = Arc::new(ctx);
BtObject {
download_context: Some(ctx),
..BtObject::new()
}
}
fn make_bt_object_with_ctx(piece_length: u32, total_length: u64, path: &str) -> BtObject {
let ctx = Arc::new(DownloadContext::new(
piece_length,
total_length,
path.to_string(),
));
BtObject {
download_context: Some(ctx),
..BtObject::new()
}
}
#[test]
fn test_get_piece_storage() {
let mut registry = BtRegistry::new();
let mut obj = BtObject::new();
let ps: Arc<dyn PieceStorage> = Arc::new(
crate::segment::piece_storage::DefaultPieceStorage::new(1024, 4096),
);
obj.piece_storage = Some(ps);
registry.put(1, obj);
assert!(registry.get_piece_storage(1).is_some());
assert!(registry.get_piece_storage(999).is_none());
registry.put(2, BtObject::new());
assert!(registry.get_piece_storage(2).is_none());
}
#[test]
fn test_get_peer_storage() {
let mut registry = BtRegistry::new();
let mut obj = BtObject::new();
let ps: Arc<dyn PeerStorage> =
Arc::new(crate::engine::bittorrent::peer::storage::DefaultPeerStorage::new());
obj.peer_storage = Some(ps);
registry.put(1, obj);
assert!(registry.get_peer_storage(1).is_some());
assert!(registry.get_peer_storage(999).is_none());
}
#[test]
fn test_get_bt_announce() {
let mut registry = BtRegistry::new();
let mut obj = BtObject::new();
obj.bt_announce = Some(Arc::new(BtAnnounce::new(
&[],
&Some("http://tracker.test/announce".to_string()),
)));
registry.put(1, obj);
assert!(registry.get_bt_announce(1).is_some());
assert!(registry.get_bt_announce(999).is_none());
}
#[test]
fn test_get_piece_storage_by_info_hash() {
let hash1 = "aaa1111111111111111111111111111111111111";
let mut obj = make_bt_object_with_info_hash(1024, 4096, "/tmp/a.bin", hash1, false);
let ps: Arc<dyn PieceStorage> = Arc::new(
crate::segment::piece_storage::DefaultPieceStorage::new(1024, 4096),
);
obj.piece_storage = Some(ps);
let mut registry = BtRegistry::new();
registry.put(1, obj);
assert!(registry.get_piece_storage_by_info_hash(hash1).is_some());
assert!(
registry
.get_piece_storage_by_info_hash("wrong_hash")
.is_none()
);
}
#[test]
fn test_get_peer_storage_by_info_hash() {
let hash1 = "aaa1111111111111111111111111111111111111";
let mut obj = make_bt_object_with_info_hash(1024, 4096, "/tmp/a.bin", hash1, false);
let ps: Arc<dyn PeerStorage> =
Arc::new(crate::engine::bittorrent::peer::storage::DefaultPeerStorage::new());
obj.peer_storage = Some(ps);
let mut registry = BtRegistry::new();
registry.put(1, obj);
assert!(registry.get_peer_storage_by_info_hash(hash1).is_some());
assert!(
registry
.get_peer_storage_by_info_hash("wrong_hash")
.is_none()
);
}
#[test]
fn test_all_download_finished_empty_registry() {
let registry = BtRegistry::new();
assert!(
registry.all_download_finished(),
"empty registry should return true"
);
}
#[test]
fn test_all_download_finished_no_piece_storage() {
let mut registry = BtRegistry::new();
registry.put(1, BtObject::new());
assert!(!registry.all_download_finished());
}
#[test]
fn test_all_download_finished_with_finished_storage() {
use crate::segment::piece_storage::DefaultPieceStorage;
let mut registry = BtRegistry::new();
let mut obj = BtObject::new();
let ps: Arc<dyn PieceStorage> = Arc::new(DefaultPieceStorage::new(0, 0));
obj.piece_storage = Some(ps);
registry.put(1, obj);
assert!(registry.all_download_finished());
}
#[test]
fn test_all_download_finished_with_unfinished_storage() {
use crate::segment::piece_storage::DefaultPieceStorage;
let mut registry = BtRegistry::new();
let mut obj = BtObject::new();
let ps: Arc<dyn PieceStorage> = Arc::new(DefaultPieceStorage::new(1024, 4096));
obj.piece_storage = Some(ps);
registry.put(1, obj);
assert!(!registry.all_download_finished());
}
#[test]
fn test_finished_count() {
use crate::segment::piece_storage::DefaultPieceStorage;
let mut registry = BtRegistry::new();
let mut obj1 = BtObject::new();
obj1.piece_storage = Some(Arc::new(DefaultPieceStorage::new(0, 0)) as Arc<dyn PieceStorage>);
registry.put(1, obj1);
let mut obj2 = BtObject::new();
obj2.piece_storage =
Some(Arc::new(DefaultPieceStorage::new(1024, 4096)) as Arc<dyn PieceStorage>);
registry.put(2, obj2);
registry.put(3, BtObject::new());
assert_eq!(registry.finished_count(), 1);
}
#[test]
fn test_is_private_torrent() {
let mut registry = BtRegistry::new();
let obj1 = make_bt_object_with_info_hash(
1024,
4096,
"/tmp/private.bin",
"aaa1111111111111111111111111111111111111",
true,
);
registry.put(1, obj1);
let obj2 = make_bt_object_with_info_hash(
1024,
4096,
"/tmp/public.bin",
"bbb2222222222222222222222222222222222222",
false,
);
registry.put(2, obj2);
let obj3 = make_bt_object_with_ctx(1024, 4096, "/tmp/noattr.bin");
registry.put(3, obj3);
assert!(registry.is_private_torrent(1));
assert!(!registry.is_private_torrent(2));
assert!(!registry.is_private_torrent(3));
assert!(!registry.is_private_torrent(999));
}
#[test]
fn test_get_torrent_name() {
let mut registry = BtRegistry::new();
let obj1 = make_bt_object_with_info_hash(
1024,
4096,
"/tmp/a.bin",
"aaa1111111111111111111111111111111111111",
false,
);
registry.put(1, obj1);
let name = registry.get_torrent_name(1);
assert!(name.is_some());
assert!(name.unwrap().starts_with("torrent_"));
let obj2 = make_bt_object_with_ctx(1024, 4096, "/tmp/noattr.bin");
registry.put(2, obj2);
assert!(registry.get_torrent_name(2).is_none());
assert!(registry.get_torrent_name(999).is_none());
}
#[test]
fn test_dht_engine_default_none() {
let registry = BtRegistry::new();
assert!(registry.get_dht_engines().is_empty());
}
#[test]
fn test_dht_engine_set_and_get() {
use aria2_protocol::bittorrent::dht::engine::{DhtEngine, DhtEngineConfig};
let rt = tokio::runtime::Runtime::new().unwrap();
let config = DhtEngineConfig::local();
let engine = rt.block_on(async { DhtEngine::start(config).await.unwrap() });
let mut registry = BtRegistry::new();
registry.set_global_dht_engine(engine);
assert!(
registry
.get_global_dht_engine_for_peer("127.0.0.1:6881".parse().unwrap())
.is_some()
);
}
#[tokio::test]
async fn global_dht_engine_install_returns_the_existing_canonical_engine() {
use aria2_protocol::bittorrent::dht::engine::{DhtEngine, DhtEngineConfig};
let first = DhtEngine::start(DhtEngineConfig::local())
.await
.expect("first local DHT engine should start");
let second = DhtEngine::start(DhtEngineConfig::local())
.await
.expect("second local DHT engine should start");
let ipv6 = DhtEngine::start(DhtEngineConfig {
listen_addr: Some("::1".parse().expect("parse IPv6 loopback")),
..DhtEngineConfig::local()
})
.await
.expect("local IPv6 DHT engine should start");
let mut registry = BtRegistry::new();
let installed = registry.get_or_install_global_dht_engine(Arc::clone(&first));
let concurrent_candidate = registry.get_or_install_global_dht_engine(Arc::clone(&second));
let installed_ipv6 = registry.get_or_install_global_dht_engine(Arc::clone(&ipv6));
assert!(Arc::ptr_eq(&installed, &first));
assert!(Arc::ptr_eq(&concurrent_candidate, &first));
assert!(Arc::ptr_eq(&installed_ipv6, &ipv6));
assert_eq!(registry.get_dht_engines().len(), 2);
assert!(
registry
.get_global_dht_engine_for_peer("127.0.0.1:6881".parse().unwrap())
.is_some_and(|engine| Arc::ptr_eq(&engine, &first))
);
assert!(
registry
.get_global_dht_engine_for_peer("[::1]:6881".parse().unwrap())
.is_some_and(|engine| Arc::ptr_eq(&engine, &ipv6))
);
first.shutdown_async().await;
second.shutdown_async().await;
ipv6.shutdown_async().await;
}
#[tokio::test]
async fn final_dht_shutdown_takes_download_engines_and_deduplicates_shared_handles() {
use aria2_protocol::bittorrent::dht::engine::{DhtEngine, DhtEngineConfig};
let engine = DhtEngine::start(DhtEngineConfig::local())
.await
.expect("local DHT engine should start");
let mut registry = BtRegistry::new();
registry.set_global_dht_engine(Arc::clone(&engine));
registry.set_dht_engine_for_gid(7, Arc::clone(&engine));
let engines = registry.take_all_dht_engines();
assert_eq!(engines.len(), 1);
assert!(Arc::ptr_eq(&engines[0], &engine));
assert!(registry.get_dht_engines().is_empty());
engine.shutdown_async().await;
}
#[test]
fn test_dht_engines_are_taken_for_final_shutdown() {
use aria2_protocol::bittorrent::dht::engine::{DhtEngine, DhtEngineConfig};
let rt = tokio::runtime::Runtime::new().unwrap();
let config = DhtEngineConfig::local();
let engine = rt.block_on(async { DhtEngine::start(config).await.unwrap() });
let mut registry = BtRegistry::new();
registry.set_global_dht_engine(Arc::clone(&engine));
assert_eq!(registry.get_dht_engines().len(), 1);
let engines = registry.take_global_dht_engines();
assert_eq!(engines.len(), 1);
assert!(registry.get_dht_engines().is_empty());
}
#[test]
fn test_dht_engine_is_tracked_by_download_gid() {
use aria2_protocol::bittorrent::dht::engine::{DhtEngine, DhtEngineConfig};
let rt = tokio::runtime::Runtime::new().unwrap();
let engine = rt.block_on(async { DhtEngine::start(DhtEngineConfig::local()).await.unwrap() });
let mut registry = BtRegistry::new();
registry.set_dht_engine_for_gid(7, Arc::clone(&engine));
assert_eq!(registry.get_dht_engines().len(), 1);
registry.clear_dht_engine_for_gid_if(7, &engine);
assert!(registry.get_dht_engines().is_empty());
}
#[test]
fn test_registry_has_empty_blocklist_by_default() {
let registry = BtRegistry::new();
assert_eq!(registry.peer_blocklist().count(), 0);
assert!(!registry.is_peer_blocked("10.0.0.1"));
}
#[test]
fn test_registry_blocklist_add_and_check() {
let mut registry = BtRegistry::new();
registry
.peer_blocklist_mut()
.add_rule("10.0.0.0/8")
.unwrap();
assert!(registry.is_peer_blocked("10.0.0.1"));
assert!(registry.is_peer_blocked("10.255.255.255"));
assert!(!registry.is_peer_blocked("192.168.1.1"));
assert_eq!(registry.peer_blocklist().count(), 1);
}
#[test]
fn test_registry_blocklist_accessors() {
let mut registry = BtRegistry::new();
registry
.peer_blocklist_mut()
.add_rule("192.168.0.0/16")
.unwrap();
assert_eq!(registry.peer_blocklist().count(), 1);
assert!(registry.peer_blocklist().contains("192.168.1.1"));
registry.peer_blocklist_mut().clear();
assert_eq!(registry.peer_blocklist().count(), 0);
}
#[test]
fn test_debug_includes_dht_and_index() {
let registry = BtRegistry::new();
let debug_str = format!("{:?}", registry);
assert!(debug_str.contains("dht_engine_count: 0"));
assert!(debug_str.contains("info_hash_index_len: 0"));
}