From 96c568d8ccd418bdf68d7b2a59ab9e7cb2dbee17 Mon Sep 17 00:00:00 2001 From: nuts_rice Date: Tue, 4 Feb 2025 12:39:36 -0500 Subject: [PATCH 1/4] =?UTF-8?q?=E2=9C=85=20tests=20for=20udp=20event=20sta?= =?UTF-8?q?ts?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../statistics/event/handler.rs | 96 +++++++++++++++++++ 1 file changed, 96 insertions(+) diff --git a/src/packages/udp_tracker_core/statistics/event/handler.rs b/src/packages/udp_tracker_core/statistics/event/handler.rs index d696951d3..d8fa049d0 100644 --- a/src/packages/udp_tracker_core/statistics/event/handler.rs +++ b/src/packages/udp_tracker_core/statistics/event/handler.rs @@ -151,4 +151,100 @@ mod tests { assert_eq!(stats.udp6_scrapes_handled, 1); } + + #[tokio::test] + async fn should_increase_the_udp_abort_counter_when_it_receives_a_udp_abort_event() { + let stats_repository = Repository::new(); + + handle_event(Event::UdpRequestAborted, &stats_repository).await; + let stats = stats_repository.get_stats().await; + assert_eq!(stats.udp_requests_aborted, 1); + } + #[tokio::test] + async fn should_increase_the_udp_ban_counter_when_it_receives_a_udp_banned_event() { + let stats_repository = Repository::new(); + + handle_event(Event::UdpRequestBanned, &stats_repository).await; + let stats = stats_repository.get_stats().await; + assert_eq!(stats.udp_requests_banned, 1); + } + + #[tokio::test] + async fn should_increase_the_udp4_requests_counter_when_it_receives_a_udp4_request_event() { + let stats_repository = Repository::new(); + + handle_event(Event::Udp4Request, &stats_repository).await; + + let stats = stats_repository.get_stats().await; + + assert_eq!(stats.udp4_requests, 1); + } + + #[tokio::test] + async fn should_increase_the_udp4_responses_counter_when_it_receives_a_udp4_response_event() { + let stats_repository = Repository::new(); + + handle_event( + Event::Udp4Response { + kind: crate::packages::udp_tracker_core::statistics::event::UdpResponseKind::Announce, + req_processing_time: std::time::Duration::from_secs(1), + }, + &stats_repository, + ) + .await; + + let stats = stats_repository.get_stats().await; + + assert_eq!(stats.udp4_responses, 1); + } + + #[tokio::test] + async fn should_increase_the_udp4_errors_counter_when_it_receives_a_udp4_error_event() { + let stats_repository = Repository::new(); + + handle_event(Event::Udp4Error, &stats_repository).await; + + let stats = stats_repository.get_stats().await; + + assert_eq!(stats.udp4_errors_handled, 1); + } + + #[tokio::test] + async fn should_increase_the_udp6_requests_counter_when_it_receives_a_udp6_request_event() { + let stats_repository = Repository::new(); + + handle_event(Event::Udp6Request, &stats_repository).await; + + let stats = stats_repository.get_stats().await; + + assert_eq!(stats.udp6_requests, 1); + } + + #[tokio::test] + async fn should_increase_the_udp6_response_counter_when_it_receives_a_udp6_response_event() { + let stats_repository = Repository::new(); + + handle_event( + Event::Udp6Response { + kind: crate::packages::udp_tracker_core::statistics::event::UdpResponseKind::Announce, + req_processing_time: std::time::Duration::from_secs(1), + }, + &stats_repository, + ) + .await; + + let stats = stats_repository.get_stats().await; + + assert_eq!(stats.udp6_responses, 1); + } + #[tokio::test] + async fn should_increase_the_udp6_errors_counter_when_it_receives_a_udp6_error_event() { + let stats_repository = Repository::new(); + + handle_event(Event::Udp6Error, &stats_repository).await; + + let stats = stats_repository.get_stats().await; + + assert_eq!(stats.udp6_errors_handled, 1); + } } From 61c07a4eb0aab52850f53e38b1aea014ff3d2efd Mon Sep 17 00:00:00 2001 From: nuts_rice Date: Fri, 7 Mar 2025 17:41:27 -0500 Subject: [PATCH 2/4] bench_flow: bench sh script --- contrib/dev-tools/benches/run-benches.sh | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100755 contrib/dev-tools/benches/run-benches.sh diff --git a/contrib/dev-tools/benches/run-benches.sh b/contrib/dev-tools/benches/run-benches.sh new file mode 100755 index 000000000..778da05e3 --- /dev/null +++ b/contrib/dev-tools/benches/run-benches.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +# This script is only intended to be used for local development or testing environments. + +# Generate storage directory if it does not exist +mkdir -p ./benches + +cargo bench --package torrust-tracker-torrent-repository +mv ./target/criterion/report/index.html ./benches/torrust-tracker-torrent-repository.html From 27b0df96486e0041ab236da115150ffd0da2b104 Mon Sep 17 00:00:00 2001 From: nuts_rice Date: Mon, 10 Mar 2025 15:32:46 -0400 Subject: [PATCH 3/4] benchmark_flow: http + udp tracker core bench mods --- contrib/dev-tools/benches/run-benches.sh | 11 +- packages/http-tracker-core/Cargo.toml | 6 + .../http-tracker-core/benches/helpers/mod.rs | 3 + .../http-tracker-core/benches/helpers/sync.rs | 38 +++++ .../http-tracker-core/benches/helpers/util.rs | 133 ++++++++++++++++++ .../benches/http_tracker_core_benchmark.rs | 24 ++++ packages/udp-tracker-core/Cargo.toml | 6 + .../udp-tracker-core/benches/helpers/mod.rs | 2 + .../udp-tracker-core/benches/helpers/sync.rs | 21 +++ .../udp-tracker-core/benches/helpers/utils.rs | 45 ++++++ .../benches/udp_tracker_core_benchmark.rs | 21 +++ 11 files changed, 308 insertions(+), 2 deletions(-) create mode 100644 packages/http-tracker-core/benches/helpers/mod.rs create mode 100644 packages/http-tracker-core/benches/helpers/sync.rs create mode 100644 packages/http-tracker-core/benches/helpers/util.rs create mode 100644 packages/http-tracker-core/benches/http_tracker_core_benchmark.rs create mode 100644 packages/udp-tracker-core/benches/helpers/mod.rs create mode 100644 packages/udp-tracker-core/benches/helpers/sync.rs create mode 100644 packages/udp-tracker-core/benches/helpers/utils.rs create mode 100644 packages/udp-tracker-core/benches/udp_tracker_core_benchmark.rs diff --git a/contrib/dev-tools/benches/run-benches.sh b/contrib/dev-tools/benches/run-benches.sh index 778da05e3..73f7e27ea 100755 --- a/contrib/dev-tools/benches/run-benches.sh +++ b/contrib/dev-tools/benches/run-benches.sh @@ -2,8 +2,15 @@ # This script is only intended to be used for local development or testing environments. -# Generate storage directory if it does not exist +# Generate benches directory if it does not exist mkdir -p ./benches cargo bench --package torrust-tracker-torrent-repository -mv ./target/criterion/report/index.html ./benches/torrust-tracker-torrent-repository.html +mv -b ./target/criterion/add_one_torrent/report/ ./benches/torrust-tracker-torrent-repository/add_one_torrent +mv -b ./target/criterion/add_multiple_torrents_in_parallel/report/ ./benches/torrust-tracker-torrent-repository/add_multiple_torrents_in_parallel +mv -b ./target/criterion/update_multiple_torrents_in_parallel/report/ ./benches/torrust-tracker-torrent-repository/update_multiple_torrents_in_parallel +mv -b ./target/criterion/update_one_torrent_in_parallel/report/ ./benches/torrust-tracker-torrent-repository/update_one_torrent_in_parallel +cargo bench --package bittorrent-http-tracker-core +mv -b target/criterion/http_tracker_handle_announce_once/ ./benches/http_tracker_handle_announce_once +cargo bench --package bittorrent-udp-tracker-core +mv -b target/criterion/udp_tracker_connect_once/ ./benches/udp_tracker_connect_once diff --git a/packages/http-tracker-core/Cargo.toml b/packages/http-tracker-core/Cargo.toml index 1e0bcff28..aaf982b04 100644 --- a/packages/http-tracker-core/Cargo.toml +++ b/packages/http-tracker-core/Cargo.toml @@ -18,6 +18,7 @@ aquatic_udp_protocol = "0" bittorrent-http-tracker-protocol = { version = "3.0.0-develop", path = "../http-protocol" } bittorrent-primitives = "0.1.0" bittorrent-tracker-core = { version = "3.0.0-develop", path = "../tracker-core" } +criterion = { version = "0.5.1", features = ["async_tokio"] } futures = "0" thiserror = "2" tokio = { version = "1", features = ["macros", "net", "rt-multi-thread", "signal", "sync"] } @@ -28,3 +29,8 @@ tracing = "0" [dev-dependencies] mockall = "0" torrust-tracker-test-helpers = { version = "3.0.0-develop", path = "../test-helpers" } + +[[bench]] +harness = false +name = "http_tracker_core_benchmark" + diff --git a/packages/http-tracker-core/benches/helpers/mod.rs b/packages/http-tracker-core/benches/helpers/mod.rs new file mode 100644 index 000000000..f2b9ab5d8 --- /dev/null +++ b/packages/http-tracker-core/benches/helpers/mod.rs @@ -0,0 +1,3 @@ +pub mod util; +pub mod sync; + diff --git a/packages/http-tracker-core/benches/helpers/sync.rs b/packages/http-tracker-core/benches/helpers/sync.rs new file mode 100644 index 000000000..20d01c3c1 --- /dev/null +++ b/packages/http-tracker-core/benches/helpers/sync.rs @@ -0,0 +1,38 @@ +//use std::sync::Arc; +use std::time::{Duration, Instant}; + +use bittorrent_http_tracker_core::{ + services::announce::AnnounceService +}; +use crate::helpers::util::{initialize_core_tracker_services, sample_announce_request_for_peer, sample_peer}; + + + + +#[must_use] +pub async fn return_announce_data_once(samples: u64) -> Duration { + let (core_tracker_services, core_http_tracker_services) = initialize_core_tracker_services(); + + let peer = sample_peer(); + + let (announce_request, client_ip_sources) = sample_announce_request_for_peer(peer); + + let announce_service = AnnounceService::new( + core_tracker_services.core_config.clone(), + core_tracker_services.announce_handler.clone(), + core_tracker_services.authentication_service.clone(), + core_tracker_services.whitelist_authorization.clone(), + core_http_tracker_services.http_stats_event_sender.clone(), + ); + + let start = Instant::now(); + for _ in 0..samples { + let _announce_data = announce_service + .handle_announce(&announce_request, &client_ip_sources, None) + .await + .unwrap(); + } + start.elapsed() + +} + diff --git a/packages/http-tracker-core/benches/helpers/util.rs b/packages/http-tracker-core/benches/helpers/util.rs new file mode 100644 index 000000000..8af32e388 --- /dev/null +++ b/packages/http-tracker-core/benches/helpers/util.rs @@ -0,0 +1,133 @@ + use std::net::{IpAddr, Ipv4Addr, SocketAddr}; + use std::sync::Arc; + + use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId}; + use bittorrent_http_tracker_protocol::v1::requests::announce::Announce; + use bittorrent_http_tracker_protocol::v1::services::peer_ip_resolver::ClientIpSources; + use bittorrent_tracker_core::announce_handler::AnnounceHandler; + use bittorrent_tracker_core::authentication::key::repository::in_memory::InMemoryKeyRepository; + use bittorrent_tracker_core::authentication::service::AuthenticationService; + use bittorrent_tracker_core::databases::setup::initialize_database; + use bittorrent_tracker_core::torrent::repository::in_memory::InMemoryTorrentRepository; + use bittorrent_tracker_core::torrent::repository::persisted::DatabasePersistentTorrentRepository; + use bittorrent_tracker_core::whitelist::authorization::WhitelistAuthorization; + use bittorrent_tracker_core::whitelist::repository::in_memory::InMemoryWhitelist; + use torrust_tracker_configuration::{Configuration, Core}; + use torrust_tracker_primitives::peer::Peer; + use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch}; + use torrust_tracker_test_helpers::configuration; + use bittorrent_primitives::info_hash::InfoHash; + + pub struct CoreTrackerServices { + pub core_config: Arc, + pub announce_handler: Arc, + pub authentication_service: Arc, + pub whitelist_authorization: Arc, + } + + pub struct CoreHttpTrackerServices { + pub http_stats_event_sender: Arc>>, + } + + pub fn initialize_core_tracker_services() -> (CoreTrackerServices, CoreHttpTrackerServices) { + initialize_core_tracker_services_with_config(&configuration::ephemeral_public()) + } + + pub fn initialize_core_tracker_services_with_config(config: &Configuration) -> (CoreTrackerServices, CoreHttpTrackerServices) { + let core_config = Arc::new(config.core.clone()); + let database = initialize_database(&config.core); + let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::default()); + let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database)); + let in_memory_whitelist = Arc::new(InMemoryWhitelist::default()); + let whitelist_authorization = Arc::new(WhitelistAuthorization::new(&config.core, &in_memory_whitelist.clone())); + let in_memory_key_repository = Arc::new(InMemoryKeyRepository::default()); + let authentication_service = Arc::new(AuthenticationService::new(&core_config, &in_memory_key_repository)); + + let announce_handler = Arc::new(AnnounceHandler::new( + &config.core, + &whitelist_authorization, + &in_memory_torrent_repository, + &db_torrent_repository, + )); + + // HTTP stats + let (http_stats_event_sender, http_stats_repository) = statistics::setup::factory(config.core.tracker_usage_statistics); + let http_stats_event_sender = Arc::new(http_stats_event_sender); + let _http_stats_repository = Arc::new(http_stats_repository); + + ( + CoreTrackerServices { + core_config, + announce_handler, + authentication_service, + whitelist_authorization, + }, + CoreHttpTrackerServices { http_stats_event_sender }, + ) + } +/* + pub fn sample_peer_using_ipv4() -> peer::Peer { + sample_peer() + } + + pub fn sample_peer_using_ipv6() -> peer::Peer { + let mut peer = sample_peer(); + peer.peer_addr = SocketAddr::new( + IpAddr::V6(Ipv6Addr::new(0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969, 0x6969)), + 8080, + ); + peer + } +*/ + pub fn sample_peer() -> peer::Peer { + peer::Peer { + peer_id: PeerId(*b"-qB00000000000000000"), + peer_addr: SocketAddr::new(IpAddr::V4(Ipv4Addr::new(126, 0, 0, 1)), 8080), + updated: DurationSinceUnixEpoch::new(1_669_397_478_934, 0), + uploaded: NumberOfBytes::new(0), + downloaded: NumberOfBytes::new(0), + left: NumberOfBytes::new(0), + event: AnnounceEvent::Started, + } + } + + pub fn sample_announce_request_for_peer(peer: Peer) -> (Announce, ClientIpSources) { + let announce_request = Announce { + info_hash: sample_info_hash(), + peer_id: peer.peer_id, + port: peer.peer_addr.port(), + uploaded: Some(peer.uploaded), + downloaded: Some(peer.downloaded), + left: Some(peer.left), + event: Some(peer.event.into()), + compact: None, + numwant: None, + }; + + let client_ip_sources = ClientIpSources { + right_most_x_forwarded_for: None, + connection_info_ip: Some(peer.peer_addr.ip()), + }; + + (announce_request, client_ip_sources) + } + #[must_use] + pub fn sample_info_hash() -> InfoHash { + "3b245504cf5f11bbdbe1201cea6a6bf45aee1bc0" // DevSkim: ignore DS173237 + .parse::() + .expect("String should be a valid info hash") + } + + use futures::future::BoxFuture; + use mockall::mock; + use tokio::sync::mpsc::error::SendError; + + use bittorrent_http_tracker_core::statistics; + + mock! { + HttpStatsEventSender {} + impl statistics::event::sender::Sender for HttpStatsEventSender { + fn send_event(&self, event: statistics::event::Event) -> BoxFuture<'static,Option > > > ; + } + } + diff --git a/packages/http-tracker-core/benches/http_tracker_core_benchmark.rs b/packages/http-tracker-core/benches/http_tracker_core_benchmark.rs new file mode 100644 index 000000000..3ca9b34bf --- /dev/null +++ b/packages/http-tracker-core/benches/http_tracker_core_benchmark.rs @@ -0,0 +1,24 @@ +use std::time::Duration; + +use criterion::{criterion_group, criterion_main, Criterion}; + + +mod helpers; +use crate::helpers::{sync, }; +fn announce_once(c: &mut Criterion) { + let _rt = tokio::runtime::Builder::new_multi_thread().worker_threads(4).build().unwrap(); + + let mut group = c.benchmark_group("http_tracker_handle_announce_once"); + + group.warm_up_time(Duration::from_millis(500)); + group.measurement_time(Duration::from_millis(1000)); + + group.bench_function("handle_announce_data", |b| { + b.iter(|| {sync::return_announce_data_once(100)}); + }); + + +} + +criterion_group!(benches, announce_once); +criterion_main!(benches); diff --git a/packages/udp-tracker-core/Cargo.toml b/packages/udp-tracker-core/Cargo.toml index fc8e2328c..88bab51c1 100644 --- a/packages/udp-tracker-core/Cargo.toml +++ b/packages/udp-tracker-core/Cargo.toml @@ -21,6 +21,7 @@ bittorrent-udp-tracker-protocol = { version = "3.0.0-develop", path = "../udp-pr bloom = "0.3.2" blowfish = "0" cipher = "0" +criterion = { version = "0.5.1", features = ["async_tokio"] } futures = "0" lazy_static = "1" rand = "0" @@ -34,3 +35,8 @@ zerocopy = "0.7" [dev-dependencies] mockall = "0" torrust-tracker-test-helpers = { version = "3.0.0-develop", path = "../test-helpers" } + +[[bench]] +harness = false +name = "udp_tracker_core_benchmark" + diff --git a/packages/udp-tracker-core/benches/helpers/mod.rs b/packages/udp-tracker-core/benches/helpers/mod.rs new file mode 100644 index 000000000..ee303aca1 --- /dev/null +++ b/packages/udp-tracker-core/benches/helpers/mod.rs @@ -0,0 +1,2 @@ +mod utils; +pub mod sync; diff --git a/packages/udp-tracker-core/benches/helpers/sync.rs b/packages/udp-tracker-core/benches/helpers/sync.rs new file mode 100644 index 000000000..188562b9e --- /dev/null +++ b/packages/udp-tracker-core/benches/helpers/sync.rs @@ -0,0 +1,21 @@ +use std::time::{Instant, Duration}; +use std::sync::Arc; +use bittorrent_udp_tracker_core::statistics; +use bittorrent_udp_tracker_core::services::connect::ConnectService; + +use crate::helpers::utils::{sample_ipv4_remote_addr, sample_issue_time}; +pub async fn connect_once(samples: u64) -> Duration { + let (udp_core_stats_event_sender, _udp_core_stats_repository) = statistics::setup::factory(false); + let udp_core_stats_event_sender = Arc::new(udp_core_stats_event_sender); + let connect_service = Arc::new(ConnectService::new(udp_core_stats_event_sender)); +let start = Instant::now(); + + for _ in 0..samples { + let _response = connect_service + .handle_connect(sample_ipv4_remote_addr(), sample_issue_time()) + .await; + + } + start.elapsed() + +} diff --git a/packages/udp-tracker-core/benches/helpers/utils.rs b/packages/udp-tracker-core/benches/helpers/utils.rs new file mode 100644 index 000000000..1e0a3d17e --- /dev/null +++ b/packages/udp-tracker-core/benches/helpers/utils.rs @@ -0,0 +1,45 @@ + use std::net::{IpAddr, Ipv4Addr, SocketAddr}; + + use futures::future::BoxFuture; + use mockall::mock; + use tokio::sync::mpsc::error::SendError; + + + use bittorrent_udp_tracker_core::statistics; + + pub(crate) fn sample_ipv4_remote_addr() -> SocketAddr { + sample_ipv4_socket_address() + } + + /* fn sample_ipv4_remote_addr_fingerprint() -> u64 { + gen_remote_fingerprint(&sample_ipv4_socket_address()) + } + + fn sample_ipv6_remote_addr() -> SocketAddr { + sample_ipv6_socket_address() + } + + fn sample_ipv6_remote_addr_fingerprint() -> u64 { + gen_remote_fingerprint(&sample_ipv6_socket_address()) + } + */ + + pub(crate) fn sample_ipv4_socket_address() -> SocketAddr { + SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080) + } + +/* fn sample_ipv6_socket_address() -> SocketAddr { + SocketAddr::new(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), 8080) + } +*/ + pub(crate) fn sample_issue_time() -> f64 { + 1_000_000_000_f64 + } + + mock! { + pub(crate) UdpCoreStatsEventSender {} + impl statistics::event::sender::Sender for UdpCoreStatsEventSender { + fn send_event(&self, event: statistics::event::Event) -> BoxFuture<'static,Option > > > ; + } + } + diff --git a/packages/udp-tracker-core/benches/udp_tracker_core_benchmark.rs b/packages/udp-tracker-core/benches/udp_tracker_core_benchmark.rs new file mode 100644 index 000000000..83278a8ca --- /dev/null +++ b/packages/udp-tracker-core/benches/udp_tracker_core_benchmark.rs @@ -0,0 +1,21 @@ +use std::time::Duration; + +use criterion::{criterion_group, criterion_main, Criterion}; + + +mod helpers; +use crate::helpers::{sync, }; + + +fn bench_connect_once(c: &mut Criterion) { + let mut group = c.benchmark_group("udp_tracker/connect_once"); + group.warm_up_time(Duration::from_millis(500)); + group.measurement_time(Duration::from_millis(1000)); + + group.bench_function("connect_once", |b| { + b.iter(|| {sync::connect_once(100)}); + }); + +} +criterion_group!(benches, bench_connect_once); +criterion_main!(benches); From 67773df169d68483b59a5545c676ce36a61d406c Mon Sep 17 00:00:00 2001 From: nuts_rice Date: Mon, 10 Mar 2025 19:34:16 -0400 Subject: [PATCH 4/4] =?UTF-8?q?Revert=20"=E2=9C=85=20tests=20for=20udp=20e?= =?UTF-8?q?vent=20stats"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 96c568d8ccd418bdf68d7b2a59ab9e7cb2dbee17. --- .../src/statistics/event/handler.rs | 75 ++++++------------- 1 file changed, 23 insertions(+), 52 deletions(-) diff --git a/packages/udp-tracker-server/src/statistics/event/handler.rs b/packages/udp-tracker-server/src/statistics/event/handler.rs index b3b86e20a..dab9764cb 100644 --- a/packages/udp-tracker-server/src/statistics/event/handler.rs +++ b/packages/udp-tracker-server/src/statistics/event/handler.rs @@ -88,103 +88,74 @@ pub async fn handle_event(event: Event, stats_repository: &Repository) { #[cfg(test)] mod tests { - use crate::statistics::event::handler::handle_event; - use crate::statistics::event::Event; - use crate::statistics::repository::Repository; + use crate::packages::udp_tracker_core::statistics::event::handler::handle_event; + use crate::packages::udp_tracker_core::statistics::event::Event; + use crate::packages::udp_tracker_core::statistics::repository::Repository; #[tokio::test] - async fn should_increase_the_udp_abort_counter_when_it_receives_a_udp_abort_event() { + async fn should_increase_the_udp4_connections_counter_when_it_receives_a_udp4_connect_event() { let stats_repository = Repository::new(); - handle_event(Event::UdpRequestAborted, &stats_repository).await; - let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp_requests_aborted, 1); - } - #[tokio::test] - async fn should_increase_the_udp_ban_counter_when_it_receives_a_udp_banned_event() { - let stats_repository = Repository::new(); - - handle_event(Event::UdpRequestBanned, &stats_repository).await; - let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp_requests_banned, 1); - } - - #[tokio::test] - async fn should_increase_the_udp4_requests_counter_when_it_receives_a_udp4_request_event() { - let stats_repository = Repository::new(); - - handle_event(Event::Udp4IncomingRequest, &stats_repository).await; + handle_event(Event::Udp4Connect, &stats_repository).await; let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp4_requests, 1); + assert_eq!(stats.udp4_connections_handled, 1); } #[tokio::test] - async fn should_increase_the_udp4_responses_counter_when_it_receives_a_udp4_response_event() { + async fn should_increase_the_udp4_announces_counter_when_it_receives_a_udp4_announce_event() { let stats_repository = Repository::new(); - handle_event( - Event::Udp4Response { - kind: crate::statistics::event::UdpResponseKind::Announce, - req_processing_time: std::time::Duration::from_secs(1), - }, - &stats_repository, - ) - .await; + handle_event(Event::Udp4Announce, &stats_repository).await; let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp4_responses, 1); + assert_eq!(stats.udp4_announces_handled, 1); } #[tokio::test] - async fn should_increase_the_udp4_errors_counter_when_it_receives_a_udp4_error_event() { + async fn should_increase_the_udp4_scrapes_counter_when_it_receives_a_udp4_scrape_event() { let stats_repository = Repository::new(); - handle_event(Event::Udp4Error, &stats_repository).await; + handle_event(Event::Udp4Scrape, &stats_repository).await; let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp4_errors_handled, 1); + assert_eq!(stats.udp4_scrapes_handled, 1); } #[tokio::test] - async fn should_increase_the_udp6_requests_counter_when_it_receives_a_udp6_request_event() { + async fn should_increase_the_udp6_connections_counter_when_it_receives_a_udp6_connect_event() { let stats_repository = Repository::new(); - handle_event(Event::Udp6IncomingRequest, &stats_repository).await; + handle_event(Event::Udp6Connect, &stats_repository).await; let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp6_requests, 1); + assert_eq!(stats.udp6_connections_handled, 1); } #[tokio::test] - async fn should_increase_the_udp6_response_counter_when_it_receives_a_udp6_response_event() { + async fn should_increase_the_udp6_announces_counter_when_it_receives_a_udp6_announce_event() { let stats_repository = Repository::new(); - handle_event( - Event::Udp6Response { - kind: crate::statistics::event::UdpResponseKind::Announce, - req_processing_time: std::time::Duration::from_secs(1), - }, - &stats_repository, - ) - .await; + handle_event(Event::Udp6Announce, &stats_repository).await; let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp6_responses, 1); + assert_eq!(stats.udp6_announces_handled, 1); } + #[tokio::test] - async fn should_increase_the_udp6_errors_counter_when_it_receives_a_udp6_error_event() { + async fn should_increase_the_udp6_scrapes_counter_when_it_receives_a_udp6_scrape_event() { let stats_repository = Repository::new(); - handle_event(Event::Udp6Error, &stats_repository).await; + handle_event(Event::Udp6Scrape, &stats_repository).await; let stats = stats_repository.get_stats().await; - assert_eq!(stats.udp6_errors_handled, 1); + assert_eq!(stats.udp6_scrapes_handled, 1); +>>>>>>> parent of 96c568d8 (✅ tests for udp event stats):src/packages/udp_tracker_core/statistics/event/handler.rs } }