refactor: [#1524] extract TestEnv for integration tests in tracker-core

Author: josecelano

packages/tracker-core/tests/common/fixtures.rs

@@ -0,0 +1,52 @@
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+use std::str::FromStr;
+
+use aquatic_udp_protocol::{AnnounceEvent, NumberOfBytes, PeerId};
+use bittorrent_primitives::info_hash::InfoHash;
+use torrust_tracker_configuration::Core;
+use torrust_tracker_primitives::peer::Peer;
+use torrust_tracker_primitives::DurationSinceUnixEpoch;
+use torrust_tracker_test_helpers::configuration::ephemeral_sqlite_database;
+
+/// # Panics
+///
+/// Will panic if the temporary file path is not a valid UTF-8 string.
+#[must_use]
+pub fn ephemeral_configuration() -> Core {
+    let mut config = Core::default();
+
+    let temp_file = ephemeral_sqlite_database();
+    temp_file.to_str().unwrap().clone_into(&mut config.database.path);
+
+    config
+}
+
+/// # Panics
+///
+/// Will panic if the string representation of the info hash is not a valid infohash.
+#[must_use]
+pub fn sample_info_hash() -> InfoHash {
+    "3b245504cf5f11bbdbe1201cea6a6bf45aee1bc0" // DevSkim: ignore DS173237
+        .parse::<InfoHash>()
+        .expect("String should be a valid info hash")
+}
+
+/// Sample peer whose state is not relevant for the tests.
+#[must_use]
+pub fn sample_peer() -> Peer {
+    Peer {
+        peer_id: PeerId(*b"-qB00000000000000000"),
+        peer_addr: SocketAddr::new(remote_client_ip(), 8080),
+        updated: DurationSinceUnixEpoch::new(1_669_397_478_934, 0),
+        uploaded: NumberOfBytes::new(0),
+        downloaded: NumberOfBytes::new(0),
+        left: NumberOfBytes::new(0), // No bytes left to download
+        event: AnnounceEvent::Completed,
+    }
+}
+
+// The client peer IP.
+#[must_use]
+pub fn remote_client_ip() -> IpAddr {
+    IpAddr::V4(Ipv4Addr::from_str("126.0.0.1").unwrap())
+}

packages/tracker-core/tests/common/mod.rs

@@ -0,0 +1,2 @@
+pub mod fixtures;
+pub mod test_env;

packages/tracker-core/tests/common/test_env.rs

@@ -0,0 +1,137 @@
+use std::net::IpAddr;
+use std::sync::Arc;
+
+use aquatic_udp_protocol::AnnounceEvent;
+use bittorrent_primitives::info_hash::InfoHash;
+use bittorrent_tracker_core::announce_handler::PeersWanted;
+use bittorrent_tracker_core::container::TrackerCoreContainer;
+use tokio::task::yield_now;
+use torrust_tracker_configuration::Core;
+use torrust_tracker_primitives::core::{AnnounceData, ScrapeData};
+use torrust_tracker_primitives::peer::Peer;
+use torrust_tracker_primitives::swarm_metadata::SwarmMetadata;
+use torrust_tracker_torrent_repository::container::TorrentRepositoryContainer;
+
+pub struct TestEnv {
+    pub torrent_repository_container: Arc<TorrentRepositoryContainer>,
+    pub tracker_core_container: Arc<TrackerCoreContainer>,
+}
+
+impl TestEnv {
+    #[must_use]
+    pub async fn started(core_config: Core) -> Self {
+        let test_env = TestEnv::new(core_config);
+        test_env.start().await;
+        test_env
+    }
+
+    #[must_use]
+    pub fn new(core_config: Core) -> Self {
+        let core_config = Arc::new(core_config);
+
+        let torrent_repository_container = Arc::new(TorrentRepositoryContainer::initialize(
+            core_config.tracker_usage_statistics.into(),
+        ));
+
+        let tracker_core_container = Arc::new(TrackerCoreContainer::initialize_from(
+            &core_config,
+            &torrent_repository_container,
+        ));
+
+        Self {
+            torrent_repository_container,
+            tracker_core_container,
+        }
+    }
+
+    pub async fn start(&self) {
+        let mut jobs = vec![];
+
+        let job = torrust_tracker_torrent_repository::statistics::event::listener::run_event_listener(
+            self.torrent_repository_container.event_bus.receiver(),
+            &self.torrent_repository_container.stats_repository,
+        );
+
+        jobs.push(job);
+
+        let job = bittorrent_tracker_core::statistics::event::listener::run_event_listener(
+            self.torrent_repository_container.event_bus.receiver(),
+            &self.tracker_core_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;
+    }
+
+    pub async fn announce_peer_started(
+        &mut self,
+        mut peer: Peer,
+        remote_client_ip: &IpAddr,
+        info_hash: &InfoHash,
+    ) -> AnnounceData {
+        peer.event = AnnounceEvent::Started;
+
+        let announce_data = self
+            .tracker_core_container
+            .announce_handler
+            .announce(info_hash, &mut peer, remote_client_ip, &PeersWanted::AsManyAsPossible)
+            .await
+            .unwrap();
+
+        // Give time to the event listeners to process the event
+        yield_now().await;
+
+        announce_data
+    }
+
+    pub async fn announce_peer_completed(
+        &mut self,
+        mut peer: Peer,
+        remote_client_ip: &IpAddr,
+        info_hash: &InfoHash,
+    ) -> AnnounceData {
+        peer.event = AnnounceEvent::Completed;
+
+        let announce_data = self
+            .tracker_core_container
+            .announce_handler
+            .announce(info_hash, &mut peer, remote_client_ip, &PeersWanted::AsManyAsPossible)
+            .await
+            .unwrap();
+
+        // Give time to the event listeners to process the event
+        yield_now().await;
+
+        announce_data
+    }
+
+    pub async fn scrape(&self, info_hash: &InfoHash) -> ScrapeData {
+        self.tracker_core_container
+            .scrape_handler
+            .scrape(&vec![*info_hash])
+            .await
+            .unwrap()
+    }
+
+    pub async fn increase_number_of_downloads(&mut self, peer: Peer, remote_client_ip: &IpAddr, info_hash: &InfoHash) {
+        let _announce_data = self.announce_peer_started(peer, remote_client_ip, info_hash).await;
+        let announce_data = self.announce_peer_completed(peer, remote_client_ip, info_hash).await;
+
+        assert_eq!(announce_data.stats.downloads(), 1);
+    }
+
+    pub async fn get_swarm_metadata(&self, info_hash: &InfoHash) -> Option<SwarmMetadata> {
+        self.torrent_repository_container
+            .swarms
+            .get_swarm_metadata(info_hash)
+            .await
+            .unwrap()
+    }
+
+    pub async fn remove_swarm(&self, info_hash: &InfoHash) {
+        self.torrent_repository_container.swarms.remove(info_hash).await.unwrap();
+    }
+}