dev: add some torrent repo tests

Author: da2ce7

packages/primitives/src/announce_event.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 
 /// Announce events. Described on  the
 /// [BEP 3. The `BitTorrent` Protocol Specification](https://www.bittorrent.org/beps/bep_0003.html)
-#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Hash, Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub enum AnnounceEvent {
     /// The peer has started downloading the torrent.
     Started,

packages/primitives/src/lib.rs

@@ -38,7 +38,7 @@ pub enum IPVersion {
 }
 
 /// Number of bytes downloaded, uploaded or pending to download (left) by the peer.
-#[derive(PartialEq, Eq, Hash, Clone, Copy, Debug, Serialize, Deserialize)]
+#[derive(Hash, Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 pub struct NumberOfBytes(pub i64);
 
 /// The database management system used by the tracker.

packages/primitives/src/peer.rs

@@ -51,7 +51,7 @@ use crate::{ser_unix_time_value, DurationSinceUnixEpoch, IPVersion, NumberOfByte
 ///     event: AnnounceEvent::Started,
 /// };
 /// ```
-#[derive(PartialEq, Eq, Debug, Clone, Serialize, Copy)]
+#[derive(Debug, Clone, Serialize, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Peer {
     /// ID used by the downloader peer
     pub peer_id: Id,

packages/primitives/src/torrent_metrics.rs

@@ -6,20 +6,20 @@ use std::ops::AddAssign;
 #[derive(Copy, Clone, Debug, PartialEq, Default)]
 pub struct TorrentsMetrics {
     /// Total number of seeders for all torrents
-    pub seeders: u64,
+    pub complete: u64,
     /// Total number of peers that have ever completed downloading for all torrents.
-    pub completed: u64,
+    pub downloaded: u64,
     /// Total number of leechers for all torrents.
-    pub leechers: u64,
+    pub incomplete: u64,
     /// Total number of torrents.
     pub torrents: u64,
 }
 
 impl AddAssign for TorrentsMetrics {
     fn add_assign(&mut self, rhs: Self) {
-        self.seeders += rhs.seeders;
-        self.completed += rhs.completed;
-        self.leechers += rhs.leechers;
+        self.complete += rhs.complete;
+        self.downloaded += rhs.downloaded;
+        self.incomplete += rhs.incomplete;
         self.torrents += rhs.torrents;
     }
 }

packages/torrent-repository/src/entry/mod.rs

@@ -86,7 +86,7 @@ pub trait EntryAsync {
 /// This is the tracker entry for a given torrent and contains the swarm data,
 /// that's the list of all the peers trying to download the same torrent.
 /// The tracker keeps one entry like this for every torrent.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Torrent {
     /// The swarm: a network of peers that are all trying to download the torrent associated to this entry
     // #[serde(skip)]

packages/torrent-repository/src/entry/mutex_std.rs

@@ -5,7 +5,7 @@ use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
 
 use super::{Entry, EntrySync};
-use crate::EntryMutexStd;
+use crate::{EntryMutexStd, EntrySingle};
 
 impl EntrySync for EntryMutexStd {
     fn get_stats(&self) -> SwarmMetadata {
@@ -48,3 +48,9 @@ impl EntrySync for EntryMutexStd {
             .remove_inactive_peers(current_cutoff);
     }
 }
+
+impl From<EntrySingle> for EntryMutexStd {
+    fn from(entry: EntrySingle) -> Self {
+        Arc::new(std::sync::Mutex::new(entry))
+    }
+}

packages/torrent-repository/src/entry/mutex_tokio.rs

@@ -5,7 +5,7 @@ use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
 
 use super::{Entry, EntryAsync};
-use crate::EntryMutexTokio;
+use crate::{EntryMutexTokio, EntrySingle};
 
 impl EntryAsync for EntryMutexTokio {
     async fn get_stats(&self) -> SwarmMetadata {
@@ -44,3 +44,9 @@ impl EntryAsync for EntryMutexTokio {
         self.lock().await.remove_inactive_peers(current_cutoff);
     }
 }
+
+impl From<EntrySingle> for EntryMutexTokio {
+    fn from(entry: EntrySingle) -> Self {
+        Arc::new(tokio::sync::Mutex::new(entry))
+    }
+}

packages/torrent-repository/src/repository/mod.rs

@@ -12,7 +12,9 @@ pub mod rw_lock_tokio;
 pub mod rw_lock_tokio_mutex_std;
 pub mod rw_lock_tokio_mutex_tokio;
 
-pub trait Repository<T>: Default + 'static {
+use std::fmt::Debug;
+
+pub trait Repository<T>: Debug + Default + Sized + 'static {
     fn get(&self, key: &InfoHash) -> Option<T>;
     fn get_metrics(&self) -> TorrentsMetrics;
     fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, T)>;
@@ -24,7 +26,7 @@ pub trait Repository<T>: Default + 'static {
 }
 
 #[allow(clippy::module_name_repetitions)]
-pub trait RepositoryAsync<T>: Default + 'static {
+pub trait RepositoryAsync<T>: Debug + Default + Sized + 'static {
     fn get(&self, key: &InfoHash) -> impl std::future::Future<Output = Option<T>> + Send;
     fn get_metrics(&self) -> impl std::future::Future<Output = TorrentsMetrics> + Send;
     fn get_paginated(&self, pagination: Option<&Pagination>) -> impl std::future::Future<Output = Vec<(InfoHash, T)>> + Send;
@@ -39,12 +41,36 @@ pub trait RepositoryAsync<T>: Default + 'static {
     ) -> impl std::future::Future<Output = (bool, SwarmMetadata)> + Send;
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
+pub struct RwLockStd<T> {
+    torrents: std::sync::RwLock<std::collections::BTreeMap<InfoHash, T>>,
+}
+
+#[derive(Default, Debug)]
 pub struct RwLockTokio<T> {
     torrents: tokio::sync::RwLock<std::collections::BTreeMap<InfoHash, T>>,
 }
 
-#[derive(Default)]
-pub struct RwLockStd<T> {
-    torrents: std::sync::RwLock<std::collections::BTreeMap<InfoHash, T>>,
+impl<T> RwLockStd<T> {
+    /// # Panics
+    ///
+    /// Panics if unable to get a lock.
+    pub fn write(
+        &self,
+    ) -> std::sync::RwLockWriteGuard<'_, std::collections::BTreeMap<torrust_tracker_primitives::info_hash::InfoHash, T>> {
+        self.torrents.write().expect("it should get lock")
+    }
+}
+
+impl<T> RwLockTokio<T> {
+    pub fn write(
+        &self,
+    ) -> impl std::future::Future<
+        Output = tokio::sync::RwLockWriteGuard<
+            '_,
+            std::collections::BTreeMap<torrust_tracker_primitives::info_hash::InfoHash, T>,
+        >,
+    > {
+        self.torrents.write()
+    }
 }

packages/torrent-repository/src/repository/rw_lock_std.rs

@@ -49,9 +49,9 @@ where
 
         for entry in self.get_torrents().values() {
             let stats = entry.get_stats();
-            metrics.seeders += u64::from(stats.complete);
-            metrics.completed += u64::from(stats.downloaded);
-            metrics.leechers += u64::from(stats.incomplete);
+            metrics.complete += u64::from(stats.complete);
+            metrics.downloaded += u64::from(stats.downloaded);
+            metrics.incomplete += u64::from(stats.incomplete);
             metrics.torrents += 1;
         }
 

packages/torrent-repository/src/repository/rw_lock_std_mutex_std.rs

@@ -57,9 +57,9 @@ where
 
         for entry in self.get_torrents().values() {
             let stats = entry.lock().expect("it should get a lock").get_stats();
-            metrics.seeders += u64::from(stats.complete);
-            metrics.completed += u64::from(stats.downloaded);
-            metrics.leechers += u64::from(stats.incomplete);
+            metrics.complete += u64::from(stats.complete);
+            metrics.downloaded += u64::from(stats.downloaded);
+            metrics.incomplete += u64::from(stats.incomplete);
             metrics.torrents += 1;
         }
 

packages/torrent-repository/src/repository/rw_lock_std_mutex_tokio.rs

@@ -75,9 +75,9 @@ where
 
         for entry in entries {
             let stats = entry.lock().await.get_stats();
-            metrics.seeders += u64::from(stats.complete);
-            metrics.completed += u64::from(stats.downloaded);
-            metrics.leechers += u64::from(stats.incomplete);
+            metrics.complete += u64::from(stats.complete);
+            metrics.downloaded += u64::from(stats.downloaded);
+            metrics.incomplete += u64::from(stats.incomplete);
             metrics.torrents += 1;
         }
 

packages/torrent-repository/src/repository/rw_lock_tokio.rs

@@ -64,9 +64,9 @@ where
 
         for entry in self.get_torrents().await.values() {
             let stats = entry.get_stats();
-            metrics.seeders += u64::from(stats.complete);
-            metrics.completed += u64::from(stats.downloaded);
-            metrics.leechers += u64::from(stats.incomplete);
+            metrics.complete += u64::from(stats.complete);
+            metrics.downloaded += u64::from(stats.downloaded);
+            metrics.incomplete += u64::from(stats.incomplete);
             metrics.torrents += 1;
         }
 

packages/torrent-repository/src/repository/rw_lock_tokio_mutex_std.rs

@@ -72,9 +72,9 @@ where
 
         for entry in self.get_torrents().await.values() {
             let stats = entry.get_stats();
-            metrics.seeders += u64::from(stats.complete);
-            metrics.completed += u64::from(stats.downloaded);
-            metrics.leechers += u64::from(stats.incomplete);
+            metrics.complete += u64::from(stats.complete);
+            metrics.downloaded += u64::from(stats.downloaded);
+            metrics.incomplete += u64::from(stats.incomplete);
             metrics.torrents += 1;
         }
 

packages/torrent-repository/src/repository/rw_lock_tokio_mutex_tokio.rs

@@ -72,9 +72,9 @@ where
 
         for entry in self.get_torrents().await.values() {
             let stats = entry.get_stats().await;
-            metrics.seeders += u64::from(stats.complete);
-            metrics.completed += u64::from(stats.downloaded);
-            metrics.leechers += u64::from(stats.incomplete);
+            metrics.complete += u64::from(stats.complete);
+            metrics.downloaded += u64::from(stats.downloaded);
+            metrics.incomplete += u64::from(stats.incomplete);
             metrics.torrents += 1;
         }
 

packages/torrent-repository/tests/common/mod.rs

@@ -1 +1,3 @@
+pub mod torrent;
 pub mod torrent_peer_builder;
+pub mod torrents;

packages/torrent-repository/tests/common/torrent.rs

@@ -0,0 +1,88 @@
+use std::sync::Arc;
+
+use torrust_tracker_configuration::TrackerPolicy;
+use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
+use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch};
+use torrust_tracker_torrent_repository::entry::{Entry as _, EntryAsync as _, EntrySync as _};
+use torrust_tracker_torrent_repository::{EntryMutexStd, EntryMutexTokio, EntrySingle};
+
+#[derive(Debug)]
+pub(crate) enum Torrent {
+    Single(EntrySingle),
+    MutexStd(EntryMutexStd),
+    MutexTokio(EntryMutexTokio),
+}
+
+impl Torrent {
+    pub(crate) async fn get_stats(&self) -> SwarmMetadata {
+        match self {
+            Torrent::Single(entry) => entry.get_stats(),
+            Torrent::MutexStd(entry) => entry.get_stats(),
+            Torrent::MutexTokio(entry) => entry.clone().get_stats().await,
+        }
+    }
+
+    pub(crate) async fn is_good(&self, policy: &TrackerPolicy) -> bool {
+        match self {
+            Torrent::Single(entry) => entry.is_good(policy),
+            Torrent::MutexStd(entry) => entry.is_good(policy),
+            Torrent::MutexTokio(entry) => entry.clone().is_good(policy).await,
+        }
+    }
+
+    pub(crate) async fn peers_is_empty(&self) -> bool {
+        match self {
+            Torrent::Single(entry) => entry.peers_is_empty(),
+            Torrent::MutexStd(entry) => entry.peers_is_empty(),
+            Torrent::MutexTokio(entry) => entry.clone().peers_is_empty().await,
+        }
+    }
+
+    pub(crate) async fn get_peers_len(&self) -> usize {
+        match self {
+            Torrent::Single(entry) => entry.get_peers_len(),
+            Torrent::MutexStd(entry) => entry.get_peers_len(),
+            Torrent::MutexTokio(entry) => entry.clone().get_peers_len().await,
+        }
+    }
+
+    pub(crate) async fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+        match self {
+            Torrent::Single(entry) => entry.get_peers(limit),
+            Torrent::MutexStd(entry) => entry.get_peers(limit),
+            Torrent::MutexTokio(entry) => entry.clone().get_peers(limit).await,
+        }
+    }
+
+    pub(crate) async fn get_peers_for_peer(&self, client: &peer::Peer, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
+        match self {
+            Torrent::Single(entry) => entry.get_peers_for_peer(client, limit),
+            Torrent::MutexStd(entry) => entry.get_peers_for_peer(client, limit),
+            Torrent::MutexTokio(entry) => entry.clone().get_peers_for_peer(client, limit).await,
+        }
+    }
+
+    pub(crate) async fn insert_or_update_peer(&mut self, peer: &peer::Peer) -> bool {
+        match self {
+            Torrent::Single(entry) => entry.insert_or_update_peer(peer),
+            Torrent::MutexStd(entry) => entry.insert_or_update_peer(peer),
+            Torrent::MutexTokio(entry) => entry.clone().insert_or_update_peer(peer).await,
+        }
+    }
+
+    pub(crate) async fn insert_or_update_peer_and_get_stats(&mut self, peer: &peer::Peer) -> (bool, SwarmMetadata) {
+        match self {
+            Torrent::Single(entry) => entry.insert_or_update_peer_and_get_stats(peer),
+            Torrent::MutexStd(entry) => entry.insert_or_update_peer_and_get_stats(peer),
+            Torrent::MutexTokio(entry) => entry.clone().insert_or_update_peer_and_get_stats(peer).await,
+        }
+    }
+
+    pub(crate) async fn remove_inactive_peers(&mut self, current_cutoff: DurationSinceUnixEpoch) {
+        match self {
+            Torrent::Single(entry) => entry.remove_inactive_peers(current_cutoff),
+            Torrent::MutexStd(entry) => entry.remove_inactive_peers(current_cutoff),
+            Torrent::MutexTokio(entry) => entry.clone().remove_inactive_peers(current_cutoff).await,
+        }
+    }
+}

