test: [#1358] add tests for events in torrent-repository pkg

Author: josecelano

packages/primitives/src/peer.rs

@@ -22,20 +22,21 @@
 //! };
 //! ```
 
+use std::fmt;
 use std::net::{IpAddr, SocketAddr};
 use std::ops::{Deref, DerefMut};
+use std::str::FromStr;
 use std::sync::Arc;
 
 use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId};
-use derive_more::Display;
 use serde::Serialize;
 use zerocopy::FromBytes as _;
 
 use crate::DurationSinceUnixEpoch;
 
 pub type PeerAnnouncement = Peer;
 
-#[derive(Debug, Display, Serialize, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Serialize, Copy, Clone, PartialEq, Eq, Hash)]
 #[serde(rename_all_fields = "lowercase")]
 pub enum PeerRole {
     Seeder,
@@ -53,6 +54,39 @@ impl PeerRole {
     }
 }
 
+impl fmt::Display for PeerRole {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PeerRole::Seeder => write!(f, "seeder"),
+            PeerRole::Leecher => write!(f, "leecher"),
+        }
+    }
+}
+
+impl FromStr for PeerRole {
+    type Err = ParsePeerRoleError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "seeder" => Ok(PeerRole::Seeder),
+            "leecher" => Ok(PeerRole::Leecher),
+            _ => Err(ParsePeerRoleError::InvalidPeerRole {
+                location: Location::caller(),
+                raw_param: s.to_string(),
+            }),
+        }
+    }
+}
+
+#[derive(Error, Debug)]
+pub enum ParsePeerRoleError {
+    #[error("invalid param {raw_param} in {location}")]
+    InvalidPeerRole {
+        location: &'static Location<'static>,
+        raw_param: String,
+    },
+}
+
 /// Peer struct used by the core `Tracker`.
 ///
 /// A sample peer:
@@ -264,6 +298,14 @@ impl Peer {
             ..self
         }
     }
+
+    #[must_use]
+    pub fn into_seeder(self) -> Self {
+        Self {
+            left: NumberOfBytes::new(0),
+            ..self
+        }
+    }
 }
 
 use std::panic::Location;

packages/torrent-repository/src/event.rs

@@ -83,3 +83,29 @@ pub mod bus {
 
     pub type EventBus = torrust_tracker_events::bus::EventBus<Event>;
 }
+
+#[cfg(test)]
+pub mod test {
+
+    use torrust_tracker_primitives::peer::Peer;
+
+    use super::Event;
+    use crate::tests::sample_info_hash;
+
+    #[test]
+    fn events_should_be_comparable() {
+        let info_hash = sample_info_hash();
+
+        let event1 = Event::TorrentAdded {
+            info_hash,
+            announcement: Peer::default(),
+        };
+
+        let event2 = Event::TorrentRemoved { info_hash };
+
+        let event1_clone = event1.clone();
+
+        assert!(event1 == event1_clone);
+        assert!(event1 != event2);
+    }
+}

packages/torrent-repository/src/statistics/event/handler.rs

