fix: [#1524] test (move to integration test)

Author: josecelano

packages/tracker-core/src/announce_handler.rs

@@ -594,83 +594,6 @@ mod tests {
             }
         }
 
-        mod handling_torrent_persistence {
-
-            use std::sync::Arc;
-
-            use aquatic_udp_protocol::AnnounceEvent;
-            use torrust_tracker_test_helpers::configuration;
-            use torrust_tracker_torrent_repository::Swarms;
-
-            use crate::announce_handler::tests::the_announce_handler::peer_ip;
-            use crate::announce_handler::{AnnounceHandler, PeersWanted};
-            use crate::databases::setup::initialize_database;
-            use crate::test_helpers::tests::{sample_info_hash, sample_peer};
-            use crate::torrent::manager::TorrentsManager;
-            use crate::torrent::repository::in_memory::InMemoryTorrentRepository;
-            use crate::torrent::repository::persisted::DatabasePersistentTorrentRepository;
-            use crate::whitelist::authorization::WhitelistAuthorization;
-            use crate::whitelist::repository::in_memory::InMemoryWhitelist;
-
-            #[tokio::test]
-            async fn it_should_persist_the_number_of_completed_peers_for_all_torrents_into_the_database() {
-                let mut config = configuration::ephemeral_public();
-
-                config.core.tracker_policy.persistent_torrent_completed_stat = true;
-
-                let database = initialize_database(&config.core);
-                let swarms = Arc::new(Swarms::default());
-                let in_memory_torrent_repository = Arc::new(InMemoryTorrentRepository::new(swarms));
-                let db_torrent_repository = Arc::new(DatabasePersistentTorrentRepository::new(&database));
-                let torrents_manager = Arc::new(TorrentsManager::new(
-                    &config.core,
-                    &in_memory_torrent_repository,
-                    &db_torrent_repository,
-                ));
-                let in_memory_whitelist = Arc::new(InMemoryWhitelist::default());
-                let whitelist_authorization = Arc::new(WhitelistAuthorization::new(&config.core, &in_memory_whitelist.clone()));
-                let announce_handler = Arc::new(AnnounceHandler::new(
-                    &config.core,
-                    &whitelist_authorization,
-                    &in_memory_torrent_repository,
-                    &db_torrent_repository,
-                ));
-
-                let info_hash = sample_info_hash();
-
-                let mut peer = sample_peer();
-
-                peer.event = AnnounceEvent::Started;
-                let announce_data = announce_handler
-                    .announce(&info_hash, &mut peer, &peer_ip(), &PeersWanted::AsManyAsPossible)
-                    .await
-                    .unwrap();
-                assert_eq!(announce_data.stats.downloaded, 0);
-
-                peer.event = AnnounceEvent::Completed;
-                let announce_data = announce_handler
-                    .announce(&info_hash, &mut peer, &peer_ip(), &PeersWanted::AsManyAsPossible)
-                    .await
-                    .unwrap();
-                assert_eq!(announce_data.stats.downloaded, 1);
-
-                // Remove the newly updated torrent from memory
-                let _unused = in_memory_torrent_repository.remove(&info_hash).await;
-
-                torrents_manager.load_torrents_from_database().unwrap();
-
-                let torrent_entry = in_memory_torrent_repository
-                    .get(&info_hash)
-                    .expect("it should be able to get entry");
-
-                // It persists the number of completed peers.
-                assert_eq!(torrent_entry.lock().await.metadata().downloaded, 1);
-
-                // It does not persist the peers
-                assert!(torrent_entry.lock().await.is_empty());
-            }
-        }
-
         mod should_allow_the_client_peers_to_specified_the_number_of_peers_wanted {
 
             use torrust_tracker_configuration::TORRENT_PEERS_LIMIT;

packages/tracker-core/src/torrent/manager.rs

@@ -74,6 +74,8 @@ impl TorrentsManager {
     pub fn load_torrents_from_database(&self) -> Result<(), databases::error::Error> {
         let persistent_torrents = self.db_torrent_repository.load_all()?;
 
+        println!("Loaded {} persistent torrents from the database", persistent_torrents.len());
+
         self.in_memory_torrent_repository.import_persistent(&persistent_torrents);
 
         Ok(())

packages/tracker-core/src/torrent/repository/in_memory.rs

@@ -61,25 +61,6 @@ impl InMemoryTorrentRepository {
             .expect("Failed to upsert the peer in swarms")
     }
 
-    /// Removes a torrent entry from the repository.
-    ///
-    /// This method is only available in tests. It removes the torrent entry
-    /// associated with the given info hash and returns the removed entry if it
-    /// existed.
-    ///
-    /// # Arguments
-    ///
-    /// * `key` - The info hash of the torrent to remove.
-    ///
-    /// # Returns
-    ///
-    /// An `Option` containing the removed torrent entry if it existed.
-    #[cfg(test)]
-    #[must_use]
-    pub(crate) async fn remove(&self, key: &InfoHash) -> Option<SwarmHandle> {
-        self.swarms.remove(key).await
-    }
-
     /// Removes inactive peers from all torrent entries.
     ///
     /// A peer is considered inactive if its last update timestamp is older than

packages/tracker-core/tests/integration.rs

@@ -6,12 +6,15 @@ use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId};
 use bittorrent_primitives::info_hash::InfoHash;
 use bittorrent_tracker_core::announce_handler::PeersWanted;
 use bittorrent_tracker_core::container::TrackerCoreContainer;
-use torrust_tracker_configuration::Core;
+use tokio::task::yield_now;
+use torrust_tracker_configuration::{AnnouncePolicy, Core};
 use torrust_tracker_primitives::core::AnnounceData;
 use torrust_tracker_primitives::peer::Peer;
+use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
 use torrust_tracker_primitives::DurationSinceUnixEpoch;
 use torrust_tracker_test_helpers::configuration::ephemeral_sqlite_database;
 use torrust_tracker_torrent_repository::container::TorrentRepositoryContainer;
+use torrust_tracker_torrent_repository::Swarms;
 
 /// # Panics
 ///
@@ -56,52 +59,114 @@ fn remote_client_ip() -> IpAddr {
     IpAddr::V4(Ipv4Addr::from_str("126.0.0.1").unwrap())
 }
 
-fn initialize() -> (Arc<Core>, Arc<TrackerCoreContainer>, InfoHash, Peer) {
-    let config = Arc::new(ephemeral_configuration());
-
-    let torrent_repository_container = Arc::new(TorrentRepositoryContainer::initialize(config.tracker_usage_statistics.into()));
-
-    let container = Arc::new(TrackerCoreContainer::initialize_from(&config, &torrent_repository_container));
+async fn initialize_test_env(core_config: Core) -> (Arc<Core>, Arc<TrackerCoreContainer>, Arc<Swarms>, InfoHash, Peer) {
+    let config = Arc::new(core_config);
 
     let info_hash = sample_info_hash();
 
     let peer = sample_peer();
 
-    (config, container, info_hash, peer)
+    let (container, swarms) = start(&config).await;
+
+    (config, container, swarms, info_hash, peer)
+}
+
+async fn start(core_config: &Arc<Core>) -> (Arc<TrackerCoreContainer>, Arc<Swarms>) {
+    let torrent_repository_container = Arc::new(TorrentRepositoryContainer::initialize(
+        core_config.tracker_usage_statistics.into(),
+    ));
+
+    let container = Arc::new(TrackerCoreContainer::initialize_from(
+        core_config,
+        &torrent_repository_container,
+    ));
+
+    let mut jobs = vec![];
+
+    let job = torrust_tracker_torrent_repository::statistics::event::listener::run_event_listener(
+        torrent_repository_container.event_bus.receiver(),
+        &torrent_repository_container.stats_repository,
+    );
+
+    jobs.push(job);
+
+    let job = bittorrent_tracker_core::statistics::event::listener::run_event_listener(
+        torrent_repository_container.event_bus.receiver(),
+        &container.db_torrent_repository,
+    );
+
+    jobs.push(job);
+
+    // Give the event listeners some time to start
+    // todo: they should notify when they are ready
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+
+    (container, torrent_repository_container.swarms.clone())
 }
 
 async fn announce_peer_started(container: &Arc<TrackerCoreContainer>, peer: &mut Peer, info_hash: &InfoHash) -> AnnounceData {
     peer.event = AnnounceEvent::Started;
 
-    container
+    let announce_data = container
         .announce_handler
         .announce(info_hash, peer, &remote_client_ip(), &PeersWanted::AsManyAsPossible)
         .await
-        .unwrap()
+        .unwrap();
+
+    // Give time to the event listeners to process the event
+    yield_now().await;
+
+    announce_data
 }
 
-async fn _announce_peer_completed(container: &Arc<TrackerCoreContainer>, peer: &mut Peer, info_hash: &InfoHash) -> AnnounceData {
+async fn announce_peer_completed(container: &Arc<TrackerCoreContainer>, peer: &mut Peer, info_hash: &InfoHash) -> AnnounceData {
     peer.event = AnnounceEvent::Completed;
 
-    container
+    let announce_data = container
         .announce_handler
         .announce(info_hash, peer, &remote_client_ip(), &PeersWanted::AsManyAsPossible)
         .await
-        .unwrap()
+        .unwrap();
+
+    // Give time to the event listeners to process the event
+    yield_now().await;
+
+    announce_data
+}
+
+async fn increase_number_of_downloads(container: &Arc<TrackerCoreContainer>, peer: &mut Peer, info_hash: &InfoHash) {
+    let _announce_data = announce_peer_started(container, peer, info_hash).await;
+    let announce_data = announce_peer_completed(container, peer, info_hash).await;
+
+    assert_eq!(announce_data.stats.downloads(), 1);
 }
 
 #[tokio::test]
 async fn it_should_handle_the_announce_request() {
-    let (_config, container, info_hash, mut peer) = initialize();
+    let (_config, container, _swarms, info_hash, mut peer) = initialize_test_env(ephemeral_configuration()).await;
 
     let announce_data = announce_peer_started(&container, &mut peer, &info_hash).await;
 
-    assert_eq!(announce_data, AnnounceData::default());
+    assert_eq!(
+        announce_data,
+        AnnounceData {
+            peers: vec![],
+            stats: SwarmMetadata {
+                downloaded: 0,
+                complete: 1,
+                incomplete: 0
+            },
+            policy: AnnouncePolicy {
+                interval: 120,
+                interval_min: 120
+            }
+        }
+    );
 }
 
 #[tokio::test]
 async fn it_should_not_return_the_peer_making_the_announce_request() {
-    let (_config, container, info_hash, mut peer) = initialize();
+    let (_config, container, _swarms, info_hash, mut peer) = initialize_test_env(ephemeral_configuration()).await;
 
     let announce_data = announce_peer_started(&container, &mut peer, &info_hash).await;
 
@@ -110,11 +175,33 @@ async fn it_should_not_return_the_peer_making_the_announce_request() {
 
 #[tokio::test]
 async fn it_should_handle_the_scrape_request() {
-    let (_config, container, info_hash, mut peer) = initialize();
+    let (_config, container, _swarms, info_hash, mut peer) = initialize_test_env(ephemeral_configuration()).await;
 
     let _announce_data = announce_peer_started(&container, &mut peer, &info_hash).await;
 
     let scrape_data = container.scrape_handler.scrape(&vec![info_hash]).await.unwrap();
 
     assert!(scrape_data.files.contains_key(&info_hash));
 }
+
+#[tokio::test]
+async fn it_should_persist_the_number_of_completed_peers_for_all_torrents_into_the_database() {
+    let mut core_config = ephemeral_configuration();
+    core_config.tracker_policy.persistent_torrent_completed_stat = true;
+
+    let (_config, container, swarms, info_hash, mut peer) = initialize_test_env(core_config).await;
+
+    increase_number_of_downloads(&container, &mut peer, &info_hash).await;
+
+    assert!(swarms.get_swarm_metadata(&info_hash).await.unwrap().unwrap().downloads() == 1);
+
+    swarms.remove(&info_hash).await.unwrap();
+
+    // Make sure the swarm metadata is removed
+    assert!(swarms.get_swarm_metadata(&info_hash).await.unwrap().is_none());
+
+    // Load torrents from the database to ensure the completed stats are persisted
+    container.torrents_manager.load_torrents_from_database().unwrap();
+
+    assert!(swarms.get_swarm_metadata(&info_hash).await.unwrap().unwrap().downloads() == 1);
+}