packages/torrent-repository/tests/common/torrents.rs

@@ -0,0 +1,148 @@
+use torrust_tracker_configuration::TrackerPolicy;
+use torrust_tracker_primitives::info_hash::InfoHash;
+use torrust_tracker_primitives::pagination::Pagination;
+use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
+use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
+use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, PersistentTorrents};
+use torrust_tracker_torrent_repository::repository::{Repository as _, RepositoryAsync as _};
+use torrust_tracker_torrent_repository::{
+    EntrySingle, TorrentsRwLockStd, TorrentsRwLockStdMutexStd, TorrentsRwLockStdMutexTokio, TorrentsRwLockTokio,
+    TorrentsRwLockTokioMutexStd, TorrentsRwLockTokioMutexTokio,
+};
+
+#[derive(Debug)]
+pub(crate) enum Torrents {
+    Std(TorrentsRwLockStd),
+    StdMutexStd(TorrentsRwLockStdMutexStd),
+    StdMutexTokio(TorrentsRwLockStdMutexTokio),
+    Tokio(TorrentsRwLockTokio),
+    TokioMutexStd(TorrentsRwLockTokioMutexStd),
+    TokioMutexTokio(TorrentsRwLockTokioMutexTokio),
+}
+
+#[allow(dead_code)]
+impl Torrents {
+    pub(crate) async fn get(&self, key: &InfoHash) -> Option<EntrySingle> {
+        match self {
+            Torrents::Std(repo) => repo.get(key),
+            Torrents::StdMutexStd(repo) => Some(repo.get(key)?.lock().unwrap().clone()),
+            Torrents::StdMutexTokio(repo) => Some(repo.get(key).await?.lock().await.clone()),
+            Torrents::Tokio(repo) => repo.get(key).await,
+            Torrents::TokioMutexStd(repo) => Some(repo.get(key).await?.lock().unwrap().clone()),
+            Torrents::TokioMutexTokio(repo) => Some(repo.get(key).await?.lock().await.clone()),
+        }
+    }
+    pub(crate) async fn get_metrics(&self) -> TorrentsMetrics {
+        match self {
+            Torrents::Std(repo) => repo.get_metrics(),
+            Torrents::StdMutexStd(repo) => repo.get_metrics(),
+            Torrents::StdMutexTokio(repo) => repo.get_metrics().await,
+            Torrents::Tokio(repo) => repo.get_metrics().await,
+            Torrents::TokioMutexStd(repo) => repo.get_metrics().await,
+            Torrents::TokioMutexTokio(repo) => repo.get_metrics().await,
+        }
+    }
+    pub(crate) async fn get_paginated(&self, pagination: Option<&Pagination>) -> Vec<(InfoHash, EntrySingle)> {
+        match self {
+            Torrents::Std(repo) => repo.get_paginated(pagination),
+            Torrents::StdMutexStd(repo) => repo
+                .get_paginated(pagination)
+                .iter()
+                .map(|(i, t)| (*i, t.lock().expect("it should get a lock").clone()))
+                .collect(),
+            Torrents::StdMutexTokio(repo) => {
+                let mut v: Vec<(InfoHash, EntrySingle)> = vec![];
+
+                for (i, t) in repo.get_paginated(pagination).await {
+                    v.push((i, t.lock().await.clone()));
+                }
+                v
+            }
+            Torrents::Tokio(repo) => repo.get_paginated(pagination).await,
+            Torrents::TokioMutexStd(repo) => repo
+                .get_paginated(pagination)
+                .await
+                .iter()
+                .map(|(i, t)| (*i, t.lock().expect("it should get a lock").clone()))
+                .collect(),
+            Torrents::TokioMutexTokio(repo) => {
+                let mut v: Vec<(InfoHash, EntrySingle)> = vec![];
+
+                for (i, t) in repo.get_paginated(pagination).await {
+                    v.push((i, t.lock().await.clone()));
+                }
+                v
+            }
+        }
+    }
+    pub(crate) async fn import_persistent(&self, persistent_torrents: &PersistentTorrents) {
+        match self {
+            Torrents::Std(repo) => repo.import_persistent(persistent_torrents),
+            Torrents::StdMutexStd(repo) => repo.import_persistent(persistent_torrents),
+            Torrents::StdMutexTokio(repo) => repo.import_persistent(persistent_torrents).await,
+            Torrents::Tokio(repo) => repo.import_persistent(persistent_torrents).await,
+            Torrents::TokioMutexStd(repo) => repo.import_persistent(persistent_torrents).await,
+            Torrents::TokioMutexTokio(repo) => repo.import_persistent(persistent_torrents).await,
+        }
+    }
+    pub(crate) async fn remove(&self, key: &InfoHash) -> Option<EntrySingle> {
+        match self {
+            Torrents::Std(repo) => repo.remove(key),
+            Torrents::StdMutexStd(repo) => Some(repo.remove(key)?.lock().unwrap().clone()),
+            Torrents::StdMutexTokio(repo) => Some(repo.remove(key).await?.lock().await.clone()),
+            Torrents::Tokio(repo) => repo.remove(key).await,
+            Torrents::TokioMutexStd(repo) => Some(repo.remove(key).await?.lock().unwrap().clone()),
+            Torrents::TokioMutexTokio(repo) => Some(repo.remove(key).await?.lock().await.clone()),
+        }
+    }
+    pub(crate) async fn remove_inactive_peers(&self, current_cutoff: DurationSinceUnixEpoch) {
+        match self {
+            Torrents::Std(repo) => repo.remove_inactive_peers(current_cutoff),
+            Torrents::StdMutexStd(repo) => repo.remove_inactive_peers(current_cutoff),
+            Torrents::StdMutexTokio(repo) => repo.remove_inactive_peers(current_cutoff).await,
+            Torrents::Tokio(repo) => repo.remove_inactive_peers(current_cutoff).await,
+            Torrents::TokioMutexStd(repo) => repo.remove_inactive_peers(current_cutoff).await,
+            Torrents::TokioMutexTokio(repo) => repo.remove_inactive_peers(current_cutoff).await,
+        }
+    }
+    pub(crate) async fn remove_peerless_torrents(&self, policy: &TrackerPolicy) {
+        match self {
+            Torrents::Std(repo) => repo.remove_peerless_torrents(policy),
+            Torrents::StdMutexStd(repo) => repo.remove_peerless_torrents(policy),
+            Torrents::StdMutexTokio(repo) => repo.remove_peerless_torrents(policy).await,
+            Torrents::Tokio(repo) => repo.remove_peerless_torrents(policy).await,
+            Torrents::TokioMutexStd(repo) => repo.remove_peerless_torrents(policy).await,
+            Torrents::TokioMutexTokio(repo) => repo.remove_peerless_torrents(policy).await,
+        }
+    }
+    pub(crate) async fn update_torrent_with_peer_and_get_stats(
+        &self,
+        info_hash: &InfoHash,
+        peer: &peer::Peer,
+    ) -> (bool, SwarmMetadata) {
+        match self {
+            Torrents::Std(repo) => repo.update_torrent_with_peer_and_get_stats(info_hash, peer),
+            Torrents::StdMutexStd(repo) => repo.update_torrent_with_peer_and_get_stats(info_hash, peer),
+            Torrents::StdMutexTokio(repo) => repo.update_torrent_with_peer_and_get_stats(info_hash, peer).await,
+            Torrents::Tokio(repo) => repo.update_torrent_with_peer_and_get_stats(info_hash, peer).await,
+            Torrents::TokioMutexStd(repo) => repo.update_torrent_with_peer_and_get_stats(info_hash, peer).await,
+            Torrents::TokioMutexTokio(repo) => repo.update_torrent_with_peer_and_get_stats(info_hash, peer).await,
+        }
+    }
+    pub(crate) async fn insert(&self, info_hash: &InfoHash, torrent: EntrySingle) -> Option<EntrySingle> {
+        match self {
+            Torrents::Std(repo) => repo.write().insert(*info_hash, torrent),
+            Torrents::StdMutexStd(repo) => Some(repo.write().insert(*info_hash, torrent.into())?.lock().unwrap().clone()),
+            Torrents::StdMutexTokio(repo) => {
+                let r = repo.write().insert(*info_hash, torrent.into());
+                match r {
+                    Some(t) => Some(t.lock().await.clone()),
+                    None => None,
+                }
+            }
+            Torrents::Tokio(repo) => repo.write().await.insert(*info_hash, torrent),
+            Torrents::TokioMutexStd(repo) => Some(repo.write().await.insert(*info_hash, torrent.into())?.lock().unwrap().clone()),
+            Torrents::TokioMutexTokio(repo) => Some(repo.write().await.insert(*info_hash, torrent.into())?.lock().await.clone()),
+        }
+    }
+}

