use super::*;
#[test]
fn test_announce_event_transitions() {
assert_eq!(
AnnounceEvent::Started.next_event(),
AnnounceEvent::Downloading
);
assert_eq!(
AnnounceEvent::StartedAfterCompletion.next_event(),
AnnounceEvent::Seeding
);
assert_eq!(AnnounceEvent::Stopped.next_event(), AnnounceEvent::Halted);
assert_eq!(
AnnounceEvent::Completed.next_event(),
AnnounceEvent::Seeding
);
assert_eq!(
AnnounceEvent::Downloading.next_event(),
AnnounceEvent::Downloading
);
assert_eq!(AnnounceEvent::Seeding.next_event(), AnnounceEvent::Seeding);
assert_eq!(AnnounceEvent::Halted.next_event(), AnnounceEvent::Halted);
}
#[test]
fn test_announce_event_next_if_after_started() {
assert_eq!(
AnnounceEvent::Stopped.next_event_if_after_started(),
AnnounceEvent::Halted
);
assert_eq!(
AnnounceEvent::Completed.next_event_if_after_started(),
AnnounceEvent::Seeding
);
assert_eq!(
AnnounceEvent::Started.next_event_if_after_started(),
AnnounceEvent::Started
);
assert_eq!(
AnnounceEvent::StartedAfterCompletion.next_event_if_after_started(),
AnnounceEvent::StartedAfterCompletion
);
assert_eq!(
AnnounceEvent::Downloading.next_event_if_after_started(),
AnnounceEvent::Downloading
);
assert_eq!(
AnnounceEvent::Seeding.next_event_if_after_started(),
AnnounceEvent::Seeding
);
}
#[test]
fn test_announce_tier_accepts_events() {
assert!(AnnounceEvent::Downloading.accepts_stopped_event());
assert!(AnnounceEvent::Stopped.accepts_stopped_event());
assert!(AnnounceEvent::Completed.accepts_stopped_event());
assert!(AnnounceEvent::Seeding.accepts_stopped_event());
assert!(!AnnounceEvent::Started.accepts_stopped_event());
assert!(!AnnounceEvent::StartedAfterCompletion.accepts_stopped_event());
assert!(!AnnounceEvent::Halted.accepts_stopped_event());
assert!(AnnounceEvent::Downloading.accepts_completed_event());
assert!(AnnounceEvent::Completed.accepts_completed_event());
assert!(!AnnounceEvent::Started.accepts_completed_event());
assert!(!AnnounceEvent::StartedAfterCompletion.accepts_completed_event());
assert!(!AnnounceEvent::Stopped.accepts_completed_event());
assert!(!AnnounceEvent::Seeding.accepts_completed_event());
assert!(!AnnounceEvent::Halted.accepts_completed_event());
}
#[test]
fn test_announce_event_string() {
assert_eq!(AnnounceEvent::Started.as_event_string(), "started");
assert_eq!(
AnnounceEvent::StartedAfterCompletion.as_event_string(),
"started"
);
assert_eq!(AnnounceEvent::Stopped.as_event_string(), "stopped");
assert_eq!(AnnounceEvent::Completed.as_event_string(), "completed");
assert_eq!(AnnounceEvent::Downloading.as_event_string(), "");
assert_eq!(AnnounceEvent::Seeding.as_event_string(), "");
assert_eq!(AnnounceEvent::Halted.as_event_string(), "");
}
#[test]
fn test_announce_events_convert_to_udp_tracker_events() {
use crate::bittorrent::tracker::udp_tracker_protocol::UdpEvent;
for (event, expected) in [
(AnnounceEvent::Started, UdpEvent::Started),
(AnnounceEvent::StartedAfterCompletion, UdpEvent::Started),
(AnnounceEvent::Downloading, UdpEvent::None),
(AnnounceEvent::Stopped, UdpEvent::Stopped),
(AnnounceEvent::Completed, UdpEvent::Completed),
(AnnounceEvent::Seeding, UdpEvent::None),
(AnnounceEvent::Halted, UdpEvent::None),
] {
assert_eq!(UdpEvent::from(event), expected);
}
}
#[test]
fn test_announce_tier_next_event() {
let mut tier = AnnounceTier::from_urls(vec!["http://tracker.test/announce".to_string()]);
assert_eq!(tier.event, AnnounceEvent::Started);
tier.next_event();
assert_eq!(tier.event, AnnounceEvent::Downloading);
tier.next_event();
assert_eq!(tier.event, AnnounceEvent::Downloading);
}
#[test]
fn test_announce_tier_next_event_if_after_started() {
let mut tier = AnnounceTier::from_urls(vec!["http://tracker.test/announce".to_string()]);
tier.event = AnnounceEvent::Stopped;
tier.next_event_if_after_started();
assert_eq!(tier.event, AnnounceEvent::Halted);
tier.event = AnnounceEvent::Completed;
tier.next_event_if_after_started();
assert_eq!(tier.event, AnnounceEvent::Seeding);
tier.event = AnnounceEvent::Started;
tier.next_event_if_after_started();
assert_eq!(tier.event, AnnounceEvent::Started);
}
#[test]
fn test_announce_list_creation() {
let list = AnnounceList::new(&[], &Some("http://tracker1.com/announce".to_string()));
assert_eq!(list.tier_count(), 1);
assert_eq!(list.get_announce(), Some("http://tracker1.com/announce"));
let multi_tier = vec![
vec![
"http://tier1-1.com/announce".to_string(),
"http://tier1-2.com/announce".to_string(),
],
vec!["http://tier2-1.com/announce".to_string()],
];
let list2 = AnnounceList::new(&multi_tier, &None);
assert_eq!(list2.tier_count(), 2);
assert_eq!(list2.get_announce(), Some("http://tier1-1.com/announce"));
let list3 = AnnounceList::new(&[], &None);
assert_eq!(list3.tier_count(), 0);
assert!(list3.get_announce().is_none());
}
#[test]
fn test_announce_list_success_resets_to_first_tier() {
let multi_tier = vec![
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
];
let mut list = AnnounceList::new(&multi_tier, &None);
assert_eq!(list.get_announce(), Some("http://t1.com/announce"));
list.announce_failure();
assert_eq!(list.get_announce(), Some("http://t2.com/announce"));
list.announce_success();
assert_eq!(list.get_announce(), Some("http://t1.com/announce"));
}
#[test]
fn test_announce_list_failure_advances_tracker() {
let urls = vec![
"http://t1.com/announce".to_string(),
"http://t2.com/announce".to_string(),
];
let mut list = AnnounceList::new(&[urls], &None);
assert_eq!(list.get_announce(), Some("http://t1.com/announce"));
list.announce_failure();
assert_eq!(list.get_announce(), Some("http://t2.com/announce"));
}
#[test]
fn test_announce_list_failure_advances_tier_on_last_url() {
let multi_tier = vec![
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
];
let mut list = AnnounceList::new(&multi_tier, &None);
list.announce_failure();
assert_eq!(list.get_announce(), Some("http://t2.com/announce"));
}
#[test]
fn test_announce_list_all_tiers_failed() {
let multi_tier = vec![
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
];
let mut list = AnnounceList::new(&multi_tier, &None);
assert!(!list.all_tiers_failed());
list.announce_failure();
assert!(!list.all_tiers_failed());
list.announce_failure();
assert!(list.all_tiers_failed());
assert!(list.get_announce().is_none());
}
#[test]
fn test_announce_list_event_management() {
let mut list = AnnounceList::new(&[vec!["http://t.com/announce".to_string()]], &None);
assert_eq!(list.get_event(), AnnounceEvent::Started);
assert_eq!(list.get_event_string(), "started");
list.set_event(AnnounceEvent::Completed);
assert_eq!(list.get_event(), AnnounceEvent::Completed);
assert_eq!(list.get_event_string(), "completed");
list.announce_success();
assert_eq!(list.get_event(), AnnounceEvent::Seeding);
}
#[test]
fn test_announce_list_stopped_allowed_tiers() {
let mut list = AnnounceList::new(
&[
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
],
&None,
);
assert_eq!(list.count_stopped_allowed_tier(), 0);
list.announce_success(); assert_eq!(list.get_event(), AnnounceEvent::Downloading);
assert_eq!(list.count_stopped_allowed_tier(), 1);
list.announce_failure(); list.announce_success(); assert_eq!(list.count_stopped_allowed_tier(), 2);
}
#[test]
fn test_announce_list_completed_allowed_tiers() {
let list = AnnounceList::new(
&[
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
],
&None,
);
assert_eq!(list.count_completed_allowed_tier(), 0);
}
#[test]
fn test_announce_list_move_to_stopped_allowed_tier() {
let mut list = AnnounceList::new(
&[
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
],
&None,
);
list.tiers[1].event = AnnounceEvent::Downloading;
assert!(!list.current_tier_accepts_stopped_event());
list.move_to_stopped_allowed_tier();
assert!(list.current_tier_accepts_stopped_event());
assert_eq!(list.get_announce(), Some("http://t2.com/announce"));
}
#[test]
fn test_announce_list_reset_tier() {
let multi_tier = vec![
vec!["http://t1.com/announce".to_string()],
vec!["http://t2.com/announce".to_string()],
];
let mut list = AnnounceList::new(&multi_tier, &None);
list.announce_failure();
assert_eq!(list.get_announce(), Some("http://t2.com/announce"));
list.reset_tier();
assert_eq!(list.get_announce(), Some("http://t1.com/announce"));
}
#[test]
fn test_announce_list_shuffle() {
let urls: Vec<String> = (0..20)
.map(|i| format!("http://tracker{}.com/announce", i))
.collect();
let mut list = AnnounceList::new(std::slice::from_ref(&urls), &None);
let _original_first = list.get_announce().unwrap().to_string();
list.shuffle();
assert_eq!(list.tier_count(), 1);
let tier_urls: Vec<&str> = list.tiers[0].urls.iter().map(|s| s.as_str()).collect();
assert_eq!(tier_urls.len(), 20);
}
#[test]
fn test_announce_list_appends_new_trackers_without_duplicates() {
let mut list = AnnounceList::new(
&[
vec!["http://torrent.test/announce".to_string()],
vec!["udp://torrent.test:6969/announce".to_string()],
],
&None,
);
let added = list.append_tiers(&[
vec![
"http://torrent.test/announce".to_string(),
"http://public.test/announce".to_string(),
],
vec!["http://public.test/announce".to_string()],
]);
assert_eq!(added, vec!["http://public.test/announce"]);
assert_eq!(list.tier_count(), 3);
assert_eq!(
list.get_tracker_url(0, 0).unwrap(),
"http://torrent.test/announce"
);
assert_eq!(
list.get_tracker_url(2, 0).unwrap(),
"http://public.test/announce"
);
}
#[test]
fn test_announce_list_appends_after_all_tiers_failed() {
let mut list = AnnounceList::new(&[vec!["http://torrent.test/announce".to_string()]], &None);
list.announce_failure();
assert!(list.all_tiers_failed());
let added = list.append_tiers(&[vec!["http://public.test/announce".to_string()]]);
assert_eq!(added, vec!["http://public.test/announce"]);
assert_eq!(list.get_announce(), Some("http://public.test/announce"));
assert!(!list.all_tiers_failed());
}