@@ -13,6 +13,7 @@ use crate::statistics::{
 
 pub async fn handle_event(event: Event, stats_repository: &Arc<Repository>, now: DurationSinceUnixEpoch) {
     match event {
+        // Torrent events
         Event::TorrentAdded { info_hash, .. } => {
             tracing::debug!(info_hash = ?info_hash, "Torrent added",);
 
@@ -27,6 +28,8 @@ pub async fn handle_event(event: Event, stats_repository: &Arc<Repository>, now:
                 .decrement_gauge(&metric_name!(TORRENT_REPOSITORY_TORRENTS_TOTAL), &LabelSet::default(), now)
                 .await;
         }
+
+        // Peer events
         Event::PeerAdded { info_hash, peer } => {
             tracing::debug!(info_hash = ?info_hash, peer = ?peer, "Peer added", );
 
@@ -96,3 +99,266 @@ fn label_set_for_peer(peer: &Peer) -> LabelSet {
         (label_name!("peer_role"), LabelValue::new("leecher")).into()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use torrust_tracker_metrics::label::LabelSet;
+    use torrust_tracker_metrics::metric::MetricName;
+
+    use crate::statistics::repository::Repository;
+
+    async fn expect_metric_to_be(
+        stats_repository: &Arc<Repository>,
+        metric_name: &MetricName,
+        label_set: &LabelSet,
+        expected_value: f64,
+    ) {
+        let value = get_metric(stats_repository, metric_name, label_set).await;
+        assert_eq!(value.to_string(), expected_value.to_string());
+    }
+
+    async fn get_metric(stats_repository: &Arc<Repository>, metric_name: &MetricName, label_set: &LabelSet) -> f64 {
+        stats_repository
+            .get_metrics()
+            .await
+            .metric_collection
+            .get_gauge_value(metric_name, label_set)
+            .unwrap_or_else(|| panic!("Failed to get metric value for metric name '{metric_name}' and label set '{label_set}'"))
+            .value()
+    }
+
+    mod for_torrent_metrics {
+
+        use std::sync::Arc;
+
+        use torrust_tracker_clock::clock::stopped::Stopped;
+        use torrust_tracker_clock::clock::{self, Time};
+        use torrust_tracker_metrics::label::LabelSet;
+        use torrust_tracker_metrics::metric_name;
+
+        use crate::event::Event;
+        use crate::statistics::event::handler::handle_event;
+        use crate::statistics::event::handler::tests::expect_metric_to_be;
+        use crate::statistics::repository::Repository;
+        use crate::statistics::TORRENT_REPOSITORY_TORRENTS_TOTAL;
+        use crate::tests::{sample_info_hash, sample_peer};
+        use crate::CurrentClock;
+
+        #[tokio::test]
+        async fn it_should_increment_the_number_of_torrents_when_a_torrent_added_event_is_received() {
+            clock::Stopped::local_set_to_unix_epoch();
+
+            let stats_repository = Arc::new(Repository::new());
+
+            handle_event(
+                Event::TorrentAdded {
+                    info_hash: sample_info_hash(),
+                    announcement: sample_peer(),
+                },
+                &stats_repository,
+                CurrentClock::now(),
+            )
+            .await;
+
+            expect_metric_to_be(
+                &stats_repository,
+                &metric_name!(TORRENT_REPOSITORY_TORRENTS_TOTAL),
+                &LabelSet::default(),
+                1.0,
+            )
+            .await;
+        }
+
+        #[tokio::test]
+        async fn it_should_decrement_the_number_of_torrents_when_a_torrent_removed_event_is_received() {
+            clock::Stopped::local_set_to_unix_epoch();
+
+            let stats_repository = Arc::new(Repository::new());
+            let metric_name = metric_name!(TORRENT_REPOSITORY_TORRENTS_TOTAL);
+            let label_set = LabelSet::default();
+
+            // Increment the gauge first to simulate a torrent being added.
+            stats_repository
+                .increment_gauge(&metric_name, &label_set, CurrentClock::now())
+                .await
+                .unwrap();
+
+            handle_event(
+                Event::TorrentRemoved {
+                    info_hash: sample_info_hash(),
+                },
+                &stats_repository,
+                CurrentClock::now(),
+            )
+            .await;
+
+            expect_metric_to_be(&stats_repository, &metric_name, &label_set, 0.0).await;
+        }
+    }
+
+    mod for_peer_metrics {
+
+        mod peer_connections_total {
+
+            use std::sync::Arc;
+
+            use aquatic_udp_protocol::NumberOfBytes;
+            use rstest::rstest;
+            use torrust_tracker_clock::clock::stopped::Stopped;
+            use torrust_tracker_clock::clock::{self, Time};
+            use torrust_tracker_metrics::label::LabelValue;
+            use torrust_tracker_metrics::{label_name, metric_name};
+            use torrust_tracker_primitives::peer::{Peer, PeerRole};
+
+            use crate::event::Event;
+            use crate::statistics::event::handler::handle_event;
+            use crate::statistics::event::handler::tests::expect_metric_to_be;
+            use crate::statistics::repository::Repository;
+            use crate::statistics::TORRENT_REPOSITORY_PEER_CONNECTIONS_TOTAL;
+            use crate::tests::{leecher, sample_info_hash, seeder};
+            use crate::CurrentClock;
+
+            fn make_peer(role: PeerRole) -> Peer {
+                match role {
+                    PeerRole::Seeder => seeder(),
+                    PeerRole::Leecher => leecher(),
+                }
+            }
+
+            // It returns a peer with the opposite role of the given peer.
+            fn make_opposite_role_peer(peer: &Peer) -> Peer {
+                let mut opposite_role_peer = *peer;
+
+                match peer.role() {
+                    PeerRole::Seeder => {
+                        opposite_role_peer.left = NumberOfBytes::new(1);
+                    }
+                    PeerRole::Leecher => {
+                        opposite_role_peer.left = NumberOfBytes::new(0);
+                    }
+                }
+
+                opposite_role_peer
+            }
+
+            #[rstest]
+            #[case("seeder")]
+            #[case("leecher")]
+            #[tokio::test]
+            async fn it_should_increment_the_number_of_peer_connections_when_a_peer_added_event_is_received(
+                #[case] role: PeerRole,
+            ) {
+                clock::Stopped::local_set_to_unix_epoch();
+
+                let peer = make_peer(role);
+
+                let stats_repository = Arc::new(Repository::new());
+                let metric_name = metric_name!(TORRENT_REPOSITORY_PEER_CONNECTIONS_TOTAL);
+                let label_set = (label_name!("peer_role"), LabelValue::new(&role.to_string())).into();
+
+                handle_event(
+                    Event::PeerAdded {
+                        info_hash: sample_info_hash(),
+                        peer,
+                    },
+                    &stats_repository,
+                    CurrentClock::now(),
+                )
+                .await;
+
+                expect_metric_to_be(&stats_repository, &metric_name, &label_set, 1.0).await;
+            }
+
+            #[rstest]
+            #[case("seeder")]
+            #[case("leecher")]
+            #[tokio::test]
+            async fn it_should_decrement_the_number_of_peer_connections_when_a_peer_removed_event_is_received(
+                #[case] role: PeerRole,
+            ) {
+                clock::Stopped::local_set_to_unix_epoch();
+
+                let peer = make_peer(role);
+
+                let stats_repository = Arc::new(Repository::new());
+
+                let metric_name = metric_name!(TORRENT_REPOSITORY_PEER_CONNECTIONS_TOTAL);
+                let label_set = (label_name!("peer_role"), LabelValue::new(&role.to_string())).into();
+
+                // Increment the gauge first to simulate a peer being added.
+                stats_repository
+                    .increment_gauge(&metric_name, &label_set, CurrentClock::now())
+                    .await
+                    .unwrap();
+
+                handle_event(
+                    Event::PeerRemoved {
+                        info_hash: sample_info_hash(),
+                        peer,
+                    },
+                    &stats_repository,
+                    CurrentClock::now(),
+                )
+                .await;
+
+                expect_metric_to_be(&stats_repository, &metric_name, &label_set, 0.0).await;
+            }
+
+            #[rstest]
+            #[case("seeder")]
+            #[case("leecher")]
+            #[tokio::test]
+            async fn it_should_adjust_the_number_of_seeders_and_leechers_when_a_peer_updated_event_is_received_and_the_peer_changed_its_role(
+                #[case] old_role: PeerRole,
+            ) {
+                use crate::statistics::event::handler::tests::get_metric;
+
+                clock::Stopped::local_set_to_unix_epoch();
+
+                let stats_repository = Arc::new(Repository::new());
+
+                let old_peer = make_peer(old_role);
+                let new_peer = make_opposite_role_peer(&old_peer);
+
+                let metric_name = metric_name!(TORRENT_REPOSITORY_PEER_CONNECTIONS_TOTAL);
+                let old_role_label_set = (label_name!("peer_role"), LabelValue::new(&old_peer.role().to_string())).into();
+                let new_role_label_set = (label_name!("peer_role"), LabelValue::new(&new_peer.role().to_string())).into();
+
+                // Increment the gauge first by simulating a peer was added.
+                handle_event(
+                    Event::PeerAdded {
+                        info_hash: sample_info_hash(),
+                        peer: old_peer,
+                    },
+                    &stats_repository,
+                    CurrentClock::now(),
+                )
+                .await;
+
+                let old_role_total = get_metric(&stats_repository, &metric_name, &old_role_label_set).await;
+                let new_role_total = 0.0;
+
+                // The peer's role has changed, so we need to increment the new
+                // role and decrement the old one.
+                handle_event(
+                    Event::PeerUpdated {
+                        info_hash: sample_info_hash(),
+                        old_peer,
+                        new_peer,
+                    },
+                    &stats_repository,
+                    CurrentClock::now(),
+                )
+                .await;
+
+                // The peer's role has changed, so the new role has incremented.
+                expect_metric_to_be(&stats_repository, &metric_name, &new_role_label_set, new_role_total + 1.0).await;
+
+                // And the old role has decremented.
+                expect_metric_to_be(&stats_repository, &metric_name, &old_role_label_set, old_role_total - 1.0).await;
+            }
+        }
+    }
+}