packages/torrent-repository/tests/entry/mod.rs

@@ -9,95 +9,13 @@ use torrust_tracker_clock::clock::{self, Time as _};
 use torrust_tracker_configuration::{TrackerPolicy, TORRENT_PEERS_LIMIT};
 use torrust_tracker_primitives::announce_event::AnnounceEvent;
 use torrust_tracker_primitives::peer::Peer;
-use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
-use torrust_tracker_primitives::{peer, DurationSinceUnixEpoch, NumberOfBytes};
-use torrust_tracker_torrent_repository::entry::{Entry, EntryAsync, EntrySync};
+use torrust_tracker_primitives::{peer, NumberOfBytes};
 use torrust_tracker_torrent_repository::{EntryMutexStd, EntryMutexTokio, EntrySingle};
 
+use crate::common::torrent::Torrent;
 use crate::common::torrent_peer_builder::{a_completed_peer, a_started_peer};
 use crate::CurrentClock;
 
-#[derive(Debug)]
-pub enum Torrent {
-    Single(EntrySingle),
-    MutexStd(EntryMutexStd),
-    MutexTokio(EntryMutexTokio),
-}
-
-impl Torrent {
-    async fn get_stats(&self) -> SwarmMetadata {
-        match self {
-            Torrent::Single(entry) => entry.get_stats(),
-            Torrent::MutexStd(entry) => entry.get_stats(),
-            Torrent::MutexTokio(entry) => entry.clone().get_stats().await,
-        }
-    }
-
-    async fn is_good(&self, policy: &TrackerPolicy) -> bool {
-        match self {
-            Torrent::Single(entry) => entry.is_good(policy),
-            Torrent::MutexStd(entry) => entry.is_good(policy),
-            Torrent::MutexTokio(entry) => entry.clone().is_good(policy).await,
-        }
-    }
-
-    async fn peers_is_empty(&self) -> bool {
-        match self {
-            Torrent::Single(entry) => entry.peers_is_empty(),
-            Torrent::MutexStd(entry) => entry.peers_is_empty(),
-            Torrent::MutexTokio(entry) => entry.clone().peers_is_empty().await,
-        }
-    }
-
-    async fn get_peers_len(&self) -> usize {
-        match self {
-            Torrent::Single(entry) => entry.get_peers_len(),
-            Torrent::MutexStd(entry) => entry.get_peers_len(),
-            Torrent::MutexTokio(entry) => entry.clone().get_peers_len().await,
-        }
-    }
-
-    async fn get_peers(&self, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
-        match self {
-            Torrent::Single(entry) => entry.get_peers(limit),
-            Torrent::MutexStd(entry) => entry.get_peers(limit),
-            Torrent::MutexTokio(entry) => entry.clone().get_peers(limit).await,
-        }
-    }
-
-    async fn get_peers_for_peer(&self, client: &peer::Peer, limit: Option<usize>) -> Vec<Arc<peer::Peer>> {
-        match self {
-            Torrent::Single(entry) => entry.get_peers_for_peer(client, limit),
-            Torrent::MutexStd(entry) => entry.get_peers_for_peer(client, limit),
-            Torrent::MutexTokio(entry) => entry.clone().get_peers_for_peer(client, limit).await,
-        }
-    }
-
-    async fn insert_or_update_peer(&mut self, peer: &peer::Peer) -> bool {
-        match self {
-            Torrent::Single(entry) => entry.insert_or_update_peer(peer),
-            Torrent::MutexStd(entry) => entry.insert_or_update_peer(peer),
-            Torrent::MutexTokio(entry) => entry.clone().insert_or_update_peer(peer).await,
-        }
-    }
-
-    async fn insert_or_update_peer_and_get_stats(&mut self, peer: &peer::Peer) -> (bool, SwarmMetadata) {
-        match self {
-            Torrent::Single(entry) => entry.insert_or_update_peer_and_get_stats(peer),
-            Torrent::MutexStd(entry) => entry.insert_or_update_peer_and_get_stats(peer),
-            Torrent::MutexTokio(entry) => entry.clone().insert_or_update_peer_and_get_stats(peer).await,
-        }
-    }
-
-    async fn remove_inactive_peers(&mut self, current_cutoff: DurationSinceUnixEpoch) {
-        match self {
-            Torrent::Single(entry) => entry.remove_inactive_peers(current_cutoff),
-            Torrent::MutexStd(entry) => entry.remove_inactive_peers(current_cutoff),
-            Torrent::MutexTokio(entry) => entry.clone().remove_inactive_peers(current_cutoff).await,
-        }
-    }
-}
-
 #[fixture]
 async fn single_empty() -> (Torrent, Peer) {
     (Torrent::Single(EntrySingle::default()), a_started_peer())

packages/torrent-repository/tests/repository/mod.rs

@@ -1 +1,182 @@
+use rstest::{fixture, rstest};
+use torrust_tracker_primitives::info_hash::InfoHash;
+use torrust_tracker_torrent_repository::entry::Entry as _;
+use torrust_tracker_torrent_repository::repository::{RwLockStd, RwLockTokio};
+use torrust_tracker_torrent_repository::EntrySingle;
 
+use crate::common::torrent_peer_builder::a_started_peer;
+use crate::common::torrents::Torrents;
+
+#[fixture]
+fn standard() -> Torrents {
+    Torrents::Std(RwLockStd::default())
+}
+#[fixture]
+fn standard_mutex() -> Torrents {
+    Torrents::StdMutexStd(RwLockStd::default())
+}
+
+#[fixture]
+fn standard_tokio() -> Torrents {
+    Torrents::StdMutexTokio(RwLockStd::default())
+}
+
+#[fixture]
+fn tokio_std() -> Torrents {
+    Torrents::Tokio(RwLockTokio::default())
+}
+#[fixture]
+fn tokio_mutex() -> Torrents {
+    Torrents::TokioMutexStd(RwLockTokio::default())
+}
+
+#[fixture]
+fn tokio_tokio() -> Torrents {
+    Torrents::TokioMutexTokio(RwLockTokio::default())
+}
+
+#[fixture]
+fn empty() -> Option<EntrySingle> {
+    None
+}
+
+#[fixture]
+#[allow(clippy::unnecessary_wraps)]
+fn default() -> Option<EntrySingle> {
+    Some(EntrySingle::default())
+}
+
+#[fixture]
+#[allow(clippy::unnecessary_wraps)]
+fn started() -> Option<EntrySingle> {
+    let mut torrent = EntrySingle::default();
+    let peer = a_started_peer();
+    torrent.insert_or_update_peer(&peer);
+    Some(torrent)
+}
+
+type Repo = (Torrents, Option<(InfoHash, EntrySingle)>);
+
+#[fixture]
+async fn make(#[default(empty())] torrent: Option<EntrySingle>, #[default(standard())] repo: Torrents) -> Repo {
+    let info_hash = InfoHash::default();
+
+    if let Some(torrent) = torrent {
+        repo.insert(&info_hash, torrent.clone()).await;
+
+        (repo, Some((info_hash, torrent)))
+    } else {
+        (repo, None)
+    }
+}
+
+#[rstest]
+#[case::empty_standard(make(empty(), standard()))]
+#[case::empty_standard_mutex(make(empty(), standard_mutex()))]
+#[case::empty_standard_tokio(make(empty(), standard_tokio()))]
+#[case::empty_tokio_std(make(empty(), tokio_std()))]
+#[case::empty_tokio_mutex(make(empty(), tokio_mutex()))]
+#[case::empty_tokio_tokio(make(empty(), tokio_tokio()))]
+#[case::default_standard(make(default(), standard()))]
+#[case::default_standard_mutex(make(default(), standard_mutex()))]
+#[case::default_standard_tokio(make(default(), standard_tokio()))]
+#[case::default_tokio_std(make(default(), tokio_std()))]
+#[case::default_tokio_mutex(make(default(), tokio_mutex()))]
+#[case::default_tokio_tokio(make(default(), tokio_tokio()))]
+#[case::started_standard(make(started(), standard()))]
+#[case::started_standard_mutex(make(started(), standard_mutex()))]
+#[case::started_standard_tokio(make(started(), standard_tokio()))]
+#[case::started_tokio_std(make(started(), tokio_std()))]
+#[case::started_tokio_mutex(make(started(), tokio_mutex()))]
+#[case::started_tokio_tokio(make(started(), tokio_tokio()))]
+#[tokio::test]
+async fn it_should_get_a_torrent_entry(
+    #[future]
+    #[case]
+    repo: Repo,
+) {
+    let (repo, maybe) = repo.await;
+
+    if let Some((info_hash, torrent)) = maybe {
+        assert_eq!(repo.get(&info_hash).await, Some(torrent));
+    } else {
+        assert_eq!(repo.get(&InfoHash::default()).await, None);
+    }
+}
+
+#[rstest]
+#[case::empty_standard(make(empty(), standard()))]
+#[case::empty_standard_mutex(make(empty(), standard_mutex()))]
+#[case::empty_standard_tokio(make(empty(), standard_tokio()))]
+#[case::empty_tokio_std(make(empty(), tokio_std()))]
+#[case::empty_tokio_mutex(make(empty(), tokio_mutex()))]
+#[case::empty_tokio_tokio(make(empty(), tokio_tokio()))]
+#[case::default_standard(make(default(), standard()))]
+#[case::default_standard_mutex(make(default(), standard_mutex()))]
+#[case::default_standard_tokio(make(default(), standard_tokio()))]
+#[case::default_tokio_std(make(default(), tokio_std()))]
+#[case::default_tokio_mutex(make(default(), tokio_mutex()))]
+#[case::default_tokio_tokio(make(default(), tokio_tokio()))]
+#[case::started_standard(make(started(), standard()))]
+#[case::started_standard_mutex(make(started(), standard_mutex()))]
+#[case::started_standard_tokio(make(started(), standard_tokio()))]
+#[case::started_tokio_std(make(started(), tokio_std()))]
+#[case::started_tokio_mutex(make(started(), tokio_mutex()))]
+#[case::started_tokio_tokio(make(started(), tokio_tokio()))]
+#[tokio::test]
+async fn it_should_get_entries(
+    #[future]
+    #[case]
+    repo: Repo,
+) {
+    let (repo, maybe) = repo.await;
+
+    if let Some((info_hash, torrent)) = maybe {
+        assert_eq!(repo.get_paginated(None).await[0], (info_hash, torrent));
+    } else {
+        assert!(repo.get_paginated(None).await.is_empty());
+    }
+}
+
+#[rstest]
+#[case::empty_standard(make(empty(), standard()))]
+#[case::empty_standard_mutex(make(empty(), standard_mutex()))]
+#[case::empty_standard_tokio(make(empty(), standard_tokio()))]
+#[case::empty_tokio_std(make(empty(), tokio_std()))]
+#[case::empty_tokio_mutex(make(empty(), tokio_mutex()))]
+#[case::empty_tokio_tokio(make(empty(), tokio_tokio()))]
+#[case::default_standard(make(default(), standard()))]
+#[case::default_standard_mutex(make(default(), standard_mutex()))]
+#[case::default_standard_tokio(make(default(), standard_tokio()))]
+#[case::default_tokio_std(make(default(), tokio_std()))]
+#[case::default_tokio_mutex(make(default(), tokio_mutex()))]
+#[case::default_tokio_tokio(make(default(), tokio_tokio()))]
+#[case::started_standard(make(started(), standard()))]
+#[case::started_standard_mutex(make(started(), standard_mutex()))]
+#[case::started_standard_tokio(make(started(), standard_tokio()))]
+#[case::started_tokio_std(make(started(), tokio_std()))]
+#[case::started_tokio_mutex(make(started(), tokio_mutex()))]
+#[case::started_tokio_tokio(make(started(), tokio_tokio()))]
+#[tokio::test]
+async fn it_should_get_metrics(
+    #[future]
+    #[case]
+    repo: Repo,
+) {
+    use torrust_tracker_primitives::torrent_metrics::TorrentsMetrics;
+
+    let (repo, maybe) = repo.await;
+
+    let expected = if let Some((_, torrent)) = maybe {
+        TorrentsMetrics {
+            torrents: 1,
+            incomplete: u64::from(torrent.get_stats().incomplete),
+            complete: u64::from(torrent.get_stats().complete),
+            downloaded: u64::from(torrent.get_stats().downloaded),
+        }
+    } else {
+        TorrentsMetrics::default()
+    };
+
+    assert_eq!(repo.get_metrics().await, expected);
+}

src/core/mod.rs

@@ -1115,9 +1115,9 @@ mod tests {
             assert_eq!(
                 torrents_metrics,
                 TorrentsMetrics {
-                    seeders: 0,
-                    completed: 0,
-                    leechers: 0,
+                    complete: 0,
+                    downloaded: 0,
+                    incomplete: 0,
                     torrents: 0
                 }
             );
@@ -1164,9 +1164,9 @@ mod tests {
             assert_eq!(
                 torrent_metrics,
                 TorrentsMetrics {
-                    seeders: 0,
-                    completed: 0,
-                    leechers: 1,
+                    complete: 0,
+                    downloaded: 0,
+                    incomplete: 1,
                     torrents: 1,
                 }
             );
@@ -1191,9 +1191,9 @@ mod tests {
             assert_eq!(
                 (torrent_metrics),
                 (TorrentsMetrics {
-                    seeders: 0,
-                    completed: 0,
-                    leechers: 1_000_000,
+                    complete: 0,
+                    downloaded: 0,
+                    incomplete: 1_000_000,
                     torrents: 1_000_000,
                 }),
                 "{result_a:?} {result_b:?}"

src/servers/apis/v1/context/stats/resources.rs

@@ -50,9 +50,9 @@ impl From<TrackerMetrics> for Stats {
     fn from(metrics: TrackerMetrics) -> Self {
         Self {
             torrents: metrics.torrents_metrics.torrents,
-            seeders: metrics.torrents_metrics.seeders,
-            completed: metrics.torrents_metrics.completed,
-            leechers: metrics.torrents_metrics.leechers,
+            seeders: metrics.torrents_metrics.complete,
+            completed: metrics.torrents_metrics.downloaded,
+            leechers: metrics.torrents_metrics.incomplete,
             tcp4_connections_handled: metrics.protocol_metrics.tcp4_connections_handled,
             tcp4_announces_handled: metrics.protocol_metrics.tcp4_announces_handled,
             tcp4_scrapes_handled: metrics.protocol_metrics.tcp4_scrapes_handled,
@@ -82,9 +82,9 @@ mod tests {
         assert_eq!(
             Stats::from(TrackerMetrics {
                 torrents_metrics: TorrentsMetrics {
-                    seeders: 1,
-                    completed: 2,
-                    leechers: 3,
+                    complete: 1,
+                    downloaded: 2,
+                    incomplete: 3,
                     torrents: 4
                 },
                 protocol_metrics: Metrics {